Browserless vs Notte

Browserless is a browser API: you point Puppeteer, Playwright or BrowserQL at managed Chrome, Firefox or WebKit for sessions of up to 60 minutes on Scale, with longer persistent sessions on Enterprise. Notte is a cloud browser built for AI agents, with residential proxies and captcha solving on by default, the Anything API, vaults and personas, and sessions of up to 300 minutes on Startup.

The companies and products

Browserless

Browserless calls itself a cloud browser automation platform: managed browsers you connect to with one line of code.

You point existing Puppeteer, Playwright or Selenium code at a Browserless WebSocket URL. You can also use BrowserQL, its GraphQL language with stealth and CAPTCHA solving, REST endpoints for screenshots, PDFs and scraping, an MCP server, a CLI and agent skills. Self-serve sessions last 2 to 60 minutes by plan. Between sessions, the browser profile can be kept, and processKeepAlive (Puppeteer) keeps the live browser for a set window. Enterprise adds persistent sessions on dedicated workers. It is a browser product, not a general sandbox: your code gets a browser, not a shell on the machine. 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 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. “19th cheapest of 356” means 18 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 workloadBrowserless: price rankNotte: price rankboat: 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 boat, which ranks 8th.
198th of 365, with limits
$1,771 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 assistant that lives on its machine all month hits a 60-minute cap on Browserless Scale and a 300-minute cap on Notte Startup (both offer longer limits on Enterprise); boat has no session cap once auto-stop is off (paid plans; default 1 hour).
311th of 361, with limits
$6,170 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
265th of 336, with limits
$350 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
258th of 349, with limits
$1,490 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
273rd of 349, with limits
$8,600 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
251st of 359, with limits
$350 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
CI jobs need a shell, Docker and often /dev/kvm, which boat has and neither browser session does.
242nd of 374, with limits
$140 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
A dev box has to keep its files and processes, which neither browser service does, so this fits boat.
341st of 371, with limits
$350 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
Browserless and Notte act on a browser only, while boat ranks 10th with a 60fps Linux desktop where an agent can use any app.
183rd of 367, with limits
$350 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
All three fit: Notte ranks 2nd with stealth and an agent built in, boat ranks 7th with Chrome on a full VM, and Browserless ranks 19th.
19th cheapest of 356
$350 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
All three fit at startup scale; Browserless adds REST endpoints for screenshots and PDFs, Notte turns on residential proxies by default, and boat ranks 7th.
50th cheapest of 343
$478 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
Both browser services beat boat here, since stealth, captcha solving and residential proxies come built in; Notte ranks 2nd and Browserless ranks 19th.
19th of 327, with limits
$17,150 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
113th of 351, with limits
$350 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

FeatureBrowserlessNotteboat
Kind of productManaged headless Chrome, Firefox and WebKit, plus BrowserQL, REST APIs and an MCP serverManaged cloud Chrome for AI agents, plus a browser agent, vaults, personas and Python FunctionsA full Linux VM per sandbox, with a desktop and Chromium inside
IsolationManaged browser pool with resource isolation between sessions; the isolation technology is not publishedIsolation model not publishedFull VM with its own kernel; vCPUs are shared, not dedicated cores
Session length2 minutes on Free, 15 on Prototyping, 30 on Starter, 60 on Scale; persistent sessions on Enterprise15 minutes on Free, 120 on Developer, 300 on Startup; custom on Enterprise, up to the API limit of 24 hNo cap once auto-stop is off (paid plans); auto-stop defaults to 1 hour and can be set up to 30 days
Browsers at once2 on Free; 10, 40 or 100 on the annual plans5, 25 or 100 by planOn the $2,000 plan, 2,000 at once; starts above 90 a minute cost extra, starts above 270 a minute fail; 2,400 included starts a day
What survives a sessionCookies, localStorage and cache for 1 to 90 days by plan; a new browser process on reconnect unless processKeepAlive (Puppeteer) keeps itA fresh browser each time; an opt-in profile keeps cookies, local storage and session storage; session files (up to 10 GiB) stay with that sessionThe disk is saved every minute and at each stop, and kept at least 14 days after a stop; memory, processes and /tmp are not saved
Bot detectionBrowserQL stealth, fingerprint mitigations, CAPTCHA solving, residential and datacenter proxiesResidential proxies, captcha solving and a matching Chrome fingerprint, all on by defaultDatacenter IPs and Chromium; bring your own proxy or captcha service
Running your own codeNo shell in a hosted session; your code drives the browser over CDP, BrowserQL or RESTPython Functions with a run() entry point, called by API, webhook or schedule; shell access is not documentedRoot shell, SSH, any language, Docker, systemd and /dev/kvm
Ready-made web toolsREST endpoints that return screenshots, PDFs and scraped content in one callAnything API turns a plain-English task into a reusable browser Function; personas with their own email and phoneChrome in the VM with Playwright, Puppeteer or CDP on a local port
AgentsA managed browser agent in beta (Agent Run API), up to 15 minutes and 60 steps a turn, plus agent skills and a Claude Code pluginAnything API builds, deploys and runs browser Functions from a task; a browser skill, CLI and MCP server for coding agents outsideClaude Code, Codex, OpenCode and more inside the VM, driven from outside with a prompt, steer and events API
Desktop and computer useBrowser only, with live URLs that hand a session to a personBrowser only, with a live view you can embed60fps Linux desktop that agents can see and use, embeddable and recordable
Keeping secrets from the model1Password fills logins into the page without the value reaching your codeVaults store passwords, 2FA secrets and cards and fill them through placeholders, so the real value stays out of the model contextOptional paid AI credentials proxy ($1 a day it is on, plus $1 per 1,000 requests) for model providers and custom HTTPS APIs; other secrets still enter the sandbox
Reaching it from outsideRegional WebSocket and HTTPS endpoints and short-lived live URLs; no ports to host onNo open ports; a short-lived signed live-view URL per sessionHTTPS URLs for up to 50 ports, token-protected; raw TCP to the sandbox IP (IPv6 only on some sandboxes; the IP changes at each resume)
Self-hostingOpen source Docker image you can run yourself; commercial use needs a licenseSource-available agent framework on local Chromium; on-premise and your own cloud on EnterpriseManaged cloud only
Where it runsSan Francisco, London and Amsterdam; New York on private fleetsSession region not published; built-in proxies exit in the US unless you pick a countryGermany, Finland and France; you cannot pick a region; snapshot copies can be stored outside the EU
Every feature Battleships tracks (43)
FeatureBrowserlessNotteboat
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 diskNo documented wayNo 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 agentsYesNo documented wayYes
Agent harness APINo documented wayNo documented wayYes
MCP serverYesYesNo documented way
GPUYesNo documented wayNo documented way
WindowsNo documented wayNo documented wayNo documented way
Arm64No documented wayNot publishedNo documented way
Self-hostingYesYesNo documented way
BYOCYesYesNo 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
SSOYesYesNo documented way
SOC 2YesYesNo documented way
HIPAAYesYesNo documented way
EU data residencyYesNot publishedNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

