E2B and Sandscale run the code your agents write in Firecracker microVMs, one per sandbox. If you are choosing between them, the isolation technology is not the deciding factor. The differences are in how you are billed for waiting, what governance ships with the platform, where it runs, and how much is documented. E2B has the larger documented feature set of the two, and this post says where it is ahead.
Everything about E2B below comes from E2B’s public pricing page, docs and infrastructure repository, read on 20 November 2026. Everything about Sandscale comes from sandscale.dev. Where we could not find something, the table says “not published”. Both products change; check the linked pages before you decide.
What they have in common
- Isolation. E2B states that every sandbox is a Firecracker microVM that boots its own kernel and is isolated from other sandboxes and the host by the hypervisor. Sandscale states the same: each sandbox is its own Firecracker microVM with its own kernel.
- Pause and resume with memory. E2B’s pause saves the filesystem and memory, so running processes and loaded variables survive. Sandscale’s pause keeps memory and files too.
- Per-sandbox lifecycle through SDKs and an API. Create, run commands, move files, pause, resume, kill.
- Custom environments. E2B has templates, built from the CLI or SDK. Sandscale has templates pinned by digest and a Dockerfile-based build.
Billing: what you pay while an agent waits
E2B bills per second for provisioned CPU and RAM while a sandbox is running. Its published rates are $0.000014 per vCPU-second and $0.0000045 per GiB-second, with disk included. Its docs say that once a sandbox is paused, killed or times out, compute billing stops immediately, and that you can enable auto-pause after a period of inactivity. So on E2B, idle time costs money until the sandbox is paused, and you control when that happens with a timeout, auto-pause or an explicit call.
Sandscale bills in awake vCPU-hours: one vCPU running for one hour while the box is awake. Paused time and idle time between tool calls are not counted. Memory is included at 4 GiB per vCPU; more than that counts as extra vCPU-hours. Plans include a monthly number of awake hours, and usage beyond that is $0.05 per awake vCPU-hour (or $10 per 500-hour pack).
For how metering works in detail, see Sandscale pricing. The practical difference is who does the pausing. On E2B you pause (or configure auto-pause) and the billing stops. On Sandscale the idle time between tool calls is not billed without any action, and pausing is available for long waits. If your agents already pause aggressively, the gap narrows.
A worked example (hypothetical workload)
This is an invented workload, not a measurement. An agent run uses a 2 vCPU box with 4 GiB for 60 minutes of wall-clock time. It is doing real work for 10 minutes and waiting for 50 (a model, or a person).
E2B, using its published rates for 2 vCPU and 4 GiB:
2 vCPU × $0.0504/h = $0.1008
4 GiB × $0.0162/h = $0.0648
Running cost = $0.1656 per hour
(The hourly figures are the per-second rates times 3,600.)
- Left running for the full hour: $0.1656 per run.
- Paused after 10 minutes of work: 10/60 × $0.1656 = $0.0276 per run. This ignores any time spent pausing and resuming, which the docs do not quantify.
Sandscale, same 2 vCPU box:
2 vCPU × (10 / 60) h = 0.333 awake vCPU-hours per run
For 1,000 runs a month that is 333.3 awake vCPU-hours, inside Pro’s 1,500 included hours. At the $0.05 overage rate those hours would be worth $16.67, but on Pro they are covered by the plan.
| 1,000 runs a month | Usage cost | Plan fee | Notes |
|---|---|---|---|
| E2B, left running 60 min | $165.60 | Hobby: $0, Pro: $150/mo | Hobby has a one-time $100 credit, 1 hour max continuous runtime, 10 concurrent sandboxes |
| E2B, paused after 10 min | $27.60 | Hobby: $0, Pro: $150/mo | Same plan notes |
| Sandscale, awake only | within 1,500 included hours (333.3 used) | Pro: $20/mo billed annually, $25 monthly | Memory: 8 GiB is included at 2 vCPU, more than the 4 GiB used for E2B above |
Read this table with care. The plan fees buy different things (for example, E2B Pro’s concurrency of 100 against Sandscale Pro’s 30 at once), the memory is not matched, and a real workload will not be this tidy. The numbers show how the two billing models behave on one shape of workload, not that one platform is cheaper for yours. If your sandboxes are awake most of the time, billing for idle time stops mattering.
Governance and security controls
This is where the products are built differently.
Sandscale puts governance for agents into the platform on every plan: Vault for secrets (kept out of prompts and logs), DLP scanning of prompts and MCP tool calls, human approvals, and a hash-chained audit log. Policies on templates, sizes, run times and which agents may run are on Team and Enterprise. Claude Code runs under policy through its hooks, so each tool call is allowed, blocked or sent to a person. Audit export, SSO and roles are on Team; SCIM and custom roles on Enterprise.
E2B documents network controls (outbound internet is on by default, with on/off and allow or deny lists), a way to inject stored secrets into outbound HTTPS requests through an egress proxy, SSH access, lifecycle webhooks, OTel telemetry export and per-sandbox metrics. We did not find approval workflows, prompt-level DLP or an audit log in the docs index. That does not prove they do not exist; it means we could not find them. Treat them as “not published”.
Compliance. E2B publishes that it has a SOC 2 Type II report, available through its Trust Center, and that a HIPAA business associate agreement can be requested through support. Sandscale says it does not claim any certification; Team and Enterprise can export the audit log as evidence for your own assessments. If your procurement process requires a SOC 2 report or a HIPAA BAA today, that is a clear difference in E2B’s favor.
Where E2B is ahead or more mature
- Documentation and tooling. E2B has a larger public documentation set: a code interpreter SDK, desktop sandboxes for computer use, a Claude Code template, a GitHub Actions use case, cookbooks, and a public docs MCP server. We have no adoption numbers for either company and are not making any claim about them; we are comparing what is documented.
- Regions. E2B documents an EU cluster on every plan (access by contacting support, for workspaces verified with a payment method). Sandscale runs in the US (N. Virginia) now; Frankfurt is “coming soon”.
- Bring your own cloud. E2B offers BYOC on AWS, Google Cloud and Azure for Enterprise customers, as a managed deployment in your account. Sandscale’s own-cloud option is AWS only, on Enterprise.
- Open infrastructure. E2B’s infrastructure repository is public on GitHub, licensed Apache-2.0 as shown on the repo page, and its BYOC docs describe E2B Embed, an Apache-2.0 runtime packaged for self-hosting on one machine. Sandscale’s pages describe self-hosted and air-gapped deployments on request, but a public source repository is not published.
- Persistence features. E2B documents volumes that outlive sandboxes and can be mounted into several (in private beta at the time of writing), snapshots, forking from a running sandbox, auto-resume on activity, and paused sandboxes kept indefinitely. Sandscale has snapshots, pause and resume, and persistent workspaces; shared volumes are not published.
- Higher published concurrency. E2B publishes Pro at 100 concurrent sandboxes, expandable to 1,100 with add-ons of 500 slots at $500 a month each. For Enterprise, its billing docs say 1,100+ and its pricing page says tens of thousands, with a commit starting at $2,000 a month that includes 500 concurrent. Sandscale publishes 30 at once on Pro and Team, with more on request on Team.
- Compliance evidence. SOC 2 Type II, and a HIPAA BAA on request, as above.
Where Sandscale differs
- Idle time is not billed by default, as described above, and plans start at $20 a month (Pro, billed annually) against $150 a month for E2B Pro. Those plans have different limits, so compare them as a whole.
- Agent governance is part of the product: approvals, DLP, Vault and the audit log on every plan.
- Larger single boxes on paid plans: up to 16 vCPU on Pro (E2B publishes 8 on Hobby and “8+” on Pro on request; 64 on Sandscale Enterprise).
- More than sandboxes: persistent workspaces, build hosts (including a GitHub Actions runner), and lab hosts that let a run claim physical devices. E2B has its own CI and desktop use cases; the two lists do not map one to one.
Limits on our side, stated plainly: US only today, no GPU mentioned in our pricing, no certification claimed, and a smaller published set of docs, integrations and examples. The TypeScript SDK is available now; the Python SDK is listed as coming soon.
Fact table
| Sandscale | E2B | |
|---|---|---|
| Isolation | Firecracker microVM, own kernel | Firecracker microVM, own kernel |
| Billing basis | Awake vCPU-hours; idle and paused free | Per second for provisioned CPU and RAM while running; billing stops when paused, killed or timed out |
| Memory | 4 GiB per vCPU included; extra counts as vCPU-hours | $0.0000045 per GiB-second |
| Published rate | Beyond plan: $0.05 per awake vCPU-hour; $10 per 500 hours | $0.000014 per vCPU-second; disk free |
| Plans | Free $0; Pro $20/mo annual ($25 monthly); Team $40/member annual ($48 monthly) | Hobby $0 + $100 one-time credit; Pro $150/mo + usage; Enterprise custom, commit from $2,000/mo with 500 concurrent included |
| Included usage | Free 100, Pro 1,500, Team 2,000 per member (pooled) awake vCPU-hours/month | Credits only on Hobby; none on Pro |
| Concurrent boxes | Free 3, Pro 30, Team 30 (more on request) | Hobby 10, Pro 100 (to 1,100 with add-ons), Enterprise 1,100+ in the billing docs, “tens of thousands” on the pricing page |
| Max box size | Free 2 vCPU, Pro 16, Team 16 (32 on request), Enterprise 64 | Hobby 8 vCPU / 8 GiB; Pro 8+ on request |
| Max session | Free 4 h, Pro 24 h, Team 24 h | Continuous runtime: Hobby 1 h, Pro 24 h; resets on pause and resume |
| GPU | Not published | No, CPU only |
| Regions | US now; EU “coming soon” | US and a shared EU cluster |
| Own cloud | AWS, Enterprise; self-hosted/air-gapped on request | BYOC on AWS, GCP, Azure for Enterprise, managed in your account; E2B Embed for single-machine self-hosting |
| Open source | Not published | Infrastructure repo public, Apache-2.0 |
| Network default | Allowlist on Free; open on Pro and Team | Outbound internet on by default, allow/deny lists |
| Secrets | Vault, kept out of prompts and logs, on every plan | Stored secrets injected into outbound HTTPS requests; 10 secrets per project on Hobby, 100 on Pro |
| Approvals, DLP | Yes, every plan | Not published |
| Audit log | Hash-chained, every plan; export on Team+ | Not published |
| SOC 2 | No certification claimed | SOC 2 Type II report via Trust Center; HIPAA BAA on request |
| Start time | Not compared here | Not published in the pages read |
| Snapshots / fork | Snapshots on every plan; pause and resume | Snapshots, forking, auto-resume, volumes (private beta) |
When to pick E2B
- You need a SOC 2 Type II report or a HIPAA BAA now, for a procurement review.
- You need an EU region today, or your own cloud on Google Cloud or Azure.
- You run a large number of concurrent sandboxes (hundreds to a thousand-plus) and want that published and expandable.
- You want to read or run the infrastructure source.
- Your agents pause themselves reliably, so idle billing is already close to zero for you.
- Your product is a code interpreter, data-analysis or computer-use app and you want the maintained SDKs and examples E2B documents for them.
When to pick Sandscale
- Your agents spend most of their wall-clock time waiting and you would rather not manage pause logic to avoid paying for it.
- You want approvals, DLP, Vault and an audit log from the platform, not built around it.
- You want one account for sandboxes, persistent workspaces and build hosts.
- You need boxes larger than 8 vCPU on a self-serve plan.
If none of these applies to you, either is a reasonable starting point, and the Free plans are enough to try your own workload on both. Measure how long your boxes are open against how long they are awake before you decide on cost; see pricing and the sandbox page for the current numbers, how pause and resume work, and the security overview.
Sources
Competitor pages read on 20 November 2026:
- https://e2b.dev/pricing
- https://e2b.dev/docs
- https://docs.e2b.dev/llms.txt
- https://docs.e2b.dev/billing
- https://docs.e2b.dev/faq/security-and-compliance
- https://docs.e2b.dev/byoc
- https://docs.e2b.dev/faq/eu-region
- https://docs.e2b.dev/faq/gpu-support
- https://docs.e2b.dev/sandbox/persistence
- https://docs.e2b.dev/sandbox
- https://docs.e2b.dev/network/internet-access
- https://docs.e2b.dev/secrets/inject
- https://docs.e2b.dev/volumes
- https://github.com/e2b-dev/infra
Sandscale pages: pricing, FAQ, security, regions, integrations.