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 lifetime payments grow. Notte sells monthly plans with extra tools such as 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 boat. 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. Each hosted agent runs in its own micro-VM, where it can write and run Python and shell commands in a 1 GiB workspace. Stealth fingerprints, CAPTCHA solving and residential proxies are included, and you pay per browser-hour. It is built for teams that need many browsers that get past anti-bot checks, not for a machine that you control with your own shell.

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 the Anything API, which turns a plain-English task into a deployed browser Function. It also sells vaults for credentials, personas with their own email and phone number, and Python Functions that turn a browser script into an API endpoint. Coding agents such as Claude Code and Cursor use Notte through a browser skill, a CLI or an MCP server. Notte is a browser service, not a general sandbox, so this page compares the two where they overlap: agents that use the web.

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 356” means 2 of the other 355 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 workloadBrowser Use: price rankNotte: price rankboat: price rank
Software factory
100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month
A coding agent needs a shell, Docker and a disk that stays. Browser Use's hosted agent runs its own scripts in a 1 GiB micro-VM, and Notte runs Python Functions. boat has root, Docker and the browser on one VM; Notte documents a boat integration.
86th of 365, with limits
$301 a month
82nd of 365, with limits
$121 a month
5th cheapest of 365
$634 a month
Always-on AI employees
50 machines 24/7 · 2 vCPU / 4 GB
An always-on assistant outlives both sessions: Browser Use agent browsers stop after 4 hours and Notte Startup sessions after 300 minutes. Notte's scheduled Functions can run recurring web tasks. A boat sandbox stops after 1 hour by default; turn auto-stop off on a paid plan.
104th of 361, with limits
$750 a month
166th of 361, with limits
$365 a month
6th cheapest of 361
$657 a month
Code interpreter bursts
100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month
213th of 336, with limits
$71 a month
217th of 336, with limits
$100 a month
189th of 336, 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 349, with limits
$270 a month
192nd of 349, with limits
$105 a month
3rd cheapest of 349
$209 a month
RL rollouts
1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month
223rd of 349, with limits
$1,010 a month
220th of 349, with limits
$500 a month
39th of 349, with limits
$2,000 a month
Agent evals
250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month
229th of 359, with limits
$90 a month
230th of 359, with limits
$100 a month
10th cheapest of 359
$200 a month
CI runners
40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month
220th of 374, with limits
$64 a month
231st of 374, with limits
$100 a month
2nd cheapest of 374
$86 a month
24/7 dev boxes
1 machine 24/7 · 4 vCPU / 8 GB
227th of 371, with limits
$25 a month
268th of 371, with limits
$100 a month
19th cheapest of 371
$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. Computer-use agents that need other apps fit boat's 60 fps Linux desktop.
130th of 367, with limits
$133 a month
126th of 367, with limits
$100 a month
7th cheapest of 367
$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. In our default ranking for this case, Notte is #2, Browser Use #3 and boat #6. boat fits when the agent also needs a shell and files.
3rd cheapest of 356
$140 a month
2nd cheapest of 356
$100 a month
7th cheapest of 356
$200 a month
Scraping & bots (startup scale)
50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month
At startup scale all three fit. In our default ranking, boat is #6 and Notte #8. boat gives each bot a whole machine with a browser and a disk that is saved between runs.
17th cheapest of 343
$198 a month
8th cheapest of 343
$100 a month
6th cheapest of 343
$90 a month
Mass scraping & bots (undetectable)
1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month
In our default ranking for mass scraping of sites that block bots, Browser Use is #1 and Notte #2. Browser Use's lifetime-payment tiers reach 1,000 browsers at once, and Notte's Startup plan stops at 100.
Cheapest of 327
$2,950 a month
2nd of 327, with limits
$975 a month
73rd of 327, 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. boat gives each one a full VM with root and nftables.
88th of 351, with limits
$68 a month
190th of 351, with limits
$100 a month
3rd cheapest of 351
$200 a month
GPU eval jobs
10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month
Not ranked: misses a requirementNot ranked: misses a requirementNot ranked: misses a requirement
macOS agents
5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month
Not ranked: misses a requirementNot ranked: misses a requirementNot ranked: misses a requirement

