Browserbase vs Notte
Browserbase and Notte both rent you hosted Chrome for AI agents through an API. Browserbase runs each browser in its own VM for up to 6 hours, with Search and Fetch APIs and four published regions, while Notte turns on residential proxies and captcha solving by default, caps Startup sessions at 300 minutes and lets you run its source-available framework yourself.
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.
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. “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 | Notte: 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 shell, Docker or a disk that stays, so a coding agent builds and tests on bochka and can call either one as its browser. | 140th of 367, with limits $1,255 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 Browserbase sessions end after 6 hours and Notte Startup sessions after 300 minutes, so an always-on assistant needs a machine like bochka to live on. | 259th of 366, with limits $3,699 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 | 270th of 345, with limits $382 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 | 250th of 361, with limits $1,099 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 | 264th of 360, with limits $5,049 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 | 349th of 364, with limits $449 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. | 244th of 377, with limits $152 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, and both browsers start fresh each session, so this fits bochka. | 251st of 368, with limits $96 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 Both control a browser only, so an agent that needs a whole desktop or other apps fits bochka's 60fps Linux desktop better. | 159th of 369, with limits $416 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 Both are built for this: Notte ranks 2nd and Browserbase 24th in our table, and bochka fits too with Chrome on a full VM next to the agent's code. | 24th cheapest of 367 $449 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; Browserbase also sells Fetch and Search APIs, Notte bills proxy traffic per GB by default, and bochka uses datacenter IPs. | 55th cheapest of 346 $537 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 browsers suit sites that block bots, with residential proxies and captcha solving; Browserbase adds Verified browsers on Scale, and bochka has neither built in. | 13th of 338, with limits $9,799 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 | 229th of 360, with limits $291 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 | Browserbase | Notte | bochka |
|---|---|---|---|
| Kind of product | Managed headless Chrome sessions, plus Search, Fetch, Functions, a Model Gateway and hosted browser Agents | Managed cloud browser sessions, plus a browser agent, vaults, personas and Python Functions | 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 | Isolation model not published | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Session length | 15 minutes on Free, 6 hours on Developer and Startup, 6+ hours on Scale | 15 minutes on Free, 120 minutes on Developer, 300 minutes on Startup, custom on Enterprise | No cap on paid plans; you set the time to live |
| Browsers at once | 3 on Free, 25 on Developer, 100 on Startup, 250+ on Scale | 5 on Free, 25 on Developer, 100 on Startup, custom on Enterprise | No session cap on paid plans; the top plan allows 2,400 starts a day |
| Getting past bot checks | Residential proxies in 200+ countries and CAPTCHA solving on paid plans, off by default; Verified browsers on Scale | Residential proxies, captcha solving and a matching Chrome fingerprint on every plan, on by default | Datacenter IPs and Chromium; bring your own proxy or captcha service |
| Saved logins | Contexts keep the Chromium user data directory (cookies, localStorage, IndexedDB), encrypted at rest | An opt-in profile keeps cookies, local storage and session storage | The whole disk persists, with snapshots every minute and on stop; Chrome profiles go with snapshots and forks |
| Running your own code | TypeScript Functions next to the browser, up to 900 seconds, no persistent storage | Python Functions called by API, webhook or schedule; no shell | Root shell, SSH, any language, Docker, systemd and /dev/kvm |
| Fork | No fork; a new session starts fresh or loads a saved Context | No session fork; a Function can be forked as a copy of its code | Fork a running sandbox with its disk and browser |
| Built-in agent | Hosted browser Agent from a plain language goal, with built-in tools only; open source Stagehand SDK | Browser agent started with a task, with streamed logs and runs exported as code; MCP server | Claude Code, Codex, OpenCode and more inside the VM, driven from outside with a prompt, steer and events API |
| Secrets and identities | Model Gateway for OpenAI, Anthropic and Google with your Browserbase key; agent variables hide values from the model | Vaults fill passwords, cards and 2FA codes so the LLM never sees them; personas with their own email and phone | AI credentials proxy keeps real keys out of the sandbox for model providers and any HTTPS API you register |
| Desktop and computer use | Browser only, with live view and session replays | Browser only, with an embeddable live view | 60fps Linux desktop with Chromium, computer use on any app, embeddable stream |
| Reaching the machine | CDP connect URL and live view links; 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; own IP |
| Regions | Oregon, Virginia, Frankfurt and Singapore, picked per session | 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 |
| Self-hosting | Hosted only; Stagehand SDK is MIT licensed | Source-available framework (SSPL) runs on local Chromium; on-premise and bring-your-own-cloud on Enterprise | Hosted only |
Every feature Battleships tracks (43)
| Feature | Browserbase | Notte | 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 | Yes | 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 | Not published | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | No | Yes | 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 | Yes | No |
| EU data residency | Yes | Not published | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
There is no comparable measurement for either browser. Neither Browserbase nor Notte publishes the vCPU or RAM behind a 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. Browserbase 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 | Browserbase, 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 | $99 · Startup · 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 | $122 · Startup · 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 | $841 · Startup · 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 | $499 · Startup · 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,049 · Startup · with limits | $100 · Startup · 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. Proxy data is extra after 1 GB or 5 GB ($12 or $10 per GB), and Search, Fetch and Agents have their own allowances.
Notte: The plan fee ($20 or $100) 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.
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 browser fits any of the five machine scenarios, because each needs a disk that stays, Docker or work longer than a session: 6 hours on Browserbase and 300 minutes on Notte Startup. Both allow 100 browsers at once on Startup, so 300 sandboxes for your users or 1,000 jobs at once need Scale or Enterprise through sales. On bochka the 1,000-job burst is the one that does not fit: bursts above 90 starts a minute are queued, and it needs more starts a day than the top plan allows.
| Scenario | Browserbase | 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 Browserbase when
you want hosted Chrome with sessions of up to 6 hours, Search and Fetch APIs, Contexts for saved logins and replays, or browsers in the US and Singapore.
- Longer sessions in their own VM. Useful for long browsing jobs: sessions run up to 6 hours on Developer and Startup, each in a fresh VM.
- Search and Fetch without a browser. Useful when many lookups need no browser at all: Search and Fetch APIs answer them per call.
- Regions in the US and Asia. Useful if your target sites are far from Europe: browsers run in Oregon, Virginia, Frankfurt or Singapore.
Use Notte when
the job is browsing sites that fight bots and you want stealth on by default, vaults and personas for logins, or the option to run the framework yourself.
- Stealth on from the first request. Useful for sites that block bots: residential proxies, captcha solving and a matching fingerprint are on by default, on every plan.
- Identities for sign-ups. Useful when agents log in or sign up: vaults fill passwords and 2FA codes, and personas have their own email and phone.
- Run it yourself. Useful if you must self-host: the framework is source-available, and Enterprise adds on-premise and bring-your-own-cloud.
Where bochka fits
If what you are really running is agents that browse and then do work, look at bochka. Browserbase and Notte both rent a browser that resets after each session, while bochka gives each agent a full VM with Chromium on a desktop, Docker and a disk that stays. Many teams can also keep both: the agent lives on bochka and calls Browserbase or Notte for sites that block bots.
A whole machine, not only a browser
Neither Browserbase nor Notte gives a shell, Docker or root, only short Functions. An agent that reads a page and then clones a repo or starts a dev server needs a second provider, and you move files between them.
No reset after 6 hours or 300 minutes
Browserbase sessions end after 6 hours and Notte Startup sessions after 300 minutes, and only a browser profile carries over. On bochka paid plans have no session cap, the disk is saved every minute, and a stopped sandbox costs nothing.
A desktop and coding agents you drive from outside
Both browsers run their own browsing agent and stop at the browser. bochka streams a 60fps desktop, ships Claude Code and Codex in each VM, and lets you fork a running sandbox and keep keys outside it through the credentials proxy.
Use bochka when the agent does more than browse: it writes and runs code, keeps its files, works for hours, or needs a desktop, Docker and coding agents on one VM. Compare it one to one: bochka vs Browserbase and bochka vs Notte.
Questions people ask
Is Browserbase cheaper than Notte?
In our model Notte is lower: browser-use agents come to $100 a month on Notte against $449 on Browserbase, and scraping at startup scale to $100 against $537. Notte's browser time is $0.01 an hour, but its proxies are on by default at $10 per GB, so traffic can change the bill.
Which is faster, Browserbase or Notte?
Neither publishes the machine size behind a 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.
Which has longer sessions?
Browserbase: up to 6 hours on Developer and Startup, against 120 minutes on Notte Developer and 300 minutes on Notte Startup. Both start a fresh browser each session and carry over only a saved profile. bochka has no session cap on paid plans.
Can Browserbase or Notte run Docker or a shell?
No. Both give you a browser plus short Functions, TypeScript on Browserbase and Python on Notte, with no shell, Docker or disk that stays. Every bochka sandbox has root, SSH, Docker, systemd and /dev/kvm.
Can I self-host Browserbase or Notte?
Notte's agent framework is source-available under SSPL and runs on local Chromium, and Enterprise adds on-premise and bring-your-own-cloud. Browserbase is hosted only, though its Stagehand SDK is MIT licensed.
Can I use either one from bochka?
Yes. A bochka sandbox has open internet, so an agent on it can open a Browserbase session over CDP or call Notte's API, SDK or MCP server. The code and files stay on the bochka VM, and the hard-to-reach pages go to the browser service.
Try bochka
Install the CLI, then run bochka new.
Product preview