How Much Does a Cloud Sandbox Cost? Hourly, Daily and Monthly Tables
Updated October 27, 2026 .md
Short answer: Sandboxer bills per second while a sandbox runs. small costs $0.018 an hour, default $0.036, large $0.072 and xlarge $0.20. A default sandbox left on costs $0.864 a day or $26.28 a month. Stopped and idle-paused sandboxes bill no compute, and each plan's price comes back as machine time.
Every number on this page comes from the pricing page and the billing docs. The rest is arithmetic, shown so you can redo it with your own hours.
The two numbers everything derives from#
- One hour of
defaultcosts $0.036. Each size has a fixed multiplier on that rate. - Your balance is counted in seconds of
defaulttime. One dollar buys 100,000 of them (3,600 / 0.036).
A sandbox's cost is seconds running × multiplier × $0.036 / 3,600. Time while stopped is never counted.
Price per size: hourly, daily, monthly#
A month here is 730 hours, the figure the pricing page uses for "always on".
| Size | vCPU / RAM / disk | Multiplier | Per hour | Per day (24 h) | Per month (730 h) | Workdays (8 h × 22 = 176 h) |
|---|---|---|---|---|---|---|
small |
2 / 4 GB / 12 GB | 0.5× | $0.018 | $0.432 | $13.14 | $3.17 |
default |
4 / 8 GB / 50 GB | 1× | $0.036 | $0.864 | $26.28 | $6.34 |
large |
8 / 16 GB / 125 GB | 2× | $0.072 | $1.728 | $52.56 | $12.67 |
xlarge |
16 / 32 GB / 251 GB | 5.56× (50/9) | $0.20 | $4.80 | $146.00 | $35.20 |
The arithmetic for large: $0.036 × 2 = $0.072 an hour; × 24 = $1.728 a day; × 730 = $52.56 a month. For xlarge: $0.036 × 50/9 = $0.20 an hour. xlarge needs the $100 plan or higher.
Per-second billing matters for short work. A small sandbox that runs 90 seconds uses 45 seconds of default time: 45 / 100,000 dollars, or $0.00045.
What plan dollars buy in machine hours#
A plan includes a month of machine time equal to its price. It renews each billing month and doesn't roll over. Time packs are $20, use the same rates, never expire, and are spent after plan time.
Machine hours = plan dollars × 100,000 / 3,600 / multiplier. Rounded down:
| Plan | default seconds |
small h |
default h |
large h |
xlarge h |
default sandboxes always on |
|---|---|---|---|---|---|---|
| $20 / month, or one $20 pack | 2,000,000 | 1,111 | 555 | 277 | not on this plan | 0.76 |
| $100 / month | 10,000,000 | 5,555 | 2,777 | 1,388 | 500 | 3.8 |
| $500 / month | 50,000,000 | 27,777 | 13,888 | 6,944 | 2,500 | 19.0 |
| $2,000 / month | 200,000,000 | 111,111 | 55,555 | 27,777 | 10,000 | 76.1 |
The last column is default hours / 730. So the $20 plan covers about three quarters of one always-on default sandbox, and the billing docs' example of one running around the clock costs $26.28: the $20 plan plus one pack.
The free trial is separate: 7 days with 25 hours of machine time, up to 2 sandboxes at once, small and default only, and auto-stop of at most 8 hours.
Running vs stopped vs idle-paused, for three common patterns#
- Running means the sandbox is never stopped (
--no-auto-stop), so all 730 hours of the month are billed. - Stopped means you stop or delete it when the work ends. Only working time is billed.
- Idle-paused means it pauses itself after a quiet period and wakes on the next use. You pay for working time plus the idle timeout before each pause. The tables below assume a 30-minute timeout; set yours with
--idle.
An agent per developer, 8 hours a day#
One default sandbox per developer, used 8 hours on each of 22 workdays.
| Hours per developer per month | Per developer | Team of 10 | |
|---|---|---|---|
| Running | 730 | 730 × $0.036 = $26.28 | $262.80 |
| Stopped at the end of the day | 8 × 22 = 176 | 176 × $0.036 = $6.34 | $63.36 |
| Idle-paused, one 30-minute tail a day | 8.5 × 22 = 187 | 187 × $0.036 = $6.73 | $67.32 |
The idle tail grows with every break longer than the timeout, so this row is a floor. Breaks shorter than the timeout keep the meter running.
For the team of 10 on idle pause, $67.32 is more than the $20 plan includes. Two ways to cover it:
- the $20 plan plus 3 packs: $20 + $60 = $80, and the $12.68 left over in packs never expires;
- the $100 plan: $100, with $32.68 of included time unused at renewal, which doesn't roll over.
A preview environment per pull request#
One small sandbox per pull request, open for 3 days, 40 pull requests a month. Reviewers visit 4 times per preview, 10 minutes each.
| Hours per preview | Per preview | 40 previews | |
|---|---|---|---|
| Running for 3 days | 72 | 72 × $0.018 = $1.296 | $51.84 |
| Idle-paused | 4 × (10 + 30) min = 2.67 | 2.67 × $0.018 = $0.048 | $1.92 |
| Deleted at merge | 0 after merge | $0 | $0 |
Each wake is a resume, and creates, resumes and forks each count as one start. Here that's 1 create + 4 wakes = 5 starts per preview, 200 a month: far under even the $20 plan's 200 a day. A stopped preview you keep counts toward your included storage until you delete it; see Get a preview URL for every pull request for the full setup.
1,000 short tasks a day#
Agent tasks of 2 minutes each on small, 1,000 a day, 30 days.
Machine time is the easy part: 1,000 × 2 min = 33.3 small hours a day. × $0.018 = $0.60 a day, $18.00 a month. That fits inside the $20 plan's included time.
The start limits decide the plan. With one fresh sandbox per task, every task is one start:
| Plan | Starts per minute / hour / day | 1,000 creates a day? |
|---|---|---|
| $20 / month | 12 / 60 / 200 | No: 200 a day |
| $100 / month | 30 / 210 / 840 | No: 840 a day |
| $500 / month | 65 / 420 / 1,680 | Yes, if no hour has more than 420 |
| $2,000 / month | 90 / 600 / 2,400 | Yes, if no hour has more than 600 |
Two ways to run it:
| Starts a day | Compute per month | Plan needed | |
|---|---|---|---|
| One sandbox per task, deleted after | 1,000 | $18.00 | $500 (for the starts, not the compute) |
A pool of 10 small sandboxes, 100 tasks each via sbx exec, stopped when the queue is empty |
10 | about $18.00 plus idle time | $20 |
| The same pool, never stopped | 10 | 10 × 730 × $0.018 = $131.40 | $20 plus 6 packs ($140) |
The pool trades isolation for starts: tasks in one sandbox share its disk and processes. If each task must start clean, you need the per-task row and its plan. Going over a start limit returns 429 rate_limited or 429 daily_limit_reached with details.resetsAt; see Limits & errors.
Storage included per plan#
Storage isn't billed. Each plan includes an amount for sandboxes that aren't running (their disk, memory image and automatic snapshots) and named snapshots. Running sandboxes don't count. Only data beyond the shared OS image is measured.
| Plan | Storage included |
|---|---|
| Free trial, or no plan | 10 GB |
| Time packs without a plan (while you have a balance) | 50 GB |
| $20 / month | 50 GB |
| $100 / month | 250 GB |
| $500 / month | 1 TB |
| $2,000 / month | 5 TB |
GB here is 2^30 bytes, as the API counts. At the limit, new sandboxes, forks and named-snapshot saves answer 402 storage_limit_reached. Stopping, resuming and deleting always work. So a stopped sandbox costs $0 in compute; its only cost is the room it takes in this allowance.
Check real numbers on your account#
We ran this on October 27, 2026 against production. A small sandbox, metered from the moment it was ready:
sbx new --name aeo-sandbox-cost-tables-1 --type small --json # our id: sb_0xp1nfcarv
id=sb_0xp1nfcarv
sbx usage $id # while running, about 50 s after create
sbx stop $id --wait
sbx usage $id --json # 35 s after the stop{"ok":true,"type":"sandbox.usage","billingMultiplier":0.5,"dollars":0.00023,"running":true,"sandboxId":"sb_0xp1nfcarv","sandboxType":"small","seconds":23,"secondsPerDollar":100000,…}
{"ok":true,"type":"sandbox.usage","billingMultiplier":0.5,"dollars":0.00024,"running":false,"sandboxId":"sb_0xp1nfcarv","sandboxType":"small","seconds":24,"secondsPerDollar":100000,…}seconds already has the 0.5× multiplier applied: roughly 48 seconds of small became 24 default seconds, $0.00024. After the stop, running is false and the count stayed at 24 while we waited. Pass --since and --until to bill your own users for a window.
For the wallet as a whole, sbx limits --json shows the plan table the API enforces:
sbx limits --json | jq -c '.sandboxPlanTiers[] | {key, dollars, includedSeconds, maxActiveSandboxes, startsPerMinute, startsPerHour, startsPerDay}'{"key":"box_20","dollars":20,"includedSeconds":2000000,"maxActiveSandboxes":100,"startsPerMinute":12,"startsPerHour":60,"startsPerDay":200}
{"key":"box_100","dollars":100,"includedSeconds":10000000,"maxActiveSandboxes":300,"startsPerMinute":30,"startsPerHour":210,"startsPerDay":840}
{"key":"box_500","dollars":500,"includedSeconds":50000000,"maxActiveSandboxes":1000,"startsPerMinute":65,"startsPerHour":420,"startsPerDay":1680}
{"key":"box_2000","dollars":2000,"includedSeconds":200000000,"maxActiveSandboxes":2000,"startsPerMinute":90,"startsPerHour":600,"startsPerDay":2400}includedSeconds is dollars × 100,000, the same conversion as the tables above. The fields for your own wallet are creditBalanceHours, subscriptionRemainingSeconds, packBalanceDollars, last24hUsageSeconds, starts and storage. We don't quote them here: our test account has raised internal limits, so its values aren't representative of any plan.
FAQ#
Do I pay for a stopped sandbox?#
No compute is billed while a sandbox is stopped or idle-paused. Its disk and memory image count toward your plan's included storage, which isn't billed either.
Is there a minimum charge per sandbox?#
The meter is per second, from the moment the sandbox is up until it stops. Our test small sandbox showed 2 billable seconds about 6 seconds after its meter started.
Does the plan fee come on top of usage?#
No. Every plan dollar comes back as machine time: the $20 plan includes 2,000,000 seconds of default, which is 555 hours. You pay more only if you buy packs.
Why does a bigger plan make sense if I don't use the hours?#
For the limits. Concurrency, start rates, included storage and xlarge access all rise with the plan, as the 1,000-tasks example shows.
What happens when my balance runs out?#
New creates, resumes and forks get 402 billing_required. Running sandboxes keep going for a 24-hour grace period, then stop with memory and disk kept. Auto-refill buys packs before that happens.
Related#
More guides
For running AI-written code we rank Sandboxer, Freestyle and E2B first: each gives code its own VM with an API or SDK and can pause with memory. Pick Daytona for Windows or GPUs, Modal or Northflank for GPUs at scale, E2B or Northflank to run in your own cloud, and Vercel Sandbox if your app lives on Vercel.
For coding agents we rank Sandboxer first: a full Ubuntu VM with Claude Code and Codex preinstalled, Docker, and stop-and-resume that keeps the agent's session in memory. Freestyle and Amp Orbs also keep memory across pauses. Pick E2B for prebuilt agent templates on open source, Docker Sandboxes for free local runs, and Codespaces if you live in GitHub.
The best Daytona alternatives depend on why you're switching. For a full Linux microVM on every sandbox with memory-saving stop and Docker, we rank Sandboxer first. E2B suits open source and self-hosting, Modal massive short-job fleets, Northflank bring-your-own-cloud with GPUs, and Vercel Sandbox apps on Vercel.
If you're leaving E2B for longer sessions or a fuller machine, we rank Sandboxer first, then Freestyle: both give each sandbox a full Linux VM that keeps memory across pauses, with Docker and no short session cap. Pick Daytona for Windows or GPUs, Northflank for bring-your-own-cloud, and stay on E2B if you need open source.