Notte vs Zenrows
Notte is a cloud browser platform for AI agents, with its own browser agent, captcha solving and sessions of up to 300 minutes on Startup. Zenrows is a web data service whose Browser Sessions are remote Chrome tabs on rotating residential IPs that close after at most 15 minutes, next to Fetch, Extract, Crawl and Batch APIs.
The companies and products
Notte
Notte is a cloud browser platform for AI agents: you start hosted Chrome sessions through an API, SDK, CLI or MCP server.
Each Notte session is a hosted browser you control over CDP, Playwright or Notte's own actions, with residential proxies, captcha solving and a consistent fingerprint on by default. Around it Notte sells a task-driven browser agent, vaults for passwords, personas with their own email and phone number, and Python Functions that turn a browser script into an API endpoint. It is a different kind of product from bochka: a browser service, not a general sandbox, so this page compares the two where they overlap, which is agents that use the web.
- Backing
- Explore the preview
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. “2nd cheapest of 367” means 1 of the other 366 providers runs 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 | Notte: 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 Notte nor Zenrows has a shell, Docker or a disk that stays, so a coding agent cannot build and test on either one. | 44th of 367, with limits $121 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 always-on assistant outlives a 300-minute Notte session and a 15-minute Zenrows session, so it needs a machine like bochka to live on. | 99th of 366, with limits $365 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 | 220th of 345, with limits $100 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 | 195th of 361, with limits $105 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 | 222nd of 360, with limits $500 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 Agent evals that mix code, files and a browser need a whole machine per run, which neither browser service offers. | 227th of 364, with limits $100 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 | 230th of 377, with limits $100 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 | 255th of 368, with limits $100 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 browser service streams a desktop, so a computer-use agent that needs a whole screen fits bochka's 60fps Linux desktop better; Notte ranks 76th, Zenrows 93rd and bochka 6th. | 76th of 369, with limits $100 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: Notte ranks 2nd with its own agent and captcha solving, Zenrows ranks 5th with residential IPs but 15-minute sessions, and bochka ranks 7th with Chrome on a full VM. | 2nd cheapest of 367 $100 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; Notte ranks 7th and Zenrows 18th, and bochka ranks 6th by running your own scrapers next to their queues and databases, with your own proxy if a site blocks data-center IPs. | 7th cheapest of 346 $100 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 Notte ranks 2nd here at $975 a month in our model, since residential proxies, fingerprints and captcha solving are on by default; Zenrows ranks 70th and bochka 71st. | 2nd of 338, with limits $975 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 | 143rd of 360, with limits $100 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 | Notte | Zenrows | bochka |
|---|---|---|---|
| What you get | A hosted browser session over API, SDK, CLI or MCP, plus a browser agent, vaults, personas and Python Functions | A remote Chrome session over CDP, plus Fetch, Extract, Crawl and Batch APIs on one credit balance | A full Linux VM with its own kernel, with Chrome and a desktop on it |
| How long a session runs | 15 min on Free, 120 min on Developer, 300 min on Startup | 1 to 15 minutes, 3 by default, on every plan | No session cap on paid plans |
| What survives a session | Fresh browser each time; an opt-in profile keeps cookies, local storage and session storage | Session closes and frees its resources; no saved state documented | The whole disk, with snapshots every minute and on stop; a stopped sandbox costs nothing |
| Outbound IPs | Residential proxies on by default at $10/GB, best-effort US exit unless you pick a country; bring your own proxy on Startup | Over 55 million residential IPs in 190+ countries, rotating on every request, with country targeting | Datacenter IPs in the EU; bring your own proxy |
| Captchas | Captcha solving for reCAPTCHA, hCaptcha and Cloudflare Turnstile, plus a matching Chrome fingerprint | Browser Sessions cannot solve captchas; the Fetch API has anti-captcha features | None built in; bring your own captcha service |
| Browser control | CDP URL, Playwright or Notte actions, with a live view you can embed | Puppeteer or Playwright over CDP; viewport, user agent and some device settings are blocked | Chrome on your own VM: Playwright, Puppeteer or CDP, any setting or extension, plus a 60fps stream |
| Built-in agent | Notte's own browser agent: start it with a task, stream logs, export the run as code | Tools for your agent to call; no agent runs inside Zenrows | Claude Code, Codex and other coding agents inside the VM, driven from outside with a prompt, steer and events API |
| MCP server | MCP server for agents outside | Hosted or local MCP server with scrape, extract, crawl, batch and browser tools | No MCP server; agents drive the sandbox through the API and CLI |
| Running your own code | Python Functions with a run() entry point, called by API, webhook or schedule; no shell | No shell; browser control over CDP only | Root shell, any language, Docker, systemd and /dev/kvm |
| Desktop and computer use | Browser only; no desktop | No desktop stream; screenshots and page actions through CDP or MCP tools | 60fps Linux desktop that agents can see and use, embeddable and recordable to MP4 |
| Keeping secrets from the model | Vaults fill passwords, cards and 2FA codes so the LLM never sees them; personas with email and phone | Not documented; auth is your Zenrows API key | AI credentials proxy: real keys never enter the sandbox, for model providers and any HTTPS API |
| Concurrency on self-serve plans | 5, 25 or 100 browsers at once by plan | 5 up to 400 sessions at once by plan | No session cap; starts are rate-limited by plan, with bursts above 90 starts a minute queued |
| Self-hosting | Source-available framework (SSPL) runs on local Chromium; on-premise and bring-your-own-cloud on Enterprise | Hosted only | Hosted only |
| Where it runs | Session region not published | Based in Spain, primarily hosted on DigitalOcean, no region to choose | EU only (Germany, Finland, France), with EU data residency and zero data retention |
Every feature Battleships tracks (43)
| Feature | Notte | 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 | Yes | 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 | No | No | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | Not published | 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 | Not published | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for Notte or Zenrows. Neither publishes the CPU or memory behind a browser session, and neither was in the StarSling hpc-sandbox-benchmarks run, where bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. For browsing work, speed depends mostly on the sites, the proxy and the model.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Notte 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 | Notte, 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 | $100 · 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 | $100 · 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 | $100 · 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 | $100 · 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 | $100 · Startup · with limits | $2,499 · Scale S5 (annual) · with limits | $2,000 · $2000/mo · with limits |
Notte: Notte's plan fee comes back as credits that expire each cycle, spent on browser sessions ($0.01 an hour), Functions ($0.05 an hour), residential proxies ($10 per GB) and model tokens at cost. Proxies are on by default, so traffic is billed per GB unless you turn them off or bring your own proxy on Startup.
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; plan credits expire at each renewal, and top-ups roll over once.
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
Neither Notte nor Zenrows fits any scenario in the table, because each one needs a machine: work longer than a session, files that stay, or Docker. Notte sessions end at 300 minutes on Startup and Zenrows sessions at 15 minutes on every plan, even the $2,499 a month Scale S5 annual plan we priced it at. For many sandboxes at once, Notte's Startup plan stops at 100 browsers and Zenrows Scale S5 at 400. On bochka the 1,000-jobs-at-once burst does not fit either: the $2,000 plan allows 2,400 starts a day and queues bursts above 90 starts a minute.
| Scenario | Notte | 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 Notte when
your agent browses for hours on sites that fight bots, and you want captcha solving, saved logins, a ready browser agent or the option to self-host.
- Sessions that last hours. Useful for long browser tasks: a Startup session runs up to 300 minutes, against at most 15 on Zenrows.
- Captchas and logins handled. Useful on sites that fight bots: captcha solving, a matching fingerprint, vaults for passwords and saved browser profiles come built in.
- Its own browser agent. Useful if you want browsing done for you: start Notte's agent with a task, or run it yourself from the source-available framework.
Use Zenrows when
you need short visits to protected pages from residential IPs in many countries, or scraping APIs and an MCP server rather than a long browser session.
- Residential IPs in 190+ countries. Useful for protected sites worldwide: over 55 million residential IPs rotate on every request, and you can pick the country.
- A full web data toolbox. Useful if you want data, not a browser: Fetch, Extract, Crawl and Batch share one credit balance, with an MCP server.
- Pay per browser minute. Good for short, spiky page visits: a session costs 5 credits a minute and closes on its own.
Where bochka fits
Notte and Zenrows are browser services, not sandboxes, and they compete on getting past bot checks. If what you are really running is agents that browse as one part of their work, writing code, keeping files and running for hours, bochka gives each one a full VM with Chrome on it. You can still call Notte or Zenrows from inside a bochka sandbox for the pages that block data-center IPs.
A whole computer next to the browser
Neither service gives you a shell, Docker or a disk, so an agent that downloads a file, runs a script on it and checks the result needs a second machine and has to move files back and forth after every step.
Nothing resets mid-task
Zenrows closes every session within 15 minutes, about 32 reconnects in an eight-hour shift, and Notte stops at 300 minutes on Startup with only cookies and storage carried over. bochka has no session cap on paid plans and saves the disk every minute.
A desktop and coding agents built in
Neither streams a desktop, so a computer-use agent sees one page at a time. bochka streams a 60fps Linux desktop and runs Claude Code or Codex inside, driven from outside, with a credentials proxy that keeps real keys out.
Use bochka when the agent does more than browse: it writes and runs code, keeps files and Chrome logins between runs, works for hours, or needs a desktop, Docker and coding agents on one VM. Compare it one to one: bochka vs Notte and bochka vs Zenrows.
Questions people ask
Is Notte cheaper than Zenrows?
In our scenarios, yes: we priced Notte at its $100 a month Startup plan and Zenrows at $2,499 a month on Scale S5 annual, though neither fits those sandbox workloads. For browser-use agents, where both fit, our model puts Notte at $100 a month and Zenrows at $166 a month. Both also bill proxy bandwidth per GB.
Which runs longer browser sessions, Notte or Zenrows?
Notte. Its sessions run up to 15, 120 or 300 minutes by plan, while a Zenrows session closes after 1 to 15 minutes on every plan. bochka has no session cap on paid plans.
Which is faster, Notte or Zenrows?
There is no comparable measurement. Neither publishes the machine size behind a session or appears in the StarSling benchmark, where bochka did 26.69 runs per second at 4 vCPU / 8 GB.
Can Notte or Zenrows solve captchas?
Notte solves reCAPTCHA, hCaptcha and Cloudflare Turnstile in its sessions. Zenrows Browser Sessions cannot solve captchas, though its Fetch API has anti-captcha features. bochka has no built-in solver, so you bring your own.
Can Notte or Zenrows run Docker?
No. Both are browser services with no shell, Docker or disk that stays; Notte adds Python Functions. A bochka sandbox is a full Linux VM with root, Docker, systemd and /dev/kvm.
Can I use Notte or Zenrows from a bochka sandbox?
Yes. A bochka sandbox has open internet, so code or an agent inside it can call Notte's API or Zenrows' APIs and MCP server. The agent builds and tests on bochka and sends hard-to-reach pages to them.
Try bochka
Install the CLI, then run bochka new.
Product preview