Browserbase vs Zenrows
Browserbase is a browser platform: Chrome sessions of up to 6 hours with saved logins, CAPTCHA solving, live view and replays. Zenrows is a web data service: remote Chrome on rotating residential IPs that closes after at most 15 minutes, next to Fetch, Extract and Crawl APIs on one credit balance.
The companies and products
Browserbase
Browserbase calls itself the complete platform to build and deploy agents that browse and interact with the web like humans: browsers, search, fetch, functions, model access and identity behind one API key.
Its core product is a headless Chrome session you drive over CDP with Playwright, Puppeteer or its open source Stagehand SDK, with proxies, CAPTCHA solving, saved browser profiles (Contexts), live view and session replays. Around it sit Search and Fetch APIs, short TypeScript Functions that run next to the browser, a Model Gateway and hosted Agents that work from a plain language goal. It is a browser platform, not a general sandbox: you get a browser, not a shell or root on the machine, so this page compares where the two overlap, which is agents that browse.
Zenrows
Zenrows calls itself web data infrastructure built for agents and applications: APIs that fetch, extract, crawl and browse protected websites.
Browser Sessions (formerly Scraping Browser) is a remote Chrome you connect to over a WebSocket and drive with Puppeteer or Playwright through the Chrome DevTools Protocol. Each session runs on rotating residential IPs and closes after 1 to 15 minutes. It is a different kind of product from bochka: a managed browser for scraping and web tasks, not a machine you get a shell on, so this page compares where the two overlap, which is browser and web agents.
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. “24th cheapest of 367” means 23 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 | Browserbase: price rank | Zenrows: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Neither gives a coding agent a shell, Docker or a disk, so builds and tests fit bochka and not either browser service. | 140th of 367, with limits $1,255 a month | 59th of 367, with limits $448 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 its machine all month hits a 6-hour cap on Browserbase and a 15-minute cap on Zenrows; bochka has no session cap on paid plans. | 259th of 366, with limits $3,699 a month | 126th of 366, with limits $833 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 | 270th of 345, with limits $382 a month | 232nd of 345, with limits $166 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 | 250th of 361, with limits $1,099 a month | 203rd of 361, with limits $361 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 | 264th of 360, with limits $5,049 a month | 229th of 360, with limits $1,111 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 | 349th of 364, with limits $449 a month | 230th of 364, with limits $166 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 CI jobs need a shell, Docker and often /dev/kvm, which bochka has and neither browser session does. | 244th of 377, with limits $152 a month | 221st of 377, with limits $83 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box has to keep its files and processes, and both Browserbase and Zenrows start every session from scratch, so this fits bochka. | 251st of 368, with limits $96 a month | 232nd of 368, with limits $58 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 Browserbase agents act on web pages through Stagehand and Zenrows exposes a browser over CDP, while bochka streams a 60fps Linux desktop where an agent can use any app. | 159th of 369, with limits $416 a month | 93rd of 369, with limits $166 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 All three fit: Zenrows ranks 5th with residential IPs and short sessions, bochka ranks 7th with Chromium on a full VM, and Browserbase ranks 24th with longer sessions, replays and CAPTCHA solving. | 24th cheapest of 367 $449 a month | 5th cheapest of 367 $166 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 Zenrows brings residential IPs on by default and scraping APIs, Browserbase brings CAPTCHA solving and Fetch and Search APIs, and bochka runs your own scrapers, queues and databases on one machine. | 55th cheapest of 346 $537 a month | 18th cheapest of 346 $227 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 Browserbase ranks 13th here, ahead of Zenrows at 70th: its CAPTCHA solving and Verified browsers target sites that block bots, while Zenrows Browser Sessions cannot solve CAPTCHAs. | 13th of 338, with limits $9,799 a month | 70th of 338, with limits $1,791 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 | 229th of 360, with limits $291 a month | 149th of 360, with limits $115 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 | Can't run it | 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 | Browserbase | Zenrows | bochka |
|---|---|---|---|
| Kind of product | Managed headless Chrome, plus Search, Fetch, Functions, a Model Gateway and hosted browser Agents | Remote Chrome (Browser Sessions) next to Fetch, Extract, Crawl and Batch APIs on one credit balance | A full Linux VM per sandbox, with a desktop and Chromium inside |
| Isolation | 1 browser per VM in its own subnet; the VM is destroyed after each session | Not published | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Session length | Up to 6 hours on Developer and Startup, 15 minutes on Free, 6+ hours on Scale | 1 to 15 minutes, 3 by default, then the session closes | No cap on paid plans; you set the time to live |
| State between sessions | Contexts keep the browser profile (cookies, localStorage, IndexedDB), encrypted at rest | Session closes and frees its resources; no saved state documented | The whole disk persists, saved every minute and on stop; a stopped sandbox costs nothing |
| Shell, root and Docker | No shell on the browser VM; Functions run short TypeScript with no containers | No shell; browser control over CDP only | Root, SSH, systemd, Docker and /dev/kvm on every machine |
| Browser control | Playwright, Puppeteer or the open source Stagehand SDK over CDP | Puppeteer or Playwright over CDP; viewport, user agent and some device settings are blocked | Chromium on your own VM: install any tool or extension and change any setting |
| Watching a session | Live view, session replays and logs | No desktop stream; screenshots and page actions through CDP or MCP tools | 60fps desktop stream with computer use on any app, embeddable in your app |
| Residential IPs | Managed residential proxies in 200+ countries on paid plans, off by default, billed per GB after 1 or 5 GB | Over 55 million residential IPs in 190+ countries, on by default and rotating on every request | Traffic leaves from EU data centers; bring your own proxy |
| CAPTCHA and bot walls | CAPTCHA solving on paid plans, Verified browsers with real fingerprints on Scale | Browser Sessions cannot solve CAPTCHAs; the Fetch API has anti-CAPTCHA features | None built in; you run your own tools |
| Agents | Its own hosted browser Agent from a plain language goal, with built-in tools only | Hosted or local MCP server with scrape, extract, crawl and browser tools; no agent runs inside | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Hosting from the machine | CDP connect URL and live view links only; no ports to host on | None; you connect out to a shared Zenrows endpoint | HTTPS URLs for up to 50 ports, token-protected; raw TCP |
| Keeping keys out of the sandbox | Model Gateway reaches OpenAI, Anthropic and Google with your Browserbase key | Not documented; auth is your Zenrows API key | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Regions | Oregon, Virginia, Frankfurt and Singapore, picked per session | Primarily hosted on DigitalOcean, no region to choose; proxy exits worldwide | EU only (Germany, Finland and France), with EU data residency |
| How you pay | Browser hours: 100 on Developer ($20), 500 on Startup ($99), then $0.12 or $0.10 an hour, billed by the minute | Monthly credit plans shared by all products; a browser session costs 5 credits a minute plus bandwidth | Monthly plan from $20, all of it usage credit spent per second; stopped sandboxes cost nothing |
Every feature Battleships tracks (43)
| Feature | Browserbase | Zenrows | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | No | Not published | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | No | No | Yes |
| Persistent disk | No | No | Yes |
| Pause/resume | No | No | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | No | Not published | Yes |
| ≥24 h sessions | No | No | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | No | No | Yes |
| Raw TCP inbound | No | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Not published | No | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
There is no comparable measurement for either. Browserbase and Zenrows do not publish the vCPU or RAM behind a browser session, and neither was in StarSling's public CPU benchmark. bochka did 26.69 runs per second at 4 vCPU / 8 GB in that run.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Browserbase and Zenrows 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 | Browserbase, a month | Zenrows, 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 | $99 · Startup · with limits | $2,499 · Scale S5 (annual) · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $122 · Startup · with limits | $2,499 · Scale S5 (annual) · 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 | $841 · Startup · with limits | $2,499 · Scale S5 (annual) · 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 | $499 · Startup · with limits | $2,499 · Scale S5 (annual) · 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 | $1,049 · Startup · with limits | $2,499 · Scale S5 (annual) · with limits | $2,000 · $2000/mo · with limits |
Browserbase: Plans include browser hours: 100 on Developer ($20) and 500 on Startup ($99), then $0.12 or $0.10 per browser hour, billed by the minute with a one-minute minimum. Proxy data is extra after 1 GB or 5 GB ($12 or $10 per GB), and Search, Fetch and Agents have their own allowances.
Zenrows: Monthly credit plans from a free 5,000 credits up to Scale S5, shared by all Zenrows products. A browser session costs 5 credits per minute plus bandwidth at 25,000 credits per GB, and plan credits expire at each renewal.
Zenrows: 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.
Limits in those scenarios
Session length is the limit that bites first: Browserbase stops at 6 hours and Zenrows at 15 minutes, so neither fits the workday agent or the always-on agent, and neither keeps a disk. Zenrows does not fit any scenario on this page, even priced at $2,499 a month on its Scale S5 annual plan. Browserbase Startup allows 100 browsers at once, so 300 sandboxes for your users or 1,000 short jobs at once need Scale through sales, while Zenrows Scale S5 allows 400. On bochka, the 1,000-job burst is the one that does not fit: bursts above 90 starts a minute are queued.
| Scenario | Browserbase | Zenrows | bochka |
|---|---|---|---|
| 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 Browserbase when
your browser tasks run for hours, need logins saved between sessions, hit CAPTCHAs, or need replays and browsers in the US or Singapore.
- Longer sessions with saved logins. Useful when a browser task runs for hours: sessions last up to 6 hours, and Contexts keep logins for the next session.
- CAPTCHA solving and Verified browsers. Useful for sites that throw CAPTCHAs: paid plans solve them, and Scale adds Verified browsers with real fingerprints.
- Replays and regions. Useful when you need to see what happened: live view and replays of every session, in the US, Frankfurt or Singapore.
Use Zenrows when
your agent opens protected pages for a few minutes at a time from rotating residential IPs, or when you want Fetch, Extract and Crawl APIs and an MCP server on one credit balance.
- Residential IPs by default. Useful for protected pages: over 55 million residential IPs in 190+ countries rotate on every request, with no setup.
- A web data toolbox on one balance. Fetch, Extract, Crawl and Batch share one credit balance with the browser, and an MCP server hands them to any agent.
- Short visits stay small. Good for quick, spiky page visits: a session costs 5 credits a minute, closes on its own, and the free plan needs no card.
Where bochka fits
Browserbase and Zenrows both rent a browser, not a machine. If what you are really running is agents that browse and then also work, by saving files, running code, starting Docker or staying logged in for days, a bochka sandbox gives each one a full VM with Chromium on a desktop inside. For bot walls at volume, Browserbase or Zenrows still does that job better, and an agent on bochka can call either one.
A whole machine around the browser
Neither gives your agent a shell, Docker or a disk. Browserbase Functions run short TypeScript with no persistent storage, so builds, dev servers and databases need a second provider, and files move between the two after every step.
No session cap, a disk that stays
Browserbase ends a session after 6 hours and keeps only the browser profile; Zenrows closes after 15 minutes and keeps nothing, about 32 reconnects in an eight-hour shift. bochka has no cap on paid plans and saves the disk every minute.
A desktop and coding agents you drive from outside
bochka streams a 60fps desktop for computer use on any app and ships Claude Code, Codex and more with a prompt, steer and events API. Browserbase runs only its own fixed-tool Agent, and Zenrows has no agent or desktop stream.
Use bochka when your agent browses as part of real work: running code and Docker next to the browser, keeping files and logins on a disk that stays, and being watched on a 60fps desktop for as long as the task takes. Compare it one to one: bochka vs Browserbase and bochka vs Zenrows.
Questions people ask
Is Browserbase cheaper than Zenrows?
For short browsing it usually is not: browser-use agents come to $166 a month on Zenrows against $449 on Browserbase, and startup-scale scraping to $227 against $537. For anything that runs longer than 15 minutes, Zenrows does not fit, even at $2,499 a month on Scale S5, while Browserbase Startup is $99 a month for the workday agent and still stops at 6 hours.
Which is faster, Browserbase or Zenrows?
There is no measurement to compare. Neither publishes the CPU or memory behind a session, and neither is in StarSling's public CPU benchmark. bochka did 26.69 runs per second at 4 vCPU / 8 GB in that benchmark.
Can Browserbase or Zenrows run Docker?
No. Both give you a Chrome over CDP, not a shell on the machine. Browserbase Functions run short TypeScript with no containers, while every bochka sandbox has root, SSH, Docker, systemd and /dev/kvm.
How long can a session run on Browserbase and Zenrows?
Browserbase sessions last up to 6 hours on Developer and Startup, 15 minutes on Free and 6+ hours on Scale. Zenrows sessions last 1 to 15 minutes, 3 by default. bochka has no session cap on paid plans.
Which one solves CAPTCHAs?
Browserbase solves CAPTCHAs on its paid plans and adds Verified browsers on Scale. Zenrows Browser Sessions cannot solve CAPTCHAs, though its Fetch API has anti-CAPTCHA features. bochka has no CAPTCHA solving built in.
Can I use bochka with Browserbase or Zenrows?
Yes. An agent on a bochka sandbox can open a Browserbase or Zenrows session over CDP, or call their Fetch APIs, and keep its code, files and tools on the bochka VM. That puts protected browsing on the browser service and the rest of the work on a machine that keeps its disk.
Try bochka
Install the CLI, then run bochka new.
Product preview