# Vercel Sandbox vs Fly Sprites: pricing, memory and idle time

Both bill measured CPU in Firecracker microVMs. Vercel bills provisioned memory; Sprites bill memory in use and pause themselves when idle.

**Runtime runs the same job for 70% less than Vercel and 81% less than
Sprites.** 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost $2.12 on
Vercel, $3.31 on Sprites and $0.64 on Runtime. All three bill CPU as it is
used; Runtime's memory rate, $0.0075 per GiB-hour, is about a third of
Vercel's and a sixth of Sprites'. Rates checked 23 September 2026.

## At a glance

Vercel's figures are at the rates of its default `iad1` region.

|              | Vercel Sandbox                                                         | Fly Sprites                                               | Runtime                                                       |
| ------------ | ---------------------------------------------------------------------- | --------------------------------------------------------- | ------------------------------------------------------------- |
| Isolation    | Firecracker microVM, own kernel                                        | Firecracker microVM                                       | Firecracker microVM, own kernel                               |
| CPU          | $0.128 per active CPU-hour                                             | $0.07 per CPU-hour of measured CPU                        | $0.025 per vCPU-hour of measured CPU, with a small floor      |
| Memory       | $0.0212 per provisioned GB-hour; 2 GB per vCPU                         | $0.04375 per GB-hour of memory in use                     | $0.0075 per reserved GiB-hour                                 |
| Size         | Up to 8 vCPUs and 16 GB on Pro                                         | Memory managed by Fly, 100 GB disk                        | vCPUs and memory chosen per sandbox                           |
| Plan fee     | Hobby allowance free; usage beyond it needs Pro                        | None required; optional monthly plans                     | None; prepaid credit from $10                                 |
| Free start   | 5 active CPU-hours and 420 GB-hours a month on Hobby                   | $30 of trial credit                                       | 50 sandbox hours, no card                                     |
| When idle    | Runs until its timeout or `stop()`; stop keeps the filesystem          | Pauses itself; memory kept at first, the disk kept always | Pauses after the idle time you set, memory and processes kept |
| Stored state | Snapshots $0.08 per GB-month, expire 30 days after last use by default | Sleeping disk $0.02 per GB-month                          | Paused storage $0.08 per GB-month, kept 1 to 365 days         |
| Interfaces   | JavaScript and Python SDKs                                             | API, CLI, MCP server; JavaScript, Python, Go, Elixir SDKs | API, CLI, MCP server, JavaScript and Python SDKs              |

## Which is cheaper, Vercel Sandbox or Sprites?

Vercel, for an agent that mostly waits, because memory is most of the bill.
Sprites charge $0.04375 per GB-hour of memory in use, about twice Vercel's
$0.0212 per provisioned GB-hour, so a waiting 4 GB sandbox costs about $0.175
an hour on Sprites and $0.085 on Vercel. Sprites' CPU is cheaper, $0.07 an hour
against $0.128, so the gap closes as the code gets busier. The order flips
when a one-minute run uses about 93 CPU-seconds of its 120.

Two things move the Sprite figure down. It bills the memory it actually uses,
so a job that uses 1 GB for the minute pays $1.12 for these runs instead of
$3.31. And it pauses by itself, so a Sprite you forget costs little. It also
stays awake for about 30 seconds after its last activity unless you delete it.

## What happens between tasks?

This decides the cost of an agent that works in bursts. A Sprite pauses itself
when idle and keeps its disk; its memory is kept at first, then dropped when it
goes cold, at a time you do not choose. A Vercel sandbox runs until its timeout
or a `stop()`, which keeps its filesystem; processes start again next session.

A Runtime sandbox pauses after the idle time you set, keeps its memory and
running processes for the retention you choose, and wakes on the next request:

```python check
from withruntime import Sandbox

dev = Sandbox.get_or_create("agent-dev", idle_pause_seconds=300)
dev.exec("git --version", check=True)
# Five quiet minutes later it pauses; the next call wakes it where it stopped.
print(Sandbox.get_or_create("agent-dev").exec("uptime").stdout)
```

