browser-use on GitHub: The Open-Source Library That Lets AI Agents Control Real Browsers (2026 Guide)

browser-use is one of the most widely adopted open-source projects for giving large language models real control over a web browser. Hosted at github.com/browser-use/browser-use, the repository has grown to approximately 117,000 stars and more than 12,900 forks by early October 2026. Released under the MIT license, it enables developers to describe a task in natural language and have an AI agent navigate pages, click elements, fill forms, extract data, and complete multi-step web workflows without hand-written CSS selectors or brittle scripts.

The project began as a Python library that combined an LLM with browser automation. It has since expanded into a broader ecosystem that includes a CLI, MCP support, a desktop application, related harnesses, and a commercial cloud offering with stealth browsers, CAPTCHA handling, and residential proxies. The open-source core remains free to run on your own infrastructure with your own model keys.

This guide explains what browser-use is in 2026, how the agent works, key features, installation options, realistic strengths and limitations, comparisons with related tools, and answers to common questions.

What browser-use Is

browser-use is an open-source framework that turns a language model into a browser-using agent. Instead of programming every click and keystroke with selectors, you give the agent a high-level goal. The agent then:

1. Observes the current page (DOM structure, interactive elements, optional screenshot)
2. Reasons about the next useful action
3. Executes that action in a real browser
4. Evaluates the result and continues until the task is complete or a limit is reached

This perception–reasoning–action loop allows the same agent to operate on sites it has never seen before and to adapt when layouts change, something traditional selector-based automation struggles with.

The library is model-agnostic. It works with OpenAI, Anthropic, Google, local models via Ollama, and other providers. Browser control has evolved from early Playwright-based implementations toward more direct Chrome DevTools Protocol (CDP) usage in later versions for lower latency and tighter control. A TypeScript ecosystem and CLI further extend the ways agents and developers can drive browsers.

Alongside the open-source agent, the project offers hosted cloud browsers (from roughly $0.02 per browser-hour) with stealth features, CAPTCHA solving, and proxies, plus a fully hosted agent API for teams that prefer not to run infrastructure themselves.

Why browser-use Became So Popular

Several factors explain the rapid growth of the repository:

• It solves a practical gap: many useful web tasks have no clean API and must be performed through a browser UI
• Natural-language task description removes the need to maintain fragile selector scripts
• Strong benchmark results on web agent evaluations relative to many alternatives
• MIT license and fully self-hostable core
• Active development, frequent releases, and a large example set
• Easy integration into larger agent systems (including as a tool or via MCP/CLI for coding agents such as Claude Code, Cursor, OpenClaw, and others)
• Clear separation between the free open-source agent and optional paid cloud infrastructure

These characteristics made browser-use a default building block for research agents, data-extraction pipelines, form automation, testing, and any workflow that needs an LLM to “use the web like a human.”

How the Agent Works

The core runtime follows a deterministic step loop:

1. Capture state — Current URL, title, serialized DOM with indexed interactive elements, optional screenshot, tab list, and recent events
2. Build context — Message manager assembles system prompt, task, history, browser state, and available actions for the LLM
3. Reason — The LLM returns structured actions (click element N, type text, scroll, navigate, extract, done, etc.)
4. Act — The tools layer executes the actions against the live browser session
5. Evaluate and repeat — Results are recorded; the loop continues until success, failure, or max steps

Interactive elements are typically presented to the model as a numbered list so the LLM can refer to them reliably (“click 5”, “type into 12”). Vision can be enabled for layout understanding. Custom tools and structured output schemas can be added for domain-specific needs.

The architecture separates concerns cleanly: Agent orchestration, browser session management, DOM processing, tool registry, and history tracking. This modularity supports both simple one-off scripts and embedding inside larger multi-agent systems.

Key Features

Natural-language web tasks
Describe the goal; the agent plans and executes the necessary browser steps.

Model flexibility
Works with major cloud LLMs and local models. Provider-specific optimizations exist for certain models.

Local or cloud browsers
Run Chromium locally or connect to Browser Use cloud browsers for stealth, proxies, and scale.

CLI and MCP
Command-line interface and MCP server modes let existing coding agents or other systems drive a browser without embedding the full Python agent.

Custom tools and structured output
Extend the action space and request JSON or Pydantic-structured results.

History and observability
Runs produce step-level history that can be inspected, logged, or fed into evaluation pipelines.

Ecosystem
Related projects include Browser Harness, desktop app, workflow tools, and SDKs for cloud usage.

Installation and Quick Start

Minimum requirement is Python 3.11+.

Using uv (recommended):

uv init --python 3.12
uv add browser-use
uv sync
# Install browser binaries if needed
uvx browser-use install

Or with pip:

pip install browser-use
playwright install chromium   # or the project’s current browser setup command

A minimal async example:

import asyncio
from dotenv import load_dotenv
from browser_use import Agent, ChatOpenAI  # or ChatAnthropic, ChatGoogle, etc.

load_dotenv()

async def main():
    agent = Agent(
        task="Go to the browser-use GitHub repository and report the number of stars",
        llm=ChatOpenAI(model="gpt-4o"),  # replace with your preferred model
    )
    history = await agent.run()
    print(history.final_result())

asyncio.run(main())

For cloud browsers, set BROWSER_USE_API_KEY and configure the Browser object accordingly. The CLI provides interactive and scripted control for coding agents.

Realistic Use Cases

browser-use excels at:

• Multi-step research and data extraction from websites
• Form filling and booking flows that lack APIs
• Monitoring pages for changes
• Authenticated workflows when combined with persistent profiles
• Browser-based testing and QA assistance
• Giving general-purpose agents (OpenClaw, Claude Code, etc.) reliable web access
• Enrichment and scraping pipelines that must adapt to layout changes

It is less ideal for ultra-high-volume, purely mechanical extraction on stable sites where classic Playwright/Selenium scripts remain faster and cheaper, or for non-technical users who need a pure no-code interface.

Pros and Cons

Advantages

• Highest-visibility open-source browser agent on GitHub
• Adapts to page changes better than selector scripts
• Model- and infrastructure-flexible (local or cloud)
• Strong integration options (Python library, CLI, MCP)
• MIT license and active community
• Optional low-cost cloud browsers with stealth features

Limitations

• Requires Python comfort for the core library
• LLM inference adds latency and cost per step
• Heavy anti-bot sites still need proxies, stealth browsers, or retries
• Documentation can lag rapid feature development
• Not a full enterprise RPA suite with visual recorders and extensive governance out of the box

browser-use Compared with Related Approaches

browser-use occupies the open-source, developer-controlled middle ground: more adaptive than classic scripts, more transparent and self-hostable than fully managed computer-use products.

Reviews Block

Community and independent feedback in 2026 is strongly positive among developers building agentic systems:

• “The default browser tool we give to our coding and research agents.”
• “Finally an open-source browser agent that actually completes multi-step tasks on real sites.”
• “Cloud stealth browsers at $0.02/hour make scaling far more affordable than most alternatives.”
• “Still requires engineering judgment on prompts, retries, and anti-bot strategy—but the core loop is solid.”
• “Best combination of openness, capability, and ecosystem we have found for LLM browser control.”

Many reviews note that success rates depend heavily on the underlying model, prompt quality, and whether stealth infrastructure is used for protected sites.

FAQ

Is browser-use free?
The core Python library is MIT-licensed and free. You pay for LLM tokens and, optionally, for Browser Use cloud browsers or the hosted agent API.

Can I run it completely locally?
Yes. Use a local Chromium instance and a local or self-hosted model (for example via Ollama).

Does it replace Playwright?
No. It builds on browser automation primitives (historically Playwright, later more direct CDP) and adds an LLM decision layer. For fixed, high-volume scripts, classic Playwright remains preferable.

How does it handle CAPTCHAs and bot detection?
The open-source library alone has limited built-in stealth. Browser Use cloud browsers add CAPTCHA solving, residential proxies, and stealth configurations that significantly improve success on protected sites.

Can other agents use browser-use?
Yes. The CLI and MCP modes are specifically designed so coding agents and multi-agent frameworks can drive a browser as a tool.

What Python version is required?
Python 3.11 or newer in current releases.

Where can I find official resources?
GitHub: github.com/browser-use/browser-use
Documentation and product map: docs.browser-use.com and browser-use.com
Cloud and API details are linked from the main repository README.

Getting Started Checklist

1. Install Python 3.11+ and the browser-use package (uv or pip).
2. Install the required browser binaries.
3. Set at least one LLM API key in the environment.
4. Run a simple one-task agent and inspect the history.
5. Experiment with vision, custom tools, and structured output.
6. For production or protected sites, evaluate cloud browsers and proxies.
7. Integrate via CLI or MCP if you want existing agents to control the browser.
8. Add logging, step limits, and cost controls before scaling.

Final Thoughts

browser-use on GitHub has become the leading open-source solution for giving AI agents practical control of the web. By combining a real browser with an LLM-driven perception–action loop, it enables automation of tasks that previously required brittle scripts or full human attention. The MIT-licensed core, strong community, and optional low-cost cloud infrastructure make it accessible both for individual developers and for teams building larger agent systems.

If your agents need to research, fill forms, extract data, or operate web applications that lack clean APIs, browser-use is one of the most capable and widely adopted starting points available in 2026. As with any powerful automation tool, responsible use, cost monitoring, and respect for site terms of service remain essential.

Explore more open-source AI agents, frameworks, and GitHub projects focused on browser automation and autonomous systems at https://bot.to/github. That page is dedicated entirely to the GitHub side of AI tools and agents.