Best free agent browsers (2026)

Last updated: August 2026. Pricing and limits taken from each vendor's live pricing page and docs.

TL;DR

Agent browsers are the browser layer AI agents use to actually do things on the web — log in, click, fill forms, extract data, scroll past bot walls. The category has split into two halves: managed cloud platforms that give you a browser over an API (most with a standing free tier), and open-source frameworks and infra you can run yourself for the cost of a machine and an LLM key.

The short version: Kernel leads for teams that need production-grade session creation, the widest set of features reachable without a subscription (profiles, managed auth, file I/O, extensions, replays, stealth), and open-source infra they can inspect or self-host. Browser Use is the strongest OSS agent framework and also sells a competing managed browser. Browserbase, Steel, Anchor, and Hyperbrowser round out the managed options worth free-tier testing before you commit.

One thing this post deliberately leaves out: agent frameworks that don't run a browser. Stagehand, Skyvern, and the like are clients — they need one of the browsers below underneath them — so they aren't compared here on latency or free-tier limits, because there's nothing of their own to measure.

Below: what an "agent browser" actually is, the five dimensions that matter, and a per-vendor breakdown of the six worth trying.

What is an agent browser?

An agent browser is a headless (or headful) Chromium instance built specifically for AI agents to drive — as opposed to a human clicking around, or a legacy scraper firing selectors. It typically ships with:

• A remote endpoint (CDP WebSocket, REST API, or SDK) so an agent process on another machine can control it
• Anti-bot handling — fingerprint randomization, residential proxies, CAPTCHA solving
• Session state — cookies and profiles that persist across runs, so agents don't re-log-in every task
• Observability — live view, replays, and network/console logs so you can debug what the agent actually did

Traditional automation tools (Playwright, Puppeteer) are the client library. Agent browsers are the browser on the other end of that connection, hardened for agent workloads.

How agent browsers differ

Five dimensions do most of the work when you're picking one:

1. Cold start latency. Agents open a lot of browsers, so spin-up time is a tax on every task. Measure it in two parts, because vendors quote whichever one flatters them: the session create call (control plane) and the end-to-end cycle of create → connect over CDP → load a page → release. Sub-second end-to-end is table stakes for production; the fastest create calls are now in the tens of milliseconds.
2. Free tier and pricing model. Managed platforms bill by browser-hour, browser-minute, GB-second, or credits. What's included at $0 varies wildly — from 1 concurrent browser to 5, and from $1 in credits to $10.
3. Stealth. Whether fingerprint randomization, CAPTCHA handling, and configurable residential proxies are on by default, gated to paid tiers, or bring-your-own. These are three separate things and vendors gate them separately.
4. Framework support. Playwright, Puppeteer, CDP, WebDriver BiDi, computer-use models, and the agent frameworks that sit on top (Browser Use, Stagehand). More surface area = fewer rewrites later.
5. Deployment model. Managed SaaS, self-hostable OSS, or both. Self-hosting matters for regulated data, network egress control, or squeezing per-run cost.

The latency numbers in this post

Every latency figure below comes from browserbench, an open-source benchmark tool published by Steel — one of the vendors compared here — which runs an identical four-step lifecycle against each provider. The published dataset is 5,000 runs per provider from AWS us-east-1, recorded January 10–11, 2026, first page google.com. It is the most recent public multi-vendor run we're aware of; anything measured seven months ago deserves a re-run before you make a decision on it.

1. Kernel: Open-source agent browser infra with the most generous free tier

What it is. Kernel is browser infrastructure purpose-built for AI agents. It runs sandboxed Chromium behind a serverless app platform and colocates the browser with your agent code to minimize round-trip latency. The infra is open source, and the managed cloud has a generous free plan for developers to quickly try Kernel's features.

Known for.

• ~37ms average session creation (34ms median) and 794ms end-to-end in the benchmark above — 5.8× faster than Browserbase on the create call and 3.7× faster end-to-end
• The most-used features reachable without a subscription — browser profiles, managed auth, file I/O, custom extensions, replays, and stealth mode are all on the free plan, with caps rather than paywalls
• Standby and idle billing — you pay for browser time, not for a session sitting idle
• Framework-agnostic — Playwright, CDP (so Puppeteer works too), WebDriver BiDi, and computer-use models, plus Browser Use and Stagehand on top
• Managed auth — credential storage for agent workflows, included on every plan with no per-connection fee
• Stealth mode - unlike other providers, Kernel includes stealth features like ISP proxies and automatic captcha solving in the free plan

Commonly used for. Production agent fleets that need low-latency browser spin-up at scale; scraping and extraction workloads where stealth matters; internal automations where teams want an audit trail via live view and replays; anything where cold-start tax adds up across thousands of runs.

Worth noting. The free plan is $0/month plus usage, with $5 in monthly credits, 5 concurrent browsers, and 5 concurrent app invocations — enough for prototyping and small production workloads. The free-tier features carry caps: 3 managed auth connections, 1 custom extension, 1-day replay retention, 1 project. Configurable proxies (residential, ISP, datacenter, and bring-your-own) and GPU acceleration require a paid plan. Paid tiers are Hobbyist at $30/month (10 concurrent browsers, $10 credits, unlimited managed auth connections, 7-day replays) and Start-Up at $200/month (150 concurrent browsers, $50 credits, unlimited extensions, 30-day replays, GPU). Usage is billed per GB-second, with no charge for idle time or proxy bandwidth.

2. Browser Use: Open-source agent framework, plus a managed browser cloud

What it is. Browser Use ships two things, and it's worth keeping them straight. The SDK is an open-source Python framework that lets an LLM drive a browser through an agent loop rather than raw selectors: you hand it a task and a model — Agent(task=..., llm=...) — and it plans the clicks and typing itself. It talks to Chromium directly over the Chrome DevTools Protocol, so it runs against any CDP endpoint, local or cloud, including every managed platform in this post. Browser Use Cloud is a separate, paid product that hosts the browsers, and it competes with the other managed platforms here.

Known for.

• ~109k GitHub stars — the most-adopted OSS browser-agent framework
• Strong showing on the WebVoyager benchmark relative to other OSS agents
• First-party model integrations for Anthropic, OpenAI, Google and others, swappable without rewriting the agent
• Multi-tab support and semantic webpage understanding built in

Commonly used for. Prototyping agents that navigate diverse, unpredictable sites; research and evaluation work; teams that want to own the agent loop and only pay for LLM tokens.

Worth noting. The SDK is MIT-licensed and free forever — run it against your own Chromium and you pay nothing but tokens. The cloud is where the free-tier comparison applies: 10 agent tasks/month with 3 concurrent sessions, browsers at $0.02/browser-hour, and monthly plans from $29. Either way, runtime cost is dominated by LLM calls, not browser time.

3. Steel: Open-source browser API with a managed cloud

What it is. Steel is an open-source browser API for AI agents, available as a self-hostable Docker image or a managed cloud service. It leans into long-running, authenticated sessions — persistent cookies, automatic sign-in, session replay.

Known for.

• True self-host option — Apache-2.0 licensed, runs in your VPC
• Persistent profiles and stateful workflows built in
• REST API + WebSocket CDP + Puppeteer/Playwright SDKs
• Second-fastest end-to-end in the benchmark above, at 894ms
• Session replay and observability tools included

Commonly used for. Agents that need to stay logged into services across many runs (SaaS admin panels, dashboards, portals); workflows where compliance requires the browser to run inside your network.

Worth noting. Self-hosted is free; you pay for the box. The managed cloud's free tier includes $10 in monthly credits, 100 browser hours, 2 concurrent sessions, and basic CAPTCHA and proxy support, with a 15-minute cap per session. Paid plans start at $29/month.

4. Browserbase: The legacy managed platform

What it is. Browserbase is a managed cloud browser service with a large ecosystem — Stagehand integration, session recordings, and Playwright/Puppeteer/Selenium compatibility.

Known for.

• Tight integration with Stagehand (same team)
• A bundled platform beyond browsers — Search, Fetch, Runtime, Model Gateway
• Session observability and network capture built in

Commonly used for. Teams migrating existing Playwright automation to the cloud; anyone standardizing on Stagehand who wants a "batteries-included" default; production agents where ecosystem maturity matters more than per-second pricing.

Worth noting. The free plan is a standing tier, not a trial: 3 concurrent browsers, 1 browser hour, 3 agent runs, 1,000 search and 1,000 fetch calls, 7-day data retention, and $5 in model tokens. Stealth mode and proxies start on the $20/month Developer plan; captcha solving does too. Browser time is billed by the minute with a one-minute minimum per session, so short tasks still cost a full minute — watch this if you run many short runs. End-to-end latency measured ~3.0s in the benchmark above.

5. Anchor Browser: MCP-native browser for agents

What it is. Anchor is a managed agent browser built around a custom Chromium fork ("Anchor Fingerprint") with native Model Context Protocol (MCP) support — so Claude, Cursor, and other MCP clients can drive it without a wrapper SDK.

Known for.

• Native MCP server for direct LLM control
• Custom Chromium fingerprint for stealth
• Session persistence and proxy rotation included

