Table of Contents
- What is a Daytona sandbox?
- Daytona 2.0 vs the original platform
- How it works: isolation, images and lifecycle
- Daytona pricing in short: one worked example
- Limits to know before you build
- Is Daytona open source? Self-hosting status
- When Daytona is the right choice
- When to pick something else
- Daytona sandbox FAQ
- What is a Daytona sandbox?
- Is the Daytona sandbox free?
- How much does the Daytona sandbox cost?
- Is the Daytona sandbox open source?
Do not index
A Daytona sandbox is an isolated cloud computer that an AI agent creates with one SDK or API call to run code you would not trust on your own machine. As of November 2026 there are two versions: on the original platform a 2 vCPU, 4 GiB sandbox costs $0.1656 per running hour ($120.89 for 730 hours), and on the new Daytona 2.0 the same shape costs the same $0.1656 on demand, or $0.1158 on preemptible capacity that Daytona can reclaim. On 2.0, Linux sandboxes are Firecracker microVMs that last at most 24 hours on the Starter plan. Both include $200 in free credit and suit short, bursty jobs; for sandboxes that stay on, Agent37 (our product) prices 2 vCPU, 4 GB of RAM and 4 GB of disk at $4.76 for 730 running hours on standard gVisor, or $11.36 as a full VM.
We run Agent37, so we have a stake here. Every Daytona price, limit and feature below comes from Daytona's own pages: daytona.io and its docs for the original platform, daytona.com and its docs for 2.0, plus the GitHub repository. All were checked on November 15, 2026. The costs are list-price math, not benchmarks.
What is a Daytona sandbox?
Daytona's docs call the product "a secure and elastic infrastructure for running AI-generated code." The sandbox is the unit you buy: a machine with its own filesystem, network stack and reserved vCPU, RAM and disk, created and controlled through an SDK, API or CLI.
In plain English: your agent gets a Linux machine in Daytona's cloud. It can install packages, clone a repository, run a dev server and compile code. If the code misbehaves, the damage stays inside the sandbox. Linux is the default, and Daytona also sells Windows, macOS and GPU sandboxes.
Daytona says sandbox creation takes under 90 milliseconds "from code to execution." That is Daytona's figure, not our measurement.
Here is the detail most guides miss: Daytona now runs two platforms, and they behave differently.
Daytona 2.0 vs the original platform
Daytona's changelog dates Daytona 2.0 to November 1, 2026. It lives at daytona.com with its own dashboard, docs and prices. The original platform, which the new docs call Daytona v0, still runs at daytona.io. Daytona publishes a migration guide, and we found no shutdown date for v0.
ã…¤ | Original platform (v0) | Daytona 2.0 |
Where | daytona.io, app.daytona.io | daytona.com, app.daytona.com |
Default Linux sandbox | Container with dedicated namespaces and enforced resource limits | Firecracker microVM with its own kernel |
Linux sandbox state | Persistent. Stop keeps files, and archive is free | Ephemeral. Deleting discards files, with no stop and start |
Longest session | No cap (15-minute auto-stop by default) | 24 hours on Starter, 48 on Team |
Billing unit | vCPU and GiB you reserve | Cores and GiB you use, never less than your guarantee |
Plan fee | None | Starter $0, Team $250 a month |
Open internet | From Tier 3 ($500 top-up) | Open by default |
SDKs | Python, TypeScript, Ruby, Go, Java | Python, TypeScript |
One practical catch. The 2.0.0 Python SDK reached PyPI on November 13 and is currently marked "temporarily withdrawn from default installation." A plain
pip install daytona still installs the 0.x SDK for the original platform; the 2.0 docs pin daytona==2.0.0. Know which platform your code targets before you compare prices.How it works: isolation, images and lifecycle
Isolation. The original docs promise every sandbox a dedicated kernel, then say "Sandboxes run as Linux containers by default." The isolation page describes that default as a container with namespaces and enforced resource limits, reserves a kernel of its own for the separate VM classes, and names no container runtime. Daytona 2.0 is plainer: every sandbox is "a hardware-isolated virtual machine with its own kernel," on Firecracker for Linux and Cloud Hypervisor for Windows. If your threat model needs a guest kernel (our microVM vs container guide explains why), that difference picks the platform for you.
Images and snapshots. A sandbox boots from an image: a Docker (OCI) image or a Dockerfile build. The original platform calls a prepared image a snapshot. On 2.0 a snapshot means something else: a capture of a running sandbox's memory and disk that new sandboxes resume from.
Lifecycle on the original platform. A sandbox persists until you delete it. Started, it bills vCPU, RAM and disk. Stopped, it keeps files, clears memory and bills disk only. Archived, a container's files move to object storage and bill nothing. A container auto-stops after 15 minutes of inactivity by default and auto-archives 7 days later.
One trap: a busy process is not "activity." The docs warn that a long job with no outside interaction "may auto-stop mid-process." Set auto-stop to 0 for long runs.
Lifecycle on 2.0. A Linux sandbox is ephemeral. It keeps its files until it is deleted, and a lifetime or idle timeout deletes it for you. It cannot be stopped and restarted. To keep work, capture an image, take a snapshot or write to a volume.
What your agent calls. The idea is the same on both: create a sandbox, run code or shell commands, edit files, use Git, open a preview URL. On the original SDK:
from daytona import Daytona, DaytonaConfig
daytona = Daytona(DaytonaConfig(api_key="YOUR_API_KEY"))
sandbox = daytona.create()
response = sandbox.process.code_run('print("Hello World")')
print(response.result)On 2.0 the calls become
daytona.v2.create() and sandbox.run_code(...). The original default images also ship with coding tools such as Claude Code and Codex preinstalled (see our Claude Code sandbox and Codex sandbox guides).Daytona pricing in short: one worked example
Neither version charges a fee to start, and both bill per second.
- Original platform: $0.0504 per vCPU-hour, $0.0162 per GiB-hour of RAM, and $0.000108 per GiB-hour of disk after the first 5 GiB free. You pay for what a sandbox reserves, not what it uses.
- Daytona 2.0: $0.1008 per core-hour on demand on the base CPU tier (one core equals 2 vCPUs where SMT is enabled), $0.0162 per GiB-hour of RAM, $0 for ephemeral disk and $0.000108 per GiB-hour for volumes. Preemptible capacity, the tab the pricing page opens on, is 30% off cores and memory ($0.0706 and $0.0113) and may be reclaimed. You pay for measured use, with your guarantee as the floor. Faster CPUs, a chosen region (1.15 to 2 times base) and Windows cost more.
One worked example: a Linux sandbox with 2 vCPU, 4 GiB of RAM and 4 GiB of disk.
- Original: 2 × $0.0504 + 4 × $0.0162 = $0.1656 per running hour. That is $16.56 for 100 hours and $120.89 for 730 hours. Disk is $0, because 4 GiB sits inside the free 5 GiB.
- 2.0: on demand, 1 core × $0.1008 + 4 × $0.0162 = $0.1656 per running hour, the same as the original platform, with ephemeral disk at $0. That is $16.56 for 100 hours and $120.89 for 730 hours, counted as aggregate hours, since a Starter session ends at 24 hours. On preemptible capacity it is $0.1158 per hour: $11.58 for 100 hours and $84.53 for 730.
Excluded: free credits, taxes, the Team plan fee, GPU and Windows charges, region multipliers, snapshot and volume storage, and your agent's model tokens and tools.
Both versions include $200 in free compute with no credit card. It is a one-time trial credit, not a free tier, and on the original platform it cannot be spent on GPU sandboxes.
The lesson: Daytona is cheap when sandboxes run for minutes and costly when they run for months, because a started sandbox bills its reservation even when idle. Our Daytona pricing breakdown covers the original platform's rates in depth.
Limits to know before you build
Most limits live in the docs, not on the pricing pages, and they differ by version.
On the original platform:
- Sandbox size. 4 vCPU, 8 GB of RAM and 10 GB of disk at most, unless Daytona raises it.
- Concurrency. A shared resource pool set by tier: 10 vCPU on Tier 1 (verified email), 100 on Tier 2 (card plus a $25 top-up), 250 on Tier 3 ($500 top-up) and 500 on Tier 4 ($2,000 top-up every 30 days).
- Network. On Tiers 1 and 2, "network access is restricted and cannot be overridden at the sandbox level." Package registries, Git hosts and model providers stay reachable. Full internet access starts at Tier 3.
- Memory state. Containers cannot pause, fork or snapshot memory. That takes the separate VM class.
On Daytona 2.0:
- Sessions. 24 hours on Starter, 48 on Team, custom on Enterprise.
- Concurrency. 100 sandboxes on Starter and 5,000 on Team.
- Sandbox size. The limits docs cap a Starter sandbox at 4 cores and 16 GiB, while the pricing page lists higher figures. Check your own plan.
So an agent that browses the open web needs a $500 top-up on the original platform, and anything that must outlive a day needs a persistence plan on 2.0.
Is Daytona open source? Self-hosting status
Not anymore. On June 11, 2026, Daytona announced it was moving its production codebase to closed source, citing security. The public repository is archived, and it opens with a notice: "This repository is no longer maintained."
What remains is the final public release, v0.190.0 from June 23, 2026, under the AGPL-3.0 license. You may still use it and fork it, "as is and without support or warranty." The SDKs and CLI continue in a separate public repository.
That leaves two ways to run Daytona on machines you control:
- Operate the archived release yourself. You own every patch, and its own README calls the Docker Compose setup "not safe to use in production."
- Bring Your Own Compute. Your servers join as a custom region while Daytona's control plane still manages them. It must be enabled for your organization.
Our Daytona self-hosted guide walks through both, and managed vs self-hosted sandboxes covers the cost side.
When Daytona is the right choice
Daytona is a good buy when your workload matches the way it bills.
- Short, bursty jobs. Code execution, test runs and evals that finish in minutes. Per-second billing keeps the gaps cheap.
- GPU, Windows or macOS work. Daytona sells all three.
- Hardware isolation by default. On 2.0, every sandbox is a virtual machine with its own kernel.
- Fan-out from one warm state. 2.0 memory snapshots let many sandboxes resume the same running environment.
When to pick something else
The math turns when sandboxes pile up running hours, or when a limit above blocks you. Four alternatives, one honest line each:
- Agent37 (ours) is built for cost. The same 2 vCPU, 4 GB RAM, 4 GB disk sandbox is $4.76 for 730 running hours on standard gVisor ($4.40 compute plus $0.36 disk), or $11.36 as a full VM with its own kernel for Docker. The tradeoffs: standard sandboxes share host resources and cannot run a Docker daemon. Compute bills while a sandbox is awake, even when idle, and disk bills while you keep it. The starter credit is $5 after you add a card, not $200. And it focuses on Linux, so GPU, Windows and macOS work stays with Daytona.
- E2B lists the same compute rates as Daytona's original platform and runs every sandbox as a Linux VM, but sessions stop at 1 hour on the free Hobby plan and 24 hours on the $150 per month Pro plan. See E2B vs Daytona.
- Modal fits when sandboxes sit beside inference or training you already run there. A Modal sandbox lives for 24 hours at most. See Modal pricing.
- Northflank publishes lower rates ($0.01667 per vCPU-hour plus $0.00833 per GB-hour) and can run in your own cloud account.
Our Daytona alternatives guide compares more options, and the sandbox pricing guide prices 15 providers at one workload.
Want to check the numbers on your own shape? The Agent37 pricing page has a calculator and a sourced provider comparison. It currently shows 94% lower cost than most sandbox providers: a list-price comparison, not a speed test. Then create a sandbox, run one real job on each platform, and compare the bills.
Daytona sandbox FAQ
What is a Daytona sandbox?
An isolated, programmable computer in Daytona's cloud that AI agents use to run generated code. Each has its own filesystem, network stack and reserved vCPU, RAM and disk. On the original platform it is a Linux container by default. On Daytona 2.0 it is a Firecracker microVM.
Is the Daytona sandbox free?
There is a free trial, not a free tier. New accounts get $200 in free compute with no credit card required, then pay as they go. On the original platform, full internet access also needs Tier 3, which requires a $500 top-up.
How much does the Daytona sandbox cost?
A 2 vCPU, 4 GiB Linux sandbox costs $0.1656 per running hour ($120.89 for 730 hours) on the original platform and on Daytona 2.0 on demand, before credits, taxes and plan fees. Daytona 2.0 preemptible capacity is 30% off at $0.1158 per hour ($84.53), and Daytona can reclaim it. On the original platform a stopped sandbox bills disk only.
Is the Daytona sandbox open source?
No. Daytona moved its production code to a private codebase in June 2026. The last public release, v0.190.0, remains available under AGPL-3.0 in an archived repository that receives no updates or fixes. The SDKs are still public.
