Anchor Browser vs Notte
Both rent your agent a managed cloud browser. Anchor Browser runs each session in its own VM with no upper limit on length and keeps logins with MFA, while Notte turns on residential proxies and captcha solving in every session but caps sessions at 15 to 300 minutes by plan.
The companies and products
Anchor Browser
Anchor Browser is cloud browser infrastructure for AI agents: managed Chromium sessions you control over CDP or a REST API, plus a hosted browser agent.
Anchor Browser is a different kind of product from bochka. Each session is a headful Chromium in its own VM that is erased when the session ends, and you drive it with Playwright or Puppeteer, with mouse and keyboard calls, or by sending a task in plain words to its hosted agent. It adds managed logins with MFA, residential proxies, stealth and CAPTCHA solving, and its own docs tell you to run your agent's code in a separate sandbox and connect to the browser over CDP.
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. “28th cheapest of 367” means 27 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 | Anchor Browser: 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 Anchor nor Notte has a shell, Docker or a lasting disk, so a coding agent cannot build and test there; it can only use them as its browser. | 180th of 367, with limits $2,000 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 assistant that runs all month needs a machine that keeps its state; Anchor keeps profiles and volume files, Notte only cookies and storage, and Notte sessions end after 300 minutes on Startup. | 71st of 366, with limits $1,845 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 | 325th of 345, with limits $2,171 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 300 sandboxes at once is more than Anchor's Growth plan (200) or Notte's Startup plan (100) allows, and each one is a browser, not a machine. | 283rd of 361, with limits $2,000 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 | 298th of 360, with limits $12,510 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 | 357th of 364, with limits $2,000 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 | 284th of 377, with limits $500 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 | 222nd of 368, with limits $42 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 Anchor and Notte act inside a browser only, so agents that need a whole desktop or other apps fit bochka's 60fps Linux desktop better. | 173rd of 369, with limits $500 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 has stealth on by default and a lower plan fee, Anchor has longer sessions and managed logins, and bochka fits when the agent also needs a shell or files. | 28th cheapest of 367 $560 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 startup-scale bots; Anchor and Notte bring residential proxies billed per GB, while bochka uses datacenter IPs and keeps each bot's files on disk. | 50th cheapest of 346 $500 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 For sites with strong bot checks, Anchor and Notte are the stronger fits because proxies, fingerprints and captcha solving come built in; on bochka you add those yourself. | 5th of 338, with limits $6,175 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 | 334th of 360, with limits $2,000 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 | Anchor Browser | Notte | bochka |
|---|---|---|---|
| What you get | A managed headful Chromium in its own VM, erased when the session ends | A hosted browser session you reach through the API; isolation model not published | A full Linux VM with its own kernel and root, on dedicated AMD Ryzen 9 9950X hosts |
| Browser control | CDP with Playwright or Puppeteer, a REST API, and mouse, keyboard and screenshot calls | A CDP URL, Playwright, Notte's own actions and an embeddable live view | Chrome in the VM over Playwright, Puppeteer or CDP, plus a 1920x1080 60fps browser stream |
| Getting past bot checks | CAPTCHA solving from Starter, full stealth Chromium on Growth, unique fingerprints on Enterprise | Residential proxies, captcha solving and a matching Chrome fingerprint on by default, on every plan | Datacenter IPs; bring your own proxy or captcha service |
| Proxies | Residential at $8 per GB with country and city targeting, sticky IPs, or your own proxy | Residential at $10 per GB, on by default, with a country you pick; your own proxy on Startup | None managed; you can run your own proxy client inside the VM |
| How long a session runs | 180 minutes by default, with no upper limit if you raise it; ends after 5 idle minutes by default | 15 min on Free, 120 min on Developer, 300 min on Startup, custom on Enterprise | No session cap on paid plans; a stopped sandbox keeps its disk |
| What survives a session | The VM is erased; profiles keep cookies, local storage and cache, and up to 10 volumes keep files | A fresh browser each time; an opt-in profile keeps cookies, local storage and session storage | The whole disk, saved every minute and on stop; Chrome profiles go with snapshots and forks |
| Fork | No fork of a session | No session fork; a Function can be forked as a copy of its code | Fork a running sandbox, browser and files included |
| Running your own code | No shell; from Growth you can run TypeScript snippets against the page, and its docs point agent code to a separate sandbox | Python Functions with a run() entry point, called by API, webhook or schedule; no shell | Root shell, any language, Docker, systemd and /dev/kvm |
| Logins and secrets | Managed identities with MFA keep logins across sessions, from Starter; secrets are hidden from the model and typed into the page | Vaults fill passwords, cards and 2FA codes so the model never sees them; personas with their own email and phone | Your agent logs in itself and Chrome profiles stay on disk; a credentials proxy keeps real API keys out of the sandbox |
| Agents | Hosted browser agents (browser-use, OpenAI, Gemini and Anthropic computer use) with human-in-the-loop, webhooks and an MCP server | Notte's own browser agent: start it with a task, stream its logs, export the run 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 |
| Desktop and computer use | Live view of the browser only, with mouse and keyboard calls | Browser only; no desktop | A full Linux desktop streamed at 60fps, embeddable and recordable to MP4 |
| Reaching it from outside | No ports of your own; only the CDP socket and the live view URL | No open ports; a short-lived signed live-view URL per session | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP |
| Where it runs | US by default; EU, Asia and Australia on Growth; any region or your own cloud on Enterprise | 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 |
| Running it yourself | Your own cloud or on-premise on Enterprise | The agent framework is source-available under SSPL and runs on local Chromium; on-premise and your own cloud on Enterprise | Hosted only |
Every feature Battleships tracks (43)
| Feature | Anchor Browser | 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 | 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) | No | Not published | Yes |
| ≥24 h sessions | Yes | 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 | No | 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 | Yes | Yes | No |
| BYOC | Yes | 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) | Yes | 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 | Not published | Not published | Yes |
Performance
There is no comparable measurement for either. Anchor Browser and Notte sell browser time, do not publish the CPU or memory behind a session, and are not in the CPU benchmark. bochka scored 26.69 runs per second on the hpc-sandbox-benchmarks Node.js test 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. Anchor Browser 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 | Anchor Browser, 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 · Free · 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 | $42 · Free · 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 | $500 · Team · 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 | $2,000 · Growth · 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 | $2,510 · Growth · with limits | $100 · Startup · with limits | $2,000 · $2000/mo · with limits |
Anchor Browser: Anchor bills $0.05 per browser-hour, counted to the nearest minute, plus $0.01 for each browser created. Plan fees (Starter $50, Team $500, Growth $2,000) become credits worth $1 each, and traffic is extra: $8 per GB through its proxy or $0.20 per GB direct.
Notte: Notte's plan fee (Developer $20, Startup $100) comes back as credits that expire each cycle, spent on browser time at $0.01 an hour, Functions at $0.05 an hour, residential proxies at $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: Plans start at $20 a month, and the whole fee is usage credit spent per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Neither Anchor Browser nor Notte fits any of the five scenarios as written, because each asks for a general machine and both sell a browser session of a size they do not publish, with no Docker. Notte's Startup plan also ends sessions at 300 minutes, short of an 8-hour workday, while Anchor's 180-minute default can be raised. Anchor allows 200 browsers at once on Growth and Notte 100 on Startup, so 300 sandboxes for your users and 1,000 jobs at once need Enterprise on both. bochka fits four scenarios; at 1,000 short jobs at once its $2,000 plan queues the starts.
| Scenario | Anchor Browser | 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 Anchor Browser when
your browser jobs run for hours, need logins with MFA kept across sessions, or need proxies by city and regions outside the US.
- Sessions as long as the job. For long browser jobs: sessions run 180 minutes by default, and you can raise the limit with no upper bound.
- Logins that stay with MFA. For agents working inside web apps with no API: managed identities with MFA stay logged in across sessions, from Starter.
- Finer proxy and region control. For location-specific work: residential proxies with city targeting and sticky IPs, plus EU, Asia and Australia regions on Growth.
Use Notte when
you want stealth, residential proxies and captcha solving on from the first session, ready-made browsing tools and a low plan fee to start.
- Stealth on from the first session. For sites that block bots: residential proxies, captcha solving and a matching fingerprint are on by default, on every plan.
- Ready-made browsing tools. For teams that want browsing handled: a task-driven agent, personas with their own email and phone, vaults and scheduled Functions.
- Source you can run yourself. For teams that must self-host: the agent framework is source-available under SSPL and runs on local Chromium.
Where bochka fits
If what you are really running is agents that browse and then do something with what they find, Anchor Browser and Notte both stop at the browser. bochka gives each agent a whole Linux VM with Chrome and a desktop inside, next to its shell, files and Docker. For pure browsing on sites that fight bots, Anchor or Notte is the better tool, and you can call either one from a bochka sandbox.
A whole machine around the browser
Neither Anchor nor Notte gives the agent a shell, Docker or a disk. Anchor's docs say to run agent code in a separate sandbox, so you pay for and wire up two services and move every download between them.
Work that survives the session
Anchor erases each session's VM and Notte starts a fresh browser and ends sessions after 300 minutes on Startup. bochka saves the whole disk every minute and on stop, and can fork a running sandbox.
A desktop, coding agents and ports
Both act inside a browser only and give you no ports. bochka streams a 60fps Linux desktop, runs Claude Code or Codex that you drive from outside, and serves HTTPS on up to 50 ports.
Use bochka when the agent does more than browse: it writes and runs code, keeps its files between runs, works for hours, or needs a desktop, Docker and coding agents on one VM. Compare it one to one: bochka vs Anchor Browser and bochka vs Notte.
Questions people ask
Is Anchor Browser cheaper than Notte?
In our model Notte usually is: its $100 a month Startup plan covers every scenario we priced, while Anchor ranges from $7 to $2,510. For browser-use agents, where both fit, Notte comes to $100 a month and Anchor to $560. Proxy traffic is extra on both, $8 per GB on Anchor and $10 per GB on Notte, where proxies are on by default.
Which is faster, Anchor Browser or Notte?
We cannot say. Neither publishes the machine behind a browser session, and neither is in the CPU benchmark. For browsing work, speed depends mostly on the sites, the proxy and the model.
Which is better at getting past bot checks?
Both handle it. Notte turns on residential proxies, captcha solving and a matching fingerprint in every session on every plan. Anchor solves CAPTCHAs from Starter, adds full stealth on Growth and unique fingerprints on Enterprise, and targets proxies down to the city.
How long can a session run on Anchor Browser and Notte?
Anchor sessions end after 180 minutes by default, and you can raise that with no upper limit. Notte caps sessions at 15 minutes on Free, 120 on Developer and 300 on Startup. bochka has no session cap on paid plans.
Can Anchor Browser or Notte run Docker?
No. Neither gives you a shell or Docker: Anchor runs TypeScript snippets against the page from Growth, and Notte runs Python Functions. bochka gives every agent a full Linux VM with root, Docker, systemd and /dev/kvm.
Can I use Anchor Browser or Notte from a bochka sandbox?
Yes. A bochka sandbox has open internet, so code or an agent inside it can connect to an Anchor browser over CDP or call Notte's API, SDK or MCP server. The agent builds and tests on bochka and sends hard-to-reach pages to them.
Try bochka
Install the CLI, then run bochka new.
Product preview