bochka vs Cloudflare Browser Run
Cloudflare Browser Run is a browser API: headless Chrome on Cloudflare's network that you drive from a Worker, over CDP or with one-shot REST calls, and that keeps nothing when the session ends. bochka gives each agent a full Linux VM with root, Docker and a disk that persists, plus a 60fps desktop with Chromium and coding agents you drive from outside.
Where bochka stands out
A whole machine, not only a browser
Every bochka sandbox is a full VM with root, SSH, systemd, Docker and nested virtualization, on dedicated AMD Ryzen 9 9950X hosts, with Chromium on a 60fps desktop inside it. A Browser Run session gives your code a Chrome over CDP, and the rest of your logic runs in a Worker.
Keeps its disk and its logins
A bochka sandbox has no session cap on paid plans, and its disk persists with snapshots every minute and on stop, so it comes back with its files, browser profile and logins. Browser Run keeps nothing after a session, closes idle browsers after 60 seconds by default, and also closes sessions when it rolls out a new release.
Coding agents you drive from outside, keys kept outside
bochka ships Claude Code, Codex, OpenCode and other agents in each sandbox, and you prompt, steer and follow them through one API with an event stream. bochka's credentials proxy keeps real API keys outside the sandbox for model providers and any HTTPS API.
The companies and products
bochka
bochka.xyz runs sandboxes for AI agents: each one is a full Linux VM with its own kernel.
You start a machine with one command or one API call, then SSH in, run Docker, open a desktop, or let a built-in agent (Claude Code, Codex, OpenCode and others) work in it. The disk stays between sessions, and a stopped sandbox costs nothing.
- Isolation
- Full VM per sandbox, own kernel
- Regions
- EU: Germany, Finland, France
Cloudflare Browser Run
Cloudflare Browser Run, formerly Browser Rendering, runs headless Chrome on Cloudflare's global network for browser automation, scraping, testing and content generation.
You use it two ways: Quick Actions, stateless REST calls that return a screenshot, PDF, Markdown, links or AI-extracted JSON, and Browser Sessions, a Chrome you drive from a Worker or any client with Puppeteer, Playwright, CDP or Stagehand. Around that sit a crawl endpoint, MCP access for agents like Claude Code and Cursor, Live View, session recordings and Guardrails, plus Kitesurf, a stateless browser built on Workers that is free while in beta. It is a browser service, not a general sandbox: you get a browser, not a shell, so this page compares where the two overlap, which is agents that browse.
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. “3rd cheapest of 367” means 2 of the other 366 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 | bochka: price rank | Cloudflare Browser Run: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A coding agent needs a shell, Docker and a disk, and a Browser Run session gives a browser only, so builds and tests fit bochka. | 3rd cheapest of 367 $634 a month | 118th of 367, with limits $1,089 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month needs files and logins that stay; Browser Run keeps nothing after a session, and bochka keeps the disk across stops. | 5th cheapest of 366 $657 a month | 245th of 366, with limits $3,289 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Running code needs a machine with a shell; Browser Run only runs JavaScript inside the page, so code interpreter work fits bochka or a sandbox product. | 186th of 345, with limits $2,000 a month | 259th of 345, with limits $299 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month | Cheapest of 361 $209 a month | 238th of 361, with limits $930 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 34th of 360, with limits $2,000 a month | 260th of 360, with limits $4,479 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 10th cheapest of 364 $200 a month | 250th of 364, with limits $364 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs need a shell, Docker and often /dev/kvm, which bochka has and a browser session does not. | 4th cheapest of 377 $86 a month | 235th of 377, with limits $112 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 18th cheapest of 368 $26 a month | 238th of 368, with limits $70 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Browser Run drives one browser, while bochka streams a 60fps Linux desktop where an agent can use any app, not only Chrome. | 6th cheapest of 369 $200 a month | 139th of 369, with limits $328 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Both fit: Cloudflare gives a managed Chrome over CDP with Live View and recordings, and bochka gives Chromium on a full VM where the same agent can also run code. | 7th cheapest of 367 $200 a month | 18th cheapest of 367 $328 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month Both fit at startup scale; Cloudflare's Quick Actions return Markdown, JSON or a crawl from one REST call with no browser code to write. | 6th cheapest of 346 $90 a month | 46th cheapest of 346 $443 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month Neither is built for sites that block bots: Cloudflare traffic is always flagged as a bot from its own IP ranges, and bochka uses datacenter IPs with no CAPTCHA solving. | 71st of 338, with limits $1,800 a month | 222nd of 338, with limits $8,779 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 2nd cheapest of 360 $200 a month | 209th of 360, with limits $218 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min 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 |
Key features
| Feature | bochka | Cloudflare Browser Run |
|---|---|---|
| Kind of product | A full Linux VM per sandbox, with a desktop and Chromium inside | Managed headless Chrome: REST Quick Actions and Browser Sessions you drive over CDP |
| What the agent can touch | The whole machine: root, SSH, any package, any process | The browser only, through Puppeteer, Playwright, CDP or MCP |
| Docker and nested virtualization | Docker, systemd and /dev/kvm on every machine | Not offered; there is no shell on the browser host |
| Session length | No cap on paid plans; you set the time to live | No fixed maximum while active; closes after 60 s idle (up to 10 min with keep_alive) and on new releases |
| Files after a session | The disk persists, with snapshots every minute and on stop; a stopped sandbox costs nothing | Nothing is kept; your code has to save and reload cookies and storage itself |
| Fork | Fork a running sandbox with its disk | No fork; every session starts fresh |
| Browser and computer use | 60fps desktop and Chromium, computer use on any app, embeddable stream | Chrome with Live View, human handoff and opt-in session recordings (DOM events, kept 30 days) |
| One-call web tasks | Run your own scripts on the VM | REST endpoints for screenshots, PDFs, Markdown, links, AI JSON extraction and multi-page crawls |
| Bot detection | Datacenter IPs and Chromium; no CAPTCHA solving | Cloudflare IP ranges, no IP rotation, always identified as bot traffic |
| Reaching the machine | HTTPS URLs for up to 50 ports, token-protected; raw TCP; own IP | CDP WebSocket and Live View links only; no ports to host on |
| Outbound rules | Open internet, no provider-side allowlist | Guardrails: up to 50 allowed hostnames plus shared domain sets, fixed at session start |
| Agents | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API | Your agent connects from outside through MCP or Stagehand; none runs inside |
| Where it runs | EU only (Germany, Finland and France) | Cloudflare's global network, close to the incoming request |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | SOC 2 |
Every feature Battleships tracks (43)
| Feature | bochka | Cloudflare Browser Run |
|---|---|---|
| Full VM (own kernel) | Yes | No |
| Docker inside | Yes | No |
| Nested virtualization | Yes | No |
| Root | Yes | Not published |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | No |
| Browser | Yes | Yes |
| Computer-use API | Yes | Yes |
| SSH | Yes | No |
| Persistent disk | Yes | No |
| Pause/resume | Yes | No |
| Automatic snapshots | Yes | No |
| Fork/clone | Yes | No |
| Live fork (no pause) | Yes | No |
| Memory fork | No | No |
| Custom image (Docker or snapshot) | Yes | Not published |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | Yes |
| Wake on request | No | No |
| HTTPS preview URLs | Yes | No |
| Raw TCP inbound | Yes | Not published |
| Public IPv4 | No | No |
| Egress allowlist | No | Yes |
| Secret proxy | Yes | No |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | No |
| Agent harness API | Yes | No |
| MCP server | No | Yes |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | No |
| BYOC | No | No |
| Open source | No | No |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Not published |
| SSO | No | Yes |
| SOC 2 | No | Yes |
| HIPAA | No | Yes |
| EU data residency | Yes | No |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement. Browser Run was not in StarSling's public CPU benchmark, and Cloudflare does not publish the vCPU or RAM behind a browser session, so there is no number to set against bochka's 26.69 runs per second at 4 vCPU / 8 GB.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Cloudflare Browser Run has 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 | bochka, a month | Cloudflare Browser Run, 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 | $20 · $20/mo | $18 · Workers Paid · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $70 · Workers Paid · with limits |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $317 · $20/mo × 3 seats | $717 · Workers Paid · with limits |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $200 · $100/mo × 2 seats | $409 · Workers Paid · with limits |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $2,000 · $2000/mo · with limits | $899 · Workers Paid · with limits |
bochka: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Cloudflare Browser Run: You need Workers Paid ($5 a month). It includes 10 browser hours a month, then $0.09 an hour, with the month's seconds rounded to the nearest hour. Browser Sessions also pay for concurrency: 10 browsers included, then $2 a month for each extra one, counted as the monthly average of your daily peak.
Cloudflare Browser Run: A browser that is not closed keeps billing until its idle timeout ends. Workers requests and CPU from the code that drives the browser are billed on top, and Kitesurf is free while in beta.
Limits in those scenarios
The Browser Run prices in the table are for a browser session with no published size and no disk that stays, so none of them is a 4 vCPU / 8 GB machine, and a browser service is not a full fit for any of the five scenarios. Workers Paid allows 200 browsers at once by default and 3 new ones a second, so sandboxes for your users and 1,000 short jobs at once need a limit increase from Cloudflare. On bochka, the 1,000-job burst is the one that does not fit: bursts above 90 starts a minute are queued, and it needs more starts per day than the top plan allows.
| Scenario | bochka | Cloudflare Browser Run |
|---|---|---|
| One coding agent, workdays | None that bite |
|
| One agent that never stops | None that bite |
|
| 50 agents in parallel | None that bite |
|
| Sandboxes for your users | None that bite |
|
| 1,000 short jobs at once |
|
|
Which one should you use?
Use Cloudflare Browser Run when
your agent only needs the web: screenshots, PDFs, Markdown or crawls from one REST call, or many short Chrome sessions run from Workers close to your users, with hostname guardrails and a human handoff.
- Web tasks in one call. Useful when you only need a page's output: screenshots, PDFs, Markdown, JSON extraction and crawls from a single REST request.
- Hostname guardrails and a human handoff. Useful when a browsing agent must stay on approved sites, or a person must step in to finish a task.
- Browsers next to your users, on Workers. Useful if your app already runs on Workers or your users are spread worldwide: browsers open close to each request.
Use bochka when
your agent browses and also works: installs, builds, Docker and dev servers on a full VM that keeps its disk and logins, with coding agents and a key proxy built in.
- A whole machine, not only a browser. An agent that reads a page and then has to clone a repo, run docker compose or start a dev server needs a second provider next to Browser Run, and has to move files between the two.
- Keeps its disk and its logins. On Browser Run your code has to save and reload cookies and storage itself, and downloads or notes from the last session are gone, so a long task must be built to restart from scratch.
- Coding agents you drive from outside, keys kept outside. With Browser Run you run the agent loop yourself, in a Worker or on your own machine, and hold every model and API key in that code.
Questions people ask
Is bochka cheaper than Cloudflare Browser Run?
The table sets a 4 vCPU / 8 GB bochka VM against a Browser Run session that keeps no disk. One agent that never stops comes to $26 on bochka against $70, and 50 agents in parallel to $317 against $717. Browser Run is lower for a workday agent ($18 against $20) and for 1,000 short jobs at once, $899 against $2,000, though neither fits that last one.
Can Cloudflare Browser Run run Docker or a shell?
No. A Browser Run session gives you Chrome over CDP or REST, and your own logic runs in a Worker. Every bochka sandbox has root, SSH, Docker, systemd and /dev/kvm.
How long can a Browser Run session last?
There is no fixed maximum while the browser is active, but it closes after 60 seconds idle by default, or up to 10 minutes with keep_alive, and when Cloudflare rolls out a new release. Nothing is saved when it closes. bochka has no session cap on paid plans and keeps the disk when you stop.
What is Cloudflare Kitesurf?
Kitesurf is a stateless browser that runs on top of Workers, made for AI agents and free while in beta. It does not yet handle video, WebGL, bot challenges that check real TLS fingerprints, or long logged-in sessions, so Cloudflare points those to its Chromium browser.
Can I use bochka and Browser Run together?
Yes. An agent on a bochka sandbox can call Quick Actions or open a Browser Run session over CDP, and keep its code, files and tools on the bochka VM. That puts quick page fetches on Cloudflare and the rest of the work on a machine that keeps its disk.
Is bochka SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention. bochka runs only in the EU, with a zero data retention option.
Start a sandbox
Install the CLI, then run bochka new.
Product preview