# boxd vs E2B

> E2B runs short-lived sandboxes from an SDK, with a time limit on every run. A boxd machine is a full computer that stays, wakes on a request with your app still running, and comes with coding agents installed.

Checked 2026-10-30. Every E2B claim links to E2B's own docs or pricing. Web page: https://boxd.sh/compare/e2b/

## At a glance

|  | boxd | E2B |
| --- | --- | --- |
| **Where boxd is ahead** |  |  |
| Session limit | None | 1 h Hobby · 24 h Pro |
| Largest, self-serve | 8 vCPU · 32 GiB | 8 vCPU · 8 GiB (more via support) |
| Machines create machines | Yes, signed in as the machine | You pass an API key in |
| Private network between machines | Org network, split by tags | Public URLs only |
| SSH | Native, own port per machine | WebSocket proxy you set up |
| Coding agents installed | Claude Code, Codex, OpenCode | Claude Code and Codex templates |
| **Where E2B is ahead** |  |  |
| Regions | Frankfurt (US waitlist) | US West ×2, EU, Asia-Pacific |
| SOC 2 | SOC 2 in progress | SOC 2 Type II |
| While asleep | Hibernated: disk only | Paused: free |

## Use boxd when

- Your agent or app runs for hours or days
- You want to SSH in and work on the machine
- You need more than 8 GiB of RAM
- You want agents installed and keys kept out

## Use E2B when

- You run thousands of short code executions
- You need US or Asia-Pacific regions today
- You need SOC 2 or a HIPAA BAA now

## Where boxd stands out

### Composable: the sandbox is one part of the kit

E2B gives you templates and an SDK. Schedules, event triggers, integrations and a network between sandboxes are yours to build: sandboxes reach each other only through public URLs, and code inside one needs an API key you pass in. Put together, boxd's parts ran the CI of 10 open-source projects 6× faster than one GitHub-hosted job.

|  | boxd | E2B |
| --- | --- | --- |
| **Composable** |  |  |
| Ready machine described in code | Machine specs, built on one another | Templates in code, extendable |
| Machines create machines | Yes, signed in as the machine | You pass an API key in |
| Built-in integrations | 100+, credentials kept out | MCP gateway; your own keys |
| Schedules and event triggers | Cron and events; sleeps between runs | No; wake on HTTP only |
| Standalone disks | Yes, outlive the machine | Volumes, private beta |
| Private network between machines | Org network, split by tags | Public URLs only |
| Tailscale or NetBird | Both, built in | Your own SOCKS5 proxy |
| Agent skills or MCP | Agent skills; no MCP server | MCP server deprecated |

### Your app answers in 156 ms from sleep

A sleeping boxd machine keeps its memory, so the server you left running is still running. An HTTPS request wakes it and gets an answer: 156 ms median across ten runs, measured on our production cluster.

### Bigger machines without asking

Self-serve sizes go to 8 vCPU and 32 GiB, with 100 GB of disk on every machine. E2B's self-serve ceiling is 8 vCPU and 8 GiB, with 10 to 20 GiB of disk.

### Claude Code, Codex and OpenCode are already there

Every machine boots with all three installed, plus headless Chrome, a desktop you can open in the browser, Docker and the boxd CLI. Your API keys stay outside the machine: the guest holds a placeholder and our proxy swaps in the real value.

### No session limit

A boxd machine runs until you delete it. It sleeps when it's idle and wakes on the next request, so a long agent run, a bot or a dev server never hits a cutoff.

boxd's timings were measured on its production cluster on 2026-10-29, ten runs each, from a client in the same datacenter: a hibernated machine's app answered an HTTPS request in 156 ms median; a new machine from a snapshot answered 1.19 s after the create command.

## Side by side

