Hosted web agents and CDP-compatible stealth browsers for AI automation teams
Browser Use is a web agent and remote browser platform for developers who automate websites with AI agents.
AI Panel Score
6 AI reviews
Reviewed
Browser Use is a web agent and remote browser platform for AI startups, agent builders and browser-automation teams. Browser Use Agents take a plain-English task, run it in a managed stealth browser and return the result, while Browser Infrastructure gives your own code remote Chromium sessions over CDP, REST or SDKs. Pricing is usage-based with no subscription: eligible signups get a one-time $15 credit, top-ups start at $5 and never expire, browsers cost $0.02 per browser-hour plus proxy traffic, and agent runs add the model's token rate plus a 20% fee. Capabilities include automatic CAPTCHA solving, residential proxies in 195+ countries, persistent login profiles and human takeover for logins. TopReviewed's six-seat AI review panel scored it 8.2/10, praising pay-as-you-go credits that never expire while noting charges beyond browser time, such as $5-per-GB residential proxy traffic that is on by default. It fits teams moving Playwright scripts to cloud browsers. Browser Use publishes comparisons with Browserbase, Steel, Hyperbrowser and Anchor.
Browser Use sells two things from one prepaid credit balance. With Browser Use Agents you post a natural-language task to the V4 API or start it from the cloud dashboard, pick a model, and an agent drives a real browser through the clicking, scrolling, logins and retries until it returns the result as text, which can be requested as JSON and validated in your own code, with a webhook when the run finishes. Follow-up turns continue in the same browser context, workspaces hold input and output files, a person can take over for logins, approvals or payments, and V4 agents can run on a schedule to watch a page for changes. With Browser Infrastructure you skip the agent: one POST starts a remote Chromium session, and the returned CDP URL plugs into existing Playwright or Puppeteer scripts without a rewrite.
Every cloud session runs on Browser Use's own hardened Chromium fork with stealth on by default, per-session fingerprint randomization drawn from macOS, Windows and Linux sets, automatic CAPTCHA solving, and managed residential proxies in 195+ countries with per-session country selection or your own proxy. Persistent profiles keep cookies, localStorage and login state, and a local-to-cloud sync copies selected cookies from a real Chrome into a cloud profile. Each session exposes a live URL that can be embedded for human review, and recording can be switched on for debugging. Secrets can be passed as sensitive-data placeholders the model never sees, logins and 2FA codes can come from a 1Password vault, and allowed and prohibited domain lists fence a session in. On Browser Use's own 71-site stealth benchmark its browsers reached 81% of protected sites against 77% for Anchor, the next provider, and on its 106-task Internal Bench Hard the agent solved 82% of tasks at $0.17 per solved task.
It is aimed at AI startups, agent builders and browser-automation teams. Hermes Agent ships it as its default browser driver, and Browser Harness plus an MCP server give coding agents such as Claude Code, Codex, Gemini CLI and Cursor a real browser. Pricing is usage-based with no subscription: eligible Google, GitHub or Microsoft signups get a one-time $15 credit, top-ups start at $5 and never expire, browsers cost $0.02 per browser-hour billed by the minute plus $5/GB for residential proxy traffic, and agent runs add the chosen model's token rate plus a 20% service fee on top of browser time. Concurrency starts at 10 sessions and rises to 1,000 with lifetime spend, while Enterprise agreements add custom concurrency, SLAs, HIPAA support and zero data retention. Browser Use publishes side-by-side comparisons with Browserbase, Steel, Hyperbrowser and Anchor.
Agents are driven through API V4 with Python and TypeScript SDKs, a REST API described by an OpenAPI 3.1 spec, webhooks, and integrations with n8n, OpenClaw and Hermes Agent; with a bring-your-own model key on eligible plans, the provider bills the tokens and Browser Use charges 20% of the published token rates. The open-source browser-use library (pip install browser-use) runs the agent loop locally against a local or cloud browser, and BU 2.0, a model built for web agents, can be called directly at $0.60 per 1M input tokens. Browser Use holds SOC 2 Type II and signs a DPA with EU Standard Contractual Clauses.
Purpose-built model for web agents that can be called directly through its own model API, including from open-source agents.
Runs agents on hosted models such as Claude Opus 5, Claude Sonnet 5, GPT-5.6, Gemini 3.6 Flash and Grok 4.5, with GPT-5.6 Luna as the default, or on your own provider key on eligible plans.
Takes a task written in plain English, runs it in a managed stealth browser and handles the clicking, scrolling, logins and retries until it returns the completed work.
Streams each session to a live URL that can be embedded for monitoring or takeover, and can record the browser as an MP4 for debugging and audit; recording is off by default for API runs.
Solves CAPTCHAs inside every cloud browser without a separate solver service or add-on charge.
Lets a person step into a running agent session to handle authentication, approvals, payments or review.
Puts V4 agents on a schedule with pause and resume controls, so a page described in one sentence can be watched and reported on when it changes.
Covers SOC 2 Type II and a signed DPA with EU Standard Contractual Clauses, and adds HIPAA support, zero or custom data retention and EU data residency on request under enterprise agreements.
Continues follow-up turns in the same browser context and keeps input and output files in persistent workspaces.
MIT-licensed Python framework, installed with pip install browser-use, for building and running browser agents locally with custom tools, configurable prompts and output schemas, and an optional connection to cloud browsers.
Saves cookies, localStorage and login state in reusable browser profiles and copies selected cookies from a local Chrome into a cloud profile.
Routes sessions through managed residential proxies with a country picked per session, or through a direct connection or your own proxy.
Returns the agent's result as text that can be requested as JSON and validated in your own code, with webhook callbacks when a run finishes.
Gives Claude Code, Codex, Gemini CLI, Cursor, Hermes Agent and OpenClaw browser control over CDP with accessibility-tree targeting, using the developer's own logged-in Chrome or cloud stealth browsers.
Starts a managed Chromium session with one API call and returns a CDP URL that existing Playwright or Puppeteer scripts connect to without a rewrite.
Exposes agents and browsers through Python and TypeScript SDKs, a REST API with an OpenAPI 3.1 spec, webhooks, an MCP server and integrations with n8n, OpenClaw and Hermes Agent.
Passes secrets as sensitive_data placeholders the model never sees, fills usernames, passwords and 2FA codes from a 1Password vault, and limits a session with allowed and prohibited domain lists.
Runs every cloud session on a hardened Chromium fork with stealth on by default and per-session canvas, WebGL, font and navigator fingerprints drawn from macOS, Windows and Linux sets.
One-time $1 free credit for eligible new signups via Google, GitHub, or Microsoft (no card required); for trying Browser Use before paying
No subscriptions, no plans, no commitment — buy credits that never expire and pay only for what you use; the core pricing model for solo developers through enterprises
For enterprises needing custom compliance, data policies, and support, on the same pay-per-use pricing
Credits-based browser infrastructure with built-in stealth, proxies and CAPTCHA solving, priced by the minute.
“Browser Use sells both the agent and the raw CDP pipe off one credit balance. Pricing is granular and usage-based, which is refreshing, but the add-on costs stack fast.”
Two products, one wallet. Browser Use Agents handles the plain-English task end to end; Browser Infrastructure just hands you a CDP URL for your existing Playwright script. That split is the right call — teams that already have automation code don't want a rewrite forced on them.
$0.02 per browser-hour sounds cheap until you add $5/GB residential proxy traffic and a 20% fee on top of model tokens. On their own 106-task benchmark they claim 82% solved at $0.17 per task, against Anchor at 77% on a 71-site stealth test. Self-reported numbers, worth a pilot before you believe them.
SOC 2 Type II and a signed DPA with EU clauses cover the compliance basics; HIPAA and zero retention are enterprise-only add-ons. Credits never expire, concurrency scales to 1,000 sessions with spend, and the open-source browser-use library gives you an exit if the hosted side doesn't work out.
Its own benchmark claims 81% success on protected sites against 77% for Anchor, the only named rival in its comparisons.
SOC 2 Type II and SCC-backed DPA cover the basics, but per-session proxy and token fees make cost predictability a contract question worth pinning down.
One POST gets a CDP URL into an existing Playwright script with no rewrite, and a $1 free credit lets you test before paying.
Fits teams already writing browser automation or agent code, not a bolt-on for teams without that workload.
V4 API, OpenAPI 3.1 spec, open-source library and a documented model (BU 2.0) point to active, multi-layered build-out.
Teams already running agent or browser-automation code who want stealth, proxies and CAPTCHA solving handled for them.
Skip it if your workload is light and the per-GB proxy and token fees would erase the hourly savings.
Solid CDP exit ramp on day one, but the three-year question is what BU 2.0 and the agent layer do to your portability.
“Two products in one credit balance: a pure CDP browser rental that slots into existing Playwright code with zero rewrite, and an agent layer with its own model, BU 2.0, that doesn't. The architecture is honest about the split, which is rare.”
The CDP-compatible session is the right call architecturally. One POST, a CDP URL, your Playwright or Puppeteer code doesn't change. That's a thin, swappable dependency — if Browser Use disappears, you repoint the URL and move on. Fingerprint randomization across macOS, Windows and Linux fleets is table-stakes engineering done properly, not a differentiator.
The agent layer is a different commitment. BU 2.0 is a purpose-built model callable directly at $0.60 per 1M input tokens, and the V4 API defaults to GPT-5.6 Luna with a 20% service fee on top of token cost on other models. That's a second vendor relationship stacked on the browser rental — fine if the agent loop earns its keep, a real tax if you'd rather orchestrate with your own framework.
The open-source browser-use library is the real hedge here: pip install, MIT license, run it against your own Chrome or their cloud. That's the exit path that makes the hosted bet lower-risk than it looks. SOC 2 Type II plus a signed DPA covers the compliance baseline; HIPAA and zero retention sit behind enterprise agreements, which is normal but worth pricing in early if you're regulated.
Publishes its own comparisons against Browserbase, Steel, Hyperbrowser and Anchor, which signals a crowded lane it's betting on self-reported benchmarks to win.
CDP compatibility means teams with existing Playwright/Puppeteer pipelines adopt without a rewrite, which matches how automation teams actually ship.
Python/TypeScript SDKs, REST, CDP, an MCP server and OpenAPI 3.1 spec cover the integration surface most agent teams need.
The MIT-licensed browser-use library gives a credible exit from the hosted plan; the BU 2.0 model and 20% token fee are the parts that lock you in.
A purpose-built model (BU 2.0) plus a hardened Chromium fork is real engineering investment, not a wrapper on someone else's browser.
Teams who already run Playwright or Puppeteer pipelines and want a drop-in stealth CDP backend without re-architecting their automation code.
Avoid if you need HIPAA-grade data handling out of the box without a separate enterprise negotiation.
$0.02/hour is the entry fee, not the invoice. Proxies and tokens do the real billing.
“No subscription, no sales call to see the meter. But three cost lines — browser time, proxy GB, model tokens plus 20% — make forecasting harder than the headline rate suggests.”
No tiers to decode. Pay as you go is the plan: $0.02/browser-hour, billed by the minute, credits that never expire. Procurement likes that — no renewal clause to negotiate, no annual commit.
But TCO math needs three inputs, not one. Browser time at $0.02/hour is noise. Residential proxy traffic at $5/GB, or $0.20/GB on your own proxy, is where volume users land. Add the 20% service fee on hosted model tokens for agent runs. A team running 50 concurrent sessions needs lifetime spend tracked just to unlock that concurrency tier — scaling cost is structural, not a sales conversation.
Enterprise pricing is quote-only, which is fair at that tier — HIPAA, custom SLAs, zero retention belong behind a contract. ROI is at least measurable: $0.17 per solved task on their own benchmark gives you a unit cost to compare against labor hours saved. Self-published number, use it as a starting estimate, not gospel.
Credit-based billing with card signup needs no procurement cycle at the pay-as-you-go tier; Enterprise reintroduces a sales process for SLAs and DPAs.
No subscription, no term, credits that never expire — about as low-friction as billing gets outside Enterprise agreements.
Per-unit rates for browser-hours, proxy GB and the 20% token fee are all published; only Enterprise is quote-only.
The $0.17-per-solved-task figure gives a usable unit-cost baseline, though it's self-published on their own Internal Bench Hard set.
Headline $0.02/hour is cheap but proxy GB and model token fees stack on top, making a real monthly bill hard to predict from the rate card alone.
Teams who want metered, invoice-free billing and can model proxy and token usage themselves.
Avoid if you need a fixed monthly number for budgeting without modeling proxy and token variance first.
A CDP URL that drops straight into existing Playwright scripts without a rewrite is the real feature here
“Browser Use ships a sane integration surface: OpenAPI 3.1, Python/TypeScript SDKs, an MCP server, and a Browser Harness for Claude Code and Cursor. The agent loop is the headline, but the plumbing underneath is what determines whether it survives week two.”
The thing I'd actually test first isn't the natural-language agent, it's whether `browser-use` locally matches the hosted V4 API closely enough that debugging one teaches you the other. MIT-licensed, pip-installable, and it's the fallback if the credit model stops making sense for a given workload. That's a real exit ramp, not a marketing line.
Workflow fit is good on paper: Browser Harness gives Claude Code and Cursor accessibility-tree browser control over CDP, and n8n/OpenClaw hooks mean you're not writing glue code from scratch. Webhooks on run completion beat polling.
My worry is the sensitive-data placeholder system and 1Password vault integration — solid security design, but it's a new mental model for secrets vs. however your team already manages env vars and vaults. Allowed/prohibited domain lists help, but that's one more config surface to maintain alongside your actual automation logic. Fine tradeoff for the stealth capability you get back.
Live session URLs and MP4 recording give real debugging surface once the demo task stops working.
An OpenAPI 3.1 spec plus a changelog page suggests docs built for people actually calling the API, not just a sales deck.
Sensitive-data placeholders and domain allow-lists are solid security but add config steps most teams haven't standardized on yet.
Scheduled agents, persistent profiles and a BYO model key path give room to grow past the basic plain-English task call.
CDP URL plugs into existing Playwright/Puppeteer code, and Browser Harness wires into Claude Code, Cursor and Codex directly.
Teams already scripting Playwright or Puppeteer who want stealth and CAPTCHA handling without swapping their existing test code.
Skip it if your team needs a single predictable line-item cost rather than three metered variables to reconcile monthly.
A developer tool, not an app, which is exactly the point and exactly the catch
“Browser Use is built for code, not for humans clicking around, so judging it on 'feel' is a little unfair to it. But the parts a person does touch — the live session view, the dashboard — matter more than the vendor seems to think.”
There's no mobile app here and honestly there shouldn't be. This is SDK and REST territory, Python and TypeScript, CDP URLs you paste into scripts you already wrote. Judging it for mobile parity is like judging a wrench for not being a phone. Fine by me.
Where it gets interesting is the live session URL you can embed to watch an agent click around, or jump in yourself for a login or a payment approval. That's the one piece of this product a human actually watches happen in real time, and it's also the part most likely to feel unfinished three months in — does the recording toggle survive a page refresh, does the takeover handoff feel smooth under load, I can't tell from a spec sheet.
Onboarding is a one-time $15 credit for Google, GitHub or Microsoft signups (email/password users are left out, which is a weird gate), then straight into $0.02-per-browser-hour billing. Clear money math, but the real onboarding is reading docs, not clicking a wizard. For the audience it's built for, that's fine.
Live view, MP4 recording and webhook callbacks show attention, but polish lives in docs and dashboards, not a crafted UI.
An OpenAPI 3.1 spec and a local pip-installable library mean you can prototype before paying, easing the ramp from hour one to month three.
Platforms list web only; this is an SDK/REST/CDP product built for code, so mobile isn't the point, but there's no mobile dashboard story either.
A $15 starter credit via Google/GitHub/Microsoft gets you running fast, though email/password signups are excluded from it.
Webhooks, persistent workspaces and human takeover for logins suggest real thought went into what happens when a run stalls.
Developers wiring AI agents into browser automation who live in SDKs and don't need a mobile view.
Avoid if you want a polished no-code dashboard experience rather than an API-first developer tool.
Own benchmark, own comparison page, own definition of winning.
“Browser Use publishes a 71-site stealth test where it beats Anchor and a 106-task benchmark where it solves 82% at $0.17 a task. Self-published numbers from the vendor running the test it designed — useful anchors, not proof.”
Anchor shows up twice here: once as a named competitor Browser Use claims to beat on stealth rate, once in the side-by-side comparisons the company itself publishes against Browserbase, Steel and Hyperbrowser. Writing your own comparison page against four rivals is a flag I'd watch, not ignore. Could be confident positioning. Could be picking the metrics that flatter you.
The open-source browser-use library is the real differentiator — MIT-licensed, pip-installable, runs the agent loop without the credit system. That's a legitimate exit path most hosted browser platforms don't offer.
SOC 2 Type II and a signed DPA are concrete. BU 2.0 as a proprietary model you can only reach through their API is the opposite direction — a second lock-in sitting right next to the exit ramp. Fair trade for some teams, worth noticing for others.
Publishing comparison pages against Browserbase, Steel, Hyperbrowser and Anchor says the lane is crowded even if the pitch is confident.
The MIT-licensed browser-use library and CDP-standard sessions mean you're not locked into a proprietary SDK shape.
A V4 API, a changelog, an OpenAPI 3.1 spec and a dedicated model (BU 2.0) point to active, funded engineering work, not a side project.
The 82%-at-$0.17 headline is specific, but it's drawn from an internal benchmark named Internal Bench Hard — graded on their own curriculum.
CAPTCHA solving, 195+ country proxies and stealth fingerprinting are named and priced, but the stealth-rate win over Anchor is self-measured, not third-party audited.
Teams that want CDP-standard browser infrastructure with a credible open-source fallback if the hosted layer ever changes terms.
You want independently verified stealth or task-success numbers before trusting a vendor's own benchmark.
Common questions answered by our AI research team
Browser hosting costs $0.02 per hour, billed in whole minutes with a 1-minute minimum.
High-quality residential proxies cost $5/GB and are on by default, routing traffic through another IP. Using your own direct proxy instead drops the rate to $0.20/GB.
Browser Infrastructure offers a Python SDK and a TypeScript SDK, plus access via REST or CDP.
Yes. The MIT-licensed browser-use Python library can run browser agents on your own machine, separate from the managed cloud infrastructure.
Browser Use includes built-in CAPTCHA solving as part of its Browser Infrastructure, alongside residential proxies in 195+ countries and persistent login profiles.
Who Browser Use competes with, and how each one differs
Browserbase is the more commercially mature managed browser platform: founded by Paul Klein IV, it has raised $67.5M total (including a $40M Series B at a $300M valuation, June 2025) and serves 1,000+ companies; its Stagehand SDK layers AI primitives (act/extract/observe) on Playwright rather than shipping a first-party agent like Browser Use does.
Bright Data's Agent Browser is serverless cloud-browser infrastructure built on its own residential-proxy and anti-bot network (400M+ IPs across 195 countries), competing with Browser Use's Browser Infrastructure at the managed-cloud-browser layer, though Bright Data's core business remains proxies and data extraction rather than an agent framework.
Steel.dev positions itself as the open-source, self-hostable alternative to managed cloud browsers — free to run on your own infrastructure — versus Browser Use's hosted-first, pay-per-browser-hour model.
Anchor targets enterprise authenticated workflows with deterministic (non-vision) automation, a 1Password-integrated auth layer, and a built-in VPN instead of third-party proxies; Browser Use's own August 2026 stealth benchmark placed Anchor second at a 77% bypass rate versus its own 81%.
Hyperbrowser bundles several hosted agent implementations with browser and web-data APIs under one credit-based pricing model, versus Browser Use's single first-party agent framework plus a separate browser-infrastructure product.
Company
Browser UseFounded
2024Pricing
Usage-basedFree Plan
Available
Browser Use is a San Francisco-based startup that builds an open-source AI agent framework and cloud browser infrastructure so AI agents can navigate and interact with websites.
