Best Headless Browser for AI Agents: Layers, Prices

The short version

For a typical AI agent, the best headless browser setup is Chrome driven by Playwright, hosted on a cloud browser such as Cloudflare Browser Run. Swap the engine for Lightpanda or Obscura to cut memory, or the driver for Vercel's agent-browser to cut tokens. Hosted headless browsers cost $0.02 to about $0.24 per browser-hour on October 29, 2026.

Most comparisons rank tools from all four layers in one list, which hides that you're choosing up to four things. Chrome, driven by Playwright, hosted on Cloudflare Browser Run, with your own code deciding the steps, is a perfectly normal answer. So is Lightpanda driven by Puppeteer on your own box with Browser Use on top. What you can't do is compare Lightpanda against Browser Use, because one is an engine and the other is a framework that needs an engine underneath it.

Most of the roundups we read for this query were written by a company with a product on the list. Firecrawl's puts Firecrawl first, as "best overall for AI agents that need web data". Bright Data's put Bright Data first when we checked in August. Mastra's, which sells nothing on its list, is the useful exception, though it leaves out prices and licences, which are the two things that usually decide.

How we checked this

Every number below came from the project's own repository, documentation or pricing page, not from another roundup. We first checked on August 3, 2026 and re-checked everything on October 29, 2026. Where something changed in between, we say what changed. Where a figure is commonly repeated but we couldn't verify it at the source, we say that too instead of passing it along.

We sell consulting. We don't sell browsers, proxies, hosting or scraping infrastructure, and we take nothing from anyone listed here.

The four layers

Layer	What it does	Options
1. Engine	Renders the page and runs its JavaScript	Chrome/Chromium, Firefox, WebKit, Lightpanda, Obscura, Cloudflare Kitesurf
2. Driver	How your code tells the engine what to do	CDP, Playwright, Puppeteer, Vercel agent-browser
3. Platform	Where the browsers actually run and who babysits them	Cloudflare Browser Run, Browserbase, Steel, Browser Use Cloud, Kernel, Hyperbrowser, Anchor, Browserless, Bright Data, your own servers
4. Agent framework	Decides what to click when you don't know in advance	Browser Use, Stagehand

You always need layers 1 and 2. Layer 3 is a question of whether you want to run browser fleets yourself. Layer 4 is optional, and skipping it is often the right call.

Layer 1: the engine

Chrome and Chromium are the default, and the default is fine. Everything targets them, every site is tested against them, and every anti-bot vendor has to be careful about blocking them because real people use them.

Lightpanda is the interesting alternative, and it's different: written in Zig, not built on Chromium or Blink or WebKit, using V8 only for JavaScript. It throws away the rendering work an agent never looks at. Its repository reports 100 pages in 5 seconds against 46 seconds for Chrome headless, with peak memory of 123MB against 2GB. That's roughly 9x on speed and 16x on memory, unchanged between our two checks.

Our March note on Lightpanda quoted 11x speed and 9x memory, which were the project's figures at the time. The project's current numbers are the ones above. If you read the 11x claim somewhere, it's stale.

Two things to know before you switch. It's AGPL-3.0, which is a real constraint for commercial work and covered below. And 1.0 is recent: the project dropped its Beta label on September 7 and shipped 1.0 on October 2, 2026. It has spoken WebDriver BiDi as well as CDP since 0.4.0 in August. "Drop-in replacement" is true of the wiring. Point it at the sites you actually scrape before you plan around the savings.

Obscura is the other engine built for this job, and the one with the easier licence. It's written in Rust with V8, Apache-2.0, and its repository pitches it as a drop-in replacement for headless Chrome with Puppeteer and Playwright. Its own numbers are 30MB of memory against 200MB-plus for Chrome, and 85ms page loads against about 500ms. It's young (v0.1.0 shipped in April 2026), and Vercel's agent-browser, which can run on top of it, marks it experimental and lists accessibility, iframe and rendering limitations in Obscura v0.2.2.

Cloudflare Kitesurf is the odd one out. It runs inside V8 isolates on Workers, you reach it through Browser Run with browser=kitesurf, and Cloudflare says its first prototype was a port of Obscura. Cloudflare's own claim is 3 to 7 times less memory and CPU than Chromium, at 1.7 times slower. It's free while in beta and not open source yet, so it only matters if you're already on Cloudflare.

Layer 2: the driver

Playwright drives Chromium, Firefox and WebKit, is Apache-2.0, and ships an MCP server and a CLI aimed specifically at coding agents. If you have no strong reason to pick something else, pick this.

Puppeteer drives Chrome and Firefox, sits slightly closer to the metal, and is also Apache-2.0. Fine and well understood, with a smaller surface than Playwright.

Vercel's agent-browser is the one worth a second look if you're paying per token. It's a Rust CLI and daemon that speaks CDP directly, with no Playwright or Node needed for the daemon at all. The useful part is what it hands back: an accessibility-tree snapshot with stable references like @e1 and @e2, rather than a screenshot or a wall of HTML. Your model reads a short structured list of the things it can actually interact with. On a long agent run that difference shows up on the invoice. It now also takes an --engine flag for chrome, lightpanda or obscura, which turns the engine question above into a one-line change you can test.