Key features

FeatureBrowser UseNotteboat
What you getA hardened Chromium browser over CDP, or a hosted agent in its own micro-VMA hosted browser session over CDP, Playwright or Notte actions, plus agents, vaults, personas and Functions; isolation model not publishedA full Linux VM with its own kernel and root, with Chrome and a desktop on it
Browsers at once10 with no payment, 50 after $100 paid in total, up to 1,000 after $25,0005, 25 or 100 by plan; custom on Enterprise100 to 2,000 sandboxes at once by plan; 12 to 90 starts a minute included, extra starts $0.03 to $0.07, starts above 3 times that fail
How long a session runsAgent browsers stop after 4 hours at most; idle ones stop after about 2 minutes unless you set keepAlive (up to 4 hours)15 min on Free, 120 min on Developer, 300 min on Startup; custom on Enterprise, up to the API limit of 24 hAuto-stop after 1 hour by default; up to 30 days, or off on a paid plan; a running sandbox bills busy or idle
What survives a sessionBrowser profiles keep cookies and logins; the agent workspace keeps up to 1 GiB of filesFresh browser each session; an opt-in profile keeps cookies, local storage and session storage; session files (up to 10 GiB) stay with that sessionThe disk, saved every minute and at each stop, kept at least 14 days; memory is not saved; fork a running sandbox
Getting past bot checksHardened Chromium fork, per-session fingerprints, CAPTCHA solving (off in the EU)Captcha solving for reCAPTCHA, hCaptcha and Turnstile, and a consistent Chrome fingerprint, on every planChromium on datacenter IPs; you set up your own proxy or captcha service
ProxiesResidential proxies in 195+ countries, on by default at $5 per GB, or your own at $0.20 per GB directResidential proxies on by default at $10 per GB; your own proxy on Startup ($0.20 per GB)None managed; you can run your own proxy client inside the VM
Hosted agentHosted browser agent with a choice of models, a session queue and an events APIAnything API turns a plain-English task into a deployed browser Function; a browser skill, CLI and MCP server for coding agentsSeven coding agents inside the VM, such as Claude Code and Codex, driven from outside with a prompt, steer and events API
Logins and identitiesSecrets typed into the page by alias, kept out of the task textVaults for passwords, cards and 2FA secrets filled through placeholders, and personas with their own email and phoneYour agent logs in itself; the optional paid AI credentials proxy keeps real keys of supported AI providers outside
Running your own codeNo shell for you; the hosted agent writes and runs Python and shell commands in its own micro-VMPython Functions with a run() entry point, called by API, webhook or schedule; shell access not documentedRoot shell, any language, Docker, systemd and /dev/kvm
DesktopLive view of the browser, embeddable, plus a recordingLive view of the browser that you can embedA full Linux desktop and Chrome streamed at 60 fps, embeddable and recordable
Serving your own portsNot part of the product: it runs browsers and agents, not your own serversNot part of the product; a short-lived signed live-view URL per sessionUp to 50 HTTPS URLs per sandbox, token-gated by default; raw ports over public IPv6
Source code and self-hostingThe browser-use agent library is MIT and runs on your own machineFramework under SSPL-1.0 runs on local Chromium; on-premise and bring-your-own-cloud on EnterpriseHosted service only
RegionsUS, plus an EU deployment in Frankfurt with fewer featuresSession region not published; built-in proxies exit in the US unless you pick a countryGermany, Finland and France; you cannot pick a region; no US or Asia region
Every feature Battleships tracks (43)
FeatureBrowser UseNotteboat
Full VM (own kernel)Not publishedNo documented wayYes
Docker insideNo documented wayNo documented wayYes
Nested virtualizationNo documented wayNo documented wayYes
RootNot publishedNot publishedYes
SystemdNot publishedNot publishedYes
Desktop GUINo documented wayNo documented wayYes
BrowserYesYesYes
Computer-use APIYesYesYes
SSHNo documented wayNo documented wayYes
Persistent diskYesNo documented wayYes
Pause/resumeNo documented wayNo documented wayYes
Automatic snapshotsNo documented wayNo documented wayYes
Fork/cloneNo documented wayNo documented wayYes
Live fork (no pause)No documented wayNo documented wayYes
Memory forkNo documented wayNo documented wayNo documented way
Custom image (Docker or snapshot)Not publishedNot publishedYes
≥24 h sessionsNo documented wayYesYes
Idle auto-stopYesYesNo documented way
Wake on requestNo documented wayNo documented wayNo documented way
HTTPS preview URLsNo documented wayNo documented wayYes
Raw TCP inboundNot publishedNot publishedYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesNo documented wayNo documented way
Secret proxyNo documented wayNo documented wayYes
Secret proxy for any APINo documented wayNo documented wayYes
Preinstalled agentsNo documented wayNo documented wayYes
Agent harness APINo documented wayNo documented wayYes
MCP serverYesYesNo documented way
GPUNo documented wayNo documented wayNo documented way
WindowsNo documented wayNo documented wayNo documented way
Arm64No documented wayNot publishedNo documented way
Self-hostingYesYesNo documented way
BYOCNo documented wayYesNo documented way
Open sourceYesYesNo documented way
Scoped API keysNot publishedNot publishedYes
Spend limitsNot publishedNot publishedYes
Usage per sandbox (API)No documented wayNo documented wayYes
Audit logsNot publishedNot publishedNo documented way
SSONo documented wayYesNo documented way
SOC 2YesYesNo documented way
HIPAAYesYesNo documented way
EU data residencyYesNot publishedNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

