Hyperbrowser vs Notte
Both sell cloud Chrome for AI agents with residential proxies and captcha solving. Hyperbrowser also sells Firecracker sandboxes for code and web data APIs, while Notte stays a browser service with its own browser agent, vaults, personas and Python Functions.
The companies and products
Hyperbrowser
Hyperbrowser calls itself the AI agents' gateway to the internet: cloud browsers, sandboxes, web data APIs and browser agents behind one API and one credit balance.
Its main product is a cloud Chrome session you drive with Playwright or Puppeteer, with stealth mode, residential proxies, CAPTCHA solving, saved profiles and recordings. Next to it Hyperbrowser sells Sandboxes, Firecracker VMs on Ubuntu 24.04 that live up to 24 hours, with memory snapshots, volumes and outbound rules, plus Fetch, Scrape and Search APIs and hosted browser agents. It is a browser and web data platform more than a general sandbox, so this page compares where it overlaps with bochka: agents that browse, and agents that run code.
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. “20th cheapest of 367” means 19 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 | Hyperbrowser: 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 Notte has no shell or Docker, and Hyperbrowser's sandboxes lose their disk on stop and do not document Docker inside, so builds fit bochka better. | 136th of 367, with limits $1,206 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 Notte sessions end after at most 300 minutes on Startup and Hyperbrowser sandboxes after 24 hours, so an always-on assistant needs a machine like bochka with no session cap. | 255th of 366, with limits $3,650 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 Neither is a natural fit; Hyperbrowser's memory snapshots start short code runs from a warm state, while Notte only runs Python Functions. | 244th of 345, with limits $246 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 | 245th of 361, with limits $1,029 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 | 262nd of 360, with limits $4,972 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 | 253rd of 364, with limits $400 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 | 238th of 377, with limits $120 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 | 240th of 368, with limits $73 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, with no Linux desktop, so agents that need other apps fit bochka's 60fps desktop better. | 144th of 369, with limits $360 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, and Notte ranks 2nd against Hyperbrowser's 20th mostly on its lower browser-hour rate; bochka ranks 7th with Chrome on a full VM next to the agent's code. | 20th cheapest of 367 $360 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 at startup scale; Hyperbrowser adds per-page Fetch and Scrape APIs, Notte turns on residential proxies by default, and bochka uses datacenter IPs. | 32nd cheapest of 346 $366 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 Both are strong here with residential proxies and captcha solving built in; Notte comes to $975 a month in our model against $9,750 on Hyperbrowser, and bochka ranks 71st. | 11th of 338, with limits $9,750 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 Hyperbrowser ranks 33rd against Notte's 143rd because its sandboxes can run code next to the browser; bochka ranks 2nd with a full VM per run. | 33rd of 360, with limits $356 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 | Hyperbrowser | Notte | bochka |
|---|---|---|---|
| Kind of product | Cloud browser sessions first, plus Firecracker sandboxes and Fetch, Scrape and Search APIs | Managed cloud browser API with a browser agent, vaults, personas and Python Functions | A full Linux VM per sandbox, with a desktop and Chromium inside |
| Running your own code | Firecracker sandboxes with exec, process and PTY terminal APIs and a sudo user; no SSH | Python Functions with a run() entry point, called by API, webhook or schedule; no shell | SSH and root on every machine, any language |
| Docker and nested virtualization | Docker builds images on your own machine; Docker or /dev/kvm inside a sandbox is not documented | No Docker | Docker, systemd and /dev/kvm on every machine |
| Machine size | Sandboxes up to 32 vCPU and 256 GiB RAM, disk up to 32 GiB; browser size not published | Not published | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB by plan |
| How long a session runs | Browsers up to 12 hours and sandboxes up to 24 hours, on every plan | 15 min on Free, 120 min on Developer, 300 min on Startup, custom on Enterprise | No session cap on paid plans; you set the time to live |
| What survives a stop | A stopped sandbox is gone; files survive on a mounted volume or in a memory snapshot you take | Fresh browser each session; an opt-in profile keeps cookies, local storage and session storage | The whole disk, with snapshots every minute and on stop; a stopped sandbox costs nothing |
| Snapshots and fork | Memory snapshot of a running sandbox, then start many new sandboxes from it instantly | No session fork; a Function can be forked as a copy of its code | Fork a running sandbox with its disk and Chrome profiles; no memory snapshots |
| Getting past bot checks | Stealth mode, residential proxies and CAPTCHA solving on paid plans; ultra stealth 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 |
| Browser control | Cloud Chrome over CDP with Playwright or Puppeteer, live view and recordings | Hosted Chrome with a CDP URL, Playwright, Notte actions and a live view you can embed | Chrome in the VM over CDP on a local port, plus a 1920x1080 60fps stream |
| Desktop and computer use | Computer-use models inside the browser; no desktop | Browser only; no desktop | 60fps Linux desktop that every built-in agent can see and use, embeddable and recordable |
| Agents | Hosted HyperAgent, Browser Use and computer-use models; sandbox images with the Claude Code or Codex CLI, run through exec | Notte's own browser agent started with a task, with logs and export to code; an MCP server | Claude Code, Codex, OpenCode and more inside the VM, driven from outside with a prompt, steer and events API |
| Keeping secrets from the model | Keys are passed in as environment variables to the process | Vaults fill passwords, cards and 2FA codes so the LLM never sees them; personas with their own email and phone | AI credentials proxy: real keys never enter the sandbox, for model providers and any HTTPS API |
| Reaching it from outside | HTTPS URL per exposed sandbox port through a shared regional proxy; no raw TCP or own IP | No open ports; a short-lived signed live-view URL per session | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Where it runs | us-central, us-east, us-west and europe-west, asia-south on Enterprise; hosted only | Session region not published, proxies exit in the US by default; on-premise and bring-your-own-cloud on Enterprise | EU only (Germany, Finland, France), with EU data residency; hosted only |
Every feature Battleships tracks (43)
| Feature | Hyperbrowser | Notte | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | 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 | No | No | Yes |
| Pause/resume | No | No | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | Yes | No | No |
| Custom image (Docker or snapshot) | Yes | Not published | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | Yes | 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 | Not published | Not published | No |
| Self-hosting | No | Yes | No |
| BYOC | No | 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 | No | Yes | No |
| SOC 2 | No | Yes | No |
| HIPAA | Not published | 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. Neither Hyperbrowser nor Notte was in StarSling's public CPU benchmark, and neither publishes the machine size behind a browser session, so there is nothing to set against bochka's 26.69 runs per second at 4 vCPU / 8 GB. Hyperbrowser publishes start times of under 50 ms for sandboxes and under 500 ms for a ready browser.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Hyperbrowser 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 | Hyperbrowser, 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 | $16 · 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 | $73 · 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 | $792 · Scale · 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 | $450 · Scale · 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 | $994 · Scale · with limits | $100 · Startup · with limits | $2,000 · $2000/mo · with limits |
Hyperbrowser: Everything spends one credit balance at $0.001 a credit: browsers cost $0.10 a browser-hour plus $10 per GB of proxy data, and sandboxes cost $0.045 per vCPU-hour plus $0.015 per GiB-hour. Startup ($30) and Scale ($100) turn their fee into credits that reset each month, and extra credits are bought by hand or by auto-reload.
Notte: Notte's plan fee (Developer $20, Startup $100) 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 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, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Neither Hyperbrowser nor Notte fits any scenario in the table, because each one needs a machine with a known size, a disk that stays or Docker, and both are priced as browser sessions. Notte also caps sessions at 300 minutes on Startup, while Hyperbrowser browsers run up to 12 hours. Both allow 100 browsers at once on their top self-serve plan, so 300 sandboxes for your users or 1,000 jobs at once need Enterprise on either. On bochka the 1,000-job burst is the one that does not fit: bursts above 90 starts a minute are queued, and it needs more starts per day than the top plan allows.
| Scenario | Hyperbrowser | 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 Hyperbrowser when
your agent needs stealth browsing and also short code runs: sandboxes with memory snapshots, browser sessions up to 12 hours, web data APIs or regions in the US.
- Sandboxes next to the browsers. Useful if your agent also runs code: Firecracker sandboxes up to 32 vCPU, with memory snapshots and default-deny outbound rules.
- Long browser sessions on every plan. Useful for long browsing jobs: a browser session can run up to 12 hours on any plan, not only the top one.
- Web data APIs and US regions. Useful if you need pages, not a browser: Fetch, Scrape and Search APIs, run from three US regions and Europe.
Use Notte when
the job is pure browsing on sites that fight bots, and you want proxies, captcha solving, a browser agent, vaults and personas handled for you, or a framework you can run yourself.
- Stealth on by default. Useful if your agents browse sites that block bots: residential proxies, captcha solving and a matching fingerprint are on in every plan.
- Ready-made browsing tools. Useful if you want browsing handled for you: a task-driven browser agent, vaults, personas with email and phone, and scheduled Functions.
- Source-available and on-premise. Useful if you must run it yourself: the agent framework is on GitHub under SSPL, and Enterprise adds on-premise and bring-your-own-cloud.
Where bochka fits
If your agent only browses, Hyperbrowser and Notte are built for that and bochka is not a stealth browser. If what you are really running is agents that browse and also work, installing tools, building code, keeping files and running for hours, bochka gives each one a full VM with Chrome and a desktop on it.
A machine that keeps running and keeps its files
Notte sessions end after at most 300 minutes on Startup and keep only cookies and storage. A Hyperbrowser sandbox lives 24 hours and loses its disk on stop unless you save to a volume or snapshot. bochka keeps the disk, with no session cap.
Docker, systemd and /dev/kvm on a full VM
Notte has no shell or Docker, and Hyperbrowser does not document Docker inside its sandboxes. An agent that runs docker compose or an emulator has to use a second machine and move files back and forth.
Coding agents, a desktop and keys kept outside
Notte's agent browses rather than writes code, and on Hyperbrowser you run the Claude Code CLI yourself with the key in an environment variable. bochka drives coding agents from outside, streams a 60fps desktop and keeps keys in a proxy.
Use bochka when the agent does more than browse: it writes and runs code, uses Docker, keeps files and Chrome logins between runs, works for hours, or needs a desktop and coding agents on one VM. Compare it one to one: bochka vs Hyperbrowser and bochka vs Notte.
Questions people ask
Is Hyperbrowser cheaper than Notte?
Usually not for browsing. A Notte browser hour costs $0.01 against $0.10 on Hyperbrowser, and both charge $10 per GB of proxy data. In our model browser-use agents come to $100 a month on Notte, $360 on Hyperbrowser and $200 on bochka.
Which is faster, Hyperbrowser or Notte?
There is no comparable measurement. Neither was in StarSling's CPU benchmark and neither publishes the machine behind a browser session. For browsing, speed depends mostly on the sites, the proxy and the model.
Can Hyperbrowser or Notte run Docker?
Notte gives you no shell and no Docker, only browser sessions and Python Functions. Hyperbrowser uses Docker on your own machine to build a sandbox image, but its docs do not describe running Docker inside a sandbox. Every bochka sandbox runs Docker, systemd and /dev/kvm.
Which is better for sites that block bots?
Both have residential proxies and captcha solving. Notte turns them on by default on every plan, while Hyperbrowser includes them on paid plans and adds ultra stealth on Enterprise. bochka uses datacenter IPs and no built-in captcha solver.
Do Hyperbrowser and Notte keep files between sessions?
Notte starts each session with a fresh browser, and a profile carries over only cookies and storage. A Hyperbrowser sandbox loses its disk on stop unless you use a volume or a memory snapshot. On bochka the whole disk persists, with snapshots every minute and on stop.
Can I use Hyperbrowser or Notte from a bochka sandbox?
Yes. A bochka sandbox has open internet, so an agent inside it can open a Hyperbrowser session over CDP or call Notte's API, SDK or MCP server. That keeps stealth browsing on them and the code and files on a VM that keeps its disk.
Try bochka
Install the CLI, then run bochka new.
Product preview