Notte vs Scrapeless
Both rent you a stealth cloud browser with residential proxies and captcha solving. Notte wraps it in a browser agent, vaults, personas and Functions with sessions up to 300 minutes, while Scrapeless is a scraping toolkit with short sessions, cheaper proxy traffic and ready-made AI scrapers.
The companies and products
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
Scrapeless
Scrapeless is a web scraping company that sells Agent Browser, a managed cloud browser, along with AI scrapers, a web unlocker and proxies.
Scrapeless Agent Browser is a different kind of product from bochka: you get a Chromium browser in their cloud that you reach over a CDP WebSocket with Puppeteer or Playwright, an MCP server or their agent-browser CLI. Each session gets a random fingerprint, CAPTCHA solving and a residential proxy, and you pay per browser-hour plus proxy traffic. It is built for teams that scrape or automate many websites, not a machine to run their own code on.
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. “2nd cheapest of 367” means 1 of the other 366 providers runs 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 | Notte: price rank | Scrapeless: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Neither gives a shell, Docker or a disk that stays, so a coding agent cannot build and test on either; bochka ranks 3rd here. | 44th of 367, with limits $121 a month | 96th of 367, with limits $868 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 Scrapeless sessions are meant to last minutes, so an always-on assistant needs a machine like bochka. | 99th of 366, with limits $365 a month | 224th of 366, with limits $2,628 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 | 220th of 345, with limits $100 a month | 246th of 345, with limits $249 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 Neither sells a machine your users can run code on; bochka ranks 1st for sandboxes for your users. | 195th of 361, with limits $105 a month | 354th of 361, with limits $741 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 | 222nd of 360, with limits $500 a month | 249th of 360, with limits $3,580 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 | 227th of 364, with limits $100 a month | 347th of 364, with limits $399 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 | 230th of 377, with limits $100 a month | 229th of 377, with limits $97 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 255th of 368, with limits $100 a month | 234th of 368, with limits $59 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 Notte and Scrapeless show a browser only, so agents that need a whole desktop fit bochka's 60fps Linux desktop better. | 76th of 369, with limits $100 a month | 122nd of 369, with limits $274 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 fit: Notte ranks 2nd with longer sessions and a built-in browser agent, Scrapeless ranks 14th with many short sessions, and bochka ranks 7th with Chrome on a full VM. | 2nd cheapest of 367 $100 a month | 14th cheapest of 367 $274 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; Notte comes to $100 a month in our model and Scrapeless to $370, while bochka ranks 6th by giving each bot a whole machine with a disk. | 7th cheapest of 346 $100 a month | 33rd cheapest of 346 $370 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 built for sites that block bots, with residential IPs and captcha solving included; Notte ranks 2nd and Scrapeless 6th, and on bochka you bring your own proxies. | 2nd of 338, with limits $975 a month | 6th of 338, with limits $7,020 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 | 143rd of 360, with limits $100 a month | 200th of 360, with limits $199 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 | Notte | Scrapeless | bochka |
|---|---|---|---|
| What you get | A hosted browser session through an API, SDK, CLI or MCP server, plus a browser agent and Functions | A managed Chromium browser you reach over a CDP WebSocket | A full Linux VM with its own kernel and root, with Chrome and a desktop on it |
| Session length | 15 min on Free, 120 min on Developer, 300 min on Startup, custom on Enterprise | 3 minutes by default, 15 minutes recommended at most, longer allowed | No session cap on paid plans |
| Browsers at once | 5, 25 or 100 by plan, custom on Enterprise | 50, 100, 200 or 400 by plan, custom above that; free tier has 1 | Many sandboxes at once; bursts above 90 starts a minute are queued |
| Getting past bot checks | Residential proxies on by default, captcha solving and a matching Chrome fingerprint | Random fingerprint per session and captcha solving included at no extra charge | Datacenter IPs; bring your own proxy or captcha service |
| Residential proxies | $10 per GB, exit in the US unless you pick a country | Over 70 million IPs in 195 countries, down to state and city, from $1.80 per GB | None managed; run your own proxy client inside the VM |
| What survives a stop | Fresh browser each session; an opt-in profile keeps cookies, local storage and session storage | Browser profiles keep cookies, storage, cache and logins, saved when the session closes | The whole disk, with snapshots every minute and on stop; a stopped sandbox costs nothing |
| Fork | No session fork; a Function can be copied | No fork; several sessions can load one profile, and only the last to close is saved | Fork a running sandbox, browser and files included |
| Running your own code | Python Functions called by API, webhook or schedule; no shell | No shell on the machine running the browser | Root shell, any language, Docker, systemd and /dev/kvm |
| Agents | Notte's own browser agent: start it with a task, stream its logs, export the run as code | A CLI skill and an MCP server so an agent on your machine can drive the cloud browser | Claude Code, Codex and other coding agents inside the VM, driven from outside with a prompt, steer and events API |
| Logins and secrets | Vaults fill passwords, cards and 2FA codes; personas with their own email and phone | Credential store and 1Password link that fill website logins | AI credentials proxy: real keys never enter the sandbox, for any HTTPS API |
| Ready-made data tools | Functions turn a browser script into an API endpoint | AI Scraper tasks for ChatGPT, Perplexity, Gemini and more, plus crawl and search tools over MCP | None; you write or run your own |
| Desktop and live view | Embeddable live view of the browser; no desktop | Live URL to watch and control the browser, plus optional recording | 60fps Linux desktop or Chrome alone, embeddable and recordable |
| Reaching it from outside | No open ports; a signed live-view URL per session | No way to serve your own ports | HTTPS URLs for up to 50 ports, token-protected; raw TCP |
| Self-hosting | Source-available framework on GitHub (SSPL); on-premise and bring-your-own-cloud on Enterprise | Hosted only | Hosted only, in the EU (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Notte | Scrapeless | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Not published | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | Not published | Yes |
| Systemd | Not published | 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 | No | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Not published | Not published | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | No | No | Yes |
| Raw TCP inbound | Not published | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | No | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | Not published | No | No |
| Self-hosting | Yes | No | No |
| BYOC | Yes | No | No |
| Open source | Yes | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | No | 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 | Not published | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for Notte or Scrapeless: neither publishes the CPU or memory behind a browser session, and neither was in the StarSling benchmark run. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. For browsing, 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 and Scrapeless 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 | Notte, a month | Scrapeless, 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 | $100 · Startup · with limits | $399 · Business · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $100 · Startup · with limits | $399 · Business · 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 | $100 · Startup · with limits | $570 · Business · 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 | $100 · Startup · with limits | $399 · Business · 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 | $100 · Startup · with limits | $716 · Business · with limits | $2,000 · $2000/mo · with limits |
Notte: Notte's plan fee comes back as credits that expire each cycle, spent on browser sessions at $0.01 an hour, Functions, model tokens and residential proxies at $10 per GB. Proxies are on by default, so traffic is billed per GB unless you turn them off.
Scrapeless: Scrapeless plans of $49, $199 or $399 are prepaid into a balance that does not roll over. Browser time runs from $0.09 an hour down to $0.072, with residential traffic billed per GB on top from $1.80.
Scrapeless: 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 Notte nor Scrapeless fits any of the five scenarios, because each asks for a general machine with a disk, Docker or work that runs for hours, and both sell browser sessions of unpublished size. Notte caps sessions at 300 minutes on Startup and allows 100 browsers at once, so 300 user sandboxes or 1,000 jobs at once need Enterprise. Scrapeless sessions are built to last minutes and its biggest self-serve plan stops at 400 at once. bochka fits four scenarios; for 1,000 short jobs its $2,000 plan queues the starts.
| Scenario | Notte | Scrapeless | 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 Notte when
one browsing task runs for hours, you want a browser agent, vaults and personas handled for you, or you need to self-host.
- Longer browser sessions. Useful if one browsing task runs for hours: Startup sessions last up to 300 minutes, where Scrapeless defaults to 3.
- Browsing handled for you. Useful if you want a task-driven browser agent, vaults for passwords and personas with their own email and phone.
- Run it yourself. Useful if you must self-host: the framework is source-available, and Enterprise adds on-premise and bring-your-own-cloud.
Use Scrapeless when
you run many short scraping sessions at once and want cheaper residential traffic, wide country coverage and ready-made scrapers.
- Cheaper proxy traffic, more places. Useful for heavy scraping: residential traffic from $1.80 per GB against $10 on Notte, in 195 countries down to city.
- More browsers at once. Useful for wide, short jobs: plans allow 50 to 400 sessions at once, against 100 on Notte Startup.
- Data, not only browsers. Useful if you want results: ready-made AI scrapers, crawling and search tools come with the same API key.
Where bochka fits
Notte and Scrapeless are cloud browsers, not machines, so if what you are really running is agents that also write code, keep files or work for hours, look at bochka. It gives each agent a full Linux VM with Chrome and a desktop on it. If the job is pure browsing on sites that fight bots, either of them fits better.
A whole computer around the browser
On Notte and Scrapeless there is no shell, Docker or disk, so the code that processes what the agent finds runs on a second machine you manage, and every file crosses between the two.
Sessions that do not reset
Notte stops at 300 minutes on Startup and Scrapeless defaults to 3, and both keep only a browser profile. On bochka paid plans have no session cap, the disk is saved every minute, and you can fork a running sandbox.
Coding agents and a desktop built in
Notte's agent only browses and Scrapeless expects you to host the agent yourself. bochka runs Claude Code, Codex and others inside the VM, driven from outside, with a 60fps desktop and a credentials proxy that keeps keys out.
Use bochka 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: bochka vs Notte and bochka vs Scrapeless.
Questions people ask
Is Notte cheaper than Scrapeless?
In our model, usually yes: Notte comes to $100 a month for browser-use agents against $274 on Scrapeless, and $975 against $7,020 for mass scraping. But Notte bills residential proxies at $10 per GB and Scrapeless from $1.80, so very heavy traffic can change that.
Which is faster?
Neither publishes the machine size behind a session, and neither was in the CPU benchmark, so there is no fair speed comparison. Scrapeless says its sessions start in under 2 seconds. For browsing, speed depends mostly on the sites, the proxy and the model.
How long can a session run on Notte and Scrapeless?
Notte sessions last 15, 120 or 300 minutes by plan, with custom limits on Enterprise. Scrapeless sessions default to 3 minutes with 15 recommended at most, though longer values can be set. A bochka sandbox has no session cap on paid plans.
Can Notte or Scrapeless run Docker?
No. Both give you a hosted browser with no shell on the machine underneath; Notte adds Python Functions. bochka gives every agent a full Linux VM with root, Docker, systemd and Chrome.
Which is better at getting past bot checks?
Both include residential proxies, captcha solving and fingerprints. Scrapeless gives a random fingerprint per session and IPs in 195 countries down to city; Notte turns proxies on by default with a US exit unless you pick a country. bochka uses datacenter IPs.
Can I use Notte or Scrapeless from a bochka sandbox?
Yes. A bochka sandbox has open internet, so an agent inside it can call Notte's API or MCP server, or connect to Scrapeless over CDP with Puppeteer or Playwright, while its code and files stay on bochka.
Try bochka
Install the CLI, then run bochka new.
Product preview