Browserbase vs Kernel

Both sell cloud browsers for AI agents. Browserbase wraps Chrome sessions of up to 6 hours in a wider platform with Search, Fetch, Functions and hosted Agents, while Kernel runs each Chromium on its own unikernel, bills memory by the second and charges nothing while a browser sits in standby.

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 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 (Authenticated Fetch reads logged-in pages without a browser), short TypeScript Functions, Runtime (sandboxed environments that back the hosted Agent shell), a Model Gateway and hosted Agents that work from a plain language goal. It is a browser platform, not a general VM: your code gets the browser, and the Agent gets a shell in a short-lived runtime, not root on a machine. This page compares where the two overlap, which is agents that browse.

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 VM, a Linux environment with a shell and root exec. Headless browsers use 1, 2 or 4 GB of memory. Headful browsers use 8 or 16 GB and have Live View and a computer controls API. On Start-Up and Enterprise, GPU-accelerated headful browsers use 4 or 8 vCPU. Around the browsers 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 boat: a managed browser, not a general sandbox. This page compares where the two overlap, which is agents that use a browser.

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. “23rd cheapest of 356” means 22 of the other 355 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 workloadBrowserbase: price rankKernel: price rankboat: price rank
Software factory
100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month
Neither is built for builds and tests: a Browserbase session has no shell, and a Kernel browser has a shell and root exec but no documented container runtime and no disk that stays after deletion.
172nd of 365, with limits
$1,255 a month
130th of 365, with limits
$873 a month
5th cheapest of 365
$634 a month
Always-on AI employees
50 machines 24/7 · 2 vCPU / 4 GB
An assistant that lives all month hits Browserbase's 6-hour session cap, and a Kernel browser's own files go when it is deleted (you copy them out with the file API); boat keeps the disk and has no session cap once auto-stop is off (paid plans; default 1 hour).
286th of 361, with limits
$3,699 a month
325th of 361, with limits
$7,684 a month
6th cheapest of 361
$657 a month
Code interpreter bursts
100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month
267th of 336, with limits
$382 a month
280th of 336, with limits
$543 a month
189th of 336, 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
300 sandboxes at once is above both Startup limits (100 on Browserbase, 150 on Kernel), and each user gets a browser, not a machine.
245th of 349, with limits
$1,099 a month
295th of 349, with limits
$2,620 a month
3rd cheapest of 349
$209 a month
RL rollouts
1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month
259th of 349, with limits
$5,049 a month
286th of 349, with limits
$12,083 a month
39th of 349, with limits
$2,000 a month
Agent evals
250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month
346th of 359, with limits
$449 a month
255th of 359, with limits
$390 a month
10th cheapest of 359
$200 a month
CI runners
40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month
245th of 374, with limits
$152 a month
260th of 374, with limits
$222 a month
2nd cheapest of 374
$86 a month
24/7 dev boxes
1 machine 24/7 · 4 vCPU / 8 GB
264th of 371, with limits
$96 a month
159th of 371, with limits
$33 a month
19th cheapest of 371
$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 headful Chromium, Live View and a computer controls API, while a Browserbase session is driven through CDP and Stagehand; boat streams a 60fps desktop for any Linux app.
199th of 367, with limits
$416 a month
39th cheapest of 367
$1,878 a month
7th cheapest of 367
$200 a month
Browser-use agents
50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month
Both fit, with Browserbase at 23rd and Kernel at 35th; boat ranks 7th because the same VM that runs Chromium can also run the agent's code.
23rd cheapest of 356
$449 a month
35th cheapest of 356
$1,014 a month
7th cheapest of 356
$200 a month
Scraping & bots (startup scale)
50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month
Both fit at startup scale, Browserbase with Fetch and Search APIs that skip the browser for simple pages, Kernel with proxies that cost nothing extra.
59th cheapest of 343
$537 a month
70th cheapest of 343
$735 a month
6th cheapest of 343
$90 a month
Mass scraping & bots (undetectable)
1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month
This is where both shine: Browserbase ranks 12th and Kernel 17th, with stealth, residential proxies and CAPTCHA solving that boat does not have.
12th of 327, with limits
$9,799 a month
17th of 327, with limits
$11,850 a month
73rd of 327, with limits
$1,800 a month
Parallel red teaming
200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month
Kernel ranks 131st against Browserbase's 259th, and boat ranks 6th with a full VM per run that can be forked.
259th of 351, with limits
$291 a month
131st of 351, with limits
$720 a month
3rd cheapest of 351
$200 a month
GPU eval jobs
10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month
Not ranked: misses a requirementNot ranked: misses a requirementNot ranked: misses a requirement
macOS agents
5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month
Not ranked: misses a requirementNot ranked: misses a requirementNot ranked: misses a requirement