Browser UseNot measured
NotteNot measured
boat28.06 runs/s

Neither Browser Use nor Notte is in the public benchmarks we use, so we cannot say which is faster. Neither publishes the CPU or memory behind a browser session. For browsing work, speed depends mostly on the sites, the proxy and the model. For reference, boat did 28.06 runs per second on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, second of 15 in StarSling's run of 3 October 2026 (run 37073680030). Every boat sandbox in that run ran on an AMD Ryzen 9 9950X host; boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure.

V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Browser Use and Notte are not in the public benchmarks we use, so we cannot say which is faster.

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. Start limits, per-start fees and plan minimums are in the price, boat's included.

ScenarioBrowser Use, a monthNotte, a monthboat, 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$8,800 · $2000/mo · with limits

Browser Use: Browser Use has no subscription. It bills $0.02 per browser-hour, rounded up to whole minutes, from prepaid credits that never expire. Traffic is extra: $5 per GB through the residential proxy, which is on by default, or $0.20 per GB direct. Agent runs add model tokens at listed per-model prices, or your own provider's cost plus 20% with your own key.

Notte: Notte has a Free plan with $10 of one-time credit. Paid plans ($20 Developer, $100 Startup) come back as monthly credits that expire each cycle; top-ups do not expire. Credits pay for browser sessions ($0.01 an hour), Functions ($0.05 an hour), residential proxies ($10 per GB, on by default) and model tokens at cost.

Notte: Plans cost $20, $100, $500 or $2,000 a month, and the whole plan price comes back as VM time for that month. Unused time expires at the end of the period. A default sandbox (4 vCPU / 8 GB) costs $0.036 an hour, billed per second while it runs, busy or idle. A stopped sandbox has no compute charge, and boat keeps its disk at least 14 days. Saved snapshots above the included count and the optional AI credentials proxy still charge while sandboxes are stopped. A card is required, also for the 7-day trial.

Limits in those scenarios

Neither fits any scenario in the table as written. Each 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 ($100 for 50 browsers, $25,000 for 1,000), and Notte Startup stops at 100, with anything above on Enterprise. boat fits every scenario except 1,000 short jobs at once. Its $2,000 plan includes 90 starts a minute, charges $0.03 to $0.07 for each extra start and refuses starts above 270 a minute. boat never queues a start.

ScenarioBrowser UseNotteboat
One coding agent, workdays
  • Pay as you go: sessions capped at 4 h
  • machine size not published
  • browser-session product, not a general sandbox
  • different kind of product: browser session
  • Startup: sessions capped at 5 h
  • missing persistent disk
  • machine size not published
  • browser-session product, not a general sandbox
