boat vs Notte
Notte is a managed cloud browser: your agent gets Chrome through an API, with residential proxies and captcha solving turned on. boat gives the agent a whole VM with its own kernel, a desktop and Chrome, Docker and a disk that stays between runs.
Where boat stands out
A whole computer, not only a browser
A boat sandbox is a full VM with its own kernel, root, systemd, Docker and /dev/kvm, and Chrome runs on it. The agent can download a file, process it with a script, start a database and check the result in the browser, all on one machine. Notte gives you a browser to drive and Python Functions, with no shell.
Nothing resets after a few hours
Paid boat plans have no session cap. The disk persists, snapshots are taken every minute and on stop, a stopped sandbox costs nothing, and you can fork a running sandbox with its Chrome profiles. Notte sessions end after 15, 120 or 300 minutes by plan and start with a fresh browser unless you save a profile.
A desktop and coding agents built in
boat streams a 60fps Linux desktop and Chrome that you can embed and record, and every built-in agent, such as Claude Code or Codex, can see and use it. You drive those agents from outside with a prompt, steer and events API. The credentials proxy keeps real AI keys out of the sandbox for any HTTPS API.
The companies and products
boat
boat.dev runs sandboxes for AI agents: each one is a full Linux VM with its own kernel.
You start a machine with one command or one API call, then SSH in, run Docker, open a desktop, or let a built-in agent (Claude Code, Codex, OpenCode and others) work in it. The disk stays between sessions, and a stopped sandbox costs nothing.
- Isolation
- Full VM per sandbox, own kernel
- Regions
- EU: Germany, Finland, France
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 boat: a browser service, not a general sandbox, so this page compares the two where they overlap, which is agents that use the web.
- Backing
- Backed by Y Combinator
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 | boat: price rank | Notte: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Notte has no shell, Docker or lasting disk, so a coding agent cannot build and test there; it can only use Notte as its browser. | 3rd cheapest of 367 $634 a month | 44th of 367, with limits $121 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Notte sessions end after at most 300 minutes on Startup and start fresh, so an always-on assistant needs a machine like boat to live on. | 5th cheapest of 366 $657 a month | 99th of 366, with limits $365 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month | 186th of 345, with limits $2,000 a month | 220th of 345, with limits $100 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month | Cheapest of 361 $209 a month | 195th of 361, with limits $105 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 34th of 360, with limits $2,000 a month | 222nd of 360, with limits $500 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 10th cheapest of 364 $200 a month | 227th of 364, with limits $100 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month | 4th cheapest of 377 $86 a month | 230th of 377, with limits $100 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Notte has no shell or disk to develop on, so it does not fit this use. | 18th cheapest of 368 $26 a month | 255th of 368, with limits $100 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Notte controls a browser only, so agents that need a whole desktop or other apps fit boat's 60fps Linux desktop better. | 6th cheapest of 369 $200 a month | 76th of 369, with limits $100 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Both fit: Notte is built for this with stealth and captcha solving on by default, and boat gives the agent Chrome on a full VM next to its code and files. | 7th cheapest of 367 $200 a month | 2nd cheapest of 367 $100 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month Both fit; Notte routes traffic through residential proxies billed per GB, while boat uses datacenter IPs and lets you bring your own proxy. | 6th cheapest of 346 $90 a month | 7th cheapest of 346 $100 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month Notte is the stronger fit for sites that block bots at scale, since residential proxies, fingerprints and captcha solving come built in; on boat you add those yourself. | 71st of 338, with limits $1,800 a month | 2nd of 338, with limits $975 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 2nd cheapest of 360 $200 a month | 143rd of 360, with limits $100 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 |
| 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 |
Key features
| Feature | boat | Notte |
|---|---|---|
| What you get | A full Linux VM with its own kernel, with Chrome and a desktop on it | A hosted browser session you reach through the API; isolation model not published |
| Browser control | Chrome in the VM: Playwright, Puppeteer or CDP on a local port, plus a 1920x1080 60fps browser stream | Hosted Chromium or Chrome with a CDP URL, Playwright, Notte actions and a live view you can embed |
| Getting past bot checks | Datacenter IPs; bring your own proxy or captcha service | Residential proxies ($10/GB, on by default), captcha solving and a matching Chrome fingerprint on every plan |
| How long a session runs | No session cap on paid plans | 15 min on Free, 120 min on Developer, 300 min on Startup |
| What survives a stop | The whole disk, with snapshots every minute and on stop; Chrome profiles go with snapshots and forks | Fresh browser each session; an opt-in profile keeps cookies, local storage and session storage |
| Fork | Fork a running sandbox, browser and files included | No session fork; a Function can be forked as a copy of its code |
| Running your own code | Root shell, any language, Docker, systemd and /dev/kvm | Python Functions with a run() entry point, called by API, webhook or schedule; no shell |
| Desktop and computer use | 60fps Linux desktop that every built-in agent can see and use, embeddable and recordable to MP4 | Browser only; no desktop |
| Agents | Claude Code, Codex and other coding agents inside the VM, driven from outside with a prompt, steer and events API | Notte's own browser agent: start it with a task, stream its logs, stop it, export the run as code; an MCP server for agents outside |
| Keeping secrets from the model | AI credentials proxy: real keys never enter the sandbox, for model providers and any HTTPS API | Vaults fill passwords, cards and 2FA codes so the LLM never sees them; personas with their own email and phone |
| Reaching it from outside | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 | No open ports; a short-lived signed live-view URL per session |
| Self-hosting | Hosted only | Source-available framework runs on local Chromium; on-premise and bring-your-own-cloud on Enterprise |
| Where it runs | EU only (Germany, Finland, France), with EU data residency and zero data retention | Session region not published; built-in proxies exit in the US unless you pick a country |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | SOC 2 |
Every feature Battleships tracks (43)
| Feature | boat | Notte |
|---|---|---|
| Full VM (own kernel) | Yes | No |
| Docker inside | Yes | No |
| Nested virtualization | Yes | No |
| Root | Yes | Not published |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | No |
| Browser | Yes | Yes |
| Computer-use API | Yes | Yes |
| SSH | Yes | No |
| Persistent disk | Yes | No |
| Pause/resume | Yes | No |
| Automatic snapshots | Yes | No |
| Fork/clone | Yes | No |
| Live fork (no pause) | Yes | No |
| Memory fork | No | No |
| Custom image (Docker or snapshot) | Yes | Not published |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | Yes |
| Wake on request | No | No |
| HTTPS preview URLs | Yes | No |
| Raw TCP inbound | Yes | Not published |
| Public IPv4 | No | No |
| Egress allowlist | No | No |
| Secret proxy | Yes | No |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | No |
| Agent harness API | Yes | No |
| MCP server | No | Yes |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | Not published |
| Self-hosting | No | Yes |
| BYOC | No | Yes |
| Open source | No | Yes |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Not published |
| SSO | No | Yes |
| SOC 2 | No | Yes |
| HIPAA | No | Yes |
| EU data residency | Yes | Not published |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement. Notte does not publish the machine size behind a browser session and was not in the StarSling benchmark run, where boat did 26.69 Node.js build-and-test 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. Notte has 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 | boat, a month | Notte, 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 | $20 · $20/mo | $100 · Startup · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $100 · Startup · with limits |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $317 · $20/mo × 3 seats | $100 · Startup · with limits |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $200 · $100/mo × 2 seats | $100 · Startup · with limits |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $2,000 · $2000/mo · with limits | $100 · Startup · with limits |
boat: 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.
Notte: Notte's plan fee 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 a session's traffic is billed per GB unless you turn them off or bring your own proxy on Startup.
Limits in those scenarios
Notte fits no scenario in the table, because each needs a machine: work that runs for more than 300 minutes, files that stay, or Docker. Notte sessions end at the plan's time limit and start with a fresh browser, and Startup allows 100 browsers at once, so 300 sandboxes for your users or 1,000 jobs at once need Enterprise. On boat the limit for the burst is starts: the $2,000 plan allows 2,400 starts a day and queues bursts above 90 starts a minute.
| Scenario | boat | Notte |
|---|---|---|
| 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 Notte when
the job is pure browsing on sites that fight bots, and you want proxies, captcha solving, a browser agent and identities handled for you.
- Getting past bot checks. Useful if your agents browse sites that block bots: Notte turns on residential proxies, captcha solving and a matching fingerprint by default.
- Ready-made browsing tools. Useful if you want browsing handled for you: a task-driven browser agent, personas with email and phone, and scheduled browser Functions.
- Open source and on-premise. Useful if you must run it yourself: the framework is source-available, and Enterprise adds on-premise and bring-your-own-cloud.
Use boat when
the agent does more than browse: it writes and runs code, keeps files and Chrome logins between runs, works for hours, or needs a desktop, Docker and coding agents on one VM.
- A whole computer, not only a browser. On Notte, anything that is not browsing has to run somewhere else, so you run a second machine and move files between it and the browser session.
- Nothing resets after a few hours. A long task on Notte has to fit in 300 minutes on Startup, and only cookies and storage carry over, so downloads and work files are gone when the session closes.
- A desktop and coding agents built in. Notte controls a browser only, so a task that also needs a terminal or a desktop app needs another tool, and its built-in agent browses rather than writes code.
Questions people ask
Is boat cheaper than Notte?
Notte's plan fee is lower in most of our scenarios: we priced every one at the $100 a month Startup plan, against $20 to $2,000 on boat. But none of the five fit on Notte, because they need sessions longer than 300 minutes, a disk or Docker. For browser-use agents, where both fit, Notte comes to $100 a month in our model and boat to $200.
Is Notte a sandbox?
Not in the usual sense. Notte hosts browser sessions and runs Python Functions, but it gives you no shell, no Docker and no disk that stays. boat gives every agent a full Linux VM with Chrome on it.
Can boat solve captchas or use residential proxies?
Not out of the box. boat sandboxes use datacenter IPs and have no built-in captcha solver, but they have open internet, so you can point Chrome at your own proxy or captcha service. Notte turns on residential proxies and captcha solving by default.
Can I use Notte from a boat sandbox?
Yes. A boat sandbox has open internet, so code or an agent inside it can call Notte's API, SDK or MCP server. That lets the agent build and test on boat and send hard-to-reach pages to Notte.
Does Notte keep my files between sessions?
No. Each Notte session starts with a fresh browser, and an opt-in profile carries over only cookies, local storage and session storage. On boat the whole disk persists, with snapshots every minute and on stop.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention. Notte shows a SOC 2 Type II badge on its site and lists HIPAA for Enterprise.
Start a sandbox
Install the CLI, then run boat new.
7-day free trial
More comparisons
- boat vs Browser Use
- boat vs Kernel
- boat vs Zenrows
- boat vs Anchor Browser
- boat vs Scrapeless
- boat vs Hyperbrowser
- boat vs Steel
- boat vs BrowserCloud
- boat vs E2B
- boat vs Daytona
- boat vs Modal
- boat vs Vercel Sandbox
- Browserbase vs Notte
- Browser Use vs Notte
- Steel vs Notte
- Hyperbrowser vs Notte
- Kernel vs Notte
- Anchor Browser vs Notte
- Browserless vs Notte
- Notte vs Scrapeless