Key features

FeatureBrowserbaseKernelboat
Kind of productManaged headless Chrome sessions, plus Search, Fetch, Functions, a Model Gateway and hosted AgentsA managed Chromium browser per session, with an app runtime for your agent codeA full Linux VM per sandbox, with a desktop and Chromium inside
Isolation1 browser per VM in its own subnet; the VM is destroyed after each sessionEach browser on its own Unikraft-based unikernel; cold starts under 20 msFull VM with its own kernel; vCPUs are shared, not dedicated cores
Machine sizevCPU and RAM per browser not published1, 2 or 4 GB headless, 8 or 16 GB headful; GPU tiers 4 or 8 vCPU; vCPU for non-GPU browsers not published4 vCPU / 8 GB by default; up to 16 vCPU / 32 GB on the $100 plan or higher
Shell accessNone in a browser session; hosted Agents and Functions get a shell in a short-lived runtimeSSH into the browser VM, and process exec with an as_root optionSSH and root on every machine
Docker and nested virtualizationNo Docker or /dev/kvm documented in sessions, Functions or the Agent runtimeA unikernel VM built around Chromium, with a Linux shell and root exec; no container runtime or /dev/kvm documentedDocker, systemd and /dev/kvm on every machine
Session length6 hours on Developer and Startup, 6+ hours on Scale, 15 minutes on FreeDeleted after its timeout, which you can set up to 72 hours; standby while idleNo cap once auto-stop is off (paid plans); auto-stop defaults to 1 hour and can be set up to 30 days
Files after a sessionA Context keeps the browser profile; the Downloads API keeps downloaded filesThe browser is deleted after its timeout (up to 72 h); profiles keep cookies, storage and browser state; you copy other files out with the file APIThe disk is saved every minute and at each stop, and kept at least 14 days after a stop; memory, processes and /tmp are not saved
Idle and wakeNo pause; a keepAlive session keeps billing until you release itStandby after 5 seconds idle with a memory snapshot and no usage chargeStop and resume by API; a stopped sandbox has no compute charge; resume reboots from the disk
ForkNo fork; a new session starts fresh or loads a ContextNo fork; browser pools keep fresh browsers warmFork a running sandbox from its last 1-minute snapshot (writes from the last minute can be missing)
Browser and computer useChrome with live view, session replay and logs; Stagehand act, extract and observeHeadful Chromium with Live View, a computer controls API, CDP and session replays; GPU-accelerated browsers on Start-Up60fps desktop and Chromium, computer use on any app, embeddable stream
Bot detectionResidential proxies in 200+ countries, CAPTCHA solving on paid plans, Verified browsers on ScaleStealth mode with a Kernel proxy and a CAPTCHA solver; ISP, residential and mobile proxies at no extra charge (fair use)Datacenter IPs and Chromium; no CAPTCHA solving
Reaching the machineCDP connect URL and live view links only; no ports to host onNo public URLs for VM ports documented; tokenized CDP and Live View URLs, and SSH -L/-R port forwardingHTTPS URLs for up to 50 ports, token-protected; raw TCP to the sandbox IP (IPv6 only on some sandboxes; the IP changes at each resume)
Agents and keysHosted browser Agent with its own built-in tools; Model Gateway for OpenAI, Anthropic and Google; 1Password sign-in; Secrets in FunctionsYou deploy your agent code as a Kernel app (Claude Agent SDK template); vaults fill logins into pages, where page scripts can read themClaude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API; optional paid credentials proxy for model providers and custom HTTPS APIs
RegionsOregon, Virginia, Frankfurt and Singaporeus-east, eu-west and ap-southeast; region choice from the Start-Up planGermany, Finland and France; you cannot pick a region; no US or Asia region
Every feature Battleships tracks (43)
FeatureBrowserbaseKernelboat
Full VM (own kernel)YesYesYes
Docker insideNo documented wayNo documented wayYes
Nested virtualizationNo documented wayNo documented wayYes
RootNo documented wayYesYes
SystemdNo documented wayNot publishedYes
Desktop GUINo documented wayYesYes
BrowserYesYesYes
Computer-use APINo documented wayYesYes
SSHNo documented wayYesYes
Persistent diskNo documented wayNo documented wayYes
Pause/resumeNo documented wayYesYes
Automatic snapshotsNo documented wayYesYes
Fork/cloneNo documented wayNo documented wayYes
Live fork (no pause)No documented wayNo documented wayYes
Memory forkNo documented wayNo documented wayNo documented way
Custom image (Docker or snapshot)No documented wayYesYes
≥24 h sessionsNo documented wayYesYes
Idle auto-stopYesYesNo documented way
Wake on requestNo documented wayYesNo documented way
HTTPS preview URLsNo documented wayNo documented wayYes
Raw TCP inboundNo documented wayNot publishedYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesYesNo documented way
Secret proxyYesNo documented wayYes
Secret proxy for any APINo documented wayNo documented wayYes
Preinstalled agentsYesYesYes
Agent harness APINo documented wayNo documented wayYes
MCP serverYesYesNo documented way
GPUNo documented wayYesNo documented way
WindowsNo documented wayNo documented wayNo documented way
Arm64No documented wayNot publishedNo documented way
Self-hostingNo documented wayNo documented wayNo documented way
BYOCNo documented wayNo documented wayNo documented way
Open sourceNo documented wayYesNo documented way
Scoped API keysNot publishedNot publishedYes
Spend limitsNot publishedYesYes
Usage per sandbox (API)Not publishedNo documented wayYes
Audit logsNot publishedYesNo documented way
SSOYesYesNo documented way
SOC 2YesYesNo documented way
HIPAAYesYesNo documented way
EU data residencyYesYesNo documented way
Zero data retentionYesYesYes

