Hyperbrowser vs Scrapeless
Both rent you a stealth Chrome in their cloud with proxies and CAPTCHA solving. Hyperbrowser also sells Firecracker sandboxes for running code, while Scrapeless stays a browser and scraping toolkit with cheaper proxy traffic and CAPTCHA solving on every plan.
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.
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. “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 | Scrapeless: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Neither is built for a software factory: Scrapeless has no shell, and Hyperbrowser's sandboxes do not document Docker inside and lose their disk on stop. | 136th of 367, with limits $1,206 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 both: Hyperbrowser sandboxes stop after 24 hours and Scrapeless sessions are meant to last minutes, while bochka has no session cap on paid plans. | 255th of 366, with limits $3,650 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 | 244th of 345, with limits $246 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 fits Hyperbrowser's sandboxes better than Scrapeless, which sells only browsers; bochka ranks first here. | 245th of 361, with limits $1,029 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 | 262nd of 360, with limits $4,972 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 | 253rd of 364, with limits $400 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 | 238th of 377, with limits $120 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 | 240th of 368, with limits $73 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 run computer use inside a browser only, while bochka streams a full Linux desktop at 60fps where the agent can use any app. | 144th of 369, with limits $360 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 browser-use agents, with Scrapeless ranking a little higher; bochka fits too and also gives the agent a shell, files and Docker next to Chromium. | 20th cheapest of 367 $360 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 At startup scale the two are close; Hyperbrowser adds per-page Fetch and Scrape APIs, Scrapeless adds ready-made AI scrapers, and bochka gives each bot a whole machine with a disk. | 32nd cheapest of 346 $366 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 Mass scraping of sites with strong bot checks is where both shine, and Scrapeless ranks 6th thanks to cheaper residential proxy traffic; bochka has no residential IPs or CAPTCHA solving. | 11th of 338, with limits $9,750 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 Hyperbrowser's sandboxes give red-team agents a place to run tools, which Scrapeless's browser does not; bochka gives each one a full VM with root and Docker. | 33rd of 360, with limits $356 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 | Hyperbrowser | Scrapeless | bochka |
|---|---|---|---|
| Kind of product | Cloud browser sessions, plus Firecracker sandboxes and fetch, scrape and search APIs | A managed Chromium browser for scraping, plus AI scrapers, a web unlocker and proxies | A full Linux VM per sandbox, with a desktop and Chromium inside |
| Running your own code | Firecracker sandboxes with exec, process and terminal APIs; no SSH | No shell on the machine running the browser | SSH and root on every machine, any language |
| Machine size | Sandboxes up to 32 vCPU and 256 GiB RAM, disk up to 32 GiB; browser size not published | Not published; you buy browser-hours | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB by plan |
| Session length | Browsers up to 12 hours; sandboxes up to 24 hours from VM start | 3 minutes by default, 15 minutes recommended at most, longer allowed | No cap on paid plans; you set the time to live |
| State after a session | Saved browser profiles; sandbox files survive only on a volume or in a memory snapshot | Browser profiles keep cookies, storage, cache and logins, saved when the session closes | The whole disk is saved every minute and on stop; a stopped sandbox costs nothing |
| Snapshots and fork | Memory snapshot of a running sandbox, then start many new ones from it | No fork; several sessions can load one profile, and only the last to close is saved | Fork a running sandbox with its disk; no memory snapshots |
| Docker and nested virtualization | Docker builds images on your machine; Docker or /dev/kvm inside a sandbox is not documented | No | Docker, systemd and /dev/kvm on every machine |
| Stealth and CAPTCHAs | Stealth mode and CAPTCHA solving on paid plans; ultra stealth on Enterprise | Random fingerprint per session; CAPTCHA solving included on every plan at no extra charge | Chromium on datacenter IPs; no fingerprint rotation or CAPTCHA solving |
| Proxies | Managed proxies at $10 per GB on paid plans; your own proxy on Enterprise | Residential IPs in 195 countries from $1.80 per GB down to $1.44; your own proxy on paid plans | None managed; you can run your own proxy client inside the VM |
| Web data tools | Fetch, Scrape and Search APIs billed per page or query, plus hosted browser agents | 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 computer use | Cloud Chrome with live view and recordings; hosted computer-use models in the browser | Live URL to watch and control the browser, plus optional session recording | A full Linux desktop streamed at 60fps, or Chrome alone; embed it, record it |
| Reaching the machine | HTTPS URL per exposed sandbox port through a shared regional proxy; no raw TCP | No way to serve your own ports | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Coding agents | Sandbox base images with the Claude Code or Codex CLI, run through the exec API | 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 |
| Regions | us-central, us-east, us-west and europe-west; asia-south on Enterprise and Select plans | More than 12 data centers, with exit IPs pinned to a country, state or city | EU only: Germany, Finland and France |
Every feature Battleships tracks (43)
| Feature | Hyperbrowser | Scrapeless | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Not published | 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 | No | 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 | 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) | 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 | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for either. Neither Hyperbrowser nor Scrapeless publishes the CPU behind its browsers, and neither was in StarSling's public 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. Hyperbrowser 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 | Hyperbrowser, 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 | $16 · Free · 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 | $73 · Free · 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 | $792 · Scale · 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 | $450 · Scale · 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 | $994 · Scale · with limits | $716 · Business · with limits | $2,000 · $2000/mo · with limits |
Hyperbrowser: Everything spends one credit balance: 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 Free gives 5,000 credits once.
Scrapeless: Plans of $49, $199 or $399 a month are prepaid into your balance, and unused funds do not roll over. Browser time runs from $0.09 an hour down to $0.072 on larger plans, with residential proxy traffic billed per GB on top.
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
None of the five scenarios fits Hyperbrowser or Scrapeless as written, because each asks for a general machine and the prices shown are for browser sessions with no disk that stays and no published size. Scrapeless sessions are built to last minutes, and Hyperbrowser browsers stop at 12 hours, so the workday and always-on agents do not fit either. Concurrency bites next: Hyperbrowser's Scale plan allows 100 browsers at once and Scrapeless's Business plan 400, so 1,000 short jobs at once need a custom or Enterprise plan on both. On bochka, that burst is also the one that does not fit, since starts above 90 a minute are queued and it needs more starts per day than the top plan allows.
| Scenario | Hyperbrowser | 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 Hyperbrowser when
your agent needs a stealth browser and also a short-lived place to run code, with memory snapshots, outbound rules, browser sessions of several hours or US regions.
- Sandboxes next to the browser. For agents that browse and also run code: Firecracker sandboxes up to 32 vCPU, with memory snapshots to start many from a warm state.
- Longer browser sessions. For browser tasks that take hours: a Hyperbrowser browser can stay open up to 12 hours, where Scrapeless sessions default to 3 minutes.
- Outbound rules and US regions. For teams that need control: default-deny outbound rules on sandboxes, and three US regions plus Europe.
Use Scrapeless when
you run many short browser sessions on sites with strong bot checks and want cheap residential proxy traffic, CAPTCHA solving on every plan and ready-made scrapers.
- Cheaper proxy traffic. For scraping where proxy data is most of the bill: residential traffic from $1.80 per GB, against $10 per GB on Hyperbrowser.
- Stealth on every plan. For small teams on bot-protected sites: random fingerprints and CAPTCHA solving come with every plan, not only paid tiers.
- More sessions at once on self-serve plans. For wide scraping runs: self-serve plans allow 50 to 400 browsers at once, where Hyperbrowser's Scale plan stops at 100.
Where bochka fits
If the browser is only one step in what your agent does, both Hyperbrowser and Scrapeless leave the rest of the work somewhere else. bochka gives each agent a full Linux VM on dedicated AMD Ryzen 9 9950X hosts, with Chromium and a 60fps desktop inside, a disk that stays and no session cap on paid plans. For heavy scraping behind bot checks, keep a stealth browser and call it from bochka.
A full VM with Docker, systemd and /dev/kvm
Scrapeless gives no shell at all, and Hyperbrowser's sandbox docs do not cover Docker inside the VM. An agent that runs docker compose or a database container needs a second machine you run yourself.
Jobs that run for days and keep their files
Hyperbrowser sandboxes stop after 24 hours and lose their disk unless you saved to a volume or snapshot. Scrapeless sessions last minutes and keep only a browser profile. bochka saves the whole disk every minute and on stop.
Coding agents driven from outside, keys kept outside
On Hyperbrowser you write the harness around exec and pass model keys in as environment variables; on Scrapeless the agent runs on your own machine. bochka ships seven agents with a steer API and a credentials proxy for any HTTPS API.
Use bochka when your agent does more than browse: it needs a shell, Docker, a desktop or a server next to Chromium, and has to keep its files and keep working for hours or days. Compare it one to one: bochka vs Hyperbrowser and bochka vs Scrapeless.
Questions people ask
Is Hyperbrowser cheaper than Scrapeless?
It depends on scale. In our scenarios Scrapeless lands lower for 50 agents in parallel ($570 against $792) and for 1,000 short jobs at once ($716 against $994), while Hyperbrowser is lower for one agent on workdays ($16 against $399), since its free credits cover it. Proxy data is billed on top, at $10 per GB on Hyperbrowser and from $1.80 per GB on Scrapeless.
Which is better at getting past bot checks?
Both are built for it. Scrapeless gives every session a random fingerprint and includes CAPTCHA solving on every plan, with residential IPs in 195 countries. Hyperbrowser has stealth modes, residential proxies and CAPTCHA solving on paid plans, plus ultra stealth on Enterprise.
Which is faster?
There is no comparable CPU measurement for either, since neither publishes the hardware behind its browsers. Hyperbrowser says a browser is ready in under 500 ms, and Scrapeless says its sessions start in under 2 seconds. bochka scored 26.69 runs per second on the Node.js benchmark at 4 vCPU / 8 GB.
Can Hyperbrowser or Scrapeless run Docker?
Scrapeless gives you a browser with no shell, so no. Hyperbrowser uses Docker on your own machine to build sandbox images, but its docs do not describe running Docker inside a sandbox. Every bochka sandbox runs Docker, systemd and /dev/kvm.
How long can a session run on each?
Hyperbrowser browsers run up to 12 hours and its sandboxes up to 24 hours from VM start. 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.
Can I use either one together with bochka?
Yes. Both are reached over CDP, so an agent on a bochka sandbox can open a Hyperbrowser or Scrapeless session with Puppeteer or Playwright when it needs a stealth browser. Its code, files and other tools stay on the bochka machine.
Try bochka
Install the CLI, then run bochka new.
Product preview