|  | boxd | E2B |
| --- | --- | --- |
| **The machine** |  |  |
| Full VM, own kernel | Yes, every machine | Yes, Firecracker ([source](https://e2b.dev/security)) |
| Default size | 2 vCPU · 8 GiB · 100 GB | 2 vCPU · 4 GiB · 10–20 GiB ([source](https://e2b.dev/pricing)) |
| Largest, self-serve | 8 vCPU · 32 GiB | 8 vCPU · 8 GiB (more via support) ([source](https://docs.e2b.dev/billing.md)) |
| Root, systemd, Docker | Yes, plus nested virtualization | Docker yes; systemd not documented ([source](https://docs.e2b.dev/template/examples/docker.md)) |
| CPU test (runs/s) | 12.6 (our run) | 11.08 ([source](https://github.com/starslingdev/hpc-sandbox-benchmarks/blob/main/LEADERBOARD.md)) |
| **Composable** |  |  |
| Ready machine described in code | Machine specs, built on one another | Templates in code, extendable ([source](https://docs.e2b.dev/template/base-image.md)) |
| Machines create machines | Yes, signed in as the machine | You pass an API key in ([source](https://docs.e2b.dev/api-key.md)) |
| Built-in integrations | 100+, credentials kept out | MCP gateway; your own keys ([source](https://docs.e2b.dev/mcp-gateway.md)) |
| Schedules and event triggers | Cron and events; sleeps between runs | No; wake on HTTP only ([source](https://docs.e2b.dev/sandbox/auto-resume.md)) |
| Standalone disks | Yes, outlive the machine | Volumes, private beta ([source](https://docs.e2b.dev/volumes.md)) |
| Private network between machines | Org network, split by tags | Public URLs only ([source](https://docs.e2b.dev/network/internet-access.md)) |
| Tailscale or NetBird | Both, built in | Your own SOCKS5 proxy ([source](https://docs.e2b.dev/network/byop.md)) |
| Agent skills or MCP | Agent skills; no MCP server | MCP server deprecated ([source](https://github.com/e2b-dev/mcp-server)) |
| **Ready when you are** |  |  |
| Sleeps with processes kept | Yes, standby and hibernate | Yes, pause keeps memory ([source](https://docs.e2b.dev/sandbox/persistence.md)) |
| Wakes on a request | Yes, HTTPS or SSH · app answers in 156 ms | Opt-in auto-resume on HTTP ([source](https://docs.e2b.dev/sandbox/auto-resume.md)) |
| Starts from a snapshot, app running | Yes · app answers in 1.19 s | Yes, templates restore running ([source](https://docs.e2b.dev/template/how-it-works.md)) |
| Session limit | None | 1 h Hobby · 24 h Pro ([source](https://docs.e2b.dev/faq/sandbox-lifetime.md)) |
| **Built for agents** |  |  |
| Coding agents installed | Claude Code, Codex, OpenCode | Claude Code and Codex templates ([source](https://docs.e2b.dev/agents/claude-code.md)) |
| SSH | Native, own port per machine | WebSocket proxy you set up ([source](https://docs.e2b.dev/sandbox/ssh-access.md)) |
| HTTPS URL per port | Yes, plus custom domains | Yes ([source](https://docs.e2b.dev/network/public-url.md)) |
| Raw TCP inbound | Yes, 3 ports per machine | Not published ([source](https://docs.e2b.dev/network/public-url.md)) |
| Secrets kept out | Yes, swapped in at the proxy | Yes, egress proxy ([source](https://docs.e2b.dev/secrets.md)) |
| **Price** |  |  |
| vCPU-hour | $0.047, CPU used | ≈$0.050 + plan fee ([source](https://e2b.dev/pricing)) |
| RAM GiB-hour | $0.014, memory in use | ≈$0.016 ([source](https://e2b.dev/pricing)) |
| While asleep | Hibernated: disk only | Paused: free ([source](https://docs.e2b.dev/faq/paused-sandboxes-concurrency.md)) |
| **Also worth knowing** |  |  |
| GPUs | No | No ([source](https://docs.e2b.dev/faq/gpu-support.md)) |
| Regions | Frankfurt (US waitlist) | US West ×2, EU, Asia-Pacific ([source](https://docs.e2b.dev/client.md)) |
| SOC 2 | SOC 2 in progress | SOC 2 Type II ([source](https://e2b.dev/security)) |
| SAML SSO | No | Planned ([source](https://e2b.dev/enterprise)) |
| Egress allowlist | Yes | Yes ([source](https://docs.e2b.dev/network/internet-access.md)) |
| Self-host | Yes, free to 16 vCPUs | Single node (E2B Embed) ([source](https://docs.e2b.dev/byoc.md)) |

## Where E2B is stronger

- **Short jobs at scale.** E2B is built for many short code runs: sandboxes restore in about 80 ms and you can run up to 1,100 at once.
- **Regions.** US West, EU and Asia-Pacific. boxd runs in Frankfurt only until the US cluster opens.
- **Compliance.** SOC 2 Type II, and a HIPAA BAA on Enterprise. boxd's SOC 2 is in progress, and it does not offer a HIPAA BAA.
- **Paused costs nothing.** A paused E2B sandbox isn't billed. A hibernated boxd machine still pays for the disk it has written.

## Questions

### Is boxd an E2B alternative?

Yes, when your sandbox needs to outlive a session. E2B caps a continuous run at 1 hour on Hobby and 24 on Pro. A boxd machine has no limit: it sleeps when idle, wakes on a request with its processes intact, and you can SSH into it like any server.

### Which is faster to start?

E2B restores a template in about 80 ms by its own docs; that is the time to restore, not to a response. On boxd we measured the full path: a new machine from a snapshot answered its first HTTPS request 1.19 s after the create command, and a hibernated machine answered in 156 ms.

### Can I move my E2B template to boxd?

Set the machine up once (install, clone, start your services), then save it as a snapshot. Every machine you create from that snapshot starts with the same files and the same processes running.

## How we measured

### Wake from hibernation

A small Python HTTP server on a default 2 vCPU machine, published on its HTTPS URL. Ten times: hibernate the machine, confirm it reports hibernated, then send one HTTPS request on a new connection from a client machine in the same datacenter. Median 156 ms until the app answered (104–213 ms); a warm request takes about 73 ms, so waking adds about 80 ms. The app's process ID was the same after every wake.

### New machine from a snapshot

A snapshot of that machine with the server running. Ten times: run `boxd new --from-snapshot`, then request the new machine's HTTPS URL until the app answers. Median 1.19 s from the create command to the app's first response (1.14–1.24 s). The first request succeeded every time; nothing was started after boot.

### CPU

The Node.js web tooling test from StarSling's open sandbox benchmark (Phoronix Test Suite 10.8.4, pts/node-web-tooling-1.0.1, Node 22.23.1, two passes per run), on a 4 vCPU machine. Three runs: 12.65, 12.86 and 12.19 runs/s. The other providers' numbers are from StarSling's own published leaderboard, which runs 4 vCPU / 8 GiB; boxd's 4 vCPU size has 16 GiB, which this test doesn't use.

### What these numbers don't include

Your own network distance. Every timing was taken from a client in the same Frankfurt datacenter; from the US, add your round trip on top. A larger app has more memory to bring back, so it takes longer than a small server.

## More comparisons

- [boxd vs Daytona](https://boxd.sh/compare/daytona/index.md)
- [boxd vs Modal](https://boxd.sh/compare/modal/index.md)
- [boxd vs Vercel Sandbox](https://boxd.sh/compare/vercel-sandbox/index.md)
- [boxd vs Blaxel](https://boxd.sh/compare/blaxel/index.md)
- [boxd vs Cloudflare Sandbox](https://boxd.sh/compare/cloudflare-sandbox/index.md)
- [Moving off Runloop](https://boxd.sh/compare/runloop/index.md)
- [boxd vs exe.dev](https://boxd.sh/blog/boxd-vs-exe-dev/)
- [boxd vs sprites.dev](https://boxd.sh/blog/boxd-vs-sprites/)
- [All comparisons](https://boxd.sh/compare/index.md)