AI DevelopmentOpen Source

Browser-Use: The Open-Source Repo Teaching AI Agents to Click

August 27, 2026
9 min read
Browser-Use open-source AI browser agents guide
Share:

Every few months a GitHub repo breaks out of the AI bubble and becomes infrastructure. Browser-Use is one of them: a Python library that lets an LLM see a web page, click buttons, fill forms, and finish the task you described in plain English.

I dug into the actual repo and docs so you do not have to: what it is and how popular it really is, how the agent loop works in 4 steps, a quickstart verified against the current README, real use cases, and an honest list of when NOT to use it.

1. What Is Browser-Use: Stars, License, and Facts

Browser-Use (github.com/browser-use/browser-use) is an open-source Python framework that makes websites accessible to AI agents. Instead of brittle CSS selectors, the agent observes the page the way assistive tech does, decides the next action with an LLM, and executes it through a real Chromium browser driven by Playwright.

GitHub stars

~112k stars (verified Sep 3, 2026)

License

MIT — free for commercial use

Stack

Python ≥ 3.11 · Playwright · any LLM

Why it matters

The project reports 89.1% on the WebVoyager benchmark (586 real-world web tasks) and the #1 spot on the Odysseys long-horizon leaderboard with 87.4%. Numbers move fast in this space, so treat them as a snapshot — but they explain why 12k+ forks exist.

There are two ways to consume it. The open-source agent runs on your own machine: free, model-agnostic (OpenAI, Anthropic, Google, Ollama, or their hosted ChatBrowserUse models), with full control of code and prompts. The hosted cloud adds stealth browsers, proxy rotation, CAPTCHA handling, and 1,000+ integrations for production. The library stays MIT either way.

2. Architecture in 4 Steps

You do not need to read the whole codebase to use it well. The agent loop is just four stages repeating until the task is done or the step budget runs out.

👁️

Step 1 — Observe

page → structured state

The browser extracts interactive elements, roles, and text into a compact representation. The LLM never scrapes raw HTML soup; it sees what it can actually do.

🧠

Step 2 — Decide

state + task → next action

The model picks one action: click element 14, type into the search box, scroll, go back, or call one of your custom tools. One decision per loop keeps runs debuggable.

🖱️

Step 3 — Act

action → Playwright

The action executes in a real Chromium session: clicks, keystrokes, form fills, navigation, file uploads. Sessions persist cookies and logins like a normal browser.

Step 4 — Verify

result → done or retry

The agent reads the new page state, checks whether the goal advanced, and either finishes with structured output or loops back. History keeps every step replayable.

The mental model that saves you tokens

Think of Browser-Use as ReAct glued to a browser: observe, reason, act, verify. Vague tasks burn steps, so constrain scope (one site, one goal, a step limit) and the loop converges fast.

3. Quickstart: Your First Agent in 5 Minutes

Every command below is copied from the current README and the official human quickstart docs, then kept minimal. Python 3.11 or newer required; 3.12 recommended with uv.

Step A — Install the package and the browser

pip install uv
uv venv --python 3.12
source .venv/bin/activate
uv pip install browser-use
uvx browser-use install

No uv? pip install browser-use also works. The last line downloads Chromium. Faster path: uvx browser-use init --template default scaffolds a working agent file.

Step B — Add your LLM key to .env

# .env — pick the provider you will actually use
BROWSER_USE_API_KEY=your-key
# GOOGLE_API_KEY=your-key
# OPENAI_API_KEY=your-key
# ANTHROPIC_API_KEY=your-key

One key is enough. ChatBrowserUse is tuned for browser tasks and reaches most providers with a single key; local models work via Ollama for fully offline runs.

Step C — Run your first agent

from browser_use import Agent, ChatBrowserUse
from dotenv import load_dotenv
import asyncio

load_dotenv()

async def main():
    llm = ChatBrowserUse()
    task = "Find the number 1 post on Show HN"
    agent = Agent(task=task, llm=llm)
    await agent.run()

if __name__ == "__main__":
    asyncio.run(main())

Swap the LLM in one line: ChatGoogle(model=”gemini-flash-latest”), ChatOpenAI(model=”gpt-4.1-mini”), or ChatAnthropic(model=”claude-sonnet-4-0”). Same Agent, same loop.

Windows note

Activate with .venv\Scripts\activate and create .env with echo. > .env. Everything else is identical cross-platform.

4. Real Use Cases That Justify the Hype

Browser agents shine where APIs do not exist, change without notice, or sit behind interfaces built for humans. These are the patterns I see surviving contact with production.

📋

Form filling at scale

Job applications, supplier onboarding, expense reports. You pass the resume and the rules; the agent types, uploads, and submits — with history as audit trail.

📊

Structured extraction

Followers, prices, listings, filings. Describe the schema once and get CSV or JSON back from sites that never offered an API.

🔁

Monitoring and QA

Nightly checks that log into your staging app, click the new flow, and screenshot regressions. Rerunnable scripts survive most site redesigns.

🔌

Glue for coding agents

Claude Code, Cursor, or OpenClaw drive the browser through the skill to finish one-off tasks: upload a video, compare three laptops, triage an inbox.

The pattern that works

Scheduled, repeatable, low-ambiguity tasks with a clear done-state. If you can write the acceptance check in one sentence, Browser-Use can probably automate it.

5. When NOT to Use Browser-Use

Honest section, because the fastest way to hate agents is pointing them at the wrong job. Browser automation costs latency, tokens, and flakiness — spend that budget where it pays.

⛔ Reach for something else when…

  • A stable API exists — APIs are cheaper, faster, and deterministic. Firecrawl or plain httpx beat a browser every time.
  • You need millisecond latency or thousands of pages per minute — one browser step takes seconds, not milliseconds.
  • The site is behind aggressive bot protection — budget for stealth cloud browsers or accept defeat; raw Chromium will eat CAPTCHAs all day.
  • The task is legally gray — credential sharing, ToS violations, or scraping personal data. The repo FAQ points at auth profiles for a reason.
  • You need pixel-perfect determinism — Playwright scripts with fixed selectors still win for rigid regression suites.

✅ Browser-Use is the right call when…

  • No API exists and the workflow is human-shaped (forms, dashboards, portals).
  • You want one codebase across providers — swap ChatBrowserUse, ChatOpenAI, ChatGoogle, or Ollama in a single line.
  • You need custom tools, structured output, and full prompt control on your own infra.
  • Volume is moderate and each run is worth a few cents of LLM calls.

Golden rule

Prototype with the open-source agent on your laptop, then decide: stay self-hosted for control, or move to the cloud when stealth, proxies, and parallelism become the bottleneck. Never pay for infrastructure before the task proves its value.

Conclusion

Browser-Use earned its 112k stars by solving an unglamorous problem well: letting code use the web as it exists, not as we wish its APIs were. The loop is simple — observe, decide, act, verify — and the quickstart genuinely runs in five minutes.

My verdict: learn it if you automate knowledge work. Start with one boring, repeatable task, keep the scope tight, log the history, and graduate to cloud browsers only when the ROI is obvious.

Cheat Sheet

Install

  • • uv pip install browser-use
  • • uvx browser-use install
  • • Python ≥ 3.11

Configure

  • • .env with one API key
  • • ChatBrowserUse default
  • • Ollama for local runs

Run

  • • Agent(task, llm)
  • • await agent.run()
  • • history for replay
Diego Rodriguez

Diego Rodriguez

Senior Full-Stack & AI Engineer

Diego has 10+ years of experience building production-grade AI-powered applications, from LLM orchestration and RAG pipelines to ML-driven risk detection and algorithmic trading systems.

Learn more about Diego