> ## Documentation Index
> Fetch the complete documentation index at: https://docs.boat.dev/llms.txt
> Use this file to discover all available pages before exploring further.
# Pricing & Limits
> What a sandbox costs per hour, what a plan buys, how many sandboxes you can run and start, and how that compares to other sandbox providers.
You pay for machine time, per second, only while a sandbox runs. A stopped sandbox costs nothing.
Storage is free too. The automatic snapshots that keep a stopped sandbox's disk cost nothing and have no count limit. Only [named snapshots](/snapshots#automatic-and-named-snapshots) above the first 10 cost money: \$1.70 a month each.
## Price
| Size | Per hour | CPU | RAM | Disk |
| - | - | - | - | - |
| `small` | **\$0.018** | 2 vCPU | 4 GB | 12 GB |
| `default` | **\$0.036** | 4 vCPU | 8 GB | 50 GB |
| `large` | **\$0.072** | 8 vCPU | 16 GB | 125 GB |
| `xlarge` \* | **\$0.200** | 16 vCPU | 32 GB | 251 GB |
"Disk" is the space for your own files; the OS and the pre-installed tools sit outside it. One `default` sandbox running a whole month (730 h) is \$26. Every size is a full Linux VM with the same tools, snapshots, hosting and desktop; only the machine changes.
\* `xlarge` needs the \$100 plan or higher. Subscribe from [Dashboard > Billing](https://boat.dev/dashboard?tab=billing), then pass `--type xlarge`. You do not need to contact us.
Pick the size when you create a sandbox, and change it on resume or fork:
```bash theme={null}
boat new --type small
boat resume bx_23456789 --type large
```
## Concurrency
A plan sets how many sandboxes you may **run at once**. Its price is not a fee: every dollar comes back as sandbox time at the rates above, so the \$20 plan is \$20 of time (555 hours of `default`) plus the right to run 100 sandboxes at the same time.
| Plan | Run at once | Time included | Starts per min / hour / day |
| - | - | - | - |
| \$20/mo | 100 | \$20 worth (555 h of `default`) | 12 / 60 / 200 |
| \$100/mo | 300 | \$100 worth (2,777 h of `default`) | 30 / 210 / 840 |
| \$500/mo | 1,000 | \$500 worth (13,888 h of `default`) | 65 / 420 / 1,680 |
| \$2000/mo | 2,000 | \$2000 worth (55,555 h of `default`) | 90 / 600 / 2,400 |
* Included time is granted each month and expires at the end of it.
* Need more time in a month: buy **credit packs** (\$20 each, same rates, they never expire), or turn on **auto-refill**. Plan time is spent first, packs after.
* Concurrency and start limits are per plan; on an organization they are multiplied by the number of seats.
* **Trial**: 25 free hours, 2 sandboxes at once, `small` and `default` only, until your first payment.
Change plans from [Dashboard > Billing](https://boat.dev/dashboard?tab=billing) or `boat billing plan 100`. Upgrades are prorated and take effect immediately.
## Compared to others
The same machine on every provider, at their public list prices (sizes as in the table above):
| \$/hour | `small` | `default` | `large` | `xlarge` |
| - | - | - | - | - |
| **boat** | **\$0.018** | **\$0.036** | **\$0.072** | **\$0.200** |
| Novita | \$0.117 (6x) | \$0.233 (6x) | \$0.467 (6x) | \$0.933 (5x) |
| Freestyle | \$0.132 (7x) | \$0.264 (7x) | \$0.529 (7x) | \$1.06 (5x) |
| exe.dev † | \$0.140 (8x) | \$0.280 (8x) | \$0.560 (8x) | \$1.12 (6x) |
| E2B | \$0.166 (9x) | \$0.331 (9x) | \$0.662 (9x) | \$1.32 (7x) |
| Daytona | \$0.166 (9x) | \$0.331 (9x) | \$0.662 (9x) | \$1.32 (7x) |
| Blaxel † | \$0.166 (9x) | \$0.331 (9x) | \$0.662 (9x) | \$1.32 (7x) |
| Cloudflare † | \$0.180 (10x) | \$0.360 (10x) | \$0.720 (10x) | \$1.44 (7x) |
| AWS AgentCore † | \$0.217 (12x) | \$0.434 (12x) | \$0.867 (12x) | \$1.73 (9x) |
| Islo | \$0.300 (17x) | \$0.600 (17x) | \$1.20 (17x) | \$2.40 (12x) |
| Deno Sandbox † | \$0.300 (17x) | \$0.600 (17x) | \$1.20 (17x) | \$2.40 (12x) |
| Fly.io Sprites † | \$0.315 (18x) | \$0.630 (18x) | \$1.26 (18x) | \$2.52 (13x) |
| Runloop | \$0.317 (18x) | \$0.634 (18x) | \$1.27 (18x) | \$2.53 (13x) |
| Vercel Sandbox † | \$0.341 (19x) | \$0.682 (19x) | \$1.36 (19x) | \$2.73 (14x) |
| Modal | \$0.380 (21x) | \$0.760 (21x) | \$1.52 (21x) | \$3.04 (15x) |
| Railway † | \$0.417 (23x) | \$0.833 (23x) | \$1.67 (23x) | \$3.33 (17x) |
† exe.dev: Cloud Pool rate; Cloudflare: active CPU only; Vercel Sandbox: active CPU only; Blaxel: CPU included in the RAM price; Railway: active CPU and used RAM only; Fly.io Sprites: active CPU and used RAM only; AWS AgentCore: active CPU and used RAM only; Deno Sandbox: active CPU only.
### "Active CPU" billing
Some providers bill only the CPU time your code actually uses. RAM is billed on top: some charge for the RAM you reserve, others (‡) for the RAM in use. The pitch is "you will rarely max the box". What it means for you:
* **You cannot know the price before you run.** The same job costs a different amount each time. Builds, test suites, browsers and agents are mostly CPU anyway.
* **RAM keeps billing while you idle.** Reserved or in use, you pay for it every second the sandbox runs.
* **They don't publish what their users actually use,** so you cannot check what "rarely max the box" saves you.
The table above prices them at full use, the only rate they publish. boat has one price per size, per hour, known before you run anything.
We publish our usage. Here is how much CPU and RAM boat sandboxes really used over the last 30 days, priced at each provider's list rates:
| Sandbox | **boat** | AWS AgentCore ‡ | Cloudflare | Fly.io Sprites ‡ | Railway ‡ | Vercel Sandbox | Deno Sandbox |
| - | - | - | - | - | - | - | - |
| quietest 1%: CPU 0.37% busy, RAM 14.77% used | **\$0.036** | \$0.012 (0.3x) | \$0.073 (2.0x) | \$0.053 (1.5x) | \$0.083 (2.3x) | \$0.171 (5x) | \$0.201 (6x) |
| median: CPU 8.79% busy, RAM 18.89% used | **\$0.036** | \$0.046 (1.3x) | \$0.097 (2.7x) | \$0.091 (2.5x) | \$0.129 (4x) | \$0.215 (6x) | \$0.235 (7x) |
| average: CPU 11.11% busy, RAM 22.97% used | **\$0.036** | \$0.057 (1.6x) | \$0.104 (2.9x) | \$0.112 (3x) | \$0.158 (4x) | \$0.226 (6x) | \$0.244 (7x) |
| busiest 1%: CPU 92.06% busy, RAM 36.1% used | **\$0.036** | \$0.357 (10x) | \$0.337 (9x) | \$0.384 (11x) | \$0.456 (13x) | \$0.641 (18x) | \$0.568 (16x) |
‡ bills RAM used, not RAM reserved.
A nearly idle sandbox can cost less where only busy CPU and used RAM are billed. From the median sandbox up, boat is the cheapest.
If your sandboxes mostly sit idle, stop them and resume them when work arrives (`boat stop` / `boat resume`, or the API). A stopped sandbox costs nothing and keeps its disk.
## Performance
We ran the [hpc-sandbox-benchmarks](https://github.com/AnicetNgrt/hpc-sandbox-benchmarks) suite on the 4 vCPU / 8 GB machine of every provider (our `default`). The headline job is a Node.js build & test loop: bundle, lint, test, repeat. Full results: [2026-08-24 leaderboard](https://github.com/AnicetNgrt/hpc-sandbox-benchmarks/blob/provider/ascii-box/docs/results/2026-08-24-cpu/leaderboard.md).
| 4 vCPU / 8 GB | Runs per second | Seconds per 1,000 runs | \$/hour | \$ per million runs |
| - | - | - | - | - |
| **boat** | **27.7** | **36** s | **\$0.036** | **\$0.36** |
| Daytona | 18.6 | 54 s (1.5x slower) | \$0.331 | \$4.95 (14x) |
| Vercel Sandbox | 13.0 | 77 s (2.1x slower) | \$0.682 | \$14.61 (40x) |
| E2B | 11.2 | 89 s (2.5x slower) | \$0.331 | \$8.19 (23x) |
| Freestyle | 9.6 | 104 s (2.9x slower) | \$0.264 | \$7.62 (21x) |
| Modal † | 9.6 | 105 s (2.9x slower) | \$0.760 | \$22.07 (61x) |
That boat row is our standard machine, where sandboxes normally run. When standard capacity is temporarily exhausted, a sandbox falls back to an older Hetzner cloud VM at the same price; that fallback did 8.9 runs per second in the same run (113 s per 1,000, \$1.13 per million).
† Modal: default runtime, cpu=4 in Modal units (the guest sees 4 CPUs; billed as 4 Modal cores) + 8 GiB. Its beta VM runtime did 15.1 runs per second. Priced as Modal bills that machine.
Measured on 2026-09-29: Vercel Sandbox · 2026-08-24: boat, Freestyle · 2026-07-23: Daytona, Modal, E2B. Rows from different runs are indicative, not a like-for-like race.
The boat row is our standard machine (AMD Ryzen 9 9950X hosts, internally called "baremetal"; each sandbox is still a full VM), measured with the same suite on 2026-08-24. Values are medians over several machines per provider, with 95% intervals within ±20% of them.
## Worked examples
| You run | Per month |
| - | - |
| One `default` sandbox, 8 hours a day, 22 days | 176 h × \$0.036 = **\$6.34**, covered by the \$20 plan |
| One `default` sandbox 24/7 | 730 h × \$0.036 = **\$26**: the \$20 plan plus one \$20 pack |
| 50 `default` sandboxes, 4 hours a day, 22 days | 4,400 h × \$0.036 = **\$158**: the \$100 plan (300 at once) plus three packs |
| 200 `small` sandboxes, 1 hour each, once | 200 h × \$0.018 = **\$3.60**, covered by any plan |
## For the API
`GET /limits` reports balances as **seconds of `default` time** (100,000 per dollar). A `small` sandbox draws 0.5 of those per second it runs, a `large` 2, an `xlarge` 5.56; `creditBalanceHours` and `packBalanceDollars` restate the same balance in hours and dollars. `boat usage ` and `GET /sandboxes/{id}/usage` give one sandbox's bill, with the size already applied. See [Billing details](/billing) for what happens when you run out, and [Organizations & teams](/organizations) for team plans and caps.
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.