# Daytona vs CodeSandbox: pricing, isolation and limits Daytona bills per second on separate CPU and memory meters; CodeSandbox sells fixed microVM sizes by the minute, rounded up. **Runtime is 77% below Daytona and 74% below CodeSandbox on the same job.** The job is 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox: $2.76 on Daytona, $2.48 on CodeSandbox, $0.64 on Runtime. Daytona meters allocated CPU and CodeSandbox sells a fixed VM, so both charge for idle cores; Runtime meters the CPU used, per second, and every sandbox is a Firecracker microVM with its own kernel. Rates checked 23 September 2026. ## At a glance CodeSandbox is part of Together, and its SDK rates here come from Together's documentation. | | Daytona | CodeSandbox SDK | 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 | By VM size: Nano (2 cores, 4 GB) is $0.1486 an hour | $0.025 per vCPU-hour of measured CPU, with a small floor | | Memory | $0.0162 per GiB-hour | Inside the VM size | $0.0075 per reserved GiB-hour | | Billing unit | Per second | Per minute, rounded up | Per second | | Shapes | vCPUs and memory on separate meters | Fixed sizes, up to 64 cores and 128 GB | vCPUs and memory chosen per sandbox | | Plan fee | None published | Build free, 10 VMs at once; Scale $170 a month, 250 | None; prepaid credit from $10 | | Free start | $200 of compute | The free Build plan | 50 sandbox hours, no card | | Snapshots, forks | Memory snapshots on VM sandboxes | Memory snapshot and restore | Files, memory and running processes; 1 to 10 forks | ## Which is cheaper, Daytona or CodeSandbox? For a run of exactly a minute, CodeSandbox: a Nano VM costs $0.1486 an hour, against $0.1656 on Daytona for 2 vCPUs and 4 GiB. The order turns on how long each run lasts. Daytona bills by the second. CodeSandbox rounds each VM's running time up to the next minute, so a 40-second run is billed as 60 seconds. For 1,000 runs of 40 seconds each, same size: | Provider | Billed time per run | Cost for 1,000 runs | | ----------- | ------------------- | ------------------: | | Daytona | 40 seconds | $1.84 | | CodeSandbox | 60 seconds | $2.48 | Short, frequent runs favour Daytona; runs that fill whole minutes favour CodeSandbox. Neither charges less while the agent waits for a model. Runtime does: measured CPU at $0.025 a vCPU-hour with a floor of a twentieth of a vCPU, and memory at $0.0075 per GiB-hour, billed by the second. ## Cost for the same job Back to whole minutes: 1,000 runs of 60 seconds on 2 vCPU and 4 GiB, a Nano VM on CodeSandbox (10 credits an hour, $0.01486 a credit), with 20 CPU-seconds of work in each run. ``` 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 CodeSandbox Size 1,000 × 60 s / 3,600 × $0.1486 = $2.48 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 ``` Monthly, at 100,000 runs, Daytona comes to $276.00, CodeSandbox to $247.67 and Runtime to $63.89. With both CPUs busy for the whole minute the job costs $1.33 on Runtime, $2.76 on Daytona and $2.48 on CodeSandbox. Plan fees, disk, network and free credit are not in the sums. ## Is every sandbox a VM? On CodeSandbox, yes: each VM is a Firecracker microVM. On Daytona, not by default: the standard sandbox is a container, and pausing with memory needs its separate VM class. On Runtime, every sandbox is a Firecracker microVM with its own Linux kernel, and there is no class to pick. [MicroVM vs container](/compare/microvm-vs-container) covers why that boundary matters for model-written code. ## Which one to pick | Priority | Choose | | --------------------------------------------------------- | ----------- | | Many short runs billed by the second on separate meters | Daytona | | GPU sandboxes, Windows machines or $200 of free compute | Daytona | | Runs that fill whole minutes on a fixed VM size | CodeSandbox | | Very large machines (64 cores, 128 GB) or 250 VMs at once | CodeSandbox | | An agent that waits on a model | Runtime | On that last row Runtime costs about a quarter of either, gives a microVM to every sandbox, allows 100 at once with no plan fee, and [forks](/glossary/sandbox-fork) copy memory and running processes. ## Moving to Runtime Daytona code needs only its import changed: ```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 ``` CodeSandbox code is ported with the [migration table](/docs/migrate#map-the-calls), where creating, running a command, reading and writing files and shutting down each map to one call. Size is set on each sandbox rather than chosen from VM tiers: ```python from withruntime import Sandbox with Sandbox.create(funding="trial") as box: print(box.exec("python3 -c 'print(6 * 7)'", check=True).stdout) ``` `npx withruntime compare --from codesandbox` shows what your CodeSandbox usage would cost here, and `npx withruntime switch --from daytona` before the first top-up matches it with up to $100 of credit. A coding agent can make the change from the single instruction in [migration](/docs/migrate), on a branch, tested against the free trial. Full pages: [Runtime vs Daytona](/docs/daytona-alternative), [Runtime vs CodeSandbox](/docs/codesandbox-alternative). ## Sources Daytona pricing page 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) - [Together Code Sandbox](https://docs.together.ai/docs/together-code-sandbox), [CodeSandbox SDK pricing](https://codesandbox.io/docs/sdk/pricing) - Runtime [pricing](/docs/pricing) Facts on this page were checked on 25 September 2026.