Performance

BrowserbaseNot measured
KernelNot measured
boat28.06 runs/s

There is no comparable measurement. Browserbase and Kernel are not in the public benchmarks we use, and neither publishes the vCPU or RAM behind a browser session, so we cannot say which is faster. For reference, boat did 28.06 runs/s on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, second of 15 in StarSling's run of 3 October 2026 (run 37073680030). Every boat sandbox in that run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Kernel publishes cold starts under 20 ms for its unikernels; boat is not in the public start-time benchmark.

V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Browserbase and Kernel are not in the public benchmarks we use, so we cannot say which is faster.

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. Start limits, per-start fees and plan minimums are in the price, boat's included.

ScenarioBrowserbase, a monthKernel, a monthboat, 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$5 · Free / Developer · 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$34 · Free / Developer · 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$625 · Start-Up · 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$1,230 · Start-Up · 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$2,537 · Start-Up · with limits$8,800 · $2000/mo · with limits

Browserbase: 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 ($12 or $10 per GB). Scale has no public price.

Kernel: Kernel bills $0.0000166667 per GB-second of memory while a browser is active: $0.06 an hour for a 1 GB headless browser and $0.48 for an 8 GB headful one. GPU browsers cost $2.88 or $5.76 an hour and need Start-Up. Standby and Kernel proxies cost nothing extra, and plans of $0, $30 and $200 a month include $5, $10 and $50 of usage.

