# Daytona vs Fly Machines: pricing, isolation and limits Daytona is a sandbox API that defaults to containers; a Fly Machine is a Firecracker VM billed by size. The same job costs $2.76 vs $1.44. **Runtime runs the same job for 77% less than Daytona and 55% less than a Fly Machine.** 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost $2.76 on Daytona, $1.44 on a `performance-2x` Machine and $0.64 on Runtime. Runtime gives every sandbox its own Firecracker microVM, like a Machine, and bills the CPU the code uses rather than the size it holds. Rates checked 23 September 2026. ## At a glance Fly Machines are at the rates of Fly.io's Ashburn (`iad`) region. | | Daytona | Fly Machines | Runtime | | ---------- | ------------------------------------------------------------- | -------------------------------------------------------------- | ---------------------------------------------------------- | | What it is | A sandbox API with SDKs for agents | General-purpose VMs, driven by the Machines API and `flyctl` | A sandbox API with SDKs for agents | | Isolation | Containers by default; VM sandboxes as a separate class | Firecracker microVM | Firecracker microVM, own kernel, every sandbox | | Price | $0.0504 per vCPU-hour, $0.0162 per GiB-hour | By size while started: `performance-2x`, 4 GB, $0.0861 an hour | $0.025 per vCPU-hour of measured CPU, $0.0075 per GiB-hour | | Billed | Per second | By the second while a Machine runs | Per second | | Disk | First 5 GiB free, then $0.000108 per GiB-hour, stopped or not | Root disk temporary; stopped rootfs $0.15 per GB-month | Included while running; paused storage $0.08 per GB-month | | Plan fee | None published | None; pay as you go | None; prepaid credit from $10 | | Free start | $200 of compute, no card | Not stated on the pricing page | 50 sandbox hours, no card | | When idle | Stops after 15 idle minutes by default | Billed while started; suspend keeps memory | Pause keeps files, memory and processes, 1 to 365 days | | Regions | US and EU | 18 regions | One US region | ## Is a Fly Machine cheaper than a Daytona sandbox? At list rates, yes. A `performance-2x` Machine, 2 performance vCPUs kept as whole cores and 4 GB, costs $0.0861 an hour. Daytona's 2 vCPUs and 4 GiB cost $0.1008 plus $0.0648, $0.1656 an hour. Both charge that whether the code is busy or waiting, so the Machine stays about half the price at any load. Fly also sells shared vCPUs. A `shared-cpu-2x` Machine with 4 GB costs about $0.50 for the 1,000 runs below, but each shared vCPU is guaranteed only 6.25% of a core, with a small burst allowance to start, so a new one would not fit 20 CPU-seconds of work into a minute. The `performance` class is the fair comparison for agent work. The price gap buys less than it seems. Daytona gives you an agent sandbox: SDKs, sessions, files, git and a code interpreter, a default idle stop after 15 minutes, and GPU or Windows machines when you need them. A Machine is a VM you drive yourself through the Machines API, with a temporary root disk and volumes for anything that must last. ## Container or microVM? A Daytona sandbox is a container unless you choose its VM class, and only VM sandboxes pause with memory and take memory snapshots. Every Fly Machine is a Firecracker microVM. So is every Runtime sandbox, with its own Linux kernel, and every one can pause with its memory and running processes. See [microVM vs container](/compare/microvm-vs-container) and [Firecracker vs Docker](/compare/firecracker-vs-docker). ## 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 Machine is a `performance-2x` with 4 GB. ``` 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 Machines Size 1,000 × 60 s / 3,600 × $0.0861 = $1.44 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, $143.50 on Machines 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 $1.44 on Machines, so Runtime is cheaper however busy the sandbox is. If each run lasted 90 seconds instead, it would be $4.14 on Daytona, $2.15 on Machines and $0.89 on Runtime, since Runtime's CPU charge follows the 20 CPU-seconds of work rather than the clock. Disk, volumes, network and free credits are left out. ## Which one to pick - **Pick Daytona** for an agent sandbox with GPUs or Windows, sandboxes in the EU as well as the US, or $200 of free compute to start. - **Pick Fly Machines** for general VMs in 18 regions with volumes and Managed Postgres in the same account, if you are building your own sandbox layer. - **Pick Runtime** for a microVM on every sandbox at under half a Machine's price and under a quarter of Daytona's, pause that keeps memory, and an agent that connects without an API key. ## 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 ``` Sandboxes get Daytona's defaults, 1 vCPU, 1 GiB and a 3 GiB disk, and pause after 15 minutes without calls, with their memory kept. From Fly Machines, where you start a Machine for each job, create a sandbox instead and let `with` stop it when the job ends: ```python from withruntime import Sandbox with Sandbox.create(funding="trial") as box: print(box.exec("python3 -c 'print(6 * 7)'", check=True).stdout) ``` 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 compare --from fly-machines` (or `--from daytona`) prices what you ran at the old provider's rates. The full side-by-sides are [Runtime vs Daytona](/docs/daytona-alternative) and [Runtime vs Fly.io](/docs/fly-alternative). ## 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/), [Machine CPU performance](https://fly.io/docs/machines/cpu-performance/), [Fly Volumes](https://fly.io/docs/volumes/overview/), [Fly.io regions](https://fly.io/docs/reference/regions/) - Runtime [pricing](/docs/pricing) Facts on this page were checked on 25 September 2026.