TL;DR for AI Agents

Browser Use is a Python library (117K+ GitHub stars and release 0.13.11, as of October 8, 2026) that enables AI agents to interact with websites. Key capabilities:

  • Natural language browsing: Agent receives task → navigates web → completes actions
  • Multi-LLM support: Works with OpenAI, Anthropic, Google, Ollama (local), and their custom ChatBrowserUse
  • Built on Playwright: Reliable browser automation under the hood
  • CLI included: Quick commands for browser control without code
  • Production-ready: Cloud offering with stealth browsers and proxy rotation

Install: uv add browser-use | Docs: https://docs.browser-use.com | GitHub: https://github.com/browser-use/browser-use

What changed as of October 2026

  • Latest release: 0.13.11 (October 7, 2026), MIT-licensed, Python 3.11 or newer. The repo had 117,438 stars on October 8, 2026.
  • Native model classes, no LangChain. Import ChatOpenAI, ChatAnthropic, ChatGoogle, ChatOllama and others directly from browser_use. The LangChain imports this post used earlier are wrong for current versions; the examples below are fixed.
  • The in-house model is BU2 (ChatBrowserUse(model='bu-2-0'), also the default for ChatBrowserUse()). It now costs $0.60 per 1M input tokens, $0.06 cached and $3.50 output. This post used to say $0.20 / $0.02 / $2.00.
  • Cloud browsers cost $0.02 per browser-hour, plus $5/GB for residential proxies, pay as you go with no subscription. Signup credit is one-time; the amount has changed several times, so check the pricing page.
  • The CLI was rebuilt on Browser Harness. You now pass Python to it (new_tab(...), page_info()) instead of the open / state / click commands shown below. Install the agent skill with browser-use skill install. Details are in the CLI section.
  • Logged-in browsing: use Browser.from_system_chrome() to reuse your Chrome profile. The old BrowserConfig(chrome_instance_path=...) example and the profile.sh sync script no longer apply.

Web automation has always been a pain point for developers. Selenium scripts break constantly, CSS selectors become outdated, and maintaining automation code is a full-time job. Browser Use takes a radically different approach: instead of writing brittle automation scripts, you simply tell an AI agent what you want done, and it figures out how to do it.

What Makes Browser Use Different

Traditional web automation looks like this:

# Old way: Fragile selectors that break constantly
driver.find_element(By.CSS_SELECTOR, "#login-form input[name='email']").send_keys(email)
driver.find_element(By.CSS_SELECTOR, "#login-form input[name='password']").send_keys(password)
driver.find_element(By.CSS_SELECTOR, "#login-form button[type='submit']").click()

Browser Use automation looks like this:

# New way: Natural language instructions
agent = Agent(
    task="Log into my account with email [email protected] and password secret123",
    llm=llm,
    browser=browser,
)
await agent.run()

The AI agent sees the page, understands the context, and figures out how to accomplish the task. When the website changes its layout, the agent adapts automatically. No more broken selectors.

Getting Started in 5 Minutes

Browser Use uses uv for package management. Here’s the quickest path to your first automation:

Step 1: Set Up Environment

# Create new project
uv init my-browser-agent
cd my-browser-agent

# Install Browser Use
uv add browser-use
uv sync

# Install Chromium browser
uvx browser-use install

Step 2: Get Your API Key

You’ll need an LLM to power the agent. The easiest option is Browser Use’s own model, optimized for browser tasks:

  1. Go to cloud.browser-use.com/new-api-key
  2. Sign up (eligible new accounts get a one-time signup credit; the amount changes, so check the pricing page)
  3. Add to your .env file:
BROWSER_USE_API_KEY=your-key-here

Step 3: Run Your First Agent

from browser_use import Agent, Browser, ChatBrowserUse
import asyncio

async def example():
    browser = Browser()
    llm = ChatBrowserUse()
    
    agent = Agent(
        task="Go to Hacker News and find the top story title",
        llm=llm,
        browser=browser,
    )
    
    history = await agent.run()
    print(f"Agent completed. Final result: {history[-1]}")
    return history

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

That’s it. The agent opens a browser, navigates to Hacker News, reads the page, and returns the top story.

Using Your Preferred LLM

Browser Use isn’t locked to their cloud model. You can use any major LLM provider:

OpenAI

from browser_use import Agent, ChatOpenAI

llm = ChatOpenAI(model="gpt-5")
agent = Agent(task="Your task", llm=llm, browser=browser)

Anthropic Claude

from browser_use import Agent, ChatAnthropic

llm = ChatAnthropic(model="claude-sonnet-4-6")
agent = Agent(task="Your task", llm=llm, browser=browser)

Local Models with Ollama

For privacy-conscious setups or offline use:

from browser_use import Agent, ChatOllama

llm = ChatOllama(model="llama3.2")
agent = Agent(task="Your task", llm=llm, browser=browser)

The CLI: Browser Automation Without Code

Browser Use includes a CLI for quick, interactive automation.

Updated October 2026: the current CLI is backed by Browser Harness and takes Python instead of the commands shown further down. Install it with uv tool install browser-use, then:

uvx browser-use <<'PY'
new_tab("https://example.com")
print(page_info())
PY

It attaches to your running Chrome over CDP by default (browser-use --doctor if it can’t connect), or to a cloud browser after browser-use auth login. The original command-style examples are kept below for older versions:

# Open a browser and navigate
browser-use open https://github.com

# See all clickable elements with indices
browser-use state