We wrote about Microsoft's Webwright in May, which attacks the same problem from the other side: record what worked once, replay it as a script, stop paying a model to rediscover the same three clicks.

Layer 3: where it runs

Running one browser is easy. Running two hundred, with crash recovery, memory limits, proxy rotation and session state, is a job. This layer is about whether you want that job, and since most people end up renting it, it's the layer where price matters most.

What a cloud browser costs per hour

Taken from each vendor's own pricing page and docs on October 29, 2026, roughly cheapest first. Rates are for one headless browser for one hour. Proxy traffic is extra unless the row says otherwise.

Platform	Per browser-hour	Max session
Browser Use Cloud	$0.02, plus $5/GB proxy (on by default)	4 h
Kernel	$0.06 headless at 1 GB, $0.48 headful, billed per GB-second	No stated cap (idle timeout up to 72 h)
Anchor	$0.05 in its docs, $0.09 on its pricing page	No upper limit
Cloudflare Browser Run	$0.09 after 10 h a month	No fixed cap while active (ends on Browser Run releases)
Hyperbrowser	$0.10	Not stated
Steel	$0.10 pay as you go, $0.08 on Scale	15 min, 1 h on Scale
Browserbase	$0.12 after 100 included hours	15 min free, 6 h paid
Browserless	About $0.24 in overage (30-second units)	2 min free, 15 to 60 min paid
Bright Data Agent Browser	Billed per GB of traffic, not by time	60 min

What it takes to start, from the same pages:

Platform	Entry paid plan	Free to start
Browser Use Cloud	Pay as you go	$1 credit, once
Kernel	Hobbyist, $30/mo	$5 of credit a month
Anchor	Starter, $50/mo	5 credits a month
Cloudflare Browser Run	Workers Paid, $5/mo minimum	10 min a day
Hyperbrowser	Startup, $30/mo	5,000 credits ($5)
Steel	Scale, $250/mo plus usage	$30 credit, once
Browserbase	Developer, $20/mo	1 h
Browserless	Prototyping, $35/mo	1,000 units
Bright Data Agent Browser	Not verified	About 1 GB a month

Three things the per-hour column hides. Proxy bandwidth is billed separately almost everywhere, and on Browser Use it's on by default, so on image-heavy pages the gigabytes can cost more than the hours. Kernel bills per GB-second and charges nothing for idle time or proxies, which flatters agents that sit waiting. And session caps decide more than price: 15 minutes is plenty for a scrape and useless for an agent that logs in and works through a queue.

Cloudflare Browser Run (renamed from Browser Rendering) is the easiest place to start, because its free tier renews every day instead of running out. The free tier when we re-checked: 3 concurrent browsers, one new browser every 20 seconds, 10 minutes of browser time per day, 5 crawl jobs, 100 pages per crawl. Paid now goes to 200 concurrent and three new browsers per second, up from 120 and one in August. Sessions idle out at 60 seconds unless you extend them, now to as long as 20 minutes, with keep_alive. If what you want is a headless browser API rather than a browser, its Quick Actions return markdown, screenshots, PDFs, links, scraped elements, structured JSON or a whole crawl from one HTTP request, with no code deployed.

Steel is the one to look at if you want the managed feature set without the lock-in. Apache-2.0, self-hostable with Docker, built on Chrome with Puppeteer and CDP, and you connect to it from Puppeteer, Playwright or Selenium. It adds the things you'd otherwise build: session state across requests, proxy rotation, stealth plugins, extension loading, and conversion to markdown or PDF. Hosted, it's $0.10 an hour pay as you go, but the next paid step is the $250-a-month Scale plan, with nothing in between.

Browserless does much the same and has been around longer, but read the licence first. It's SSPL-1.0 or commercial, and the repository is direct about it: closed-source commercial use, or a closed-source CI system, means buying a licence. Its cloud bills in 30-second units, which works out at about $0.24 an hour in overage, the highest rate here.

Browserbase is the commercial cloud a lot of agent tooling defaults to, partly because it also publishes Stagehand. $20 a month buys 100 browser-hours, then $0.12 an hour, and paid sessions run up to six hours against 15 minutes on the free plan.

Browser Use Cloud is the cheapest per hour by some distance, at $0.02 with stealth and CAPTCHA solving included. The catch is the residential proxy, on by default at $5 per GB.

Kernel bills per GB-second, doesn't charge for idle time or proxies, and lets an idle browser wait in standby for up to 72 hours. The images behind its hosted service are published under Apache-2.0.

Hyperbrowser and Anchor sit in the middle on price. Anchor puts no upper limit on session length, but its docs and its pricing page disagreed on the hourly rate when we checked, $0.05 against $0.09, so ask before you budget.

