Browserbase vs Scrapeless
Browserbase is a browser platform: cloud Chrome sessions of up to 6 hours with saved logins, replays, the Stagehand SDK and search, fetch and agent APIs around it. Scrapeless sells a stealth browser built for scraping: short sessions with a random fingerprint, residential proxies and CAPTCHA solving included on every plan.
The companies and products
Browserbase
Browserbase calls itself the complete platform to build and deploy agents that browse and interact with the web like humans: browsers, search, fetch, functions, model access and identity behind one API key.
Its core product is a headless Chrome session you drive over CDP with Playwright, Puppeteer or its open source Stagehand SDK, with proxies, CAPTCHA solving, saved browser profiles (Contexts), live view and session replays. Around it sit Search and Fetch APIs, short TypeScript Functions that run next to the browser, a Model Gateway and hosted Agents that work from a plain language goal. It is a browser platform, not a general sandbox: you get a browser, not a shell or root on the machine, so this page compares where the two overlap, which is agents that browse.
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. “24th cheapest of 367” means 23 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 | Browserbase: 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 A coding agent needs a shell, Docker and a disk, which neither browser gives, so builds and tests fit bochka. | 140th of 367, with limits $1,255 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 An assistant that runs all month outlives a Browserbase session (6 hours) and a Scrapeless session (minutes by default); bochka has no session cap on paid plans. | 259th of 366, with limits $3,699 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 | 270th of 345, with limits $382 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 Giving each of your users a machine to run code on is not what either browser sells; bochka is built for it. | 250th of 361, with limits $1,099 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 | 264th of 360, with limits $5,049 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 | 349th of 364, with limits $449 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 | 244th of 377, with limits $152 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 A dev box has to keep its files and processes, and both browsers keep only a browser profile between sessions. | 251st of 368, with limits $96 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 Both browsers stop at the page, while bochka streams a 60fps Linux desktop where an agent can use any app. | 159th of 369, with limits $416 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 All three fit: Browserbase adds Stagehand, replays and long sessions, Scrapeless adds stealth and proxies by default, and bochka puts Chromium on a full VM where the agent can also run code. | 24th cheapest of 367 $449 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 Both browsers fit startup-scale scraping; Browserbase also sells Fetch and Search APIs, Scrapeless sells ready-made AI scrapers, and bochka gives each bot a whole machine with a disk. | 55th cheapest of 346 $537 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 For sites with strong bot checks, both browsers beat bochka: residential proxies and CAPTCHA solving come with each, and Scrapeless includes CAPTCHA solving on every plan at no extra charge. | 13th of 338, with limits $9,799 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 | 229th of 360, with limits $291 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 | Browserbase | Scrapeless | bochka |
|---|---|---|---|
| What you get | Managed headless Chrome sessions, plus search, fetch, functions and hosted browser agents | A managed Chromium browser you reach over a CDP WebSocket, plus scrapers, a web unlocker and proxies | A full Linux VM with its own kernel and root, with a desktop and Chromium inside |
| Shell, code and Docker | No shell on the browser VM; hosted Agents and Functions get a short-lived TypeScript runtime | No shell on the machine running the browser | SSH, any language, Docker, systemd and /dev/kvm on every machine |
| Session length | 6 hours on Developer and Startup, 6+ hours on Scale, 15 minutes on Free | 3 minutes by default, 15 minutes recommended at most, longer allowed | No cap on paid plans; you set the time to live |
| State between sessions | Contexts keep the browser profile (cookies, localStorage, IndexedDB), encrypted at rest | Profiles keep cookies, storage, cache and logins; with shared profiles only the last session to close is saved | The whole disk is saved every minute and on stop; a stopped sandbox costs nothing |
| Fork | No fork; a new session starts fresh or loads a Context | No fork; several sessions can load one profile | Fork a running sandbox with its disk |
| Stealth and CAPTCHAs | CAPTCHA solving and basic stealth on paid plans; Verified browsers on Scale | Random fingerprint per session and CAPTCHA solving included on every plan | Chromium on datacenter IPs; no fingerprint rotation or CAPTCHA solving |
| Proxies | Residential proxies in 200+ countries on paid plans, $12 or $10 per GB after the included 1 GB or 5 GB | Over 70 million residential IPs in 195 countries, from $1.80 per GB on the base plan | None managed; you can run your own proxy client inside the VM |
| Browsers at once (self-serve) | 3, 25 and 100 on Free, Developer and Startup; 250+ on Scale through sales | 50, 100, 200 or 400 by plan; 1 on the free tier | No session cap on paid plans; starts are limited per minute, hour and day |
| Watching sessions | Live view, session replay and logs for every session | Live URL to watch and control the browser, plus optional recording | A full Linux desktop streamed at 60fps, or Chrome alone; embed it, record it |
| Agents | Stagehand SDK (act, extract, observe) and a hosted browser Agent with built-in tools | A CLI skill and an MCP server so an agent on your own machine drives the cloud browser | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keys and logins | Model Gateway for OpenAI, Anthropic and Google; agent variables hide values from the model | Credential store and 1Password link that fill website logins into the browser | Credentials proxy keeps real keys outside the sandbox for any HTTPS API |
| Hosting | CDP connect URL and live view links only; no ports to host on | No way to serve your own ports | HTTPS URLs for up to 50 ports, token-protected; raw TCP |
| Extra data tools | Search and Fetch APIs answer simple lookups without a browser | AI Scraper tasks for ChatGPT, Perplexity, Gemini and more, plus crawl and search over MCP | None; you write or run your own |
| Regions | Oregon, Virginia, Frankfurt and Singapore | More than 12 data centers; regions not listed on the pages we checked | EU only (Germany, Finland and France) |
Every feature Battleships tracks (43)
| Feature | Browserbase | Scrapeless | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Not published | 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 | No | 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) | No | Not published | Yes |
| ≥24 h sessions | No | No | 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 | Yes | 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 | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Not published | 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 | No | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
There is no comparable measurement for either browser. Browserbase and Scrapeless sell browser time, do not publish the CPU or memory behind a session, and are not in StarSling's CPU benchmark. bochka scored 26.69 runs per second on the hpc-sandbox-benchmarks Node.js test at 4 vCPU / 8 GB.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Browserbase 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 | Browserbase, 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 | $99 · 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 | $122 · 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 | $841 · 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 | $499 · 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 | $1,049 · Startup · with limits | $716 · Business · with limits | $2,000 · $2000/mo · with limits |
Browserbase: Plans include browser hours: 100 on Developer ($20) and 500 on Startup ($99), then $0.12 or $0.10 per browser hour, billed by the minute. Proxy data is extra after 1 GB or 5 GB, at $12 or $10 per GB.
Scrapeless: Plans of $49, $199 or $399 a month are prepaid into a balance, and unused funds do not roll over. Browser time runs from $0.09 an hour down to $0.072, and residential proxy traffic is 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 on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
None of the five scenarios fits either browser as written, because each asks for a general machine and both sell a browser session with no shell, no disk that stays and no published size. Browserbase's 6-hour cap and Scrapeless's minutes-long sessions rule out the workday and always-on agents. Concurrency bites next: Browserbase Startup stops at 100 at once and Scrapeless Business at 400, so 300 user sandboxes need Browserbase Scale and 1,000 short jobs need a custom plan on both. bochka fits four scenarios; at 1,000 short jobs at once it queues bursts above 90 starts a minute and allows fewer starts per day than the job needs.
| Scenario | Browserbase | 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 Browserbase when
your agents need long browser sessions, saved logins, replays and the Stagehand SDK, or browsers in the US and Singapore.
- Sessions that last hours. For browsing jobs that run long: sessions of up to 6 hours on paid plans, while Scrapeless sessions default to 3 minutes.
- A browser stack for building agents. For teams writing their own browser agents: the open source Stagehand SDK, saved logins in Contexts, and live view and replays of every session.
- Regions you can pick. For users or target sites in the US or Asia: run each session in Oregon, Virginia, Frankfurt or Singapore.
Use Scrapeless when
you run lots of short scraping sessions on sites with strong bot checks and want fingerprints, CAPTCHA solving and cheap residential proxy traffic included.
- Stealth included. For sites with strong bot checks: a random fingerprint per session and CAPTCHA solving on every plan at no extra charge.
- Cheaper proxy traffic. For proxy-heavy scraping: residential traffic from $1.80 per GB on the base plan, against $10 to $12 per GB on Browserbase.
- More sessions at once. For many short tasks in parallel: up to 400 sessions at once on self-serve plans, against 100 on Browserbase Startup.
Where bochka fits
Browserbase and Scrapeless are both cloud browsers, so the overlap with bochka is agents that browse. If what you are really running is agents that browse and then also have to work, with a shell, files, Docker or a server next to the browser, look at bochka. For pure stealth scraping at volume, either browser is the better tool, and an agent on bochka can call one over CDP.
A whole machine around the browser
Neither browser gives a shell, Docker or root, so an agent that reads a page and then clones a repo or starts a dev server needs a second provider. On bochka it is one full VM with its own kernel, Docker, systemd and /dev/kvm.
Runs as long as the task, keeps its disk
Browserbase stops at 6 hours and Scrapeless defaults to 3 minutes, and both keep only a browser profile, so downloads and processes are lost. bochka has no session cap on paid plans and saves the disk every minute.
Agents inside, driven from outside
Scrapeless needs an agent you host yourself, and Browserbase's Agent has fixed built-in tools. bochka ships Claude Code, Codex and more, driven through one API, with a credentials proxy for any HTTPS API and a 60fps desktop.
Use bochka when your agent does more than browse: it needs a shell, files, Docker, a desktop or a server next to the browser, and has to keep working for hours or days. Compare it one to one: bochka vs Browserbase and bochka vs Scrapeless.
Questions people ask
Is Browserbase cheaper than Scrapeless?
Not in most of our scenarios. One coding agent on workdays comes to $99 on Browserbase against $399 on Scrapeless, but 50 agents in parallel come to $841 against $570 and 1,000 short jobs to $1,049 against $716. Neither fits these as a general machine, and Scrapeless proxy traffic is much cheaper per GB.
Which is faster, Browserbase or Scrapeless?
There is no comparable measurement. Neither publishes the CPU or memory behind a session, and neither is in the CPU benchmark. Scrapeless says its sessions start in under 2 seconds.
How long can a session run on Browserbase and Scrapeless?
Browserbase sessions run up to 6 hours on Developer and Startup and 15 minutes on Free. Scrapeless sessions default to 3 minutes, with 15 minutes as the recommended maximum, though longer values can be set. bochka has no session cap on paid plans.
Which is better at getting past bot checks?
Both have residential proxies and CAPTCHA solving. Scrapeless gives every session a random fingerprint and includes CAPTCHA solving on every plan, while Browserbase needs a paid plan and keeps Verified browsers for Scale. bochka runs Chromium on datacenter IPs.
Can Browserbase or Scrapeless run Docker?
No. Both give you a browser over CDP, not a shell on the machine. Browserbase's hosted Agents and Functions run in a short TypeScript runtime with no persistent storage. Every bochka sandbox has root, SSH, Docker, systemd and /dev/kvm.
Can I use either one from a bochka sandbox?
Yes. Both are reached over CDP, so an agent on bochka can open a Browserbase or Scrapeless session with Puppeteer or Playwright when it needs a stealth browser, and keep its code and files on the bochka machine.
Try bochka
Install the CLI, then run bochka new.
Product preview