# E2B vs Northflank: pricing, isolation and limits

Both bill allocated vCPUs and memory, and Northflank's rates are lower on both: the same job costs $1.11 there and $2.76 on E2B.

**Runtime runs the same job for 77% less than E2B and 42% less than
Northflank.** 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost $2.76 on
E2B, $1.11 on Northflank and $0.64 on Runtime, because Runtime bills the CPU an
agent uses while it waits on a model instead of every vCPU it holds. Rates
checked 23 September 2026.

## At a glance

|                | E2B                              | Northflank                                                      | Runtime                                                  |
| -------------- | -------------------------------- | --------------------------------------------------------------- | -------------------------------------------------------- |
| Isolation      | Firecracker microVM, own kernel  | Its own microVM with Kata Containers, or gVisor                 | Firecracker microVM, own kernel                          |
| CPU            | $0.0504 per allocated vCPU-hour  | $0.01667 per allocated vCPU-hour                                | $0.025 per vCPU-hour of measured CPU, with a small floor |
| Memory         | $0.0162 per GiB-hour             | $0.00833 per GB-hour                                            | $0.0075 per reserved GiB-hour                            |
| Plan fee       | Hobby $0; Pro $150 a month       | None published for compute                                      | None; prepaid credit from $10                            |
| Free start     | $100 of usage credit, once       | 2 free services and 1 free database                             | 50 sandbox hours, no card                                |
| Session length | 1 hour on Hobby, 24 hours on Pro | No forced time limit, seconds to weeks                          | Leases of up to an hour, extended as often as needed     |
| Sandbox model  | A sandbox, created in one call   | A service with a deployment plan                                | A sandbox, created in one call                           |
| Where it runs  | E2B's cloud, or self-hosted      | Northflank's regions, or your AWS, GCP, Azure or Oracle account | Runtime's own dedicated servers                          |

## Is Northflank cheaper than E2B?

Yes, on both meters. Northflank's vCPU is $0.01667 an hour against E2B's
$0.0504, and its memory $0.00833 per GB-hour against $0.0162 per GiB-hour. Both
bill what the sandbox holds for as long as it runs, so the ratio holds however
busy the work is: a 2 vCPU, 4 GB sandbox is $0.0667 an hour on Northflank and
$0.1656 on E2B.

What differs is the shape of the product. E2B is a sandbox API: one call
returns a running sandbox, and a session lasts up to 1 hour on Hobby or 24 on
Pro. Northflank is a platform that also runs sandboxes: each one is a service
with a deployment plan, with no forced time limit, and it can run in your own
cloud account and rent GPUs.

## When is Runtime cheaper than Northflank?

When the agent waits. Runtime's measured CPU costs $0.025 a vCPU-hour of CPU
actually used, and Northflank's $0.01667 a vCPU-hour of CPU held. In this
page's job, 1,000 one-minute runs at 2 vCPU and 4 GiB, Runtime costs less as
long as each run keeps the CPUs busy for under 88 CPU-seconds out of the 120
it could use. A typical agent, which spends most of its time waiting on a
model, is far below that line. A sandbox that runs every CPU flat out is above
it.

## Cost for the same job

1,000 runs of a 2 vCPU, 4 GiB sandbox (4 GB on Northflank). Each run lasts 60
seconds and keeps the CPU busy for 20 CPU-seconds: an agent that mostly waits
for a model.

```
E2B         CPU    1,000 × 60 s / 3,600 × 2 × $0.0504  = $1.68
            Memory 1,000 × 60 s / 3,600 × 4 × $0.0162  = $1.08
            Total                                         $2.76

Northflank  CPU    1,000 × 60 s / 3,600 × 2 × $0.01667 = $0.556
            Memory 1,000 × 60 s / 3,600 × 4 × $0.00833 = $0.555
            Total                                         $1.11

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 $276.00 on E2B, $111.10 on Northflank and
$63.89 on Runtime. With both CPUs busy for the whole minute, it is $1.33 on
Runtime against $2.76 on E2B and $1.11 on Northflank, so for work that keeps
every CPU busy all the time Northflank costs less than Runtime. Plan fees,
storage, network and free allowances are left out.

## Which one to pick

- **Pick E2B** for a sandbox API with a code interpreter and paused sandboxes
  kept with no expiry, or a runtime you can self-host under Apache-2.0.
- **Pick Northflank** for sandboxes that keep every CPU busy, GPUs by the
  hour, or sandboxes inside your own AWS, GCP, Azure or Oracle account.
- **Pick Runtime** for agents that wait on a model: 42% less than Northflank
  and 77% less than E2B in the example, a sandbox in one call, pause and forks
  that keep memory and processes, and an agent that connects without an API
  key.

## Switch from either one

From E2B, Runtime's SDK runs your code after one import change:

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

```python no-run
from withruntime.e2b import Sandbox  # was: from e2b import Sandbox
```

From Northflank, there is no service or deployment plan to create. A sandbox
service becomes `Sandbox.create()`, a command becomes `exec`, and deleting the
service becomes `stop()`. A sandbox you want to find again takes a name:

```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();
}
```

```python check
from withruntime import Sandbox

dev = Sandbox.get_or_create("dev", idle_pause_seconds=900)
dev.exec("git pull || true")
```

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. The full side-by-sides are
[Runtime vs E2B](/docs/e2b-alternative) and
[Runtime vs Northflank](/docs/northflank-alternative);
[Kata Containers vs Firecracker](/compare/kata-containers-vs-firecracker)
compares the two microVM designs.

## Sources

E2B pricing and Northflank's sandbox page rechecked 25 September 2026; the
rest checked 23 September 2026.

- [E2B pricing](https://e2b.dev/pricing), [E2B sandbox persistence](https://docs.e2b.dev/sandbox/persistence)
- [Northflank pricing](https://northflank.com/pricing), [Northflank sandboxes](https://northflank.com/product/sandboxes), [Sandboxes on Northflank](https://northflank.com/docs/v1/application/sandboxes/sandboxes-on-northflank)
- Runtime [pricing](/docs/pricing)

Facts on this page were checked on 25 September 2026.