browser-use--browser-use/skills/open-source/references/examples.md

Example Patterns & Templates

Table of Contents

• Fast Agent
• Parallel Browsers
• Follow-Up Tasks
• Sensitive Data
• Playwright Integration

---

Fast Agent

Maximize speed with optimized config:

from browser_use import Agent, Browser, BrowserProfile, ChatGroq

# Fast LLM (Groq or Gemini Flash Lite)
llm = ChatGroq(model="meta-llama/llama-4-maverick-17b-128e-instruct")

# Minimize wait times
browser = Browser(
    minimum_wait_page_load_time=0.1,
    wait_between_actions=0.1,
)

agent = Agent(
    task="Find top HN post",
    llm=llm,
    browser=browser,
    flash_mode=True,  # Skip LLM thinking, use memory only
    extend_system_message="Be fast. Execute multiple actions per step.",
)

await agent.run()

Key optimizations:

• flash_mode=True — skip evaluation, next goal, thinking
• Low wait times — 0.1 instead of defaults
• Fast LLM — Groq or Gemini Flash Lite
• Multi-action prompts — fill multiple fields per step

Parallel Browsers

Run multiple agents concurrently:

import asyncio
from browser_use import Agent, Browser, ChatBrowserUse

async def run_task(task: str, index: int):
    browser = Browser(user_data_dir=f'./temp-profile-{index}')
    try:
        agent = Agent(task=task, llm=ChatBrowserUse(), browser=browser)
        result = await agent.run()
        return result
    finally:
        await browser.close()

async def main():
    tasks = [
        "Find the latest AI news on TechCrunch",
        "Get Bitcoin price from CoinGecko",
        "Find top Python packages on PyPI",
    ]
    results = await asyncio.gather(*[run_task(t, i) for i, t in enumerate(tasks)])

Each agent gets its own browser with a separate profile to avoid conflicts.

Follow-Up Tasks

Chain tasks in a persistent browser session:

from browser_use import Agent, Browser, ChatBrowserUse

browser = Browser(keep_alive=True)
await browser.start()

agent = Agent(
    task="Go to GitHub and search for 'browser-use'",
    llm=ChatBrowserUse(),
    browser=browser,
)
await agent.run()

# Queue follow-up in same browser (cookies/localStorage preserved)
agent.add_new_task("Click on the first repository and extract the star count")
await agent.run()

await browser.close()

keep_alive=True keeps browser open between tasks. Agent maintains memory and browser state.

Sensitive Data

Handle credentials without exposing to LLM:

agent = Agent(
    task="Login to example.com",
    llm=llm,
    sensitive_data={
        'x_user': 'my-username',       # All sites
        'x_pass': 'my-password',       # All sites
    },
    browser=Browser(allowed_domains=['*.example.com']),
)

• LLM sees placeholder names (x_user, x_pass), not real values
• Real values injected into form fields at execution time
• Never appears in logs or LLM context

Per-Domain Credentials

sensitive_data = {
    'github_user': 'gh-username',
    'github_pass': 'gh-password',
    'gmail_user': 'gmail-address',
}

Best Practices

• Use Browser(allowed_domains=[...]) to restrict navigation
• Set use_vision=False for sensitive pages
• Prefer storage_state='auth.json' over sending passwords
• Use TOTP secrets with bu_2fa_code suffix for 2FA (see browser.md)

Playwright Integration

Share Chrome between Playwright and Browser-Use via CDP:

import subprocess
from playwright.async_api import async_playwright
from browser_use import Agent, Browser, Tools, ChatBrowserUse

# 1. Start Chrome with remote debugging
proc = subprocess.Popen([
    'google-chrome', '--remote-debugging-port=9222', '--user-data-dir=/tmp/chrome-debug'
])

pw = None
try:
    # 2. Connect Playwright
    pw = await async_playwright().start()
    pw_browser = await pw.chromium.connect_over_cdp("http://localhost:9222")
    pw_page = pw_browser.contexts[0].pages[0]

    # 3. Connect Browser-Use to same Chrome
    browser = Browser(cdp_url="http://localhost:9222")

    # 4. Custom tools using Playwright
    tools = Tools()

    @tools.action(description='Fill form field using Playwright selector')
    async def pw_fill(selector: str, value: str) -> str:
        await pw_page.fill(selector, value)
        return f'Filled {selector}'

    @tools.action(description='Take Playwright screenshot')
    async def pw_screenshot() -> str:
        await pw_page.screenshot(path='screenshot.png')
        return 'Screenshot saved'

    # 5. Agent orchestrates using both
    agent = Agent(task="Fill out the form", llm=ChatBrowserUse(), browser=browser, tools=tools)
    await agent.run()
finally:
    if pw:
        await pw.stop()
    proc.terminate()
    proc.wait()

Both Playwright and Browser-Use operate on the same pages through the shared CDP connection.