Browser Use

Visit Website

Introduction

Browser Use is an open-source library and a hosted browser-agent platform from the Browser Use project. The official GitHub repository is MIT-licensed. You can run the agent locally against Chrome, or send work to Browser Use’s cloud. Official pricing documentation (last verified 5 November 2026 on browser-use.com/pricing) states there is no subscription: the cloud charges for browser time and, separately, for the agent’s model usage, with concurrency limits that rise as you prepay.

It is a general browser agent, not a specialised test runner. Official pages do describe “AI agents for end-to-end QA” and contrast Browser Use with Playwright: Browser Use is for plain-English checks you may not keep as code, while Playwright remains the better home for a durable, deterministic regression suite. That distinction is important. Teams can use it to explore, smoke-check or automate a path in a real browser, including via MCP, but it does not replace assertions, fixtures and CI reports in a conventional test framework.

Features

1. MIT-licensed harness: The core library on GitHub is MIT. You can run it against a local Chrome with your own model keys. Official docs present the local path as free of Browser Use cloud charges.
2. Hosted browsers without a subscription: Official pricing lists $0.02 per browser-hour and no monthly plan fee. You pay for time the cloud browser is up.
3. Separate agent usage charge: Official pricing lists a median of $0.006 per task on the bu-ultrafast model. Other models and task lengths will differ; treat that figure as the vendor’s published median, not a guarantee.
4. Signup credit and a free concurrency tier: Official pricing documents a $1 one-time credit for eligible signups and 10 concurrent browsers at $0. Additional concurrency unlocks with total spend (for example $100 total paid unlocks 50 concurrent, $1,000 unlocks 250). See the current pricing.md for the full ladder; it can change.
5. MCP server: Browser Use documents MCP access so a coding agent can request browser tasks without embedding the library by hand.
6. Python package: Official install docs use uv add browser-use (or the equivalent pip/uv install of the published package) as the local getting-started path.
7. Proxies and CAPTCHA handling as paid options: Official pricing lists a home-IP proxy at $5/GB or a direct proxy at $0.20/GB, and states that CAPTCHA solving is included. Performance claims about stealth or CAPTCHA success are vendor-stated; measure them on your own sites.
8. Plain-language tasks: You describe a goal (“open the app, sign in, check that the invoice downloads”) and the agent operates the browser. That is the product, and also why it is less deterministic than a scripted test.
9. Usable for QA, not only for research: Official marketing includes end-to-end QA as a use case: fast, throwaway or exploratory checks in English, alongside scripted tests you keep.
10. Open development: The GitHub repository is public, so you can read releases, issues and how the agent loop is implemented.

Pros

1. You can start locally, for free: The MIT licence and local Chrome path mean a trial does not require a contract or a cloud invoice.
2. Simple cloud price shape: No subscription, a published browser-hour rate, and a published median task cost are easier to reason about than an opaque credit bundle — as long as you watch hours and model choice.
3. MCP is documented: Coding agents can drive a real browser through the official MCP path.
4. Good for checks you would not bother to script: Exploratory QA, a one-off production smoke, or a path that changes too often to be worth a Playwright test are the honest fit.
5. Concurrency scales with spend, not with seats: Official docs unlock more parallel browsers as total payment grows, which may suit bursty jobs.
6. Inspectable source: Because the harness is public, you can see what the agent sends to the model and how it acts on the page.

Cons

1. Not a test framework: There is no first-class suite model, reporter, flake quarantine or assertion library comparable to Playwright, Cypress or pytest. If you need a durable regression pack, official guidance points you back at scripted tests.
2. Non-deterministic runs: The same English instruction can take different clicks on different days. That is acceptable for exploration and risky as a merge gate.
3. Cloud cost has several meters: Official pricing bills browser hours, network traffic, and model tokens from one credit balance. The pricing page notes that traffic, especially on the home-IP proxy, can dominate a bill. A chatty task on a slow page can cost more than the published median agent-task figure.
4. Stealth, proxy and CAPTCHA claims are vendor-stated: Official pages and benches may show strong numbers on selected sites. They are not a promise that a given login, bot wall or region will work for you.
5. Operational responsibility on the local path: Running locally means you bring the browser, the model API keys, and the isolation. The MIT licence does not include hosted reliability.

Usage and Links (Example)

Official docs describe a local install with uv:

uv add browser-use

From there you write a short Python script that constructs an agent, gives it a task in English, and lets it drive Chrome. Exact class names and parameters should be copied from the current README or docs, because they change between releases. A testing-oriented task is typically a smoke check, for example “open the staging URL, sign in with the test user, and confirm the dashboard heading is visible,” rather than a permanent assertion file.

For the hosted path, create an account at browser-use.com, spend the signup credit if you are eligible, and send the same style of task to the cloud browsers. For an IDE or coding agent, follow the official MCP documentation.

Do not treat a successful agent run as a substitute for a committed Playwright test unless you have deliberately accepted the non-determinism.

Resources:

• Browser Use website
• GitHub repository
• Official pricing
• Machine-readable pricing
• Open-source docs
• Cloud docs

Pricing

Figures below are from Browser Use’s official pricing page and the machine-readable pricing.md, last verified 5 November 2026 on that page. Confirm there before you buy; these numbers can change.

1. Subscription: None. Official docs state there is no subscription.
2. Browser time: $0.02 per browser-hour on the hosted browsers, billed by the minute with a one-minute minimum.
3. Agent usage: Official docs list a $0.006 median cost per task for bu-ultrafast. Other models and longer tasks will differ. Token rates for named models are on the pricing page.
4. Local harness: MIT-licensed and free to run against local Chrome, with your own model bills if you use a paid model.
5. Signup credit: $1 one-time credit for eligible signups, as documented.
6. Concurrency: 10 concurrent browsers at $0. Higher caps unlock with total amount paid (examples officially listed include $100 → 50 concurrent and $1,000 → 250 concurrent). See the pricing document for the full ladder.
7. Proxies: Home-IP proxy $5/GB, or direct proxy $0.20/GB, as listed. CAPTCHA solving is stated as included.
8. Anything not in that document: See the site.

Recommended for?

1. Teams that want a real-browser agent for exploratory QA, demos, or smoke checks described in English.
2. Engineers already using coding agents who can attach the official MCP server and ask the agent to click through a flow.
3. Groups that want to try a local, MIT-licensed harness first, and only later send bursty jobs to the cloud.
4. Projects that will keep Playwright (or similar) for the durable suite, and use Browser Use beside it, not instead of it.
5. Not a fit if you need deterministic CI gates, a vendor that only sells a test-management UI, or a fully hands-off “write my regression pack into git” product.

Conclusion

Browser Use is a capable open-source browser agent with a straightforward cloud price list: no subscription, a low published browser-hour rate, and a separate agent-usage charge. The MIT licence and MCP server make it easy to try, and official docs are honest enough to say it is not a replacement for scripted end-to-end tests.

Use it where an English-language pass through a real browser is enough, and keep a conventional framework for the checks you will run on every pull request. Re-read the official pricing document before you scale concurrency, proxies or model choice, and treat vendor benches for stealth and CAPTCHA as starting points, not guarantees. For QA teams, the product is a sharp complement to a test suite, not a substitute for one.