bochka vs Scrapfly
Scrapfly Cloud Browser is a remote Chromium you drive over CDP, built to get past anti-bot walls, and each session ends after 30 minutes at most. bochka gives each agent a full Linux VM with its own kernel, a 60fps desktop and Chromium, Docker and a disk that persists, for as long as the work takes.
Where bochka stands out
A whole computer, not only a browser
On bochka each agent gets a full Linux VM with its own kernel, root, systemd and Docker, and Chromium runs on the same machine. The agent can download a file, open it with a script, run a build and check the result in the browser. Scrapfly gives you a browser over CDP; any code runs on your own servers.
Work that lasts longer than 30 minutes
bochka has no session cap on paid plans, and the disk persists with snapshots every minute and on stop, so a stopped sandbox comes back with all its files and costs nothing while off. A Scrapfly session ends after 30 minutes at most, and only the browser profile is saved.
Coding agents built in
bochka ships Claude Code, Codex, OpenCode and other agents inside each sandbox, and you drive them from outside with a prompt, steer and events API. The AI credentials proxy keeps real keys out of the sandbox and can switch to another account when one runs out of credits.
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
Scrapfly
Scrapfly is a managed web scraping and browser automation platform; Cloud Browser is its remote browser product.
Cloud Browser gives you a remote Chromium session (Scrapium) that you connect to over a WebSocket with the Chrome DevTools Protocol, from Playwright, Puppeteer or agent frameworks. Sessions come with datacenter or residential proxies, browser fingerprints, a captcha solver, an unblock endpoint and optional live VNC control. It is a browser API for scraping and web agents, not a general sandbox: there is no shell, filesystem or container to run your own code in.
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 | Scrapfly: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Scrapfly is only a compromise here: an agent that installs, builds and tests needs a shell, a disk and Docker, and a Cloud Browser session has none of them. | 3rd cheapest of 367 $634 a month | 117th of 367, with limits $1,089 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB A Scrapfly session ends after 30 minutes and keeps no files, so an assistant that works all day needs a machine like bochka's. | 5th cheapest of 366 $657 a month | 119th of 366, with limits $724 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month | 186th of 345, with limits $2,000 a month | 221st of 345, with limits $100 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 | 248th of 361, with limits $1,066 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 | 223rd of 360, with limits $739 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 | 228th of 364, with limits $100 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Scrapfly runs a browser, not your build, so CI jobs belong on a VM. | 4th cheapest of 377 $86 a month | 283rd of 377, with limits $496 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 18th cheapest of 368 $26 a month | 256th of 368, with limits $100 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Both fit; Scrapfly's live VNC shows the browser window, while bochka streams a whole 60fps Linux desktop. | 6th cheapest of 369 $200 a month | 20th cheapest of 369 $913 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Both fit: Scrapfly hands your agent a remote Chromium over CDP, and bochka gives it Chromium on a full VM where it can also save files and run code. | 7th cheapest of 367 $200 a month | 33rd cheapest of 367 $915 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; bochka runs your scraper and its browser on one machine with a disk, and Scrapfly bills browser time and bandwidth from shared credits. | 6th cheapest of 346 $90 a month | 78th cheapest of 346 $1,659 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month Scrapfly fits mass scraping of guarded sites better: residential proxies, fingerprints, a captcha solver and an unblock endpoint come built in, while on bochka you bring your own proxies and solvers. | 71st of 338, with limits $1,800 a month | 21st of 338, with limits $19,164 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month bochka gives each attacker or target a full VM with root and Docker; Scrapfly can only play the browser side. | 2nd cheapest of 360 $200 a month | 57th of 360, with limits $208 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 | Scrapfly |
|---|---|---|
| What you get | A full Linux VM with its own kernel, root and systemd | A remote Chromium session reached over a CDP WebSocket; no shell or OS access |
| Browser and desktop | 60fps Linux desktop with Chromium, computer use and browser control, embeddable stream | Chromium over CDP for Playwright and Puppeteer; live VNC or WebRTC control of the browser, embeddable viewer kit |
| Anti-bot and captchas | None built in; bring your own proxies and solvers | Fingerprints, a captcha solver (Turnstile, reCAPTCHA, GeeTest, DataDome slider and more) and an unblock endpoint |
| Outbound IPs | The machine's own IP, dedicated IPv6 or IPv4 | Datacenter or residential proxy pool, with a country chosen per session |
| Session length | No session cap on paid plans | 15 minutes by default, 30 minutes at most, then the session ends |
| What survives a stop | The whole disk, with snapshots every minute and on stop; a stopped sandbox costs nothing | Only the browser profile (cookies, storage, fingerprint), and only as a handoff to the Web Scraping API; tabs and files are lost |
| Reconnecting later | Stop and start the same sandbox any time; it boots from its saved disk | Reconnect to a session kept open with auto_close=false; it keeps billing while you are away |
| Running your own code | Any language, Docker, root and /dev/kvm on every machine | Your code runs on your side and drives the browser remotely |
| Fork | Fork a running sandbox into copies | No fork or clone of a session |
| Reaching services inside | HTTPS URLs for up to 50 ports, raw TCP, own IP | Only the CDP and VNC endpoints of the session |
| Agents | Claude Code, Codex, OpenCode and more preinstalled, driven from outside with a prompt, steer and events API | An MCP endpoint in the browser and a CLI agent that runs on your machine with your own model key |
| Keeping secrets out of reach | AI credentials proxy: real keys for model providers or any HTTPS API never enter the sandbox | Credential vault autofills login passwords into the browser so your script never sees them |
| Where it runs | EU only (Germany, Finland, France), with EU data residency and zero data retention | Hosting region not published; proxies exit in many countries; EU transfers covered by SCCs |
| 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 | Scrapfly |
|---|---|---|
| Full VM (own kernel) | Yes | Not published |
| Docker inside | Yes | No |
| Nested virtualization | Yes | No |
| Root | Yes | Not published |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | Yes |
| 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 | No |
| 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 | No |
| 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 | Yes |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Not published |
| SSO | No | No |
| SOC 2 | No | Yes |
| HIPAA | No | Yes |
| EU data residency | Yes | No |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement. Scrapfly does not publish the CPU or memory behind a browser session and was not in the public sandbox benchmark. bochka did 26.69 runs per second there on its dedicated AMD Ryzen 9 9950X (Zen 5) hosts 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. Scrapfly 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 | Scrapfly, 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 | $500 · Enterprise · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $500 · Enterprise · 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 | $500 · Enterprise · 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 | $980 · Enterprise · 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 | $500 · Enterprise · 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.
Scrapfly: Scrapfly sells monthly credit plans shared across all its APIs. A browser session uses 1 credit per 30 seconds, plus credits for every MB of traffic (more on residential proxies), a 5-credit minimum, and extra for captchas solved or VNC. Pro and up can buy more credits; Custom plans start from $1,200.
Limits in those scenarios
The limit that bites on Scrapfly is the 30-minute session cap: one agent on workdays, one agent all month and 50 agents in parallel all need longer sessions and a disk, so none of them fit, even on Enterprise. Enterprise also allows 100 sessions at once, short of 300 sandboxes for your users or 1,000 short jobs. On bochka the limit is a sandbox count (100 to 2,000 by plan) plus starts per minute, so the 1,000-job burst gets queued and needs more starts per day than the $2,000 plan allows.
| Scenario | bochka | Scrapfly |
|---|---|---|
| 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 Scrapfly when
your agent only needs a browser on guarded sites, for short sessions, with residential proxies, captcha solving and unblocking done for you.
- Built to get past anti-bot walls. Useful if your targets fight bots: Scrapfly solves Turnstile, reCAPTCHA and GeeTest and can clear a full-page wall before you connect.
- Residential proxies in many countries. Useful if a site must see a visitor from a given country or a home connection: pick the proxy pool and country per session.
- One API for the whole scraping job. Useful if you mostly scrape: the same credits cover a Scrape API, screenshots, extraction and a crawler next to the browser.
Use bochka when
your agent needs a real computer around its browser: code, files, Docker and a desktop that last for hours, with coding agents built in.
- A whole computer, not only a browser. An agent that scrapes a page and then has to process what it found needs somewhere to run code and keep files. With Scrapfly you run and pay for that second machine yourself, and move the data between the two.
- Work that lasts longer than 30 minutes. A long research or login-heavy task gets cut at 30 minutes and loses open tabs and downloads. Keeping a Scrapfly session alive between steps with auto_close=false also keeps it billing.
- Coding agents built in. Scrapfly's agent mode is a CLI on your machine using your own model key. You still host, start and watch the agent yourself, and a key in that process can leak.
Questions people ask
Is Scrapfly Cloud Browser a sandbox?
No. It is a remote Chromium session you control over CDP, with no shell, filesystem or containers for your code. Your code runs on your own servers and drives the browser. bochka gives each agent a full Linux VM with Chromium on it.
How long can a Scrapfly browser session run?
15 minutes by default and 30 minutes at most, then it is terminated and cannot be reconnected. Open tabs and live page state are lost; only the browser profile is saved. bochka has no session cap on paid plans and keeps the whole disk.
Is bochka cheaper than Scrapfly?
For agent work, bochka is far cheaper in the scenarios we priced, and it fits where Scrapfly does not: one agent on workdays is $20 a month on bochka against $500 on Scrapfly Enterprise, and 50 agents in parallel are $317 against $500. Scrapfly's 30-minute session cap means none of those fit there. For 1,000 short jobs at once neither fits, at $2,000 on bochka and $500 on Scrapfly.
Does bochka solve captchas or offer residential proxies?
No. bochka runs Chromium on a full VM that exits through its own IP in the EU, and you bring any proxies or captcha services you need. Scrapfly builds both in, which is why it is the better pick for scraping well-guarded sites.
Can I watch and take over the browser?
Both let you. Scrapfly offers live VNC or WebRTC control of a session, with an embeddable viewer and a password per session. bochka streams the whole Linux desktop at 60fps, and you can embed it in your app.
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. Scrapfly lists SOC 2 Type II and ISO 27001 on its compliance page.
Start a sandbox
Install the CLI, then run bochka new.
Product preview