# Sandbox pricing and limits
URL: https://docs.munito.ai/sandboxes/pricing

A sandbox pays for each second, for its CPU and its memory. It pays for the higher of its floor and its real use.

- The ceiling is the vCPUs and the memory that the sandbox sees.
- The floor is the smallest share that the sandbox pays for: a quarter of the ceiling.

## Sizes [#sizes]

| Preset    | Ceiling       | Floor              | Idle, per hour | Busy at the ceiling, per hour |
| --------- | ------------- | ------------------ | -------------- | ----------------------------- |
| `small`   | 1 vCPU, 1 GiB | 0.25 vCPU, 256 MiB | $0.0072        | $0.0288                       |
| `default` | 2 vCPU, 4 GiB | 0.5 vCPU, 1 GiB    | $0.0162        | $0.0648                       |
| `large`   | 4 vCPU, 8 GiB | 1 vCPU, 2 GiB      | $0.0324        | $0.1296                       |

| Resource    | Price                                            |
| ----------- | ------------------------------------------------ |
| CPU         | $0.0252 per vCPU-hour                            |
| Memory      | $0.0036 per GiB-hour                             |
| Saved state | $0.0001 per GiB-hour, about $0.073 per GiB-month |

- A create without `size` gets the `default` size.
- For another size, set `vcpus` and `memory_mib` in place of `size`.
- A preset starts in less than one second. A custom size takes some seconds.
- For a larger root disk, set `disk_gib`, for example `{"size": "large", "disk_gib": 40}`.
- To pay for the ceiling all the time, set `"reserved": true`. The floor is then the ceiling.
- The saved state of a [paused sandbox](https://docs.munito.ai/sandboxes/persistence) pays the storage price. Data that two saved states share, such as a fork and its parent, counts one time.
- The Sandboxes page of the console shows the vCPU-hours, the GiB-hours and the spend of the month.

## Free time and credits [#free-time-and-credits]

- Each organization gets 25 free hours of a `default` sandbox at full use, one time. That is the first $1.62 of sandbox usage, so an idle sandbox runs longer for free.
- The free time needs no credits.
- After the free time, a sandbox needs credits. Buy credits on the Billing page of the [console](https://console.munito.ai/billing).
- A sandbox runs after its request ends. Thus, the API checks the credits before it starts or extends a sandbox.

| Code               | When the API answers 402                                                                    |
| ------------------ | ------------------------------------------------------------------------------------------- |
| `credits_low`      | The credits pay for less than one hour of the largest size, 16 vCPUs and 32 GiB at full use |
| `credits_used_up`  | The credits of your organization are used up                                                |
| `credits_required` | Your organization has no credits                                                            |

- The API answers these codes to a create and to a new timeout, after the free time is used.
- When the free time and the credits are used up, your running sandboxes stop. Their `end_reason` is `credits`.
- With automatic top-up on, the sandboxes continue while the top-up can add credits.

## Limits [#limits]

| Limit               | Value                                                                                                                        |
| ------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| vCPUs               | 1 to 16                                                                                                                      |
| Memory              | 512 to 32,768 MiB, in steps of 256 MiB. At least 512 MiB for each vCPU                                                       |
| Disk                | 10 to 100 GiB, set with `disk_gib`. The default is 10                                                                        |
| Life of a sandbox   | 10 to 86,400 seconds. The default is 3,600, one hour                                                                         |
| Time of a command   | 1 to 1,800 seconds. The default is 60                                                                                        |
| Output of a command | 1 MiB for each stream when you wait for the result. `truncated` is true when the API cuts the output                         |
| File                | 100 MiB                                                                                                                      |
| Environment         | 100 variables. A value is 32 KiB or less                                                                                     |
| Metadata            | 16 keys. A key is 64 characters or less, and a value 512 or less                                                             |
| Running sandboxes   | 100 at once for each organization. Above this limit, a create gets 429 `sandbox_limit_reached`. Talk to an engineer for more |
| Creates             | No limit. API requests from one IP address are limited to 8,000 a minute                                                     |
| Public ports        | 16 for each sandbox                                                                                                          |
| SSH keys            | 16 for each sandbox                                                                                                          |
| Signed URL          | 60 seconds to 7 days. The default is one hour                                                                                |

### Network [#network]

- A sandbox has outbound internet access.
- A sandbox cannot reach your other sandboxes or private addresses. It cannot send mail over SMTP.
- For a sandbox with no network, set `"internet": false`.
- Inbound connections come only through [ports and SSH](https://docs.munito.ai/sandboxes/ports-and-ssh), also with `"internet": false`.

## A weekend of agents [#a-weekend-of-agents]

Agents wait for their models most of the time, so the price of an idle sandbox sets the bill. This table gives the price of 60 sandboxes with 2 vCPUs, 4 GiB and a 10 GiB disk, idle from Friday 18:00 to Monday 09:00 (63 hours). It uses the lowest published usage price of each provider on 2026-10-28, with no plan fee, free tier or credit.

| Provider                                                            | The weekend | Multiple |
| ------------------------------------------------------------------- | ----------- | -------- |
| Munito                                                              | $61         | 1x       |
| [boat](https://docs.boat.dev/pricing)                               | $68         | 1.1x     |
| [Tensorlake](https://www.tensorlake.ai/pricing)                     | $140        | 2.3x     |
| [Cloudflare](https://developers.cloudflare.com/containers/pricing/) | $214        | 3.5x     |
| [Modal](https://modal.com/pricing)                                  | $225        | 3.7x     |
| [Railway](https://railway.com/pricing)                              | $263        | 4.3x     |
| [Vercel](https://vercel.com/docs/vercel-sandbox/pricing)            | $321        | 5.2x     |
| [Freestyle](https://www.freestyle.sh/pricing)                       | $503        | 8.2x     |
| [E2B](https://e2b.dev/pricing)                                      | $626        | 10.2x    |
| [Daytona](https://www.daytona.io/pricing)                           | $630        | 10.3x    |
| [Blaxel](https://blaxel.ai/pricing)                                 | $632        | 10.3x    |
| [Runloop](https://www.runloop.ai/pricing)                           | $1,210      | 19.8x    |

- Munito: an idle sandbox pays its floor, 0.5 vCPU and 1 GiB.
- Tensorlake: the rates of the Pro plan.
- Cloudflare: a container with 2 vCPUs needs 6 GiB of memory or more.
- Modal: the row requests 0.25 core and 1 GiB, the floor of a Munito sandbox.
- Railway: the row prices 1 GiB of memory in use, the memory floor of a Munito sandbox.
- Blaxel: the row prices an active sandbox. A sandbox in standby pays only for its snapshot.
