Browserless vs Zenrows
Browserless is a browser API: headless Chrome, Firefox and WebKit for up to 60 minutes, with CAPTCHA solving, saved profiles and a Docker image you can run yourself. Zenrows is a web data service whose Browser Sessions are remote Chrome tabs on rotating residential IPs that close after at most 15 minutes.
The companies and products
Browserless
Browserless calls itself a cloud browser automation platform: managed headless browsers you connect to with one line of code.
You point existing Puppeteer, Playwright or Selenium code at a Browserless WebSocket URL, or use BrowserQL, its GraphQL language with stealth and CAPTCHA solving, REST endpoints for screenshots, PDFs and scraping, and an MCP server. Sessions are short (2 to 60 minutes by plan), and only the browser profile can be kept between them. It is a browser product, 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. “19th cheapest of 367” means 18 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 | Browserless: 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 browser service gives a coding agent a shell, Docker or a disk, so builds and tests fit bochka, which ranks 3rd. | 170th of 367, with limits $1,771 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 60-minute cap on Browserless and a 15-minute cap on Zenrows; bochka has no session cap on paid plans. | 297th of 366, with limits $6,170 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 | 267th of 345, with limits $350 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 | 264th of 361, with limits $1,490 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 | 279th of 360, with limits $8,600 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 | 247th of 364, with limits $350 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 | 241st of 377, with limits $140 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 files and processes, which neither browser session does; bochka ranks 18th here. | 336th of 368, with limits $350 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 Neither Browserless nor Zenrows streams a desktop, so a computer-use agent sees only a browser page; bochka ranks 6th with a 60fps desktop. | 141st of 369, with limits $350 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, Browserless ranks 19th with longer sessions and saved profiles, and bochka ranks 7th with Chromium on a full VM. | 19th cheapest of 367 $350 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 All three fit at startup scale; Zenrows adds Fetch, Extract and Crawl APIs, Browserless adds REST screenshots and PDFs, and bochka runs your own scrapers next to a database. | 47th cheapest of 346 $478 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 Browserless ranks 20th here, ahead of Zenrows at 70th, because BrowserQL stealth and CAPTCHA solving are built for sites that block bots; bochka uses datacenter IPs and ranks 71st. | 20th of 338, with limits $17,150 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 Red teaming needs a whole machine an agent can attack, not a browser tab, so bochka ranks 2nd and both browser services trail far behind. | 247th of 360, with limits $350 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 | Browserless | Zenrows | bochka |
|---|---|---|---|
| Kind of product | Managed headless Chrome, Firefox and WebKit, plus BrowserQL, REST APIs and an MCP server | Fetch, Extract, Crawl, Batch and Browser Sessions, sharing one credit balance | A full Linux VM per sandbox, with a desktop and Chromium inside |
| Session length | 2 minutes on Free, 15 on Prototyping, 30 on Starter, 60 on Scale; custom on Enterprise | 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 | Persisted sessions keep cookies, localStorage and cache for 1 to 90 days by plan | Session closes and frees its resources; no saved state documented | The disk persists, with snapshots every minute and on stop; a stopped sandbox costs nothing |
| Shell, root and Docker | No shell or SSH; browser control over CDP, BrowserQL or REST | No shell; browser control over CDP only | Root, SSH, systemd, Docker and /dev/kvm on every machine |
| Browser control | Puppeteer, Playwright or Selenium over WebSocket, or BrowserQL | Puppeteer or Playwright over CDP; viewport, user agent and some device settings are blocked | Chromium on your own VM: install any tool and change any setting |
| Outbound IPs | Built-in residential and datacenter proxies, or your own on paid plans | Over 55 million residential IPs in 190+ countries, rotating by default, with country targeting | Traffic leaves from EU data centers; bring your own proxy if you need other IPs |
| CAPTCHA solving | BrowserQL solves reCAPTCHA and image challenges, with stealth and fingerprint mitigations | Browser Sessions cannot solve CAPTCHAs; the Fetch API has anti-CAPTCHA features | None built in; you run your own tools |
| Desktop and computer use | Headless browsers, live URLs that hand a session to a person, computer-use integrations | No desktop stream; screenshots and page actions through CDP or MCP tools | 60fps desktop with Chromium, computer use on any app, embeddable stream |
| Agents | Its own browser agent (Agent Run API, beta), up to 15 minutes and 60 steps per turn | Tools for your agent to call; no agent runs inside Zenrows | Claude Code, Codex, OpenCode and more preinstalled, driven from outside with a prompt, steer and events API |
| Most browsers at once, self-serve | 100 on the Scale annual plan | 400 on the Scale S5 annual plan | 300 at once fits the table's user-sandbox scenario; starts per minute and per day are capped by plan |
| Hosting from the machine | Fixed regional endpoints and short-lived live URLs; 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 your code | 1Password integration fills logins into the page without the value reaching your code | 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 |
| Self-hosting | Open source Docker image you can run yourself; commercial use needs a license | Hosted only | Hosted only |
| Where it runs | San Francisco, London and Amsterdam; New York on private fleets | Primarily hosted on DigitalOcean, no region to choose; proxy exits worldwide | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Browserless | Zenrows | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | No | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | Not published | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | 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) | Not published | 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 | Not published | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | No | 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 | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | Yes | No | No |
| BYOC | Yes | No | No |
| Open source | Yes | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | No | 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 | Not published | Not published | Yes |
Performance
There is no comparable measurement for either. Browserless and Zenrows do not publish the vCPU or RAM behind a browser session, and neither is in StarSling's hpc-sandbox-benchmarks run, where bochka did 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. Browserless 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 | Browserless, 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 | $350 · Scale annual · 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 | $350 · Scale annual · 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 | $1,026 · Scale annual · 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 | $410 · Scale annual · 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,400 · Scale annual · with limits | $2,499 · Scale S5 (annual) · with limits | $2,000 · $2000/mo · with limits |
Browserless: Browserless bills in units: one unit is up to 30 seconds of a connected browser, and a reconnect starts a new block. Plans include 20,000, 180,000 or 500,000 units a month, proxy traffic and CAPTCHA solves use the same units, and annual billing is 30% lower and adds concurrency.
Zenrows: Zenrows sells monthly credit plans shared by all its products. A browser session costs 5 credits a minute plus bandwidth at 25,000 credits per GB, and plan credits expire at each renewal.
Zenrows: Plans start at $20 a month, and the whole fee becomes usage credit spent per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Session length is the limit that bites for both: 60 minutes on Browserless Scale and 15 minutes on Zenrows, so neither fits the workday agent, the always-on agent or the 50-agent fleet, and neither keeps a disk or runs Docker. Concurrency comes next: Browserless Scale annual allows 100 browsers at once, so 300 user sandboxes and 1,000 short jobs need Enterprise, 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 | Browserless | 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 Browserless when
your web tasks run up to an hour and need saved logins, CAPTCHA solving, Firefox or WebKit, a live hand-off to a person, or a browser you can run on your own servers.
- Longer sessions with saved logins. Useful for multi-step web tasks: Scale sessions last 60 minutes, and saved profiles keep cookies and cache for up to 90 days.
- CAPTCHA solving and stealth. Useful for sites that throw challenges: BrowserQL solves reCAPTCHA and image challenges, which Zenrows Browser Sessions cannot.
- Run it on your own machines. Useful if browsers must stay inside your network: the Browserless Docker image is open source and can be self-hosted.
Use Zenrows when
you need short visits to protected pages from residential IPs in many countries, many browsers at once, or ready-made Fetch, Extract and Crawl APIs instead of scripts.
- Residential IPs in 190+ countries. Useful for protected sites: over 55 million residential IPs rotate by default, and you can pick the country.
- A full web data toolbox. Useful when you want data, not scripts: Fetch, Extract, Crawl and Batch share one credit balance with the browser.
- More browsers at once, pay per minute. Good for short, spiky visits: 5 credits a browser minute, up to 400 at once on Scale S5, and a free plan with no card.
Where bochka fits
Browserless and Zenrows are both browser services, not sandboxes, so if your agent only reads web pages, pick between them on CAPTCHAs, IPs and session length. If what you are really running is agents that browse and then work, cloning repos, running code, keeping files for hours, look at bochka. Each bochka sandbox is a full VM with Chromium on a 60fps desktop, and you can still call Browserless or Zenrows from it for protected sites.
A whole machine next to the browser
Neither Browserless nor Zenrows gives you a shell, Docker or a disk. An agent that finds something on a page and has to build or test it needs a second machine, and you move files between the two after every step.
Runs as long as the task, keeps its disk
Browserless ends a session after at most 60 minutes 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 session cap on paid plans and saves the disk every minute.
Coding agents and a desktop you can watch
bochka ships Claude Code, Codex and OpenCode, driven from outside, and streams a 60fps desktop for computer use on any app. Browserless has a beta agent capped at 15 minutes a turn; Zenrows runs no agent and shows no desktop.
Use bochka when your agent browses as part of real work: running code and Docker next to the browser, keeping files and logins for hours, or being watched on a 60fps desktop. Compare it one to one: bochka vs Browserless and bochka vs Zenrows.
Questions people ask
Is Browserless cheaper than Zenrows?
It depends on the job. For browser-use agents the table puts Zenrows at $166 a month against $350 on Browserless, and for startup scraping $227 against $478. For mass scraping that needs to get past bot walls, Zenrows is lower at $1,791 against $17,150, but Browserless ranks higher because it solves CAPTCHAs.
Which is faster, Browserless or Zenrows?
There is no comparable measurement. Neither publishes the CPU or RAM behind a browser session, and neither is in the public CPU benchmark where bochka did 26.69 runs per second at 4 vCPU / 8 GB.
How long can a session run on Browserless and Zenrows?
Browserless allows 2 minutes on Free, 15 on Prototyping, 30 on Starter and 60 on Scale, with custom limits on Enterprise. Zenrows sessions last 1 to 15 minutes, 3 by default. bochka has no session cap on paid plans.
Which one solves CAPTCHAs?
Browserless does: BrowserQL solves reCAPTCHA and image challenges, and each solve uses units. Zenrows Browser Sessions cannot solve CAPTCHAs, though its Fetch API has anti-CAPTCHA features. bochka has no CAPTCHA solving built in.
Can Browserless or Zenrows run Docker or a shell?
No. Both give you a browser to drive over CDP or their APIs, not a shell on the machine. You can self-host the Browserless Docker image on your own server, but that is your machine. Every bochka sandbox has root, SSH, Docker, systemd and /dev/kvm.
Can I use bochka with Browserless or Zenrows?
Yes. An agent on a bochka sandbox can connect to a Browserless or Zenrows session over WebSocket, or call their MCP tools, and keep its code and files 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