# Click element by index
browser-use click 5

# Type text
browser-use type "browser-use"

# Take a screenshot
browser-use screenshot current-page.png

# Close the browser
browser-use close

The browser stays open between commands, making it perfect for exploration and debugging. Chain commands together to build quick automations without writing Python.

Real-World Use Cases

1. Job Application Automation

agent = Agent(
    task="""
    Fill out the job application on this page using my resume:
    - Name: John Smith
    - Email: [email protected]
    - Phone: 555-0123
    - Upload resume from ~/Documents/resume.pdf
    - Write a cover letter emphasizing my Python experience
    """,
    llm=llm,
    browser=browser,
)

2. E-commerce Price Monitoring

agent = Agent(
    task="""
    Go to amazon.com, search for "mechanical keyboard",
    find the top 5 results, and record their names and prices.
    Return the data as JSON.
    """,
    llm=llm,
    browser=browser,
)

3. Social Media Management

agent = Agent(
    task="""
    Log into Twitter, go to my notifications,
    and summarize any mentions from the last 24 hours.
    """,
    llm=llm,
    browser=browser,
)

Custom Tools: Extending the Agent

You can add custom capabilities to your agent:

from browser_use import Tools

tools = Tools()

@tools.action(description='Save data to a local file')
def save_to_file(filename: str, content: str) -> str:
    with open(filename, 'w') as f:
        f.write(content)
    return f"Saved to {filename}"

@tools.action(description='Send a Slack notification')
def notify_slack(message: str) -> str:
    # Your Slack webhook logic here
    return "Notification sent"

agent = Agent(
    task="Scrape product prices and save to prices.json, then notify Slack",
    llm=llm,
    browser=browser,
    tools=tools,
)

Handling Authentication

For sites requiring login, you have options:

Use Your Existing Browser Profile

browser = Browser.from_system_chrome()

This reuses your existing Chrome profile with all saved logins, cookies, and sessions. You may need to fully close Chrome first. (Older versions used Browser(config=BrowserConfig(chrome_instance_path=...)).)

Cloud Profiles for Production

Follow the profile sync guide, then use Browser(use_cloud=True, cloud_profile_id='your-profile-id'). Profile sync copies cookies, not local storage, IndexedDB or extensions. (The profile.sh script this post linked earlier now returns 404.)

Production Deployment

For production workloads, Browser Use offers cloud infrastructure:

browser = Browser(
    use_cloud=True,  # Use stealth browsers in the cloud
)

The cloud offering provides:

  • Stealth browsers: Avoid detection and CAPTCHA challenges
  • Proxy rotation: Prevent IP blocks
  • Scalable infrastructure: Run many agents in parallel
  • Memory management: Chrome is memory-hungry; they handle it

Sandbox Deployment

For isolated, production-ready runs:

from browser_use import Browser, sandbox, ChatBrowserUse
from browser_use.agent.service import Agent

@sandbox()
async def scrape_task(browser: Browser):
    agent = Agent(
        task="Find the current Bitcoin price on CoinGecko",
        browser=browser,
        llm=ChatBrowserUse()
    )
    return await agent.run()

# Runs in isolated environment
result = asyncio.run(scrape_task())

Integration with AI Coding Tools

Claude Code Skill

Browser Use provides a skill file for Claude Code users. Updated October 2026: the simplest way is now browser-use skill install after installing the CLI. The manual method:

mkdir -p ~/.claude/skills/browser-use
curl -o ~/.claude/skills/browser-use/SKILL.md \
  https://raw.githubusercontent.com/browser-use/browser-use/main/skills/browser-use/SKILL.md

Now you can ask Claude Code to “open the browser and check my email” and it knows how.

LLM Context File

For AI agents that support context files:

https://docs.browser-use.com/llms-full.txt

Point your coding agent (Cursor, Continue, etc.) to this URL for full Browser Use documentation in context.

Performance and Pricing

ChatBrowserUse (Their Optimized Model)

  • Completes tasks 3-5x faster than generic models
  • Optimized specifically for browser automation
  • Pricing per 1M tokens (bu-2-0, as of October 2026):
    • Input: $0.60
    • Cached input: $0.06
    • Output: $3.50
  • Cloud browsers: $0.02 per browser-hour, residential proxies $5/GB

Using Your Own LLM

Completely free for the Browser Use library itself. You pay only for:

  • Your chosen LLM provider’s API costs
  • Cloud infrastructure if you use their hosted browsers

Quick Reference

TaskCommand/Code
Install (library)uv add browser-use
Install (CLI)uv tool install browser-use
Agent skillbrowser-use skill install
Install browseruvx browser-use install
Open URL (CLI)browser-use open https://example.com
See elementsbrowser-use state
Click elementbrowser-use click <index>
Screenshotbrowser-use screenshot output.png
Generate templateuvx browser-use init --template default

The Bottom Line

Browser Use represents a fundamental shift in how we approach web automation. Instead of brittle scripts that break with every UI change, you describe what you want in natural language and let an AI agent figure out the implementation details.

At 117,000+ GitHub stars and growing (as of October 2026), it’s clearly resonating with developers tired of maintaining Selenium scripts. Whether you’re automating job applications, monitoring prices, or building AI assistants that can interact with the web, Browser Use removes the friction between intent and execution.

The combination of open-source flexibility (use any LLM) with production-ready cloud infrastructure (when you need it) makes it suitable for everything from weekend projects to enterprise automation pipelines.

Links: