Browser Use vs. Kernel: Pricing, Stealth, and Performance

All articles

Browser Use and Kernel both provide cloud browsers for automation. You can connect existing scripts or run an AI agent on either provider, but their billing, session management, and execution options differ.

Let's compare them across pricing, stealth, performance, authentication, and developer experience.

TL;DR

Choose Browser Use for inexpensive, subscription-free browser time, or a hosted agent that completes tasks for you. Choose Kernel when standby or running code beside the browser fits your application. Both support authentication; proxy traffic can change which provider costs less.

Compare	Browser Use	Kernel
Main offering	Browser infrastructure + hosted agents	Browser infrastructure + execution APIs for your code
Browser time	Headless: $0.02/hour Headful: unsupported Billed per minute.	Headless: $0.06/hour Headful: $0.48/hour Billed per second.
Managed proxy traffic	$5/GB residential	Unmetered, subject to fair use
Managed proxy types	Residential	ISP, residential, and mobile
Standby	Stop the browser to end runtime billing	Preserves state without usage charges when inactive
Concurrency	Initial: 10, max: 1,000; based on spend	Initial: 5, max: 150; based on subscription
Authentication	Profiles, cookie sync, and 1Password for hosted agents	Profiles and Managed Auth
Lifecycle latency	371.5 ms	398 ms
Protected-site access	90.5%	80.5%
Compliance	SOC 2, HIPAA (Enterprise), DPA, self-service US zero data retention	SOC 2, HIPAA (Enterprise)

∗ Pricing: checked October 27, 2026; Subscriptions and resource allocations affect the bill.
∗ Performance: sum of phase medians in BrowserArena's October 27 run.
∗ Stealth: figures from Browser Use's September 25 study, whose site selection favors Browser Use.
∗ Max concurrency: excludes enterprise plans.

What Is Browser Use?

Browser Use offers two commercial products:

Browser Infrastructure provides managed Chromium browsers for your scripts or agents. Connect through the Chrome DevTools Protocol (CDP) using Playwright or Puppeteer.
Browser Use Agents accepts a task, operates the browser, and returns the result. The service handles the agent loop.

The open-source browser-use Python library is a third option for running and customizing your own agent. Using Browser Use Infrastructure does not require that library or rewriting existing scripts into natural-language tasks.

What Is Kernel?

Kernel provides managed browsers in isolated virtual machines. Its API creates a browser and returns connection details for your automation code.

Around that browser, Kernel offers persistent profiles, standby, managed authentication, live views, and code execution. You can control it remotely over CDP or execute code inside its environment.

The products can also work together: the open-source Browser Use library can drive a Kernel browser. In that setup, Browser Use supplies the agent logic, and Kernel supplies the browser.

Comparison

The infrastructure overlaps directly. The differences become clearer when you look at the workload and how much of its execution you want to manage.

Pricing

Browser Use pricing is usage-based: $0.02 per browser-hour, rounded up to whole minutes, plus $5/GB for managed residential traffic. Direct traffic or your own proxy costs $0.20/GB, with the external proxy bill separate. No subscription is required; purchased credits don't expire.

Kernel bills by the second. Base headless browsers cost approximately $0.06/hour, and base headful browsers cost $0.48/hour. Larger allocations and GPU browsers cost more. Its managed proxy traffic is unmetered and not billed separately, subject to fair use and upstream destination restrictions.

Kernel's Developer, Hobbyist, and Start-Up plans cost $0, $30, and $200 per month, plus usage. They include $5, $10, and $50 in monthly usage credits respectively. Hobbyist adds configurable managed proxies; bringing your own proxy requires Start-Up.

Let's calculate an example: 600 ten-minute sessions per month, one concurrent browser, and either 1 GB or 10 GB of managed proxy traffic. That's 100 active browser-hours. For Kernel, use Hobbyist with its base headless browser so proxy configuration is available.

Monthly workload	Browser Use	Kernel Hobbyist
100 hours + 1 GB traffic	$7	$30
100 hours + 10 GB traffic	$52	$30

Browser Use charges $2 for time, then $5 or $50 for traffic. Kernel's approximately $6 runtime charge fits within Hobbyist's $10 usage credit, leaving the $30 subscription.

Kernel's Developer plan includes the default stealth ISP proxy. If that configuration is sufficient, the same 100 base headless hours cost about $1 after its $5 monthly usage credit, before other usage; the table uses Hobbyist for configurable proxies.

∗ These are illustrative bills, excluding signup credits, idle time, inference, and other usage. They don't establish equal throughput or identical proxy networks. Kernel's included traffic is subject to proxy fair use.

