browser-use: The Open-Source Framework With 110,000+ GitHub Stars That Lets AI Agents Control Your Browser

Why AI Browser Automation Matters in 2026

The web wasn't built for AI agents. Every login form, CAPTCHA, and dynamic JavaScript interface represents a barrier between intelligent systems and the information they need. But what if your AI could browse the web the same way you do—clicking buttons, filling forms, navigating pages, and extracting data?

That's exactly what browser-use delivers. This MIT-licensed framework has exploded to over 110,000 GitHub stars since its launch in October 2024, becoming the de facto standard for giving AI agents real browser capabilities. Whether you're building web scrapers, automating repetitive tasks, or creating agents that interact with web applications, browser-use bridges the gap between language models and the visual web.

What Is browser-use?

browser-use is a Python library that lets AI agents use a web browser the same way humans do. You describe a task in natural language—"Find the number of stars on the browser-use repo" or "Apply to this job with my resume"—and the agent opens a browser, navigates to the right pages, clicks buttons, types text, and completes the task.

Under the hood, browser-use combines:

• Playwright for reliable browser automation
• Large Language Models (GPT-5.5, Claude, Gemini, or browser-use's own optimized model) for decision-making
• Computer vision techniques to understand page layouts
• Structured action spaces that translate natural language into browser operations

The result? Agents that can handle complex, multi-step web workflows without brittle selectors or hardcoded scripts.

How It Works: Architecture Overview

browser-use follows a simple but powerful architecture:

1. Task Description: You provide a natural language goal
2. Browser State: The framework captures the current page state (DOM, screenshots, accessibility tree)
3. LLM Reasoning: The language model analyzes the state and decides the next action
4. Action Execution: Playwright executes the chosen action (click, type, navigate, etc.)
5. Loop: The cycle repeats until the task is complete or fails gracefully

This loop runs asynchronously, allowing you to spawn multiple agents in parallel for batch operations.

Core Components

from browser_use import Agent, ChatBrowserUse

# The Agent class orchestrates the browser automation loop
agent = Agent(
    task="Search for flights from NYC to London on Dec 15",
    llm=ChatBrowserUse(model='openai/gpt-5.5'),
)

# Run the agent asynchronously
history = await agent.run()

The Agent class handles the reasoning loop, while the ChatBrowserUse wrapper provides a unified interface across different LLM providers.

Getting Started: Installation & Your First Agent

Setting up browser-use takes less than five minutes:

Step 1: Install the Package

# Using uv (recommended)
uv add browser-use

# Or with pip
pip install browser-use

Requires Python 3.11 or higher.

Step 2: Configure Your LLM API Key

Create a .env file in your project root:

# Option 1: Use Browser Use's API (supports multiple models)
BROWSER_USE_API_KEY=your-key-here

# Option 2: Use your own provider keys
# OPENAI_API_KEY=your-key
# ANTHROPIC_API_KEY=your-key
# GOOGLE_API_KEY=your-key

Get a Browser Use API key from cloud.browser-use.com, or bring your own provider credentials.

Step 3: Write Your First Agent

import asyncio
from browser_use import Agent, ChatBrowserUse

async def main():
    agent = Agent(
        task="Find the top 3 trending repositories on GitHub today",
        llm=ChatBrowserUse(model='openai/gpt-5.5'),
    )
    result = await agent.run()
    print(result)

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

Run it, and watch your agent navigate GitHub, extract data, and return structured results.

Choosing Your LLM: GPT-5.5, Claude, or Browser-Use's Own Model

browser-use is model-agnostic, but performance varies significantly:

ChatBrowserUse (Recommended for Speed)

Browser Use's own optimized models (bu-2-0-mini-preview, bu-30b-a3b-preview) are fine-tuned specifically for browser automation:

llm = ChatBrowserUse(model='bu-2-0-mini-preview')  # Fastest
# or
llm = ChatBrowserUse(model='bu-30b-a3b-preview')  # Open-source preview

Pros: 3-5x faster than general models, lower cost, SOTA accuracy on browser tasks
Cons: Requires Browser Use API key

OpenAI GPT-5.5

from browser_use import ChatOpenAI
llm = ChatOpenAI(model='gpt-5.5')

Pros: Excellent reasoning, widely available
Cons: Higher cost, slower than optimized models

Anthropic Claude Sonnet

from browser_use import ChatAnthropic
llm = ChatAnthropic(model='claude-sonnet-4-6')

Pros: Strong at following complex instructions
Cons: Can be verbose, moderate speed

Unified API (All Models Through One Key)

The ChatBrowserUse wrapper accepts provider-prefixed model IDs:

llm = ChatBrowserUse(model='anthropic/claude-sonnet-4-6')
# or 'openai/gpt-5.5', 'google/gemini-3-pro'

One API key, all models.

Real-World Example: Automated Job Applications

Let's build an agent that applies to jobs on your behalf:

import asyncio
from browser_use import Agent, ChatBrowserUse, Browser

async def apply_to_job(job_url: str, resume_path: str):
    browser = Browser()
    
    agent = Agent(
        task=f"""
        Go to {job_url}.
        Fill out the job application form with information from my resume at {resume_path}.
        Upload the resume file.
        Submit the application.
        Confirm successful submission.
        """,
        llm=ChatBrowserUse(model='openai/gpt-5.5'),
        browser=browser,
    )
    
    result = await agent.run()
    await browser.close()
    return result

# Usage
asyncio.run(apply_to_job(
    "https://example.com/jobs/12345",
    "/path/to/resume.pdf"
))

This agent will:

1. Navigate to the job posting
2. Parse your resume (you'd need a custom tool for PDF extraction)
3. Fill in form fields intelligently
4. Handle file uploads
5. Submit and verify

Adding Custom Tools

Extend the agent with domain-specific actions:

from browser_use import Tools
import PyPDF2

tools = Tools()

@tools.action(description='Extract text from a PDF resume file')
def extract_resume_text(pdf_path: str) -> str:
    with open(pdf_path, 'rb') as f:
        reader = PyPDF2.PdfReader(f)
        text = ""
        for page in reader.pages:
            text += page.extract_text() + "\n"
    return text

agent = Agent(
    task="Apply to this job using my resume",
    llm=llm,
    browser=browser,
    tools=tools,  # Agent can now call extract_resume_text
)

Production Use Cases

browser-use shines in scenarios where traditional web scraping falls short:

1. Dynamic Web Scraping

Extract data from JavaScript-heavy sites that resist traditional scrapers:

async def scrape_ecommerce():
    agent = Agent(
        task="""
        Go to example-shop.com.
        Search for 'wireless headphones'.
        Extract the top 10 results with: product name, price, rating, and URL.
        Return as JSON.
        """,
        llm=ChatBrowserUse(model='bu-2-0-mini-preview'),
    )
    return await agent.run()

2. Automated QA Testing

Test web applications with natural language test cases:

async def test_checkout_flow():
    agent = Agent(
        task="""
        Go to myapp.com.
        Add 2 items to cart.
        Proceed to checkout.
        Fill in shipping details with test data.
        Complete payment with test card.
        Verify order confirmation appears.
        """,
        llm=ChatBrowserUse(model='openai/gpt-5.5'),
    )
    return await agent.run()

3. Social Media Automation

Schedule posts, extract analytics, or monitor mentions across platforms.

4. Research & Data Collection

Aggregate information from multiple sources, compare prices, or monitor competitors.

Key Benefits

• Natural Language Interface: Describe tasks in plain English—no CSS selectors or XPath
• Model Flexibility: Use GPT-5.5, Claude, Gemini, or optimized browser-use models
• Open Source & Free: MIT license, runs on your infrastructure
• Production-Ready: Handles authentication, CAPTCHAs (with cloud), and complex workflows
• Benchmark Leader: #1 on Odysseys with 87.4% accuracy on 200 real-world tasks
• Extensible: Add custom tools, system prompts, and structured outputs
• Parallel Execution: Run multiple agents concurrently for batch operations
• Authentication Support: Reuse existing Chrome profiles or handle login flows

Frequently Asked Questions

Is browser-use free to use?

Yes! browser-use is open source under the MIT license. You only pay for the LLM API calls (OpenAI, Anthropic, Google, or Browser Use's own models). The framework itself is completely free.

Which LLM works best with browser-use?

Browser Use's own optimized models (bu-2-0-mini-preview, bu-30b-a3b-preview) are 3-5x faster than general models with state-of-the-art accuracy. For general-purpose models, GPT-5.5 and Claude Sonnet both work well, though they're slower and more expensive.

Can browser-use handle CAPTCHAs?

The open-source version can solve simple CAPTCHAs, but complex ones require Browser Use Cloud, which provides stealth browsers with proxy rotation and advanced fingerprinting to avoid detection.

How do I use my existing browser login sessions?

browser-use can connect to your real Chrome profile with saved logins. Pass your Chrome user data directory when initializing the Browser class, and the agent inherits your cookies and sessions.

Can I run multiple agents in parallel?

Yes! browser-use supports async execution. You can spawn multiple Agent instances concurrently using asyncio.gather() for batch operations like scraping 100 pages or applying to multiple jobs.

What about production deployment and scaling?

For production, Browser Use Cloud handles scalable browser infrastructure, memory management, proxy rotation, and high-performance parallel execution. The open-source version works for smaller-scale or development use cases.

Does it work with coding agents like Claude Code or Cursor?

Absolutely! browser-use has a CLI mode that integrates with Claude Code, Codex, Cursor, and other coding agents. Install the skill once, and your coding agent can complete browser tasks on your behalf.