> ## Documentation Index
> Fetch the complete documentation index at: /docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Regions and limits

> Where sandboxes run, and each plan's limits.

## Region

Sandboxes run in a single region today. The API, the dashboard and live view are served from the same region. **Coming soon:** more regions.

## Plan limits

| Limit | Free | Starter | Pro | Scale |
| - | - | - | - | - |
| Sandboxes at once (running only) | 5 | 20 | 100 | 500 |
| vCPU at once (running only) | 5 | 40 | 400 | 2,000 |
| Largest [sandbox size](/docs/concepts/sizes.md) | Medium, and at most 2 Medium sandboxes at once | Medium | Large | XL |
| Size when you name none | The smallest the template allows (Small for `base`) | The template's own size | The template's own size | The template's own size |
| Sandbox creates per minute | 10 | 30 | 60 | 120 |
| API requests per minute | 100 | 200 | 300 | 600 |
| API keys (active) | 2 | 5 | 20 | 50 |
| Custom templates | 2 | 10 | 25 | 100 |
| Template storage | 10 GiB | 50 GiB | 150 GiB | 500 GiB |
| Largest template image | 10 GiB | 10 GiB | 10 GiB | 10 GiB |
| Paused sandboxes | 5, deleted 14 days after pausing (we email you first) | 50 | 200 | 800 |
| Public internet egress | Off | On | On | On |
| Egress included a month | 5 GB | 25 GB | 100 GB | 250 GB |
| vCPU-hours included a month (each with 2 GiB of memory per vCPU) | 100 | 330 | 1,800 | 7,500 |
| Vault secrets | Unlimited | Unlimited | Unlimited | Unlimited |

Prices are on [Pricing](/docs/pricing.md).

* **At once means running.** Sandboxes that are being created or are running count towards "sandboxes at once" and "vCPU at once"; paused sandboxes never do.
* **A sandbox created without a size** runs, on Free, at the smallest size its template allows: Small (1 vCPU, 2 GiB) for `base`, `python`, `node`, `code-interpreter` and templates you built at Small or less, so five run at once; Medium for `desktop` and `agent-desktop`, which count towards the two Medium. On paid plans it runs at the template's own size and counts at that size. See [Sandbox sizes](/docs/concepts/sizes.md).
* **The largest size applies to every create.** A size above it is refused, and so is a sandbox created without a size from a template registered above it. A sandbox you already have keeps its size if your plan changes.
* **API requests** counts requests made with an API key. The dashboard's own requests do not count.
* **Template storage** is the sum of the image size of each template's current build. The build before it is kept so a rebuild can be rolled back, but it is not counted. One template image is at most the largest template image size. See [Templates](/docs/concepts/templates.md#build-your-own).
* **Paused sandboxes on Free** are deleted 14 days after they were paused. We email the team's owners and admins three days before. Resuming the sandbox starts the 14 days again the next time it is paused.
* **Included vCPU-hours and egress** are per calendar month (UTC) and reset on the first. Each included vCPU-hour includes 2 GiB-hours of memory. Free stops when either runs out: new sandboxes and resumes are refused, and running sandboxes are paused (or deleted, end reason `included_usage`, when your paused sandboxes are already at the limit) until the month ends. Paid plans keep running and are billed for what is over. A credit balance you already have pays for what is over first, on any plan; Free stops only once it is spent. Owners and admins are emailed at 80% and 100% of each. Usage is counted hourly, so a team can run past the line by up to about an hour before it applies. See [Pricing](/docs/pricing.md).
* **Public internet egress** is on by default on paid plans. On Free it is off for now (see the table): the 5 GB a month needs a cap that acts in real time, and usage is counted hourly. **Coming soon:** Free egress on, capped at 5 GB.
* **Vault secrets** have no limit on any plan.

## When you reach a limit

Nothing you already have is stopped or deleted because you reached a limit, or because you moved to a plan with lower limits. New sandboxes, resumes, pauses, API keys and templates are refused until you are back under it. The one exception is Free's included usage for the month: when it runs out, running sandboxes are paused too.

Every refusal names the limit and your plan. A refusal at a plan limit has `error_code` `plan_limit_exceeded` and four more fields:

```json
{ "code": 429, "message": "concurrent sandbox limit reached (5): the Free plan runs at most 5 sandboxes at once - pause or delete one, or upgrade the plan", "error_code": "plan_limit_exceeded", "limit_name": "concurrent_sandboxes", "limit": 5, "current": 5, "plan": "free", "requestId": "3f2c9a0e7b1d4c55a8e6f0b2d4c6e8a1" }
```

| Situation | Response |
| - | - |
| Sandboxes at once, vCPU at once, or the number of sandboxes at the largest size, on a create, a fork or a resume | `429` `plan_limit_exceeded`, `limit_name` `concurrent_sandboxes`, `concurrent_vcpu` or `concurrent_at_max_size`. Pause or delete a sandbox, then retry |
| A size above your plan's largest | `403` `plan_limit_exceeded`, `limit_name` `max_size`; `limit` and `current` are vCPU |
| Pausing a sandbox yourself at the paused limit | `403` `plan_limit_exceeded`, `limit_name` `paused_sandboxes` |
| Idle pause, or a pause on timeout, at the paused limit | The sandbox is deleted instead of paused, and its end reason is `paused_limit` |
| An API key beyond the limit | `403` `plan_limit_exceeded`, `limit_name` `api_keys`. Revoke a key to make room |
| A new template beyond the template count, or when template storage is full | `403` `plan_limit_exceeded`, `limit_name` `templates` or `template_storage` (`limit` and `current` in bytes). Rebuilding a template you have is not a new template |
| A build whose image would take template storage past the limit, or an image larger than the largest template image | The build fails with a message giving the sizes |
| Requests or creates per minute | `429` `rate_limited` with `Retry-After`, `limit_name` `api_requests_per_minute` or `creates_per_minute`, `limit` and `plan` |
| A Free paused sandbox 14 days after pausing | Deleted, end reason `paused_retention` |
| Free, once the month's included vCPU-hours or egress are used up (and any credit is spent) | Creates, forks and resumes: `403` `plan_limit_exceeded`, `limit_name` `included_vcpu_hours` or `included_egress_gb`. Running sandboxes are paused |

## Other limits

These apply as well and are not part of the plan table:

| Limit | Free | Starter | Pro | Scale |
| - | - | - | - | - |
| Longest timeout | No maximum | No maximum | No maximum | No maximum |
| Template builds in progress at once | 2 | 2 | 2 | 2 |

Every plan allows `timeout=-1`, which means no deadline; see [Lifecycle](/docs/concepts/lifecycle.md#no-time-limit). Free running time still counts against the month's included vCPU-hours. Across every plan, a team is also limited to about 50 requests a second (bursts of 200) and 120 creates a minute; above that the answer is `429` `rate_limited` with `Retry-After`. Builds in progress count queued builds too: the shared builder runs one build at a time today, so a second build waits in the queue (its log says so) until the first finishes.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.