# Daytona vs Fly Sprites: pricing, isolation and limits Daytona bills allocated vCPUs and memory and defaults to containers; Sprites are Firecracker microVMs billed on CPU used and memory in use. **Runtime runs the same job for 77% less than Daytona and 81% less than Sprites.** 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost $2.76 on Daytona, $3.31 on Sprites with all 4 GB in use, and $0.64 on Runtime. Runtime measures CPU like Sprites, at about a third of the rate, reserves memory at under half of Daytona's rate, and puts every sandbox in its own microVM. Rates checked 23 September 2026. ## At a glance | | Daytona | Fly Sprites | Runtime | | ----------- | ------------------------------------------------------------- | --------------------------------------------------------- | --------------------------------------------------------- | | Isolation | Containers by default; VM sandboxes as a separate class | Firecracker microVM | Firecracker microVM, own kernel, every sandbox | | CPU | $0.0504 per allocated vCPU-hour | $0.07 per CPU-hour of measured CPU | $0.025 per vCPU-hour of measured CPU, with a small floor | | Memory | $0.0162 per allocated GiB-hour | $0.04375 per GB-hour of memory in use | $0.0075 per reserved GiB-hour | | Disk | First 5 GiB free, then $0.000108 per GiB-hour, stopped or not | 100 GB; $0.50 per GB-month hot, $0.02 cold | Included while running; paused storage $0.08 per GB-month | | Size | vCPUs, memory and disk chosen per sandbox | Memory managed by Fly | vCPUs and memory chosen per sandbox | | Plan fee | None published | None required; optional monthly plans | None; prepaid credit from $10 | | Free start | $200 of compute, no card | $30 of trial credit | 50 sandbox hours, no card | | When idle | Stops after 15 idle minutes by default | Pauses itself; memory kept at first, the disk kept always | Pause keeps files, memory and processes, 1 to 365 days | | Also offers | GPU sandboxes and Windows machines | SDKs in Go and Elixir as well as JavaScript and Python | Forks, desktop, code interpreter, MCP server | ## Is Daytona cheaper than Sprites? It depends on how much memory the sandbox really uses. The two bill in opposite ways. Daytona charges for what the sandbox is given, every vCPU and every GiB, for as long as it runs. Sprites charge for what it uses: CPU time at $0.07 an hour, and memory in use at $0.04375 per GB-hour. For the job below, an agent that keeps its CPU busy a third of the time, the Sprite's CPU costs $0.39 and the rest is memory. That puts the break-even at about 3.25 GB in use: | Memory the Sprite uses | Sprites | Daytona (4 GiB allocated) | | ---------------------- | ------: | ------------------------: | | 1 GB | $1.12 | $2.76 | | 2 GB | $1.85 | $2.76 | | 4 GB | $3.31 | $2.76 | Busy CPUs move it the other way. With both CPUs working the whole minute a Sprite's CPU charge rises to $2.33, while Daytona's stays the same. Runtime is cheaper than both at every row: $0.64 for the job, because its measured CPU is $0.025 a vCPU-hour and its memory $0.0075 a GiB-hour. ## Cost for the same job 1,000 runs of a 2 vCPU, 4 GiB sandbox. Each run lasts 60 seconds and keeps the CPU busy for 20 CPU-seconds: an agent that mostly waits for a model. The Sprite is assumed to use all 4 GB for the whole minute. ``` Daytona CPU 1,000 × 60 s / 3,600 × 2 × $0.0504 = $1.68 Memory 1,000 × 60 s / 3,600 × 4 × $0.0162 = $1.08 Total $2.76 Sprites CPU 1,000 × 20 s / 3,600 × $0.07 = $0.39 Memory 1,000 × 60 s / 3,600 × 4 × $0.04375 = $2.92 Total $3.31 Runtime CPU 1,000 × 20 s / 3,600 × $0.025 = $0.14 Memory 1,000 × 60 s / 3,600 × 4 × $0.0075 = $0.50 Total $0.64 ``` At 100,000 runs a month that is $276.00 on Daytona, $330.56 on Sprites and $63.89 on Runtime. With both CPUs busy for the whole minute, it is $1.33 on Runtime against $2.76 on Daytona and $5.25 on Sprites, so Runtime is cheaper however busy the sandbox is. Plan fees, disk, network and free credits are left out. ## What does an idle sandbox keep, and cost? A Daytona sandbox stops after 15 idle minutes by default. Its disk past the first 5 GiB is billed at $0.000108 per GiB-hour whether it runs or not, and only VM sandboxes pause with their memory. A Sprite pauses itself shortly after its last activity, keeps its disk, and keeps its memory until it goes cold; cold storage is $0.02 per GB-month. A paused Runtime sandbox keeps its files, memory and running processes for the retention you set, 1 to 365 days, for $0.08 per GB-month, and the next request wakes it: ```ts check import { Sandbox } from "withruntime"; const sbx = await Sandbox.create({ timeoutSeconds: 600 }); await sbx.exec("echo state > /workspace/state.txt"); await sbx.pause(); // memory and files are kept; compute billing stops // ... later, even from another process: const again = await Sandbox.connect(sbx.id); await again.wake({ timeoutSeconds: 1200 }); await again.extend(600); // more time before the lease ends await again.stop(); ``` ## Which one to pick - **Pick Daytona** for GPU or Windows sandboxes, sizes you set yourself, or $200 of free compute to start. - **Pick Sprites** for sandboxes that use little memory and sleep for long stretches, a 100 GB disk, or SDKs in Go and Elixir. - **Pick Runtime** for under a quarter of either price on an agent that waits, a microVM on every sandbox, and memory kept across a pause for as long as you choose. ## Switch from either one From Daytona, Runtime's SDK runs your code after one import change: ```ts no-run import { Daytona } from "withruntime/daytona"; // was: from "@daytona/sdk" ``` ```python no-run from withruntime.daytona import Daytona # was: from daytona import Daytona ``` Its `stop()` pauses a sandbox with its files and memory, and `start()` carries on. From Sprites, `client.createSprite(name)` becomes `Sandbox.create()`, a Sprite found by name becomes `Sandbox.getOrCreate(name)`, and `sprite.execFile(cmd, args)` becomes `exec([cmd, ...args])`: ```ts import { Sandbox } from "withruntime"; const box = await Sandbox.create({ funding: "trial" }); try { console.log((await box.exec(["python3", "-c", "print(6 * 7)"], { check: true })).stdout); } finally { await box.stop(); } ``` Or give your coding agent the one instruction in [migration](/docs/migrate): it switches the project on a branch, tests it on the free trial and reports the monthly saving. `npx withruntime switch --from fly` (or `--from daytona`) before your first top-up matches that top-up with credit, up to $100. The full side-by-sides are [Runtime vs Daytona](/docs/daytona-alternative) and [Runtime vs Fly.io](/docs/fly-alternative); [how to pause and resume a sandbox](/how-to/pause-and-resume-a-sandbox) covers idle sandboxes on Runtime. ## Sources Daytona and Fly.io pricing pages rechecked 25 September 2026; the rest checked 23 September 2026. - [Daytona pricing](https://www.daytona.io/pricing), [Daytona sandboxes](https://www.daytona.io/docs/en/sandboxes) - [Fly.io pricing](https://fly.io/pricing/), [Sprites](https://fly.io/sprites/), [Sprites lifecycle and persistence](https://docs.sprites.dev/concepts/lifecycle/) - Runtime [pricing](/docs/pricing) Facts on this page were checked on 25 September 2026.