See [how to pause and resume a sandbox](/how-to/pause-and-resume-a-sandbox).

## Cost for the same job

1,000 runs of a 2 vCPU sandbox with 4 GiB, or 4 GB on Vercel. The Sprite is
assumed to use all 4 GB for the whole minute. Each run lasts 60 seconds and
keeps the CPU busy for 20 CPU-seconds: an agent that mostly waits for a model.

```
Vercel   CPU    1,000 × 20 s / 3,600 × $0.128       = $0.71
         Memory 1,000 × 60 s / 3,600 × 4 × $0.0212  = $1.41
         Total                                         $2.12

Sprites  CPU    1,000 × 20 s / 3,600 × $0.07        = $0.39
         Memory 1,000 × 60 s / 3,600 × 4 × $0.04375 = $2.92
         Total                                         $3.31

Runtime  CPU    1,000 × 20 s / 3,600 × $0.025       = $0.14
         Memory 1,000 × 60 s / 3,600 × 4 × $0.0075  = $0.50
         Total                                         $0.64
```

At 100,000 runs a month that is $212.44 on Vercel, $330.56 on Sprites and
$63.89 on Runtime. With both CPUs busy for the whole minute, it is $1.33 on
Runtime against $5.68 on Vercel and $5.25 on Sprites, so Runtime is cheaper
however busy the sandbox is. Plan fees, creations, storage, network and free
allowances are left out.

## Which one to pick

- **Pick Vercel Sandbox** if your app is on Vercel, or you need sandboxes in a
  region you choose, from 19, with up to 10,000 at once on Pro.
- **Pick Sprites** for long-lived agent computers that sleep cheaply: a
  sleeping Sprite's disk costs $0.02 per GB-month, with SDKs for Go and Elixir
  as well as JavaScript and Python.
- **Pick Runtime** for measured CPU at about a fifth of Vercel's rate and a
  third of Sprites', memory sized to the job, and a pause that keeps memory for
  as long as you choose.

## Switch from either one

From Vercel Sandbox, change the import and keep the code, with no Vercel
project or token:

```ts no-run
import { Sandbox } from "withruntime/vercel"; // was: from "@vercel/sandbox"
```

From Sprites, `client.createSprite(name)` becomes `Sandbox.getOrCreate(name)`
(or `Sandbox.create()` for a one-off), `sprite.execFile(cmd, args)` becomes
`exec([cmd, ...args])`, and `sprite.delete()` becomes `stop()`:

```ts
import { Sandbox } from "withruntime";
const box = await Sandbox.create({ funding: "trial" });
try {
  console.log((await box.exec(["python3", "-c", "print(6 * 7)"], { check: true })).stdout);
} finally {
  await box.stop();
}
```

Or give your coding agent the one instruction in [migration](/docs/migrate): it
switches the project on a branch, tests it on the free trial and reports the
monthly saving. `npx withruntime switch --from vercel` (or `--from fly`) before
your first top-up matches that top-up with credit, up to $100. The full
side-by-sides are [Runtime vs Vercel Sandbox](/docs/vercel-sandbox-alternative)
and [Runtime vs Fly.io](/docs/fly-alternative).

## Sources

Vercel Sandbox pricing rechecked 25 September 2026; the rest checked
23 September 2026.

- [Vercel Sandbox pricing](https://vercel.com/docs/sandbox/pricing), [Understanding Vercel Sandboxes](https://vercel.com/docs/sandbox/concepts)
- [Fly.io pricing](https://fly.io/pricing/), [Sprites](https://fly.io/sprites/), [Sprites documentation](https://docs.sprites.dev/), [Sprites lifecycle and persistence](https://docs.sprites.dev/concepts/lifecycle/)
- Runtime [pricing](/docs/pricing)

Facts on this page were checked on 25 September 2026.