# Vercel Sandbox vs Fly Machines: pricing, isolation and limits

Both are Firecracker microVMs. Vercel Sandbox bills active CPU plus memory; a Fly Machine bills its whole size by the hour while started.

**A Fly Machine undercuts Vercel on this job, and Runtime undercuts both: by
55% against the Machine and 70% against Vercel.** 1,000 one-minute runs of a
2 vCPU, 4 GiB sandbox cost $2.12 on Vercel, $1.44 on a Fly Machine and $0.64
on Runtime. Runtime meters CPU as Vercel does, but its CPU rate is about a
fifth of Vercel's and its memory rate less than half. Rates checked
23 September 2026.

## At a glance

Both rivals are priced in Ashburn: Vercel's default `iad1` region and Fly's
`iad`.

|              | Vercel Sandbox                                       | Fly Machines                                                       | Runtime                                                  |
| ------------ | ---------------------------------------------------- | ------------------------------------------------------------------ | -------------------------------------------------------- |
| Isolation    | Firecracker microVM, own kernel                      | Firecracker microVM                                                | Firecracker microVM, own kernel                          |
| What it is   | A sandbox API for untrusted code                     | General-purpose VMs, run through the Machines API and `flyctl`     | A sandbox API for agent code                             |
| CPU          | $0.128 per active CPU-hour                           | By size while started: `performance-2x` with 4 GB, $0.0861 an hour | $0.025 per vCPU-hour of measured CPU, with a small floor |
| Memory       | $0.0212 per provisioned GB-hour                      | Included in the size; more at $5 per GB a month                    | $0.0075 per reserved GiB-hour                            |
| Largest size | 8 vCPUs and 16 GB on Pro; 32 and 64 GB on Enterprise | 16 performance vCPUs and 128 GB                                    | vCPUs and memory chosen per sandbox                      |
| Plan fee     | Hobby allowance free; usage beyond it needs Pro      | None; pay as you go                                                | None; prepaid credit from $10                            |
| When idle    | Stop keeps the filesystem; processes start again     | Root disk is temporary; volumes keep files, suspend keeps memory   | Pause keeps files, memory and processes, 1 to 365 days   |
| Regions      | 19                                                   | 18                                                                 | One US region                                            |

## Is a Fly Machine cheaper than Vercel Sandbox?

At this size, yes, for almost any job. A `performance-2x` Machine costs
$0.0861 an hour however busy it is. Vercel's memory alone, 4 GB at $0.0212 a
GB-hour, is $0.0848 an hour, so by the time a Vercel sandbox has paid for its
memory it has nearly paid for the whole Machine. Vercel costs more as soon as a
one-minute run uses a single CPU-second, and with both CPUs busy it costs
almost four times as much.

A Machine's `performance` vCPUs are whole cores kept for it. A `shared-cpu-2x`
Machine with 4 GB costs about $0.50 for the same 1,000 runs, but its shared
vCPUs are guaranteed 6.25% of a core each, with a small burst allowance, so a
new one would not fit 20 CPU-seconds into the minute.

What the Machine does not give you is a sandbox API. You create and destroy
Machines yourself through the Machines API, and add a volume if files must
outlive the Machine's temporary root disk. Runtime and Vercel create a sandbox
in one call. Runtime's default CPU is shared and billed as measured;
`cpu: "reserved"` keeps every vCPU for the sandbox, as a performance Machine
does.

```ts
import { Runtime } from "withruntime";

const runtime = new Runtime();
const box = await runtime.sandboxes.create({
  funding: "trial",
  vcpu: 2,
  memoryMiB: 4096,
  timeoutSeconds: 120,
  onLeaseEnd: "stop", // gone when the job ends, like a destroyed Machine
});
try {
  console.log((await box.exec(["python3", "-c", "print(6 * 7)"], { check: true })).stdout);
} finally {
  await box.stop();
}
```

## Cost for the same job

The job behind the headline: 1,000 runs, 60 seconds each, 20 CPU-seconds of
work, on 2 vCPU with 4 GiB (4 GB on Vercel), against a `performance-2x`
Machine with 4 GB.

```
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

Machines  Size   1,000 × 60 s / 3,600 × $0.0861     = $1.44

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
```

For a month of 100,000 runs, the totals are $212.44 on Vercel, $143.50 on
Machines and $63.89 on Runtime. With both CPUs busy for the whole minute, it is
$1.33 on Runtime, $5.68 on Vercel and $1.44 on Machines. The Machine is priced
as destroyed at the end of each run. Plan fees, creation charges, storage,
network and free allowances do not appear in the totals.

## Which one to pick

- **Vercel Sandbox**, when the application already lives on Vercel and the
  sandboxes should share its account; Pro allows up to 10,000 at once.
- **Fly Machines**, when you want general-purpose VMs and are happy to manage
  them, need sizes up to 128 GB, or want volumes and Managed Postgres next to
  them.
- **Runtime**, when you want a sandbox API rather than raw VMs, priced 55%
  under a Machine and 70% under Vercel, with pause and
  [forks](/glossary/sandbox-fork) that carry memory and running processes.

## Moving to Runtime

Vercel Sandbox code keeps its shape with a new import, and no longer needs a
Vercel project or token:

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

```python no-run
from withruntime.vercel import sandbox  # was: from vercel import sandbox
```

On Fly, the usual pattern is one Machine created per job through the
Machines API. Swap each of those for a Runtime sandbox created for the job
and stopped at the end, as the sample above does; commands, files and
teardown follow [map the calls](/docs/migrate#map-the-calls).

`npx withruntime switch --from vercel` or `--from fly` before the first
top-up gets it matched with up to $100 of credit. A coding agent can run the
whole port from the single instruction in [migration](/docs/migrate), on a
branch and on the free trial. Detail:
[Runtime vs Vercel Sandbox](/docs/vercel-sandbox-alternative),
[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/), [Machine CPU performance](https://fly.io/docs/machines/cpu-performance/), [Machine suspend and resume](https://fly.io/docs/reference/suspend-resume/), [Fly Volumes](https://fly.io/docs/volumes/overview/), [Fly.io regions](https://fly.io/docs/reference/regions/)
- Runtime [pricing](/docs/pricing)

Facts on this page were checked on 25 September 2026.