Bright Data's Agent Browser, which its docs call Browser API, bills on traffic rather than time, with unlimited concurrent sessions and a 60-minute session cap. Its pricing page wouldn't load for us on October 29, so we haven't put a per-GB number on it.

Layer 4: the agent framework

Only add this layer if you need it, and you need it less often than the marketing suggests. If you know the steps in advance, write the steps. A driver executing a known sequence is faster, cheaper and far more predictable than a model working it out on every run.

Browser Use is the biggest of these by a distance: MIT, about 119,000 stars on October 29, Python and now TypeScript, and it drives Chrome over CDP through its own library rather than through Playwright. Its README used to claim first place on the Odysseys leaderboard at 87.4%. That line came out on September 9, 2026, and the headline number now is 90.5% on Stealth Bench V2, which scores Browser Use's cloud browsers rather than the agent. You'll also see 89.1% on WebVoyager quoted around the web. That comes from Browser Use's own December 2024 post, across 586 tasks: self-reported, older, and never in the README. The same team released jev-ultrafast in September, an MIT agent whose README shows a Zürich to London Google Flights search in 7.1 seconds.

Stagehand comes from Browserbase, is MIT, and splits the work sensibly. Version 4 lists three AI primitives: act() for a single step, extract() for structured data and observe() for reading state, with the multi-step agent() documented under v3. The pitch is that you use natural language only where the page is unpredictable and normal code everywhere else, which matches how these projects actually go.

Licences that restrict commercial use

This field contains four different licences with different consequences, and none of the roundups we read for this update names them.

Tool	Licence	What it means for commercial use
Playwright	Apache-2.0	Use freely
Puppeteer	Apache-2.0	Use freely
Vercel agent-browser	Apache-2.0	Use freely
Obscura	Apache-2.0	Use freely
Steel	Apache-2.0	Use freely, including self-hosted
Browser Use	MIT	Use freely
Stagehand	MIT	Use freely
Lightpanda	AGPL-3.0	Strong copyleft. Expect legal review before it goes near a networked product
Browserless	SSPL-1.0 or commercial	Closed-source commercial or CI use requires a purchased licence
Cloudflare Kitesurf	Not open source yet	Only usable through Cloudflare Browser Run

If you're a small team shipping a closed-source product, that table probably decides more than any benchmark on this page. And Lightpanda, the engine with the strongest cost case on this page, is one of the two that need a licensing conversation.

How to choose

Five questions, in this order.

Do you need a browser session at all? If the job is a screenshot, a PDF or a page as markdown, one HTTP call to an endpoint like Cloudflare's Quick Actions is cheaper and simpler than holding a browser open.

Do you know the steps in advance? If yes, skip layer 4 entirely. Playwright plus your own code. Most "agent" browser projects are really scheduled automation with a model bolted on for no reason.

Is your bill dominated by tokens or by servers? Tokens point at layer 2: something that returns an accessibility tree instead of screenshots, like Vercel's agent-browser. Servers point at layer 1: the memory profile of Lightpanda or Obscura is the single biggest lever available, if your targets work under it. If the servers aren't yours, compare the per-hour prices above at your real session length, not the headline rate.

Does the site want you there? Your own app, or a partner's API, means you can ignore the stealth question. Sites actively defending against automation are a different project, and closer to CloakBrowser territory than to anything on this page.

Do agents need to share a logged-in session? This gets underestimated and breaks things late. One set of credentials with several agents working in parallel needs isolation, or they'll trample each other's state. ego-lite exists specifically for that, and layer 3 platforms with session persistence handle a gentler version of it.

Where we're coming from

We've been writing up this landscape as it moved, and the dates are checkable: Scrapling in February, OpenSandbox and Lightpanda in March, CloakBrowser and Webwright in May, ego-lite in July, jev-ultrafast in September.

This note was written against generic queries rather than product names, which was deliberate. We published what it earned, alongside six months of data on everything else here.

If you're picking this stack for something commercial and would rather talk it through than read another list, that's what we do.

Words worth knowing

Headless browser – a browser with no window. It loads pages and runs their JavaScript exactly like Chrome does, just invisibly, for automated work.

Cloud browser – a headless browser someone else runs for you, rented by the hour. Also sold as "browser as a service" or a "headless browser API".

Browser-hour – one browser open for one hour. The unit most cloud browser prices are quoted in.

CDP (Chrome DevTools Protocol) – the low-level language for telling a browser what to do. Playwright, Puppeteer and most of the tools here are wrappers around it.

Accessibility tree – the structured description of a page that screen readers use. It lists the things you can actually interact with, which makes it much cheaper to send to a model than a screenshot or raw HTML.

AGPL-3.0 – an open-source licence that can require you to publish your own source code if you offer the software over a network.

SSPL-1.0 – a licence written to stop cloud providers reselling a product as a service. In practice it pushes most closed-source commercial users toward a paid licence.

Concurrency limit – how many browsers you're allowed to run at once. The number that decides whether a platform fits, and the one people check last.