# Modal pricing in 2026: the rates, and a cost calculator

Modal bills sandboxes $0.1419 per physical core-hour (two vCPUs) and $0.0240 per GiB-hour, on the higher of what was requested or used.

**Runtime costs 84% less than Modal for an agent that waits on a model.**
100,000 one-minute runs of a 2 vCPU, 4 GiB sandbox, each using 20 CPU-seconds,
cost $63.89 a month on Runtime and $396.60 on Modal, $332.71 less. Runtime needs
no CPU request sized in advance: it bills what your code uses. Rates checked 25
October 2026.

## How Modal bills

Modal publishes per-second rates. A sandbox is billed for whichever is higher,
the CPU and memory it requested or what it used, so a requested core is billed
while it waits. Modal counts CPU in physical cores, and one physical core is
two vCPUs.

| Meter  | Modal, as published                                        | Converted                                                                                |
| ------ | ---------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
| CPU    | $0.00003942 per physical core-second | × 3,600 = $0.1419 per core-hour, $0.0710 per vCPU-hour |
| Memory | $0.00000667 per GiB-second            | × 3,600 = $0.0240 per GiB-hour                                         |

For 2 vCPUs (one core) and 4 GiB that is $0.1419 + $0.0960 = $0.2380 an hour,
busy or not. Runtime charges $0.025 per vCPU-hour of measured CPU, floor a twentieth of a vCPU, and $0.0075 per reserved GiB-hour: $0.03125 an hour
waiting and $0.08 an hour fully busy.

## Example workloads

A month of each, CPU and memory only, from the calculator above.

| Workload                                                         |                              Runtime |                              Modal |
| ---------------------------------------------------------------- | -----------------------------------: | ---------------------------------: |
| Agent runs: 2 vCPU, 4 GiB, 60 s, 20 CPU-seconds, 100,000 a month |              $63.89 |    $396.60 |
| Every CPU busy: 2 vCPU, 4 GiB, 60 s, 120 CPU-seconds, 100,000    |   $133.33 |   $396.60 |
| Chat code sessions: 2 vCPU, 4 GiB, 5 min, 30 CPU-seconds, 20,000 |    $54.17 |    $396.60 |
| Data analysis: 4 vCPU, 16 GiB, 60 min, 2,880 CPU-seconds, 2,000  | $280.00 | $1,336.03 |

The chat-session row shows the difference most clearly. Five-minute sessions
that use 30 CPU-seconds each cost Modal the same as one-minute runs, because it
bills the request for the whole session. On Runtime they cost $54.17, 86% less.
With every CPU busy, Runtime still saves 66%.

A smaller CPU request lowers Modal's figure, but it also caps what the sandbox
can use when it needs more. Runtime has no request to trade off: a sandbox can
use every vCPU it has and pays only for what it used.

Modal sandboxes run for up to 24 hours, with snapshots to carry state
beyond that. A Runtime sandbox has no time limit. It runs while it works, so a
long session is priced the same way as a short one: by
the CPU it used and the memory it reserved.

## What the calculator leaves out

- **Plan fees.** Modal's Starter plan is $0 and includes $30 of compute a
  month. The Team plan is $250 a month. Runtime has no plan, only prepaid
  credit from $10.
- **Free credit.** The calculator does not subtract Modal's $30 a month of
  Starter compute. It prices list rates. Runtime includes 100 free hours of a 1 GB machine
  on the [free trial](/docs/included-usage), no card.
- **Storage and network.** Left out on both sides. A paused Runtime sandbox
  keeps its files, memory and running processes for $0.08 per GB a month.

## Price your own runs exactly

The CLI prices the sandboxes you have run on Runtime at Modal's published
rates, using the same vCPUs, memory and running time:

```bash check
runtime compare --from modal
```

It reads the last 30 days of settled sandboxes (`--days` up to 90) and says
what you save a month. Credit you add within 30 days of signing up is matched, up to $1,000 in total ([welcome match](/docs/pricing#welcome-match)).

The rest of the comparison, isolation included (Modal uses gVisor; Runtime a
microVM with its own kernel), is in [Runtime vs
Modal](/docs/modal-sandbox-alternative). [Modal
alternatives](/compare/modal-alternatives), [E2B vs
Modal](/compare/e2b-vs-modal) and [Modal vs Vercel
Sandbox](/compare/modal-vs-vercel-sandbox) compare it with the others.

## Sources

- [Modal pricing](https://modal.com/pricing), checked 25 October 2026
- [Modal resources and billing](https://modal.com/docs/guide/resources)
- Runtime [pricing](/docs/pricing)

Rival rates on this page were checked on 25 October 2026.