Commonly used for. Agents driven directly from an MCP-capable model or IDE; workflows where minimizing the code between LLM and browser matters; multi-account automations where stealth is the primary requirement.

Worth noting. The free tier is $5 in monthly credits with 5 concurrent sessions. Starter is $50/month with 25 concurrent sessions; Growth is $2,000/month with 200. Usage is metered per resource: $0.01 per browser creation, $0.05 per browser-hour, $8/GB of proxy data, and $0.01 per AI step. It was the slowest of the five managed providers in the benchmark above — 3.8s to create a session, 8.0s end-to-end — and the only one that didn't complete every run.

6. Hyperbrowser: Straightforward managed cloud, thin free tier

What it is. Hyperbrowser is a managed cloud browser platform positioned as a lighter, faster alternative to older browser-as-a-service providers, with a credit-based pricing model and a straightforward API.

Known for.

• Simple credit accounting — 1 credit = $0.001, and a browser hour is 100 credits ($0.10)
• Playwright and Puppeteer compatible
• Stealth and CAPTCHA handling available

Commonly used for. Teams evaluating managed browser services without a sales call; smaller-scale agent workloads that fit within paid-tier limits.

Worth noting. The free tier is the thinnest of the managed options here — 1,000 credits ($1) and 1 concurrent browser — so it's a look, not a build. Paid plans are Startup at $30/month (30,000 credits, 25 concurrent browsers, 30-day retention) and Scale at $100/month (100,000 credits, 100 concurrent browsers, advanced stealth). It also measured slower than Kernel, Steel, and Browserbase in the benchmark above, at 1.7s to create a session and 3.7s end-to-end. Verify latency for your workload before scaling.

Comparison table

Latency columns are the benchmark averages described above (January 2026, 5,000 runs per provider). Pricing as of August 2026.

Matching agent browsers to use cases

• You're building a production agent that spins up many short-lived browsers. Create latency compounds. Start with Kernel.
• You want to own the agent loop and only pay for tokens. Use the Browser Use SDK (or another framework, like Stagehand) against self-hosted Chromium or a managed browser under the hood.
• You need the browser inside your VPC for compliance. Steel self-hosted, or Kernel's enterprise deployment.
• You're already deep in Playwright and want a managed drop-in. Browserbase or Kernel — both are CDP-compatible with minimal code changes.
• Your agent is driven directly from an MCP client (Claude Desktop, Cursor). Anchor for native MCP; Kernel and Browserbase via their MCP servers.
• You're prototyping and don't want to talk to sales. Kernel or Steel have the most workable free tiers; both give you real concurrency.
• Stealth is the primary requirement. Kernel (stealth mode on the free plan) or Anchor (custom Chromium fingerprint).

FAQs

What's the difference between an agent browser and Playwright?
Playwright is a client library — it speaks to a browser over CDP. An agent browser is the browser on the other end, packaged for agent workloads with anti-bot handling, session state, observability, and remote endpoints. You typically use both: Playwright (or Stagehand, or Browser Use) as the client, and an agent browser as the runtime.

Can I run agents locally without any of these?
Yes — install Playwright, launch Chromium, drive it from any LLM. You'll rebuild the stealth, session management, replay, and scaling pieces yourself. Fine for prototypes; painful in production. Open-source infra (Kernel, Steel, Browser Use) exists so you don't have to.

Which is genuinely free forever?
The OSS options — the Browser Use SDK, Steel (self-hosted), and Kernel's open-source infra — are free to run forever; you pay only for the machine and LLM calls. Managed free tiers (Kernel, Browser Use Cloud, Steel cloud, Anchor, Hyperbrowser, Browserbase) are meaningful for prototyping and small production workloads but have usage or concurrency caps.

Do I need residential proxies and stealth?
Depends on the sites. Public documentation sites, most SaaS apps you're authenticated into, and your own products — no. Consumer sites with active bot detection (airlines, ticketing, e-commerce, social) — yes. Test without stealth first; add it when you hit walls. Note that fingerprint-level stealth and configurable residential proxies are usually gated separately, so check both.

How much does an agent browser actually cost in production?
Two components: browser time and LLM tokens. LLM tokens usually dominate. Browser time lands in the $0.02–$0.12 per browser-hour range across the managed providers here, so a task that finishes in a minute costs a fraction of a cent in browser time and cents to tens of cents in tokens. Standby and idle-billing policies matter more than the headline rate if your sessions sit open — as do per-session billing minimums.

Is this list going to change?
Yes. The category is moving fast — new entrants, pricing changes, and new capabilities (like computer-use models) land every few months. Bookmark the vendors' pricing pages and re-check quarterly if you're picking one for the long haul.