Kernel vs Scrapeless
Both rent you a cloud Chromium browser that your agent drives over CDP. Kernel puts each browser on its own unikernel that you can SSH into and that sleeps for free when idle, while Scrapeless is built for short stealth scraping sessions with random fingerprints and residential IPs in 195 countries.
The companies and products
Kernel
Kernel is browser infrastructure for web agents and automations: you create cloud Chromium browsers from its API and drive them over CDP.
Each Kernel browser is Chromium on its own Unikraft-based unikernel, headless (1 GB) or headful (8 or 16 GB) with Live View and a computer controls API. Around it Kernel sells stealth mode with proxies and a CAPTCHA solver, saved browser profiles, managed logins, session replays and an app runtime for your agent code. It is a different kind of product from bochka: a managed browser, not a general sandbox, so this page compares where the two overlap, which is agents that use a browser.
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. “38th cheapest of 369” means 37 of the other 368 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 | Kernel: 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 software factory needs a shell, Docker and a place to build; Scrapeless has no shell and Kernel's unikernel documents no container runtime. | 98th of 367, with limits $873 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 works all month needs files that stay; Kernel keeps only browser state in a profile, and Scrapeless sessions are meant to last minutes. | 203rd of 366, with limits $2,033 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 | 266th of 345, with limits $347 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; Kernel caps Start-Up at 150 browsers at once and Scrapeless at 400 on Business. | 228th of 361, with limits $768 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 | 246th of 360, with limits $3,133 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 | 252nd of 364, with limits $390 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 | 259th of 377, with limits $222 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 | 144th of 368, with limits $33 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 Kernel fits computer use with Live View and a computer controls API, while Scrapeless shows only a live browser URL; bochka streams a full Linux desktop at 60fps. | 38th cheapest of 369 $1,878 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: Scrapeless ranks 14th with stealth and proxies in every session, Kernel ranks 21st with SSH and free standby, and bochka ranks 7th because the agent can also run code next to its Chromium. | 21st cheapest of 367 $366 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 Scrapeless ranks 33rd and Kernel ranks 45th, while bochka ranks 6th by giving each bot a whole machine with a disk that keeps its files. | 45th cheapest of 346 $443 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: Kernel ranks 4th and Scrapeless ranks 6th, since both bring proxies and CAPTCHA solving that bochka does not. | 4th of 338, with limits $6,000 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 Red-team agents need their own tools; Kernel at least gives SSH into the browser VM, while Scrapeless gives a browser only. | 61st of 360, with limits $293 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 | Kernel | Scrapeless | bochka |
|---|---|---|---|
| Kind of product | A managed Chromium browser per session, with an app runtime for your agent code | A managed Chromium browser over a CDP WebSocket, sold next to AI scrapers and proxies | A full Linux VM per sandbox, with a desktop and Chromium inside |
| Isolation | Each browser runs on its own Unikraft-based unikernel | Not published | Every sandbox is a full VM with its own kernel, on dedicated AMD Ryzen 9 9950X hosts |
| Shell and Docker | SSH into the browser VM and process exec with an as_root option; no container runtime documented | No shell on the machine running the browser | SSH and root, Docker, systemd and /dev/kvm on every machine |
| Machine size | 1 GB headless, 8 or 16 GB headful; vCPU count not published | Not published; you buy browser-hours | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB by plan |
| Session length | Stays alive while something drives it; an idle browser is deleted after its timeout, up to 72 hours | 3 minutes by default, 15 minutes recommended at most, longer allowed | No cap on paid plans; you set the time to live |
| Idle and wake | Standby after 5 seconds idle with a memory snapshot and no charge; a new connection picks it up | The session closes when its time to live runs out | Stop and resume by API; resume reboots from disk, and a stopped sandbox costs nothing |
| State between sessions | Profiles keep cookies, storage and browser state; files go when the browser is deleted | Profiles keep cookies, storage, cache and logins; if sessions share one, only the last to close is saved | The whole disk is saved every minute and on stop, and you can fork a running sandbox |
| Live view and computer use | Headful Chromium with Live View, a computer controls API and session replays | Live URL to watch and control the browser, plus optional session recording | A full Linux desktop streamed at 60fps, computer use and browser control, embeddable |
| Stealth and CAPTCHAs | Stealth mode with an ISP proxy and a CAPTCHA solver | Random fingerprint per session you can tune, CAPTCHA solving included | Chromium on datacenter IPs; no fingerprint rotation or CAPTCHA solving |
| Proxies | ISP, residential and mobile proxies, not charged; your own proxy on Start-Up | Over 70 million residential IPs in 195 countries, down to city; traffic billed per GB | None managed; you can run your own proxy client inside the VM |
| Reaching the machine | No inbound ports; tokenized CDP and Live View URLs, and SSH port forwarding | No way to serve your own ports | HTTPS URLs for up to 50 ports, token-protected; raw TCP |
| Agents | Deploy agent code as a Kernel app, including a Claude Agent SDK template | 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 |
| Logins and keys | Vaults fill logins into forms, and managed auth keeps sign-ins in profiles | Credential store and 1Password link that fill website logins into the browser | AI credentials proxy: real keys never enter the sandbox, for model providers and any HTTPS API |
| Regions | us-east, eu-west and ap-southeast; region choice from the Start-Up plan | More than 12 data centers, with proxy exits in 195 countries | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Kernel | 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 | Not published | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | No | No | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | 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 | Yes | No | No |
| HTTPS preview URLs | No | No | Yes |
| Raw TCP inbound | Not published | 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 | Yes | No | No |
| Windows | No | No | No |
| Arm64 | Not published | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | Yes | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Yes | 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 CPU measurement for either one: neither Kernel nor Scrapeless publishes the vCPUs behind a browser, and neither is in StarSling's CPU benchmark. Kernel publishes cold starts under 20 ms and Scrapeless says sessions start in under 2 seconds. bochka scored 26.69 runs per second on the 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. Kernel 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 | Kernel, 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 | $5 · Free / Developer · 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 | $34 · Free / Developer · 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 | $625 · Start-Up · 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 | $420 · Start-Up · 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 | $747 · Start-Up · with limits | $716 · Business · with limits | $2,000 · $2000/mo · with limits |
Kernel: Kernel bills $0.0000166667 per GB-second of memory while a browser is active, so a 1 GB headless browser costs less than an 8 GB headful one. Standby and proxies are free, and plans of $0, $30 and $200 a month include $5, $10 and $50 of usage.
Scrapeless: 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, 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 while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
None of the five scenarios fits Kernel or Scrapeless, because each asks for a general machine with a disk and neither sells one or publishes a machine size. Kernel caps browsers at 150 at once on Start-Up, so 300 sandboxes for your users and 1,000 short jobs need Enterprise; Scrapeless stops at 400 sessions at once on Business, so 1,000 jobs need a custom plan. On bochka, the 1,000-job burst is the one that does not fit: starts above 90 a minute are queued and it needs more starts per day than the plan allows.
| Scenario | Kernel | 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 Kernel when
you want browsers that sleep for free between steps, that you can SSH into, with proxies, saved logins and session replays included, in the US, EU or Asia.
- A browser you can get inside. For agents that need a little more than CDP: SSH into the browser VM and run processes as root.
- Free standby with pages kept. For agents that pause between steps: a Kernel browser stops charging after 5 seconds idle and wakes with its pages loaded.
- Proxies and browser tooling included. For teams that want ready parts: proxies cost nothing extra, and profiles, managed logins and session replays come built in.
Use Scrapeless when
you run many short scraping sessions on sites with strong bot checks and want fingerprints, CAPTCHAs, residential IPs and ready-made scrapers handled for you.
- Built to get past bot checks. For scraping hard sites: a random fingerprint per session, free CAPTCHA solving and residential IPs you can pin to a city.
- A full scraping toolkit. For teams that want data, not browsers: AI scrapers, a web unlocker and crawl and search tools behind one API key.
- Many short sessions at once. For high fan-out jobs: up to 400 sessions at once on the Business plan, each starting in under 2 seconds.
Where bochka fits
Kernel and Scrapeless are both browsers, not general sandboxes, so this is about the overlap. If what you are really running is agents that browse and then have to install, build, save files or serve something, look at bochka: each agent gets a whole Linux VM with Chromium and a desktop inside.
A whole machine around the browser
Scrapeless gives no shell, and Kernel's unikernel is built only for Chromium with no Docker documented. To build or test what the agent found, you run a second machine and wire it to the browser yourself.
Files that stay for long jobs
A Kernel browser's files go when it is deleted, and Scrapeless sessions default to 3 minutes and keep only a profile. bochka saves the whole disk every minute, has no session cap on paid plans, and forks a running sandbox.
Agents inside, keys outside
With Scrapeless the agent runs on your own server with its keys, and Kernel's vaults type logins into pages that scripts can read. bochka drives coding agents inside from outside, and its credentials proxy keeps real keys out of the machine.
Use bochka when your agent browses and also works: a shell, Docker, files that stay, a 60fps desktop and servers next to the browser, for hours or days. Compare it one to one: bochka vs Kernel and bochka vs Scrapeless.
Questions people ask
Is Kernel cheaper than Scrapeless?
It depends on how busy the browser is. In the scenario table one agent running all month comes to $34 on Kernel and $399 on Scrapeless, but 50 agents in parallel come to $625 against $570, and neither fits any scenario as a general machine. Kernel does not charge for proxies or standby, while Scrapeless bills proxy traffic per GB on top.
Which is faster, Kernel or Scrapeless?
There is no CPU measurement for either, since neither publishes the vCPUs behind a browser. Kernel says its unikernels cold start in under 20 ms, and Scrapeless says its sessions start in under 2 seconds.
Can Kernel or Scrapeless run Docker?
No. Kernel lets you SSH into the browser VM and run processes, but its unikernel documents no container runtime, and Scrapeless gives no shell at all. On bochka every sandbox is a full VM with Docker, systemd and /dev/kvm.
How long can a session last?
A Kernel browser stays alive while something drives it, and an idle one is deleted after its timeout, which you can set up to 72 hours. A Scrapeless session closes after 3 minutes by default, with 15 minutes recommended at most. bochka has no session cap on paid plans.
Which one is better at getting past bot checks?
Both are built for it. Scrapeless gives every session a random fingerprint, CAPTCHA solving and over 70 million residential IPs in 195 countries, while Kernel's stealth mode uses an ISP proxy and a CAPTCHA solver, with proxies at no charge. bochka runs Chromium on datacenter IPs.
Can I use Kernel or Scrapeless from a bochka sandbox?
Yes. Both are reached over CDP, so an agent on a bochka sandbox can open a stealth browser when it needs one and keep its code, files and tools on the bochka machine.
Try bochka
Install the CLI, then run bochka new.
Product preview