# E2B vs Morph: pricing, isolation and limits

E2B bills vCPUs and memory separately; Morph bills a machine in MCUs, $0.05 each an hour. The same job costs $2.76 on E2B, $1.67 on Morph.

**Runtime runs the same job for 77% less than E2B and 62% less than Morph.**
1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost $2.76 on E2B, $1.67 on
Morph and $0.64 on Runtime. Runtime bills the CPU your code uses rather than
the machine it holds, and needs no monthly plan. Rates checked
23 September 2026.

## At a glance

|                    | E2B                                         | Morph Cloud                                                 | Runtime                                                    |
| ------------------ | ------------------------------------------- | ----------------------------------------------------------- | ---------------------------------------------------------- |
| Isolation          | Firecracker microVM, own kernel             | Full virtual machines                                       | Firecracker microVM, own kernel                            |
| Price              | $0.0504 per vCPU-hour, $0.0162 per GiB-hour | $0.05 per MCU-hour: 1 vCPU, 4 GB of memory or 16 GB of disk | $0.025 per vCPU-hour of measured CPU, $0.0075 per GiB-hour |
| How size is billed | vCPUs plus memory                           | Whichever of CPU, memory or disk needs the most MCUs        | Measured CPU plus reserved memory                          |
| Largest machine    | 8 vCPUs and 8 GiB                           | 64 vCPUs and 256 GB on Developer; 256 vCPUs on Team         | vCPUs and memory chosen per sandbox                        |
| Plan fee           | Hobby $0; Pro $150 a month                  | Free with no credit; Developer $40 and Team $250 a month    | None; prepaid credit from $10                              |
| Free start         | $100 of usage credit, once                  | 1,000 MCUs with the $40 Developer plan                      | 50 sandbox hours, no card                                  |
| At once            | 20 on Hobby, 100 on Pro                     | 8 devboxes on Developer, 32 on Team                         | 8 on the trial, 100 paid to start, raised on request       |
| Branching          | Pause keeps files, memory and processes     | Infinibranch: a running machine to hundreds of replicas     | Forks: 1 to 10 running copies with memory and processes    |

## Is Morph cheaper than E2B?

For a 2 vCPU, 4 GB machine, yes. One MCU covers 1 vCPU, 4 GB of memory or
16 GB of disk, and a machine pays for whichever resource needs the most MCUs.
2 vCPUs need 2 MCUs and 4 GB needs 1, so the machine is 2 MCUs: $0.10 an hour.
E2B charges $0.1008 for the two vCPUs and $0.0648 for the memory, $0.1656 an
hour.

The MCU rule favours shapes with about 4 GB per vCPU. A 2 vCPU machine with
8 GB is still 2 MCUs on Morph, $0.10 an hour, while E2B adds $0.0648 an hour
for the extra memory. A machine with more CPU than memory pays for each vCPU
on both.

Morph's plans also count. Its free tier includes no MCUs; the $40 Developer
plan includes 1,000 and runs 8 devboxes at once. E2B's free Hobby plan runs 20 and comes with $100 of
credit.

Runtime charges for neither the machine nor its allocation: it measures the
CPU a run uses, so an agent waiting on a model pays a floor of a twentieth of
a vCPU while it waits.

## Cost for the same job

1,000 runs of a 2 vCPU, 4 GiB sandbox (2 MCUs on Morph). 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

Morph    Size   1,000 × 60 s / 3,600 × 2 MCU × $0.05 = $1.67

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, $166.67 on Morph 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.67 on Morph, so Runtime is cheaper however busy
the sandbox is. Plan fees, included credit, storage, network and taxes are
left out.

## Can I branch a running sandbox?

On Morph, yes: Infinibranch copies a running machine, memory included, to
hundreds of parallel replicas. E2B pauses and resumes a sandbox with its
memory and processes, and keeps a paused one with no expiry.

Runtime forks a running sandbox into 1 to 10 copies, each with the source's
files, memory and running processes, and keeps a snapshot to start more later:

```python check
from withruntime import Runtime

runtime = Runtime()
image = runtime.images.build(name="data", recipe={"pip": ["pandas"], "apt": ["jq"]},
                             on_log=lambda line: print(line["text"]))
with runtime.sandboxes.create(image=image["id"]) as base:
    forks = base.fork(count=2, funding="trial")  # copies as it is now, running
    for fork in forks:
        fork.stop()
    snapshot = base.snapshot(name="with-pandas", retention_days=7)
    with runtime.sandboxes.create(snapshot=snapshot["id"]):
        pass
    runtime.snapshots.delete(snapshot["id"])
```

## Which one to pick

- **Pick E2B** for vCPUs and memory set separately, a free plan with $100 of
  credit and 20 sandboxes at once, or a runtime you can self-host under
  Apache-2.0.
- **Pick Morph** for machines up to 256 vCPUs, branching a running machine to
  hundreds of replicas, or shareable Devboxes that scale to zero and keep
  their memory.
- **Pick Runtime** for under a quarter of E2B's price and well under half of
  Morph's on an agent that waits, with no monthly plan, 100 sandboxes at once
  on a paid account, and forks that keep memory.

## 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 Morph, a started instance becomes `Sandbox.create()`, commands run with
`exec`, and stopping becomes `stop()`. A snapshot you start instances from
becomes a Runtime snapshot, and a branch becomes `fork`:

```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. The full side-by-sides are
[Runtime vs E2B](/docs/e2b-alternative) and
[Runtime vs Morph](/docs/morph-alternative). For evals that fan out from one
prepared machine, see [agent evals and SWE-bench](/use-cases/agent-evals-and-swe-bench).

## Sources

E2B and Morph pricing pages 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)
- [Morph Cloud pricing](https://cloud.morph.so/web/pricing), [Morph Devboxes](https://cloud.morph.so/web/product/devboxes), [Morph snapshots](https://cloud.morph.so/docs/documentation/instances/creating-snapshot)
- Runtime [pricing](/docs/pricing) and [Python guide](/docs/python#images-volumes-and-snapshots)

Facts on this page were checked on 25 September 2026.