Browser Use vs Notte
Browser Use and Notte both rent stealth cloud browsers with proxies and CAPTCHA solving for AI agents. Browser Use bills per browser-hour and scales to 1,000 browsers as your lifetime spend grows, while Notte sells monthly plans with extra tools like personas, vaults and browser Functions.
The companies and products
Browser Use
Browser Use makes the popular open-source browser-agent library and runs Browser Use Cloud, a service of managed browsers and a hosted agent that uses them.
Browser Use Cloud is a different kind of product from bochka: you get a hardened Chromium browser in their cloud that you drive over CDP with Playwright or Puppeteer, or a hosted agent that you send tasks to through an API. It comes with stealth fingerprints, CAPTCHA solving and residential proxies, and you pay per browser-hour. It is built for teams that need many browsers that get past anti-bot checks, not a machine to run their own code on.
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. “3rd cheapest of 367” means 2 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 | Browser Use: 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 you a shell, Docker or a lasting disk, so a coding agent cannot build and test on either; bochka ranks 3rd here. | 48th of 367, with limits $301 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 always-on assistant outlives both: Browser Use agent browsers stop after 4 hours and Notte Startup sessions after 300 minutes. | 63rd of 366, with limits $750 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 | 216th of 345, with limits $71 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 | 199th of 361, with limits $270 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 | 227th of 360, with limits $1,010 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 | 226th of 364, with limits $90 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 | 219th of 377, with limits $64 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 | 212th of 368, with limits $25 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 computer-use agents that need other apps fit bochka's 60fps Linux desktop better. | 83rd of 369, with limits $133 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, with stealth and proxies on by default; Notte ranks 2nd and Browser Use ranks 3rd, and bochka fits too when the agent also needs a shell and files. | 3rd cheapest of 367 $140 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 Notte ranks 7th and Browser Use ranks 14th for startup-scale scraping; bochka ranks 6th by giving each bot a whole machine with a browser and a disk that stays. | 14th cheapest of 346 $198 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 Browser Use ranks 1st for mass scraping of sites that block bots, since its spend tiers reach 1,000 browsers at once, while Notte's Startup plan stops at 100. | Cheapest of 338 $2,950 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 Red-team agents need their own tools and a shell, which neither browser service gives them; bochka ranks 2nd here. | 50th of 360, with limits $68 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 | Browser Use | Notte | bochka |
|---|---|---|---|
| What you get | A hardened Chromium browser over CDP, or a hosted agent you send tasks to | A hosted browser session over CDP, Playwright or Notte actions, plus agents, vaults, personas and Functions | A full Linux VM with its own kernel and root, with Chrome and a desktop on it |
| Browsers at once | 10 to 1,000, rising with lifetime payments | 5, 25 or 100 by plan; custom on Enterprise | Many sandboxes in parallel, each a whole VM; starts are limited per day and per hour by plan |
| How long a session runs | Agent browsers stop after 4 hours; idle ones are cleaned up after about 20 minutes | 15 min on Free, 120 min on Developer, 300 min on Startup | No session cap on paid plans |
| What survives a session | Browser profiles keep cookies and logins; workspaces sync up to 950 MiB of files | Fresh browser each session; an opt-in profile keeps cookies and storage | The whole disk, saved every minute and on stop; fork a running sandbox |
| Getting past bot checks | Hardened Chromium fork, per-session fingerprints, CAPTCHA solving (off in the EU) | Captcha solving for reCAPTCHA, hCaptcha and Turnstile, and a consistent Chrome fingerprint | Chromium on datacenter IPs; bring your own captcha service |
| Proxies | Residential proxies in 195+ countries, on by default at $5 per GB, or bring your own | Residential proxies on by default at $10 per GB; bring your own on Startup | None managed; run your own proxy client inside the VM |
| Hosted agent | Hosted browser agent with a choice of models, a session queue and an events API | Browser agent you start with a task, stream and stop, and export as code; an MCP server | Claude Code, Codex and other coding agents inside the VM, driven from outside with a prompt, steer and events API |
| Logins and identities | Secrets typed into the page by alias, so the model never sees them | Vaults for passwords, cards and 2FA codes, and personas with their own email and phone | Credentials proxy: real keys never enter the sandbox, for any HTTPS API |
| Running your own code | No shell on the machine running the browser | Python Functions called by API, webhook or schedule; no shell | Root shell, any language, Docker, systemd and /dev/kvm |
| Desktop | Live view of the browser tab, embeddable, plus a recording | Live view of the browser you can embed; no desktop | A full Linux desktop streamed at 60fps, embeddable and recordable |
| Serving your own ports | No | No; a short-lived signed live-view URL per session | HTTPS URLs for up to 50 ports, token-protected; raw TCP |
| Source code and self-hosting | The browser-use agent library is MIT and runs on your own machine | Framework under SSPL-1.0; on-premise and bring-your-own-cloud on Enterprise | Hosted only |
| Regions | US, plus an EU deployment in Frankfurt with a smaller feature set | Session region not published; built-in proxies exit in the US unless you pick a country | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Browser Use | Notte | bochka |
|---|---|---|---|
| Full VM (own kernel) | Not published | 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 | Yes | 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 | No | 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 | Yes | Yes | No |
| BYOC | No | 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 | No | 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. Browser Use and Notte do not publish the CPU or memory behind a browser session, and neither was in the CPU benchmark. bochka scored 26.69 runs per second on the StarSling Node.js test 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. Browser Use 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 | Browser Use, 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 | $7 · Pay as you go · 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 | $25 · Pay as you go · 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 | $178 · Spend tier 50 · 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 | $150 · Spend tier 500 · 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 | $210 · Spend tier 1000 · with limits | $100 · Startup · with limits | $2,000 · $2000/mo · with limits |
Browser Use: Browser Use bills $0.02 per browser-hour, rounded up to whole minutes, from prepaid credits that never expire. Residential proxy traffic is $5 per GB and on by default, direct traffic is $0.20 per GB, and agent runs add model tokens plus a 20% fee.
Notte: Notte's plan fee ($0, $20 or $100 a month) comes back as credits that expire each cycle, spent on browser sessions at $0.01 an hour, Functions at $0.05 an hour, residential proxies at $10 per GB (on by default) and model tokens at cost.
Notte: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Neither fits any scenario in the table, because each one asks for a general machine and both sell a browser session of a size they do not publish. Browser Use stops agent browsers after 4 hours and Notte Startup sessions after 300 minutes, which rules out the workday and always-on agents. For many at once, Browser Use needs lifetime payments ($200 for 50 browsers, $5,000 for 500, $25,000 for 1,000), while Notte Startup stops at 100 and anything above needs Enterprise. bochka fits every scenario except 1,000 short jobs at once, where its $2,000 plan queues the starts.
| Scenario | Browser Use | 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 Browser Use when
you need many browsers at once on sites with strong bot checks, want to pay per browser-hour with no plan, or want an MIT agent you can also run yourself.
- Scales to 1,000 browsers. For big scraping jobs: concurrency grows from 10 to 1,000 browsers as your lifetime spend grows, with no monthly plan.
- MIT library you can run anywhere. For teams that want the same agent locally: the browser-use library is MIT, with about 118k GitHub stars.
- No plan, credits that keep. For uneven workloads: no monthly plan, and prepaid credits never expire; an EU deployment also runs in Frankfurt.
Use Notte when
your agents sign up and log in to sites, so personas, vaults and scheduled browser Functions save you work, or when you need it on your own cloud.
- Identities and vaults built in. For sign-up and login flows: personas with their own email and phone, and vaults that fill passwords and 2FA codes.
- Browser scripts as endpoints. For recurring browser jobs: Functions turn a script into an API you call, hit as a webhook or run on a schedule.
- Runs on your own cloud. For teams that must keep it in-house: Enterprise offers on-premise and bring-your-own-cloud deployments.
Where bochka fits
Browser Use and Notte are browser services, not sandboxes, so they overlap with bochka only where agents use the web. If what you are really running is agents that browse and also write code, keep files, run for hours or use a desktop, look at bochka. You can still call Browser Use or Notte from inside a bochka sandbox for the pages that fight bots.
A whole machine around the browser
Neither gives you a shell, Docker or a disk, so anything that is not browsing runs on a second machine you manage. A bochka sandbox is a full VM with root, Docker, systemd and /dev/kvm, with Chrome on it.
No session clock
Browser Use agent browsers stop after 4 hours and Notte Startup sessions after 300 minutes, keeping only cookies and a few files. bochka has no session cap on paid plans, saves the disk every minute and can fork a running sandbox.
A desktop and coding agents
Both stream a browser tab only, and their agents browse rather than write code. bochka streams a 60fps Linux desktop and ships Claude Code, Codex and other agents you drive from outside, with real keys kept out by a credentials proxy.
Use bochka when the agent does more than browse: it writes and runs code, keeps files between runs, works for hours or days, or needs a desktop, Docker and coding agents on one VM. Compare it one to one: bochka vs Browser Use and bochka vs Notte.
Questions people ask
Is Browser Use cheaper than Notte?
It depends on volume. In our scenarios Browser Use comes to $7 a month for a workday agent against $100 on Notte's Startup plan, but Notte's flat $100 a month is less for 50 agents in parallel ($178 on Browser Use). For browser-use agents we model $140 a month on Browser Use and $100 a month on Notte, with proxy traffic billed on top for both.
Which is faster, Browser Use or Notte?
Neither publishes the machine size behind a browser, and neither was in the CPU benchmark, so there is no fair speed comparison. For browsing work, speed depends mostly on the sites, the proxy and the model.
Which one runs longer sessions?
Browser Use agent browsers run up to 4 hours. Notte sessions run 15 minutes on Free, 120 on Developer and 300 on Startup, with longer limits only on Enterprise. A bochka sandbox has no session cap on paid plans.
Can Browser Use or Notte run Docker?
No. Both give you a browser with no shell on the machine underneath; Notte adds Python Functions but still no Docker. bochka gives each agent a full Linux VM with Docker, systemd and root.
Are Browser Use and Notte open source?
The browser-use library is MIT and runs on your own machine. Notte's agent framework is on GitHub under SSPL-1.0, which is source-available, and its hosted cloud is not; on-premise is Enterprise only.
Can I use Browser Use or Notte from a bochka sandbox?
Yes. A bochka sandbox has open internet, so code or an agent inside it can call either service's API, SDK or MCP server. The agent builds and tests on bochka and sends hard-to-reach pages to the stealth browser.
Try bochka
Install the CLI, then run bochka new.
Product preview