Browserless vs Notte
Browserless is a browser API: you point Puppeteer, Playwright or BrowserQL at headless Chrome, Firefox or WebKit for sessions of up to 60 minutes. Notte is a cloud browser built for AI agents, with residential proxies and captcha solving on by default, its own browser agent, vaults and personas, and sessions of up to 300 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.
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
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 | Notte: 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 that stays, so builds and tests fit bochka, which ranks 3rd. | 170th of 367, with limits $1,771 a month | 44th of 367, with limits $121 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 300-minute cap on Notte; bochka has no session cap on paid plans. | 297th of 366, with limits $6,170 a month | 99th of 366, with limits $365 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 | 220th of 345, with limits $100 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 | 195th of 361, with limits $105 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 | 222nd of 360, with limits $500 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 | 227th of 364, with limits $100 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. | 241st of 377, with limits $140 a month | 230th of 377, with limits $100 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, which neither browser service does, so this fits bochka. | 336th of 368, with limits $350 a month | 255th of 368, with limits $100 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 Browserless and Notte act on a browser only, while bochka ranks 6th with a 60fps Linux desktop where an agent can use any app. | 141st of 369, with limits $350 a month | 76th of 369, with limits $100 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 stealth and an agent built in, bochka ranks 7th with Chrome on a full VM, and Browserless ranks 19th. | 19th cheapest of 367 $350 a month | 2nd cheapest of 367 $100 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; Browserless adds REST endpoints for screenshots and PDFs, Notte turns on residential proxies by default, and bochka ranks 6th. | 47th cheapest of 346 $478 a month | 7th cheapest of 346 $100 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 Both browser services beat bochka here, since stealth, captcha solving and residential proxies come built in; Notte ranks 2nd and Browserless ranks 20th. | 20th of 338, with limits $17,150 a month | 2nd of 338, with limits $975 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 | 247th of 360, with limits $350 a month | 143rd of 360, with limits $100 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 | Notte | bochka |
|---|---|---|---|
| Kind of product | Managed headless Chrome, Firefox and WebKit, plus BrowserQL, REST APIs and an MCP server | Managed cloud Chrome for AI agents, plus a browser agent, vaults, personas and Python Functions | A full Linux VM per sandbox, with a desktop and Chromium inside |
| Isolation | Browsers in Docker containers | Isolation model not published | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Session length | 2 minutes on Free, 15 on Prototyping, 30 on Starter, 60 on Scale | 15 minutes on Free, 120 on Developer, 300 on Startup | No cap on paid plans; you set the time to live |
| Browsers at once | 2 on Free; 10, 40 or 100 on the annual plans | 5, 25 or 100 by plan | Bursts above 90 starts a minute are queued; up to 2,400 starts a day on the $2,000 plan |
| What survives a session | Cookies, localStorage and cache for 1 to 90 days by plan; a new browser process on reconnect | A fresh browser each time; an opt-in profile keeps cookies, local storage and session storage | The whole disk, with snapshots every minute and on stop; a stopped sandbox costs nothing |
| Bot detection | BrowserQL stealth, fingerprint mitigations, CAPTCHA solving, residential and datacenter proxies | Residential proxies, captcha solving and a matching Chrome fingerprint, all on by default | Datacenter IPs and Chromium; bring your own proxy or captcha service |
| Running your own code | No shell; your code drives the browser over CDP, BrowserQL or REST | Python Functions with a run() entry point, called by API, webhook or schedule; no shell | Root shell, SSH, any language, Docker, systemd and /dev/kvm |
| Ready-made web tools | REST endpoints that return screenshots, PDFs and scraped content in one call | A browser agent you start with a task, personas with their own email and phone | Chrome in the VM with Playwright, Puppeteer or CDP on a local port |
| Agents | A managed browser agent in beta, up to 15 minutes and 60 steps a turn | Its own browser agent: stream its logs, stop it, export the run as code | Claude Code, Codex, OpenCode and more inside the VM, driven from outside with a prompt, steer and events API |
| Desktop and computer use | Browser only, with live URLs that hand a session to a person | Browser only, with a live view you can embed | 60fps Linux desktop that agents can see and use, embeddable and recordable |
| Keeping secrets from the model | 1Password fills logins into the page without the value reaching your code | Vaults fill passwords, cards and 2FA codes so the LLM never sees them | AI credentials proxy: real keys stay outside the sandbox, for model providers and any HTTPS API |
| Reaching it from outside | Regional WebSocket and HTTPS endpoints and short-lived live URLs; no ports to host on | No open ports; a short-lived signed live-view URL per session | HTTPS URLs for up to 50 ports, token-protected; raw TCP |
| Self-hosting | Open source Docker image you can run yourself; commercial use needs a license | Source-available agent framework on local Chromium; on-premise and your own cloud on Enterprise | Hosted only |
| Where it runs | San Francisco, London and Amsterdam; New York on private fleets | Session region not published; built-in proxies exit in the US unless you pick a country | EU only (Germany, Finland and France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Browserless | Notte | 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 | Yes | 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 | Not published | No |
| Self-hosting | Yes | Yes | No |
| BYOC | Yes | Yes | No |
| Open source | Yes | Yes | 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 | Yes | No |
| EU data residency | Yes | Not published | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for either. Browserless and Notte do not publish the vCPU or RAM behind a browser session, and neither was in StarSling's CPU benchmark, where bochka did 26.69 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. Browserless and Notte 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 | Notte, 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 | $100 · Startup · 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 | $100 · Startup · 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 | $100 · Startup · 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 | $100 · Startup · 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 | $100 · Startup · 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.
Notte: Notte's plan fee comes back as credits that expire each cycle, spent on browser sessions ($0.01 an hour), Functions, residential proxies ($10 per GB) and model tokens. Proxies are on by default, so traffic is billed per GB unless you turn them off.
Notte: 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
Neither Browserless nor Notte fits any scenario in the table, because each one needs a machine of a known size, a disk that stays or Docker, and both sell a browser session. Session caps bite first: 60 minutes on Browserless Scale and 300 on Notte Startup, so the workday agent, the always-on agent and the 50-agent fleet do not fit either. Both allow 100 browsers at once on their top self-serve plan, so 300 user sandboxes or 1,000 jobs at once need Enterprise. On bochka the 1,000-job burst is the one that does not fit, because bursts above 90 starts a minute are queued.
| Scenario | Browserless | Notte | 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
you already have Puppeteer, Playwright or Selenium scripts, need Firefox or WebKit, want one-call screenshots and PDFs, or must self-host the browser in your own network.
- Scripts you already have. Useful if you have Puppeteer, Playwright or Selenium code: point it at a Browserless URL, with Firefox and WebKit too.
- One-call REST endpoints. Useful when you only need a screenshot, a PDF or a scraped page: one REST call, no script.
- Run it on your own servers. Useful if browsers must stay in your network: the Browserless Docker image is open source and self-hostable.
Use Notte when
your agents browse sites that fight bots and you want proxies, captcha solving, a browser agent, vaults and personas handled for you, on sessions of up to 300 minutes.
- Stealth on by default. Useful if your agents browse sites that block bots: residential proxies, captcha solving and a matching fingerprint start on.
- Longer sessions. Useful for longer browsing jobs: Notte sessions run up to 300 minutes on Startup, against 60 on Browserless Scale.
- Browsing handled for you. Useful if you want a task-driven browser agent, vaults, and personas with their own email and phone.
Where bochka fits
Browserless and Notte are browser services, not sandboxes, so this is only about the overlap. If what you are really running is agents that browse and then also write code, run tools or keep files, bochka gives each one a full VM with Chromium and a desktop on it.
A whole machine next to the browser
Neither service gives you a shell, Docker or root. An agent that reads a page and then has to clone a repo or start a dev server needs a second provider, and you move files between the two.
No reset after an hour or five
Browserless ends a session after 60 minutes on Scale and Notte after 300 on Startup, and both keep only browser storage. On bochka the disk stays, with snapshots every minute, and you can fork a running sandbox.
Coding agents and a desktop built in
Both services run their own browser agent only. bochka ships Claude Code, Codex and others that you drive from outside, a 60fps desktop for apps beyond the browser, and a proxy that keeps API keys out.
Use bochka when your agent browses and also works: installs, builds, Docker and dev servers on a full VM that keeps its disk and runs as long as the task takes, with coding agents and a key proxy built in. Compare it one to one: bochka vs Browserless and bochka vs Notte.
Questions people ask
Is Browserless cheaper than Notte?
In our model Notte comes out lower: browser-use agents cost $100 a month on Notte Startup against $350 on Browserless Scale annual, and startup-scale scraping $100 against $478. Both bill extra for residential proxy traffic, Browserless in units and Notte at $10 per GB.
Which is faster, Browserless or Notte?
Neither publishes the machine behind a browser session, and neither was in StarSling's CPU benchmark, so there is no fair number to compare. For browsing, speed depends mostly on the sites, the proxy and the model.
Can Browserless or Notte run Docker or a shell?
No. A hosted Browserless session gives you a browser over CDP, BrowserQL or REST, and Notte gives you a browser and Python Functions, with no shell in either. Every bochka sandbox has root, SSH, Docker, systemd and /dev/kvm.
How long can a session run on each?
Browserless allows 2, 15, 30 or 60 minutes by plan, and Notte 15, 120 or 300 minutes, with custom limits on Enterprise for both. bochka has no session cap on paid plans and keeps the disk when you stop.
Which one is better at getting past bot checks?
Both have stealth, CAPTCHA solving and residential proxies. Notte turns them on by default for every session, while Browserless offers them through BrowserQL and its proxy options. bochka uses datacenter IPs, so you bring your own proxy or captcha service.
Can I self-host Browserless or Notte?
Browserless publishes its core as a Docker image you can run yourself, and commercial use needs a license. Notte's agent framework is source-available and runs on local Chromium, while on-premise Notte is Enterprise only. bochka is hosted only.
Try bochka
Install the CLI, then run bochka new.
Product preview