Browser Use is the most-starred AI browser-automation framework on GitHub, bar none. As of late July 2026 it sits at 107,036 stars, 11,768 forks, MIT license, pure Python, with v0.13.7 released on July 27-less than two years after the first commit on October 31, 2024. The authors are Magnus Müller and Gregor Žunič from ETH Zurich, maintaining the project across Zurich and San Francisco. What it does in one sentence: let an LLM use a browser the way a human does-screenshot the page, decide the next step, output mouse clicks and keystrokes. On the Odysseys leaderboard it ranks #1 with an 87.4% average pass rate, ahead of the computer-use agents from OpenAI, Anthropic, Google, and Microsoft-a benchmark of 200 long-horizon web tasks.
What Pain It Solves
Anyone who's written a scraper has hit these: Selenium/Playwright scripts locate elements via CSS selectors, the target site redesigns, and find_element(by=ID) collapses across the board with midnight alerts; login state, pagination, pop-ups, captchas, lazy-load each need hand-written tolerance code that ends up longer than the business logic; dynamic SPA elements show up late and you write explicit waits until you doubt your life; Cloudflare anti-bot, canvas captchas, sliders-traditional scripts just surrender; and bolting browser capability onto your own AI agent means wrapping a pile of actions yourself. Browser Use packs all of this into one Agent: you hand it a goal ("scrape every product price off this site into a CSV") and it watches screenshots to plan the path, handles login/pagination/pop-ups, retries on failure. The core shift is from "hard-coded selectors" to "let the model look with its eyes"-as long as the page is visually still there, the agent still finds it.
The Vision Route: How It Survives Without Selectors
This is the fundamental split from traditional scripts. Classic automation is structural addressing: DOM trees, XPath, CSS classes-once the page structure shifts, it mismatches. Browser Use goes vision-first: each step screenshots first, feeds the image to the LLM, and the model "sees" what to click and what to type the way a human would, then emits a coordinate-bearing action. Three direct consequences. One, redesign-resistant: a button moves from red to blue, its class changes from btn-primary to v2__cta-as long as it's on screen, the agent clicks it. Two, it handles dynamic pages: lazy-load, pull-to-refresh, infinite scroll-the model waits for elements to appear, no hardcoded waits. Three, cross-site generalization: the same agent logic runs on sites it's never seen, because it doesn't assume structure. The cost is slow and expensive: each step is one LLM call plus one screenshot, complex tasks easily run dozens of rounds, and token/time costs dwarf a selector script. So its positioning is not "replace Playwright for high-frequency stable scraping" but "do what Playwright can't-see, judge, adapt."
One Key Reaches Claude/GPT/Gemini, Plus Local Offline
The model layer is its most flexible part. The official ChatBrowserUse accepts provider-prefixed model ids, so a single BROWSER_USE_API_KEY reaches the whole Claude/GPT/Gemini stack without separately applying for OpenAI/Anthropic/Google keys: anthropic/claude-sonnet-4-6, openai/gpt-5.5, google/gemini-3-pro drop straight in. The team also ships bu-* models tuned for browser tasks (hosted bu-2-0, open-source preview browser-use/bu-30b-a3b-preview), averaging 3-5x faster than other models with SOTA accuracy. Don't want to be locked to a cloud? Swap in ChatOpenAI(model="gpt-4o"), ChatAnthropic(model="claude-opus-4-8") on your own key, or plug in local ChatOllama(model="qwen2.5") for fully offline-contracts, internal systems, sensitive back-office operations never leave your machine. The team benchmarks across 100 real-world web tasks (BU Bench V1), with each model's success rate public in the browser-use/benchmark repo, so you can pick a model by its score.
Custom Tools and Agent Orchestration
Clicking the mouse isn't enough; often an agent must call an API to be efficient. Browser Use hangs custom functions off the @tools.action decorator: write query_db(sql) or send_slack(msg), and the LLM itself decides when to "operate visually" vs. call a tool directly, mixing vision and API calls-scraping a logged-in backend, login goes through browser vision while data pulls go through API, skipping pointless screenshot rounds. It's natively async, so you can open multiple browser contexts in parallel across tabs to fan out batch tasks. There are two entry points: the Python library, for embedding a browser agent into your own product, scheduling, and parallel scraping-kind of repeatable automation; and the CLI, which acts as the "eyes and hands" for existing coding agents (Claude Code, Codex, Cursor, Hermes, OpenClaw)-run browser-use skill install once to register the skill, then tell the agent "upload this video to YouTube" or "compare these three laptops and give me a price table" and it drives the browser itself. Rule of thumb: one-off tasks via CLI, repeatable automation via library.
Three-Minute Setup
# 1. Install (Python >= 3.11)
uv add browser-use
# or: pip install browser-use
playwright install chromium # browser engine
# 2. Configure .env, pick one
echo 'BROWSER_USE_API_KEY=your-key' > .env # one official key covers all
# or use your own: GOOGLE_API_KEY / ANTHROPIC_API_KEY
# 3. Minimal runnable
python -c "
import asyncio
from browser_use import Agent, ChatBrowserUse
async def main():
agent = Agent(
task='Open github.com, search browser-use, return the stars of the first repo',
llm=ChatBrowserUse(model='openai/gpt-5.5'),
)
await agent.run()
asyncio.run(main())
"For local offline, swap llm for ChatOllama(model="qwen2.5") and leave the rest. If you already have a coding agent, it's even easier-paste the setup prompt from the README into Claude Code; it installs and connects to the browser itself, and you just give orders.
Who It's For + Five Pitfalls
For: people doing batch operations across frequently-redesigned SaaS dashboards and multiple platforms; scraping login-gated, anti-bot pages; developers building AI agents who want to give their hands "eyes"; privacy or offline scenarios requiring data to stay on-domain.
Five pitfalls. One, Chrome is memory-hungry-parallel instances will blow up your machine, and at production scale the team flat-out recommends Browser Use Cloud, which manages the browser infrastructure, memory, proxy rotation, stealth fingerprinting, and parallel scheduling. Two, captchas: the open-source build has no built-in solver, Cloudflare anti-bot and sliders are basically impassable-either go with its Cloud (stealth fingerprint + proxy rotation + captcha solving built in) or hang your own proxies. Three, login-state reuse: don't rescan QR every time, reuse a real browser profile with your already-logged-in Chrome session, or spin up temp accounts via AgentMail; for remote browsers you can curl ... | BROWSER_USE_API_KEY=xxx sh to sync your local profile over. Four, cost: the vision route makes one LLM call per step, long tasks burn tokens fast-simple, high-frequency scraping is cheaper written in plain Playwright. Five, compliance: operating others' sites via automation depends on their ToS; bulk scraping and bypassing anti-bot sit in a legal gray area, read the terms before commercial use-the tool is MIT, but your usage may not be.
vs. the Competition
Against traditional Selenium/Playwright, the essence is "script" vs. "agent": the former is fast, stable, cheap, but brittle-selector-dependent, breaks on redesign; the latter is slow, costly, but can see, adapt, and survive redesigns-complementary, not a replacement. Against OpenAI Operator, Anthropic computer-use, Google Project Mariner, and Microsoft's computer-use, Browser Use ranks #1 on the Odysseys 200-task long-horizon web benchmark at 87.4%, ahead of these closed-source big-lab offerings-and it's open-source MIT, model-swappable, locally offline-capable, and embeddable in your own code, whereas the closed ones are black-box SaaS. Against peers like Phase and AgentE, its ecosystem is the thickest: a 107k-star community, a 100-task public benchmark, 1000+ cloud integrations (Gmail/Slack/Notion). In one line: for stable high-frequency scraping write Playwright; for an AI that watches the page and adapts, with open-source control-Browser Use.
References
- Browser Use GitHub repo (107k stars, MIT, Python): https://github.com/browser-use/browser-use
- Official docs (library / CLI / Cloud / custom tools): https://docs.browser-use.com
- Odysseys leaderboard (200 long-horizon tasks, 87.4% #1): https://odysseysbench.com/leaderboard
- BU Bench V1 benchmark (100 real tasks, per-model success rates): https://github.com/browser-use/benchmark
- Supported models and pricing (ChatBrowserUse provider-prefixed ids): https://docs.browser-use.com/supported-models