Kernel vs. Browserbase: which cloud browser platform fits your AI agent stack?

Last updated: August 17, 2026. Latency figures come from browserbench, an open-source benchmark published by Steel. Pricing and feature claims were verified against each vendor's live pricing page and public docs on that date.

TL;DR: Kernel wins on the three differences that matter most in production. Kernel runs headful browsers by default, with headless and GPU-accelerated modes as per-session options, where Browserbase offers headless browsers only. Kernel is measurably faster — 37ms to create a session against Browserbase's 213ms, and 794ms against 2,967ms for a full create → connect → load → release cycle on browserbench. And Kernel sessions can run up to 72 hours against Browserbase's 6-hour cap. On top of that: more levers when a site fights back, MP4 replays and live view as first-class primitives, and per-second billing with Standby Mode, so idle browsers don't run the meter. If your agent needs a real rendered display, has to move fast, has to stay logged in for a long time, or has to reach anti-bot-guarded sites, Kernel is the clear pick.

The rest of this piece breaks it down: the specific reasons teams migrate, a full feature matrix, and a decision framework you can actually use.

The biggest differences

Both give you a Chromium browser in the cloud. Both offer session recordings and Playwright support. But three differences show up early and matter a lot in production:

Headful vs. headless. Browserbase offers headless browsers only. On Kernel, headful is the default — it's what supports live view, replays, and the strongest stealth posture — and headless is the lighter option (1 GB vs. 8 GB) for simple scraping. GPU acceleration is a third mode for WebGL, video, and canvas-heavy work. That matters because a growing share of agent workloads — computer-use agents, visual verification, media-heavy sites, sites that behave differently under real rendering — either work better with a real display or don't work at all without one.

Speed. On browserbench, Kernel creates a session in 37ms against Browserbase's 213ms (5.8× faster) and completes the full create → connect → load → release cycle in 794ms against 2,967ms (3.7× faster end-to-end). Kernel's own docs put browser creation at a 30ms p50 and 105ms p99. That gap compounds every time an agent acquires a browser.

Session duration. Kernel sessions can run up to 72 hours on a single configurable timeout. Browserbase caps sessions at 6 hours (and at 15 minutes on its free tier). For short-lived tasks this doesn't matter; for long scrapes, long-lived authenticated flows, human-in-the-loop workflows, and computer-use agents that operate on human timescales, the 6-hour ceiling is often the constraint people run into first.

The rest of the differences — idle-time billing, first-class replays, five proxy types, Web Bot Auth, framework breadth, MCP support — reinforce the same story: Kernel is built for how production agents actually consume browsers.

Why teams choose Kernel over Browserbase

The reasons teams migrate are usually specific and technical, not ideological. Here are the ones we hear most often.

Kernel offers headful and GPU browsers

Browserbase offers headless browsers only. Kernel offers headful (the default), headless, and headful + GPU as per-session modes, priced per second at different rates. The difference matters more than it used to:

• Computer-use agents operating via screenshots, mouse, and keyboard need a real rendered display. Headless approximations skip parts of the pipeline (compositor, real font rendering, some GPU paths) that visual agents depend on.
• Sites that fingerprint headless environments behave differently or block outright when they detect classic headless signals. A headful browser sidesteps a class of detection you'd otherwise be fighting with stealth patches.
• Media-heavy workflows — WebGL, canvas rendering, video playback — often either don't work or work poorly headless. That's what GPU acceleration is for.
• Visual verification and human handoff — showing a human what the agent actually sees, or handing off mid-session — is much cleaner when the underlying browser is already rendering to a real display.

Kernel treats the mode as a per-session choice, so you pay the higher rate only for the sessions that need it.

Kernel ships five proxy types, stealth builds, and Web Bot Auth

Every browser platform has a stealth story. What separates them is how many levers they hand you when a target site fights back.

Kernel ships:

• Stealth-mode browser builds as a first-class configuration flag on every plan, including the free one. Stealth adds a default ISP proxy and an automatic CAPTCHA solver, both opt-out so you can bring your own.
• Five proxy types — datacenter, ISP, residential, mobile, and custom (BYO) — with health checking, geo-targeting, and per-session selection. Configurable and BYO proxies are a paid-plan feature.
• Web Bot Auth, cryptographically signing browser requests per RFC 9421 so sites that participate in the standard can verify the automation rather than guess at it. Kernel is a listed identity with Vercel and Cloudflare, so for agents talking to compliant destinations this is a way to get invited in rather than sneak in.
• An hCaptcha solver in beta, on request, on top of the stealth-mode solver that handles the common challenge types.
• Browser extensions, including ad-hoc uploads and Chrome Web Store fetch, so you can bolt on tooling that isn't in Kernel's default stack.

Browserbase ships proxies, auto-CAPTCHA solving on paid tiers, and its Agent Identity product with Verified sessions on the Scale tier. Fine for the median case. Less flexible when a target site starts fingerprinting the platform itself.

The practical difference: with Kernel, when a site starts blocking, you have several independent things to change — stealth on or off, proxy type, a specific exit IP, a profile, a signed identity, computer controls instead of CDP.

Kernel sessions run up to 72 hours

Kernel sessions can run for up to 72 hours on a single configurable timeout (the default is 60 seconds, and the countdown only starts once the browser goes idle). Browserbase caps every session at 6 hours.

For most agent workloads that acquire and release browsers quickly, this doesn't matter. For a growing set of workloads it matters a lot:

• Long-running scrapes across paginated archives, or watchers that need to react to changes in near real time.
• Authenticated workflows where the login is expensive (2FA, email verification, CAPTCHA gate) and re-authenticating every 6 hours is either impossible or ruins the automation's cost profile.
• Human-in-the-loop flows where a person may return to the same session hours later to resolve an exception.
• Computer-use agents that operate on the timescale of "a workday," not "a function call."

If you've ever architected around a 6-hour cap — chunking work, checkpointing state, hoping the resume path works — you know the tax. Kernel's 72-hour ceiling removes it.

Kernel offers MP4 replays and live view

Debugging production agents is hard because a stack trace tells you almost nothing about what the browser was actually doing. Both platforms have observability stories; Kernel treats it as core product.

A Kernel session can be:

• Watched live via a token-based URL, with readOnly mode for observers, iframe embedding for dashboards, and a kiosk mode for fullscreen viewing without browser chrome.
• Recorded as an MP4 and downloaded later. Recording is opt-in and session-scoped: start it, run the automation, stop it. Replays require a headful session and are retained 1 / 7 / 30 days depending on plan.
• Instrumented in real time via a server-sent events stream carrying console, network, page, interaction, screenshot, and operational events — resumable by sequence number, and exportable over OTLP.

The MP4 replay in particular is the difference between "the agent failed at step 47 and I don't know why" and "the agent failed at step 47 because the modal that popped up wasn't the one it expected, here it is on video."

Browserbase also has this surface: rrweb session recordings, an HLS session-replay stream, MP4 recording downloads, and a live viewer. The difference is integration depth rather than existence — Kernel's telemetry is category-selectable and streamable live, and a human can jump into a session mid-run from the hosted dashboard without any custom UI on your side.

Kernel bills per second and doesn't meter idle browsers

This is the pricing difference that shows up on the bill.

Kernel meters usage per second at $0.0000166667 per GB-second, and the browser type sets the multiplier. A browser is active only while something is driving it — a CDP or WebDriver client, a live-view viewer, or an in-flight computer-controls request. Five seconds after the last of those goes away it enters Standby Mode: state is preserved, billing stops. Browsers waiting in a pool don't accrue usage charges either, and proxy bandwidth is never billed.

One exception worth planning around: GPU browsers don't support standby, so a GPU session bills for its full lifetime.

Kernel's plans layer on included credits: Developer (free) with $5/mo, Hobbyist at $30/mo with $10, Start-Up at $200/mo with $50, Enterprise custom. Concurrency runs 5 → 10 → 150 → custom.

Browserbase's Developer tier is $20/month and includes 100 browser hours; Startup is $99/month and includes 500. Overages are billed at $0.12/hr and $0.10/hr respectively, and the meter is browser-hours: what counts is the session being open, not the session doing something.

For an agent that acquires a browser, waits on a slow CAPTCHA, waits on a slow LLM roundtrip, waits on a slow target site, and does a hundred of those a day, the difference between "billed for the seconds you were actually driving" and "billed for the wall-clock hours the browser was alive" compounds fast.

