# How Much Does a Cloud Sandbox Cost? Hourly, Daily and Monthly Tables

> 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.

Source: https://sandboxer.com/guides/sandbox-cost-tables. Updated 2026-10-27.

**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](/pricing) and the [billing docs](/docs/billing). The rest is arithmetic, shown so you can redo it with your own hours.

## The two numbers everything derives from

- One hour of `default` costs **$0.036**. Each size has a fixed multiplier on that rate.
- Your balance is counted in seconds of `default` time. 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](/guides/idle-auto-pause-and-wake-on-use) 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](/guides/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](/docs/limits).

## 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:

```bash
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
```

```json
{"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:

```bash
sbx limits --json | jq -c '.sandboxPlanTiers[] | {key, dollars, includedSeconds, maxActiveSandboxes, startsPerMinute, startsPerHour, startsPerDay}'
```

```json
{"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

- [Billing](/docs/billing)
- [Limits & errors](/docs/limits)
- [Does a cloud sandbox pause itself when idle?](/guides/idle-auto-pause-and-wake-on-use)
- [Persistent or ephemeral sandboxes for agents](/guides/persistent-or-ephemeral-sandboxes-for-agents)