# Blaxel vs Northflank: pricing, isolation and limits

Northflank bills allocated CPU and memory at low hourly rates; Blaxel bills memory only while active. The same job is $1.11 against $2.76.

**Runtime runs the same job for 77% less than Blaxel and 42% less than
Northflank.** 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost $2.76 on
Blaxel, $1.11 on Northflank and $0.64 on Runtime, because Runtime bills the CPU
your code uses rather than the CPUs it holds. Rates checked 23 September 2026.

## At a glance

|                       | Blaxel                                      | Northflank                                              | Runtime                                                  |
| --------------------- | ------------------------------------------- | ------------------------------------------------------- | -------------------------------------------------------- |
| Isolation             | Lightweight virtual machines                | Kata Containers and gVisor                              | Firecracker microVM, own kernel, every sandbox           |
| CPU                   | Included with memory: 8 GB gets 4 cores     | $0.01667 per allocated vCPU-hour                        | $0.025 per vCPU-hour of measured CPU, with a small floor |
| Memory                | $0.0000115 per GB-second of active time     | $0.00833 per GB-hour                                    | $0.0075 per reserved GiB-hour                            |
| 2 vCPU, 4 GB, an hour | $0.1656 while active                        | $0.0667 while running                                   | $0.03125 waiting, $0.08 fully busy                       |
| Idle                  | Standby after about 15 s; no compute charge | Runs until you stop it; no forced time limit            | Pause keeps files, memory and processes, 1 to 365 days   |
| What you create       | A sandbox                                   | A service with a deployment plan                        | A sandbox, in one call                                   |
| Plan fee              | None; tiers grow with credit added          | None published for compute                              | None; prepaid credit from $10                            |
| Free start            | Up to $200 of credit                        | 2 free services and 1 free database                     | 50 sandbox hours, no card                                |
| Where it runs         | Blaxel's own regions                        | Northflank's regions, or your AWS, GCP or Azure account | Dedicated servers Runtime operates                       |

## Standby or always on: which is cheaper?

It depends on how much of the day the sandbox works. A 2 vCPU, 4 GB service on
Northflank costs $0.0667 an hour, billed for every hour it runs. Northflank
presents running for weeks as a feature ("no forced time limits"); its free
Developer Sandbox is "always-on compute, no sleeping".

Blaxel charges $0.1656 an hour for 4 GB while the sandbox is active, about two
and a half times as much, but nothing for compute once it is on standby, which
starts about 15 seconds after the last connection closes. Standby costs
snapshot storage, $0.20 per GB-month. On compute alone, Blaxel is the cheaper
of the two when a sandbox is active for less than about 40% of the hours
Northflank would keep it running.

Runtime does both. A waiting sandbox is billed only the CPU floor, a twentieth
of a vCPU, so 2 vCPU and 4 GiB costs $0.03125 an hour while it waits on a
model, under half of Northflank's figure. Set `idlePauseSeconds` and it pauses
itself, keeping memory and processes for $0.08 per GB-month, and the next
request wakes it.

## Cost for the same job

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

```
Blaxel      Memory 1,000 × 60 s × 4 × $0.0000115       = $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 Blaxel, $111.10 on Northflank and
$63.89 on Runtime. With both CPUs busy for the whole minute, it is $1.11 on
Northflank, below $1.33 on Runtime, and $2.76 on Blaxel. Northflank's allocated
rate wins when every CPU works all the time. The Blaxel figure assumes standby
the moment each run ends. Storage, network, taxes and free allowances are left
out.

## How do they isolate code?

Northflank states that its sandboxes use Kata Containers and gVisor for
VM-level isolation. Blaxel describes its sandboxes as lightweight virtual
machines and does not name the hypervisor. Runtime gives every sandbox a
Firecracker microVM with its own Linux kernel. See
[Kata Containers vs Firecracker](/compare/kata-containers-vs-firecracker) and
[Firecracker vs gVisor](/compare/firecracker-vs-gvisor) for how those
boundaries differ.

## Which one to pick

- **Pick Blaxel** if your sandboxes are idle most of the time and must come
  back fast: Blaxel states a resume in under 25 ms, and its top tier runs over
  100,000 sandboxes at once.
- **Pick Northflank** for sandboxes that run for days with every CPU busy, for
  GPUs (L4, A100 and H100 by the hour), or to run in your own AWS, GCP or Azure
  account.
- **Pick Runtime** for agents that wait on a model: measured CPU makes the
  typical run 42% cheaper than Northflank and 77% cheaper than Blaxel, and a
  sandbox is one call, with pause and [forks](/glossary/sandbox-fork) that keep
  memory.

## Switch from either one

Neither has a drop-in import on Runtime; the calls map directly
([map the calls](/docs/migrate#map-the-calls)). Blaxel's
`SandboxInstance.create()` becomes `Sandbox.create()` and its `delete()`
becomes `stop()`. A Northflank sandbox service with its deployment plan
becomes one create call with the size you want:

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

const box = await Sandbox.create({ funding: "trial" });
try {
  await box.files.write("/workspace/task.py", "print(6 * 7)\n");
  console.log((await box.exec("python3 /workspace/task.py", { check: true })).stdout);
} finally {
  await box.stop();
}
```

```python
from withruntime import Sandbox

with Sandbox.create(funding="trial") as box:
    box.files.write("/workspace/task.py", "print(6 * 7)\n")
    print(box.exec("python3 /workspace/task.py", check=True).stdout)
```

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 compare --from northflank` (or
`--from blaxel`) prices what you ran at the old provider's rates. The full
side-by-sides are [Runtime vs Blaxel](/docs/blaxel-alternative) and
[Runtime vs Northflank](/docs/northflank-alternative).

## Sources

Rates checked 23 September 2026. Both pricing pages, Blaxel's sandbox
documentation and Northflank's sandbox page reread 25 September 2026.

- [Blaxel pricing](https://blaxel.ai/pricing), [Blaxel sandboxes](https://docs.blaxel.ai/Sandboxes/Overview)
- [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) and [security](/docs/security)

Facts on this page were checked on 25 September 2026.