Koyeb vs Deno Sandbox
Both run code in microVMs. Koyeb sandboxes are services that keep running until you delete them, can sleep and wake on a request, and come in sizes up to GPUs, while Deno Sandbox gives short 2 vCPU runs of up to 30 minutes that start in under 200 ms behind a host allowlist.
The companies and products
Koyeb
Koyeb is a serverless cloud for apps, inference and sandboxes, and in February 2026 it agreed to join Mistral AI.
A Koyeb sandbox is a Koyeb service: a microVM started from any Docker image and driven from Python or JavaScript SDKs that run commands, read files and expose a port. It can scale to zero when idle and wake on the next request, and it can run on CPU or GPU instance types. It is built for teams that run AI agents or untrusted code next to apps they already host on Koyeb.
Deno Sandbox
Deno Sandbox is part of Deno Deploy, the hosting platform from the company behind the Deno runtime, and runs untrusted or AI-generated code in Linux microVMs.
Each sandbox is a Firecracker microVM with 2 vCPU, up to 4 GB of memory and a 10 GB disk that is wiped when it ends, created from a TypeScript or Python SDK. Outbound traffic goes through a proxy that can enforce a host allowlist and swap placeholder secrets for real ones. It is built for short runs of agent or user code, and a sandbox can be promoted to a Deno Deploy app.
- Isolation
- Firecracker microVM per sandbox
Which use cases each one fits
For each use case, Battleships prices every sandbox provider on the same workload and sorts them from the cheapest monthly bill up. “4th cheapest of 345” means 3 of the other 344 providers run that workload, with every feature it needs, for less. “With limits” means the provider runs it but misses something, so it is listed after every full match. Open a use case for its whole ranking and what each provider misses.
| Use case and its workload | Koyeb: price rank | Deno Sandbox: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory runs builds for hours; Koyeb can stay up that long but loses its local disk on redeploy, Deno stops at 30 minutes, and bochka keeps the disk by default. | 54th of 367, with limits $366 a month | 290th of 367, with limits $5,665 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on one machine all month cannot run on Deno's 30-minute sandboxes, and on Koyeb its files need a volume to survive a deep sleep. | 135th of 366, with limits $923 a month | 287th of 366, with limits $5,803 a month | 5th cheapest of 366 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Short code runs suit both: Koyeb ranks 4th here with small instances that sleep when idle, and Deno Sandbox starts in under 200 ms and bills CPU only while code runs. | 4th cheapest of 345 $66 a month | 141st of 345, with limits $329 a month | 186th of 345, with limits $2,000 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Koyeb ranks 6th and fits; Deno Builder allows 20 sandboxes at once per region, and bochka ranks 1st with token-protected HTTPS on up to 50 ports. | 6th cheapest of 361 $495 a month | 148th of 361, with limits $1,863 a month | Cheapest of 361 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Neither fits as priced: Koyeb's eco instances guarantee half of each vCPU, and Deno is capped at 2 vCPU, 20 at once and 30 minutes. | 237th of 360, with limits $1,631 a month | 122nd of 360, with limits $7,963 a month | 34th of 360, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 19th cheapest of 364 $429 a month | 296th of 364, with limits $1,563 a month | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month | 142nd of 377, with limits $88 a month | 304th of 377, with limits $731 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 217th of 368, with limits $37 a month | 179th of 368, with limits $200 a month | 18th cheapest of 368 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Computer-use agents need a desktop, and neither Koyeb nor Deno Sandbox has one; bochka streams a 60fps Linux desktop with Chromium. | 81st of 369, with limits $123 a month | 280th of 369, with limits $1,583 a month | 6th cheapest of 369 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month On Koyeb and Deno you install and run a headless browser yourself, while bochka ships Chromium on a desktop in every sandbox. | 172nd of 367, with limits $123 a month | 284th of 367, with limits $783 a month | 7th cheapest of 367 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 172nd of 346, with limits $89 a month | 286th of 346, with limits $573 a month | 6th cheapest of 346 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 65th of 338, with limits $1,683 a month | 247th of 338, with limits $11,923 a month | 71st of 338, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 233rd of 360, with limits $299 a month | 251st of 360, with limits $367 a month | 2nd cheapest of 360 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Koyeb ranks 3rd with GPU instances up to H100 and H200; Deno Sandbox and bochka have no GPUs. | 3rd cheapest of 98 $628 a month | Can't run it | Can't run it |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Can't run it | Can't run it | Can't run it |
Key features
| Feature | Koyeb | Deno Sandbox | bochka |
|---|---|---|---|
| Isolation | MicroVM per instance | Firecracker microVM with its own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | Instance types up to 40 vCPU / 128 GB, and GPU types far larger | 2 vCPU fixed, 768 MB to 4 GB memory, 10 GB disk | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB on the $100 plan and above |
| Session length | No forced cap; an optional auto-delete timer of up to 24 hours | Up to 30 minutes; longer work can be promoted to a Deno Deploy app | No cap on paid plans; you set the time to live |
| Disk that persists | Local disk lost on redeploy; volumes in preview, 1 to 10 GB, Frankfurt and Washington | Root disk wiped when the sandbox ends; volumes of 300 MB to 20 GB, Chicago only | The whole disk is kept, saved every minute and on stop; a stopped sandbox costs nothing |
| Sleep and wake | Scales to zero after 5 idle minutes and wakes on the next request; Light Sleep wakes in about 200 ms | No pause; a new sandbox starts in under 200 ms | Stop and start by API; a stopped sandbox keeps its disk |
| Snapshots and fork | SDK snapshots of the filesystem or running processes, and new sandboxes from them (experimental) | Read-only snapshots of a volume that new sandboxes can boot from | Automatic disk snapshots; fork a running sandbox with its disk |
| Docker and nested virtualization | Starts from any Docker image; nested virtualization not documented | Root access; Docker and nested virtualization not documented | Docker, systemd and /dev/kvm for Android emulators and VMs |
| Sandboxes at once | 100 services on Pro, 1,000 on Scale | 3 per region on Pro, 20 per region on Builder | Fits 50 agents and 300 user sandboxes at once in the scenarios here; the top plan allows 2,400 starts a day |
| Inbound access | One exposed HTTPS port at a time, plus an optional TCP proxy to one port | HTTPS URL per exposed port, public without authentication; SSH | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP |
| Outbound rules | Block all outbound traffic, or allow only listed IPs and CIDRs | Host allowlist per sandbox, enforced by a proxy outside the VM | Open internet, no provider-side allowlist |
| Keeping API keys out of the sandbox | Secrets are set as environment variables inside the service | Secrets swapped in on outbound requests to approved hosts; the sandbox only sees a placeholder | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Desktop and coding agents | No desktop; agents run through the command API, and an MCP server lets agents manage Koyeb | No desktop; a root image with Claude Code, run through the shell command API | 60fps Linux desktop with Chromium, and seven agents preinstalled with a prompt, steer and events API |
| GPUs | RTX 4000 SFF Ada up to H100, H200 and multi-GPU | No | No |
| Regions | EU, US and Asia | Amsterdam and Chicago | EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Koyeb | Deno Sandbox | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Not published | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | No | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Not published | No | Yes |
| Memory fork | Yes | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | Yes | No | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | No | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | Yes | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | No | Yes | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for Koyeb or Deno Sandbox: neither was part of the hpc-sandbox-benchmarks run. bochka did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB. Deno's fixed 2 vCPU shape could not run the 4 vCPU test, and Koyeb guarantees at least 0.25 dedicated vCPU per GB of memory, so its speed depends on how busy the host is.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Koyeb and Deno Sandbox have no published run in this suite yet, so there is no like-for-like number to compare.
Pricing in five scenarios
Each bill is priced from the providers' public price lists by the open Battleships engine, with the cheapest plan that runs the scenario.
| Scenario | Koyeb, a month | Deno Sandbox, a month | bochka, a month |
|---|---|---|---|
| One coding agent, workdays 4 vCPU / 8 GB, 50 GB disk, 8 hours a day, 22 days a month, files kept between days | $29 · Pro | $53 · Pro · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $57 · Pro | $200 · Builder · with limits | $26 · $20/mo |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $475 · Pro | $2,779 · Builder · with limits | $317 · $20/mo × 3 seats |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $329 · Scale | $783 · Builder · with limits | $200 · $100/mo × 2 seats |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $485 · Scale · with limits | $1,563 · Builder · with limits | $2,000 · $2000/mo · with limits |
Koyeb: Koyeb bills each instance per second from the moment it starts, at a fixed price per instance type, and Deep Sleep costs nothing. Pro costs $29 a month with $10 of usage included and Scale $299 a month with $100 included; bandwidth above 1 TB is extra.
Deno Sandbox: Sandboxes need Pro at $20 a month or Builder at $200 a month; the fee is not credit but includes CPU, memory and egress allowances shared with Deno Deploy apps. Past those, CPU costs $0.10 per hour of active CPU time and memory $0.025 per GiB-hour for the whole life of the sandbox.
Deno Sandbox: Plans start at $20 a month, and the whole fee is usage credit. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Deno Sandbox fits none of the five scenarios as written: it lives up to 30 minutes, is fixed at 2 vCPU with up to 4 GB, and Builder allows 20 sandboxes at once per region. Koyeb fits four of the five, but its priced eco-xlarge shape has a 20 GiB disk with no published price for more. At 1,000 short jobs at once nothing fits: Koyeb's burstable CPU throttles above half of each vCPU, Deno caps at 20 at once, and bochka's top plan queues starts above 90 a minute.
| Scenario | Koyeb | Deno Sandbox | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel | None that bite |
| None that bite |
| Sandboxes for your users | None that bite |
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Koyeb when
your sandboxes need to stay up for hours, sleep when idle and wake on a request, use more than 2 vCPU or a GPU, or run in Asia.
- Sandboxes that stay up, sleep and wake. Good when a sandbox should live for hours but idle cheaply: Koyeb has no forced cap and wakes a sleeping sandbox on request.
- Bigger machines and GPUs. Useful when 2 vCPU is not enough: Koyeb goes up to 40 vCPU / 128 GB, and GPU types up to H100 and H200.
- More regions and more at once. Fits teams that need Asia or many sandboxes: Koyeb runs in the EU, US and Asia, with 1,000 services on Scale.
Use Deno Sandbox when
you run short pieces of untrusted code that must start in milliseconds, reach only the hosts you allow, and never see real secrets, especially on Deno Deploy.
- Locked-down outbound traffic. Useful for untrusted code: each sandbox can reach only the hosts you list, enforced by a proxy outside the VM.
- Real keys never enter the sandbox. Good when agent code must call APIs: the sandbox sees a placeholder, and the proxy swaps in the real secret for approved hosts.
- Fast starts and a path to Deno Deploy. Fits short bursts on Deno Deploy: a sandbox starts in under 200 ms, bills CPU only while code runs, and can become a Deploy app.
Where bochka fits
Koyeb is a cloud for apps that also runs sandboxes, and Deno Sandbox is built for short, locked-down runs. If your agents do hours of real work, building, testing, running Docker, emulators and a browser, look at bochka: a full VM that keeps its disk, with agents, a desktop and hosting built in.
A machine that lasts and keeps its files
A Deno sandbox ends after 30 minutes and wipes its root disk. Koyeb stays up, but loses its local disk on redeploy or deep sleep. Lasting files need a volume offered in only one or two regions; bochka saves the whole disk every minute.
Docker, systemd and /dev/kvm
Neither Koyeb nor Deno documents nested virtualization, and Deno does not document Docker inside a sandbox, so Android emulators and VM-based tests must run elsewhere. bochka gives root, systemd, Docker and /dev/kvm on every sandbox.
Agents, desktop and ports built in
On both you drive agents through shell commands and parse output yourself, with no desktop. Koyeb exposes one port at a time and Deno's URLs are public. bochka has seven agents, a 60fps desktop and 50 token-protected HTTPS ports.
Use bochka when your agents do real work for hours on a machine that keeps its disk: builds, Docker, emulators, a desktop browser and preview servers, with agents and keys handled for you. Compare it one to one: bochka vs Koyeb and bochka vs Deno Sandbox.
Questions people ask
Is Koyeb cheaper than Deno Sandbox?
In every scenario on this page Koyeb comes out lower, for example $57 against $200 a month for one agent that never stops and $475 against $2,779 a month for 50 agents in parallel. Deno Sandbox does not fit any of the five as written, while Koyeb fits four. bochka comes to $26 and $317 for the same two.
Which is faster, Koyeb or Deno Sandbox?
Neither has a comparable CPU measurement. Deno says a sandbox starts in under 200 ms, and Koyeb's Light Sleep wakes in about 200 ms. Koyeb offers much bigger machines, while Deno is fixed at 2 vCPU.
How long can a sandbox run on each?
A Deno sandbox lives up to 30 minutes, and longer work can be promoted to a Deno Deploy app. Koyeb sets no forced limit: a sandbox runs until you delete it, or until an auto-delete timer of up to 24 hours that you choose. bochka has no cap on paid plans.
Can Koyeb or Deno Sandbox run Docker?
Koyeb starts each sandbox from any Docker image, but neither Koyeb nor Deno documents nested virtualization, and Deno's docs do not say Docker works inside a sandbox. bochka runs Docker and systemd and exposes /dev/kvm for Android emulators and VMs.
Do Koyeb or Deno Sandbox have GPUs?
Koyeb does, from an RTX 4000 SFF Ada up to H100 and H200, billed per second. Deno Sandbox and bochka are CPU only.
Which keeps files between runs?
Neither by default. Koyeb's local disk is lost on redeploy and Deno's root disk is wiped when a sandbox ends, so both need a volume: 1 to 10 GB in preview on Koyeb, 300 MB to 20 GB in Chicago on Deno. bochka keeps the whole disk and saves it every minute.
Try bochka
Install the CLI, then run bochka new.
Product preview