BrowserlessNot measured
NotteNot measured
boat28.06 runs/s

There is no comparable measurement. Browserless and Notte are not in the public benchmarks we use, and neither publishes the vCPU or RAM behind a browser session, so we cannot say which is faster. For reference, boat did 28.06 runs/s 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. For browsing work, speed depends mostly on the sites, the proxy and the model.

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. Browserless 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.

ScenarioBrowserless, 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
$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$8,800 · $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. Annual plans cost $25, $140 or $350 a month for 20,000, 180,000 or 500,000 units; proxy traffic and CAPTCHA solves use the same units. Monthly billing costs more and gives less concurrency, and there is a $0 Free plan with 2-minute sessions.

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) 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. The plan price comes back as VM time for that month: $20 is about 555 hours of a 4 vCPU / 8 GB sandbox, billed per second. The $20 plan runs 100 sandboxes at once and includes 12 starts a minute, 60 an hour and 200 a day. Create, fork and resume each count as one start; a resume onto the kept machine does not count. Extra starts cost $0.03 to $0.07 each, up to 1,200 a day, and starts above that fail. A stopped sandbox uses no machine time and keeps its disk for at least 14 days. Saved snapshots above the included count and the AI credentials proxy still cost money.

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 on a self-serve plan; Enterprise limits on both are priced by sales. 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 boat the 1,000-job burst does not fit either: on the $2,000 plan, starts above 90 a minute cost extra, starts above 270 a minute fail with 429, and boat never queues a start. boat auto-stop defaults to 1 hour.

ScenarioBrowserlessNotteboat
One coding agent, workdays
  • Scale annual: sessions capped at 1 h
  • missing persistent disk
  • machine size not published
  • browser-session product, not a general sandbox
  • 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
  • Scale annual: sessions capped at 1 h
  • missing persistent disk
  • machine size not published
  • browser-session product, not a general sandbox
  • 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
  • Scale annual: sessions capped at 1 h
  • missing persistent disk, 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
  • Scale annual: max 100 concurrent
  • machine size not published
  • browser-session product, not a general sandbox
  • different kind of product: browser session
  • 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
  • Scale annual: max 100 concurrent
  • machine size not published
  • browser-session product, not a general sandbox
  • different kind of product: browser session
  • 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 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, plain-English browser Functions, 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 boat 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, boat 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 carry over browser storage. On boat there is no session cap once auto-stop is off (paid plans; default 1 hour), the disk is saved every minute and kept at least 14 days after a stop, and you can fork a running sandbox.

Coding agents and a desktop built in

Both services run their own browser agent. boat ships Claude Code, Codex and others that you drive from outside, a 60fps desktop for apps beyond the browser, and an optional paid proxy that keeps model and custom API keys out.

Use boat when your agent browses and also works: installs, builds, Docker and dev servers on a full VM that keeps its disk and, with auto-stop off, runs as long as the task takes, with coding agents built in. Compare it one to one: boat vs Browserless 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 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; boat comes to $200 and $90. Both bill extra for residential proxy traffic, Browserless in units and Notte at $10 per GB. Both also have a free plan.

Which is faster, Browserless or Notte?

There is no comparable measurement. Neither publishes the machine behind a browser session, and neither is in the public benchmarks we use. For browsing, speed depends mostly on the sites, the proxy and the model.

Can Browserless or Notte run Docker or a shell?

Not in a hosted session. A hosted Browserless session gives you a browser over CDP, BrowserQL or REST, and Notte gives you a browser and Python Functions, with no documented shell in either. You can run the Browserless Docker image on your own server. Every boat 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. On boat, auto-stop defaults to 1 hour; you can turn it off on a paid plan, and boat keeps the disk at least 14 days after a 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. boat 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. boat is a managed cloud only.

Try boat

Install the CLI, then run boat new.

7-day free trial

More comparisons