Kernel cold-starts in milliseconds

Agent loops acquire a browser, do one or two actions, release it, and repeat. If each acquisition costs a couple of seconds, and your agent does that a few hundred times per task, most of your wall-clock time is spent waiting on infrastructure that isn't doing any work.

Kernel's browsers boot on a unikernel runtime in under 30ms — a 30ms p50 and 105ms p99 on browser creation, and 37ms on browserbench against Browserbase's 213ms. End to end, browserbench puts the full create → connect → load → release cycle at 794ms against 2,967ms.

The bigger win is that Kernel's runtime is cheap enough per-browser that browser pools become economically sensible — configure a pool size, and acquisition becomes a wait against a warm queue instead of a cold spin-up. Pooled browsers sit at zero usage cost until they're acquired. (Pools take one fixed configuration and don't support GPU browsers, so per-session variation still wants on-demand creation.)

Kernel persists sessions with profiles and managed auth

Kernel's profiles are a first-class primitive for persisting cookies and local storage across browsers. Combined with the managed authentication primitive — a hosted login UI, an embeddable React component, or programmatic credential submission — the "log in once, use forever" pattern is a supported workflow rather than a hack you build on top.

Managed auth also handles automatic re-authentication, credential health checks, and a per-connection event timeline. Credentials are encrypted with per-organization keys, never returned by the API, and never passed to an LLM. If you've ever been paged at 2am because an agent's session expired and nobody noticed, you'll appreciate the difference between "the auth broke" being a dashboard item versus a fire. Connection limits are 3 on the free plan and unlimited on paid ones.

Browserbase has Contexts for state reuse and an Agent Identity product on paid tiers. It works. It's less deep.

Kernel supports every major framework

Browserbase supports Playwright, Puppeteer, and CDP, but the marketing (and much of the onboarding) leans hard on Stagehand — its own SDK. That's fine if Stagehand is what you want. If you've already standardized on something else, you're swimming upstream.

Kernel treats browser automation frameworks as consumers, not competitors. The same underlying browser works with Playwright (including executing your Playwright code inside the browser's own VM, which removes the round trip and the CDP fingerprint), CDP directly (so any CDP-based tool works), WebDriver BiDi, computer controls for Anthropic-, OpenAI-, and Gemini-style visual agents, plus first-class integrations for Stagehand and Browser Use.

There's also a first-class MCP server, with setup for Claude (Desktop, Code, and the official claude.ai connector), Cursor, VS Code, Zed, Windsurf, Goose, and OpenCode, over both Streamable HTTP and stdio.

Kernel's compliance posture is public

Kernel is SOC 2 Type II, HIPAA, PCI DSS, and ISO 27001 compliant, with GDPR in progress; reports are available on request. SOC 2 covers every plan. Beyond that: organization-level project isolation, scoped API keys with rotation and grace periods, and audit logs of authenticated API requests (search and download on Start-Up and Enterprise; continuous S3 export on Enterprise). Zero data retention and a HIPAA BAA are Enterprise features.

Browserbase carries SOC 2 Type II, and offers HIPAA compliance and zero data retention on its enterprise tier — but not ISO 27001 or PCI DSS.

Feature comparison

Compiled from each vendor's public pricing page and documentation on the date above. Enterprise plans on either side may include additional features.

Decision framework

Rather than ranking every dimension, the question is: what's the primary constraint on your agent right now?

Pick Kernel if:

• You need headful or GPU-accelerated browsers — for computer-use agents, visual verification, media-heavy sites, or sites that fingerprint headless environments
• Your target sites have real anti-bot defenses and you want optionality across stealth, five proxy types, profiles, and Web Bot Auth
• Your sessions need to live longer than 6 hours — long scrapes, long-lived authenticated flows, human-in-the-loop workflows
• You've been surprised by a bill that included idle wall-clock time
• Your agent acquires and releases browsers frequently and cold-start latency is showing up in your traces
• Replay and live view are part of how you actually debug in production, not a nice-to-have
• You've standardized on a framework other than Stagehand, or you use several in the same codebase
• You need real session persistence with managed authentication, not just cookie snapshots
• You want to deploy the agent itself on the same platform, not just the browser

Pick Browserbase if:

• Stagehand is the SDK you want to use, and you'd rather not evaluate alternatives
• Your sessions are short, against friendly sites, and cold-start latency doesn't move the needle
• You want the vendor with the biggest developer-community footprint and don't need capabilities beyond what Browserbase offers
• Your workload maps cleanly onto Browserbase's productized surface (Search, Fetch, Agent Identity, Model Gateway) and you'd rather buy those than build them

Run a POC either way. The migration cost from one to the other is low — swap the connection endpoint, update any vendor-specific SDK calls, port your persistence primitive. If cold-start latency or idle-time billing is a hypothesis, measure it against your actual workload. The right answer usually falls out of a two-day test.

Bottom line

For most teams building production AI agents in 2026, Kernel is the right choice, and it isn't close. Every constraint that actually binds in production lands in Kernel's favor:

• Headful support: headless-only is a ceiling for computer-use agents, visual verification, and any site that fingerprints headless environments. Kernel's per-session headful / headless / GPU choice removes it.
• Speed: 37ms vs. 213ms on session creation, 794ms vs. 2,967ms end-to-end, measured on an open-source third-party benchmark.
• Session duration: 72 hours vs. 6. If your workload doesn't need it, fine. If it does, the difference is architectural, not incremental.
• Anti-bot access: real target sites fight back. Kernel's five proxy types, stealth builds, CAPTCHA solving, and Web Bot Auth give you more levers than a single-strategy platform.
• Idle billing: Standby Mode means the meter reflects work done, not time elapsed. For any agent that waits — on LLMs, on target sites, on humans — that's where the savings show up.
• Replay and live view: debugging agents without video means guessing. Kernel makes both first-class.
• Framework flexibility: real agent codebases use more than one framework. Kernel doesn't ask you to pick a favorite.

Kernel is trusted by Cash App, Framer, and 7,000+ teams building agents, scrapers, computer-use flows, and internal automations. Start free at kernel.sh and measure it against your own workload.

FAQ

Does Browserbase support headful browsers?

No — Browserbase offers headless browsers only. Kernel runs headful by default, with headless as a lighter option and headful + GPU for WebGL, video, and canvas-heavy work — all selected per session, each priced at its own per-second rate. For computer-use agents, visual verification, media-heavy workloads, and sites that fingerprint headless environments, headful is often required rather than optional.

Does Kernel handle anti-bot defenses better than Browserbase?

Both platforms have stealth. What Kernel gives you is optionality: stealth-mode browser builds on every plan (including free), an automatic CAPTCHA solver, an hCaptcha solver in beta on request, five kinds of proxies (datacenter, ISP, residential, mobile, custom) with health checking and BYO support on paid plans, profiles for warm session state, and Web Bot Auth for signing requests to sites that participate in the standard. When a target site fingerprints one strategy, you swap to another. Browserbase offers proxies and auto-CAPTCHA on paid tiers, with Verified sessions on Scale.

How long can a session run on Kernel vs Browserbase?

Kernel sessions can run for up to 72 hours on a single configurable timeout. Browserbase caps sessions at 6 hours, and free-tier sessions at 15 minutes. For short-lived agent tasks this doesn't matter. For long scrapes, long-lived authenticated workflows, human-in-the-loop flows, and computer-use agents that operate on human timescales, the 6-hour ceiling is often the constraint people run into first.

Does Kernel bill for idle browser time?

Not for standard browsers. Five seconds after the last CDP or WebDriver client, live-view viewer, or computer-controls request goes away, the browser enters Standby Mode — state is preserved, billing stops. Browsers waiting in a pool don't accrue usage charges, and proxies are never billed. The exception is GPU-accelerated browsers, which don't support standby and bill for their full lifetime. Browserbase meters browser-hours, so an open session bills whether or not it's doing anything.

What are Kernel's live view and replay features?

Every Kernel session exposes a live-view URL you can open, embed in an iframe, or hand to a human mid-run, with a readOnly mode for observers and a kiosk mode for fullscreen viewing. Headful sessions can also be recorded as MP4 files and downloaded later, and any session can stream telemetry — console, network, page, interaction, screenshots, and operational events — as server-sent events, resumable by sequence number and exportable over OTLP. Replay retention is 1 day on the free plan, 7 days on Hobbyist, and 30 days on Start-Up.

Is Kernel a drop-in replacement for Browserbase?

Close to it. The migration is a connection-endpoint change plus, if you were using Browserbase's SDK, replacing those calls with Kernel's equivalents; if you were on Playwright or CDP directly, it's close to a one-line change. Kernel supports the same core frameworks Browserbase does (Playwright, CDP, Stagehand — plus any CDP-based tool) and adds WebDriver BiDi, Browser Use, and a computer-controls API. Session persistence via Kernel's profile primitive maps cleanly onto Browserbase's Contexts. Managed authentication and stealth have equivalents on both sides, with more depth on Kernel.

How does Kernel's cold start compare to Browserbase's?

On browserbench, Kernel creates a session in 37ms against Browserbase's 213ms — 5.8× faster — and Kernel's own docs report a 30ms p50 and 105ms p99 on browser creation. End to end, the full create → connect → load → release cycle measures 794ms against 2,967ms. For workloads that acquire a fresh browser per task — most agent workloads — that difference compounds across a run. If cold-start latency isn't in your traces today, it's likely because you've engineered around it.

Do I have to use Stagehand with Kernel?

No. Kernel supports Stagehand as one of many framework options — Playwright, CDP, WebDriver BiDi, Stagehand, Browser Use, and computer controls are all first-class, and any CDP-based tool works. If Stagehand is what you want, it works on Kernel. If you'd rather use Playwright directly, that also works, without any nudging toward a house SDK.

Which is cheaper, Kernel or Browserbase?

It depends on the shape of your workload, but for agents that wait, Kernel usually wins on two reinforcing counts.

First, Kernel is faster, and speed is cheaper on a per-second meter. A 37ms session creation against 213ms, and a 794ms end-to-end cycle against 2,967ms, means fewer billed seconds for the same output.

Second, idle time isn't metered. Browserbase's Developer tier is $20/month with 100 included browser hours and $0.12/hr overages; Startup is $99/month with 500 hours and $0.10/hr overages, metered on browser-hours. Kernel's plans are Developer (free, $5/mo credits), Hobbyist ($30/mo, $10), Start-Up ($200/mo, $50), Enterprise custom — metered per second at $0.0000166667 per GB-second, with standby browsers off the meter, so a browser waiting on an LLM response or a slow target site isn't costing you.

The caveat is that a headful Kernel browser is 8 GB and therefore 8× the headless rate, and GPU browsers don't standby. Model it against your actual workload — session length, idle fraction, and browser type — before deciding on price alone.

Does Kernel support session persistence?

Yes. Kernel's profiles are a first-class primitive for persisting cookies and local storage across browsers. Combined with managed authentication (hosted login UI, embeddable React component, or programmatic credential submission), the "log in once, use forever" pattern is a supported workflow with automatic re-authentication, credential health checks, and an event timeline for every login attempt. Credentials are encrypted with per-organization keys and never passed to an LLM.

Does Kernel work with the Model Context Protocol (MCP)?

Yes — both do. Kernel ships an MCP server with setup for Claude (Desktop, Code, and the official claude.ai connector), Cursor, VS Code, Zed, Windsurf, Goose, and OpenCode, over Streamable HTTP or stdio, with OAuth 2.1 or API-key auth. Browserbase also publishes an official MCP server built on Stagehand, with hosted and local deployment options. The main difference is that Kernel's MCP is browser-runtime-native and exposes the full platform surface — browsers, pools, profiles, proxies, extensions, replays, apps — while Browserbase's is Stagehand-flavored.

Can I use Kernel in a regulated environment?

Yes. Kernel is SOC 2 Type II, HIPAA, PCI DSS, and ISO 27001 compliant, with GDPR in progress, and reports are available on request. SOC 2 applies on every plan. Organization-level project isolation, scoped API keys with rotation and grace periods, and audit logs of authenticated API requests are available on self-serve plans (audit-log search and download on Start-Up; continuous S3 export, zero data retention, and a HIPAA BAA on Enterprise). Browserbase carries SOC 2 Type II and offers HIPAA and zero data retention on its enterprise tier, but not ISO 27001 or PCI DSS.

Vendor features and pricing change frequently — verify current details on each vendor's site before making a purchase decision.