Kernel headful browsers would bring this example to about $68/month. The cheaper option depends on the browser configuration and traffic, not just the hourly rate.

Hosted Browser Use agents add model cost plus a 20% orchestration fee. Kernel app invocations have a separate compute charge, and any model provider bills independently.

Stealth

Browser Use runs a hardened Chromium fork with stealth enabled by default. Kernel includes baseline anti-detection settings; enabling its stealth mode adds a managed ISP proxy and automatic CAPTCHA solving. Both offer supported CAPTCHA handling, but their configurations and networks differ.

Kernel also offers residential and mobile proxies. IP persistence varies by proxy type and configuration, so use comparable settings when testing.

In Stealth Bench V2, measured September 25, 2026, Browser Use reached the target page on 90.5% of visits, versus Kernel's 80.5%. The study covered 100 protected sites, visited twice, with each provider's proxy and solver. A judge checked whether the real page loaded within 60 seconds.

Browser Use published the study and selected sites where its browsers had historically succeeded while stock Chrome with a US proxy failed. That favors Browser Use. The result supports its access advantage on this selected workload; it doesn't establish better task completion or a success rate across the web.

Performance

BrowserArena, maintained by Notte, measures creating a session, connecting Playwright over CDP, navigating to example.com, and releasing the session.

On October 27, both providers completed all 100 measured sequential runs after ten warm-ups. Their runners used AWS us-east-1 and the same machine class. The phase medians were:

Phase	Browser Use	Kernel
Create session	165.5 ms	23 ms
Connect over CDP	112.5 ms	74 ms
Navigate	70 ms	260 ms
Release	23.5 ms	41 ms
Sum of phase medians	371.5 ms	398 ms

Kernel created sessions and connected faster. Browser Use navigated and released faster, giving it a slightly lower total that day. This total sums separate medians; it isn't the median of complete session times.

The ordering changes across runs. In the published records for October 21, 22, and 26, Kernel had lower lifecycle figures. Kernel's creation phase was faster on all four inspected dates.

These measurements describe a short browser lifecycle after warm-ups, not cold starts or agent task speed. For longer workflows, page behavior, model calls, and repeated browser actions can matter much more than session creation.

Sessions & Authentication

Browser Use's V4 API allows sessions up to four hours. Ending a CDP connection doesn't stop the browser; explicitly stop it to end runtime billing.

Kernel's standby mode preserves browser state without usage charges. It activates after five seconds without connected CDP, WebDriver, or Live View clients, or an in-flight computer-control request. Leaving an idle CDP connection open keeps the browser active. GPU browsers don't support standby.

Once standby begins, Kernel's idle deletion timeout starts. You can configure it up to 72 hours. This is useful when work pauses overnight or waits for someone to return, but it is an idle timeout rather than a four-hour-style total session cap.

Both providers support authentication and saved profiles. Browser Use can sync a local login, and its hosted agents can use a configured 1Password integration to fill passwords and TOTP codes. Kernel's Managed Auth orchestrates login, monitors connections, and can attempt recovery for eligible expired sessions.

The setup differs, but both support authentication. Cookies can expire, and flows requiring an email code, approval, or other human action may still need user input. Session lifetime, idle billing, and execution options are more useful deciding factors here.

For scaling, Browser Use starts at 10 concurrent browser/agent sessions, increasing with qualifying project payments. Kernel's plan limits start at five. Standby browsers and reserved pools still occupy Kernel concurrency slots, even when they aren't generating usage charges.

Developer Experience

Both providers support existing Playwright and Puppeteer workflows. If your script already works locally, either can supply its remote browser.

Browser Use Agents is useful when you want to delegate a goal, such as finding and downloading an invoice, without maintaining the reasoning loop. You still need to check that the returned result is correct.

Kernel's Playwright Execution API runs code in the same VM as the browser. A block of actions can execute there without sending every operation from your application over a remote CDP connection. Kernel also lets you deploy your own automation apps.

That gives developers another choice beyond remote control: keep the workflow logic they already own and run it closer to the browser. The benefit depends on the workload; the lifecycle benchmark above doesn't measure this execution path.

Conclusion

Browser Use is a good fit when you want low-cost browser time, direct infrastructure access without a subscription, or hosted agents. Kernel deserves consideration for workflows that benefit from standby and code running beside the browser. Its included proxy traffic can also outweigh the higher runtime rate, within its fair-use terms.

Choose using the sites, traffic, and session behavior your application needs. For existing Playwright code, the Browser Use connection guide is a practical starting point.

Published November 3, 2026