None for this scenario
One agent that never stops
  • Pay as you go: sessions capped at 4 h
  • machine size not published
  • browser-session product, not a general sandbox
  • different kind of product: browser session
  • Startup: sessions capped at 5 h
  • missing persistent disk
  • machine size not published
  • browser-session product, not a general sandbox
None for this scenario
50 agents in parallel
  • Spend tier 50: sessions capped at 4 h
  • missing Docker inside
  • machine size not published
  • browser-session product, not a general sandbox
  • Startup: sessions capped at 5 h
  • missing persistent disk, Docker inside
  • machine size not published
  • browser-session product, not a general sandbox
None for this scenario
Sandboxes for your users
  • machine size not published
  • browser-session product, not a general sandbox
  • different kind of product: browser session
  • machine size per session not published
  • Startup: max 100 concurrent
  • machine size not published
  • browser-session product, not a general sandbox
  • different kind of product: browser session
None for this scenario
1,000 short jobs at once
  • machine size not published
  • browser-session product, not a general sandbox
  • different kind of product: browser session
  • machine size per session not published
  • Startup: max 100 concurrent
  • machine size not published
  • browser-session product, not a general sandbox
  • different kind of product: browser session
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429

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 that you can also run yourself.

  • Scales to 1,000 browsers. For big scraping jobs: concurrency grows from 10 to 1,000 browsers as lifetime payments grow, 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 120k GitHub stars.
  • No plan, credits that keep. For uneven workloads: no monthly plan, and prepaid credits never expire. An EU deployment 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.
  • A flat plan and your own cloud. A $100 Startup plan covers 100 browsers at once, and Enterprise offers on-premise and bring-your-own-cloud.

Where boat fits

Browser Use and Notte are browser services, not general sandboxes, so they overlap with boat where agents use the web. If your agents browse and also write code, keep files, run for hours or use a desktop, look at boat. You can still call Browser Use or Notte from inside a boat sandbox for the pages that fight bots.

A whole machine around the browser

Browser Use's hosted agent runs scripts in a small micro-VM, and Notte runs Python Functions. A boat sandbox is a full VM with root, Docker, systemd and /dev/kvm, with Chrome on it.

Long runs on one disk

Browser Use agent browsers stop after 4 hours and Notte Startup sessions after 300 minutes; profiles carry cookies and storage. boat runs until its auto-stop (1 hour by default, up to 30 days or off on a paid plan), saves the disk every minute and can fork a running sandbox.

A desktop and coding agents

Both stream a browser view, and their agents browse rather than write code. boat streams a 60 fps Linux desktop and ships Claude Code, Codex and other agents that you drive from outside.

Use boat when the agent does more than browse: it writes and runs code, keeps files between runs, works for hours, or needs a desktop, Docker and coding agents on one VM. Compare it one to one: boat vs Browser Use and boat vs Notte.

boat's own limits
  • Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
  • Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
  • A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
  • Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
  • boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
  • Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
  • Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
  • Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source

Questions people ask

Is Browser Use cheaper than Notte?

It depends on volume. A workday agent comes to $7 a month on Browser Use against $100 on Notte's Startup plan. For 50 agents in parallel, Notte's flat $100 costs less than Browser Use's $178; boat is $317 for a full VM each. For browser-use agents we model $140 a month on Browser Use, $100 on Notte and $200 on boat. Proxy traffic is billed on top on both browser services.

Which is faster, Browser Use or Notte?

We cannot say. Neither publishes the machine size behind a browser, and neither is in the public benchmarks we use. 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 custom limits on Enterprise. A boat sandbox stops after 1 hour by default; on a paid plan you can set up to 30 days or turn auto-stop off.

Can Browser Use or Notte run Docker?

Not as documented. Browser Use's hosted agent runs its own Python and shell commands in a micro-VM, and Notte runs Python Functions; neither documents Docker. boat 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; its hosted cloud is not, and on-premise is Enterprise only. boat is a hosted service only.

Can I use Browser Use or Notte from a boat sandbox?

Yes. A boat 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 boat and sends hard-to-reach pages to the stealth browser.

Try boat

Install the CLI, then run boat new.

7-day free trial

More comparisons