Kernel: You pick a monthly plan from $20. The plan price comes back as VM time for that month: $20 is about 555 hours of a 4 vCPU / 8 GB sandbox, billed per second. The $20 plan runs 100 sandboxes at once and includes 12 starts a minute, 60 an hour and 200 a day. Create, fork and resume each count as one start; a resume onto the kept machine does not count. Extra starts cost $0.03 to $0.07 each, up to 1,200 a day, and starts above that fail. A stopped sandbox uses no machine time and keeps its disk for at least 14 days. Saved snapshots above the included count and the AI credentials proxy still cost money.

Limits in those scenarios

The table prices both as browser sessions with no published vCPU count and no disk that stays, so none of them is a 4 vCPU / 8 GB machine with a 50 GB disk. Browserbase also stops sessions at 6 hours on self-serve plans, which rules out the workday and always-on agent. Concurrency bites next: 100 at once on Browserbase Startup and 150 on Kernel Start-Up (standby and pool browsers count), so 300 sandboxes for your users and 1,000 short jobs at once need Browserbase Scale or Kernel Enterprise, with no public price. On boat the 1,000-job burst does not fit either: on the $2,000 plan, starts above 90 a minute cost extra, starts above 270 a minute fail with 429, and boat never queues a start.

ScenarioBrowserbaseKernelboat
One coding agent, workdays
  • Startup: sessions capped at 6 h
  • missing persistent disk
  • machine size not published
  • browser-session product, not a general sandbox
  • missing persistent disk
  • machine size not published
  • browser-session product, not a general sandbox
  • different kind of product: browser session
None for this scenario
One agent that never stops
  • Startup: sessions capped at 6 h
  • missing persistent disk
  • machine size not published
  • browser-session product, not a general sandbox
  • missing persistent disk
  • machine size not published
  • browser-session product, not a general sandbox
  • different kind of product: browser session
None for this scenario
50 agents in parallel
  • Startup: sessions capped at 6 h
  • missing persistent disk, Docker inside
  • machine size not published
  • browser-session product, not a general sandbox
  • missing persistent disk, Docker inside
  • machine size not published
  • browser-session product, not a general sandbox
  • different kind of product: browser session
None for this scenario
Sandboxes for your users
  • Startup: max 100 concurrent
  • machine size not published
  • browser-session product, not a general sandbox
  • different kind of product: browser session
  • Start-Up: max 150 concurrent
  • machine size not published
  • browser-session product, not a general sandbox
  • different kind of product: browser session
None for this scenario
1,000 short jobs at once
  • Startup: max 100 concurrent
  • machine size not published
  • browser-session product, not a general sandbox
  • different kind of product: browser session
  • Start-Up: max 150 concurrent
  • machine size not published
  • browser-session product, not a general sandbox
  • different kind of product: browser session
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429

Which one should you use?

Use Browserbase when

you want one platform for web agents: Chrome sessions plus Search, Fetch, Functions and hosted Agents, Stagehand, Verified browsers for strict bot walls, and regions in the US and Singapore.

  • More than a browser. Useful when simple lookups need no browser at all: Search and Fetch APIs, Functions and hosted Agents sit next to the sessions.
  • Stagehand and Verified browsers. Useful if you want an open source SDK with act, extract and observe, and Verified browsers on Scale for strict bot walls.
  • Regions on every paid plan. Useful if your users are in the US or Asia: sessions run in Oregon, Virginia, Frankfurt or Singapore, picked per session.

Use Kernel when

your browsers sit idle a lot or run for long stretches: free standby with memory kept, browsers that live up to 72 hours, SSH and root exec in the browser VM, GPU browsers, and stealth with proxies that cost nothing extra.

  • Free standby with memory kept. Useful if agents sit idle between steps: after 5 seconds idle a Kernel browser stops charging and comes back with its pages loaded.
  • A shell in the browser VM. Useful when the agent needs to run a command next to the browser: Kernel offers SSH and process exec with root.
  • Browsers that live up to 72 hours. Useful for long browsing jobs: a Kernel browser lives until its timeout, which you can set up to 72 hours, while Browserbase stops at 6 hours on self-serve plans.

Where boat fits

Browserbase and Kernel both sell a browser, not a machine. If what you are really running is agents that browse and then also install, build, test or host something, boat gives each one a full Linux VM with Chromium on a desktop, a disk kept at least 14 days after a stop and coding agents built in. For stealth scraping behind bot walls, either of them is the better tool, and an agent on boat can call them over CDP.

A whole machine with Docker

A Browserbase session gives no shell, and a Kernel browser has a shell but no documented Docker or /dev/kvm. An agent that has to run docker compose or a dev server needs a second provider, plus file copying between the two.

Files that stay and a fork

Browserbase rebuilds its VM after every session and Kernel deletes the browser after its timeout; both carry over a browser profile, and you copy other files out yourself. boat keeps the disk, snapshots it every minute and can fork a running sandbox to try two paths.

Hosting, agents and keys outside

Neither gives a public URL for a port: you get CDP and live view links, plus SSH port forwarding on Kernel. boat gives HTTPS URLs on up to 50 ports, ships Claude Code and Codex you drive from outside, and its optional paid credentials proxy keeps model and custom API keys outside the sandbox.

Use boat when your agent browses and also works: installs, builds, Docker and dev servers on a full VM with a disk kept across stops, a 60fps desktop with Chromium, HTTPS on 50 ports and coding agents built in. Compare it one to one: boat vs Browserbase and boat vs Kernel.

boat's own limits
  • Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
  • Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
  • A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
  • Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
  • boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
  • Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
  • Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
  • Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source

Questions people ask

Is Kernel cheaper than Browserbase?

In most scenarios, yes, though both are priced as browser sessions with no disk. One agent running all month comes to $34 on Kernel against $122 on Browserbase, and 50 agents in parallel to $625 against $841. Kernel's standby is free, so mostly idle browsers cost even less. For 300 sandboxes for your users, both go past their self-serve concurrency and need a sales plan. boat comes to $26 and $317 for a 4 vCPU / 8 GB VM that keeps its disk.

Which is faster, Browserbase or Kernel?

There is no comparable measurement. Neither is in the public benchmarks we use, and neither publishes the vCPUs behind a standard browser. Kernel publishes cold starts under 20 ms for its unikernels.

Can Browserbase or Kernel run Docker?

Not documented on either. A Browserbase session gives you Chrome over CDP, and its Agent and Functions run in a short TypeScript runtime. Kernel gives SSH and root exec in its browser VM but documents no container runtime. Every boat sandbox has root, Docker, systemd and /dev/kvm.

How long can a session run on each?

Browserbase sessions last up to 6 hours on Developer and Startup and 15 minutes on Free. A Kernel browser is deleted after its timeout, which you can set up to 72 hours, and goes to free standby while idle. On boat, auto-stop defaults to 1 hour; you can turn it off on a paid plan, and boat keeps the disk at least 14 days after a stop.

Which is better for scraping sites that block bots?

Both are built for it. Browserbase has residential proxies in 200+ countries, CAPTCHA solving and Verified browsers on Scale, and Kernel has stealth mode with a Kernel proxy, a CAPTCHA solver and proxies at no extra charge. boat runs Chromium on datacenter IPs and solves no CAPTCHAs.

Can I use boat with Browserbase or Kernel?

Yes. An agent on a boat sandbox can open a Browserbase or Kernel browser over CDP and keep its code, files and tools on the boat VM. That puts protected browsing on them and the rest of the work on a machine that keeps its disk.

Try boat

Install the CLI, then run boat new.

7-day free trial

More comparisons