Browser Use

• Fully Hosted Cloud: Send tasks through the API and let Browser Use run the agent, browser, and infrastructure.
• CLI: Give an existing agent (Claude Code, Codex, Hermes, OpenClaw, Pi, Cursor, etc.) browser access. You can use it interactively or in scripts.
• Python Library: Run the open source agent in your own application, with custom tools, structured output, and your choice of model.

The CLI and Python library can each connect to a local or cloud browser. A cloud browser hosts the browser; the fully hosted API runs the agent as well.

We recommend BU2, our model optimized for browser automation: ChatBrowserUse(model='bu-2-0'). It uses BROWSER_USE_API_KEY; ChatBrowserUse() currently selects the same model.

The best choice depends on your tasks, latency, and budget. See the BU2 model card, benchmark, and supported models and pricing to compare options.

Yes. ChatBrowserUse accepts provider-prefixed model IDs through the Browser Use gateway, using BROWSER_USE_API_KEY:

from browser_use import Agent, ChatBrowserUse

llm = ChatBrowserUse(model='anthropic/claude-sonnet-4-6')  # or 'google/gemini-3-pro'
agent = Agent(task='...', llm=llm)

You can also use providers directly through wrappers such as ChatOpenAI, ChatAnthropic, and ChatGoogle, with each provider's own API key. See supported models.

No. Agent(...) supplies the Browser Use system prompt automatically, including when you change models. Put your task in task=. Use extend_system_message to add instructions or override_system_message to replace the default prompt when you need custom behavior.

See the custom system prompt example.

Yes. Register a function with Tools and pass it to the agent. This example adds a tool for the current UTC time and uses BROWSER_USE_API_KEY from .env:

import asyncio
from datetime import datetime, timezone

from browser_use import ActionResult, Agent, ChatBrowserUse, Tools
from dotenv import load_dotenv

load_dotenv()
tools = Tools()

@tools.action(description='Get the current date and time in UTC.')
def get_current_time() -> ActionResult:
    return ActionResult(extracted_content=datetime.now(timezone.utc).isoformat())

async def main():
    agent = Agent(
        task="What is the current UTC time?",
        llm=ChatBrowserUse(model='bu-2-0'),
        tools=tools,
    )
    history = await agent.run()
    print(history.final_result())

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

The Python library is free and MIT-licensed. Model inference and hosted browsers are separate: API providers, including ChatBrowserUse, and Browser Use Cloud charge for usage. You can also use a local browser and a local model through Ollama, subject to your hardware and model requirements.

This open-source library is licensed under the MIT License. For Browser Use services & data policy, see our Terms of Service and Privacy Policy.

• Local browser: Use Browser.from_system_chrome() to reuse a Chrome profile. See the real-browser guide and example.
• Cloud browser: Follow the profile sync guide, then use Browser(use_cloud=True, cloud_profile_id='your-profile-id').

Profile sync transfers cookies, not local storage, IndexedDB, or extensions. Some sites may require you to sign in again.

Browser Use Cloud provides stealth browsers and proxies designed to reduce bot detection and CAPTCHA challenges. With the Python library, enable a cloud browser with Browser(use_cloud=True) and set BROWSER_USE_API_KEY.

Results depend on the site and challenge; no browser configuration guarantees that every CAPTCHA can be avoided or solved.

Choose how much you want to manage:

• Keep your agent code: Connect the CLI or Python library to cloud browsers for managed browser infrastructure, stealth, profiles, and recordings.
• Have us run the agent too: Use the fully hosted Cloud API to submit tasks and retrieve results.

You can also host the Python library and browsers on your own infrastructure.

Yes. Save a successful run, then replay its clicks and typing with new values. The snippet below runs inside an async function:

from browser_use import Agent, ChatBrowserUse

llm = ChatBrowserUse()
agent = Agent(task='Open https://example.com/billing and request an invoice copy for Ada Lovelace, ada@example.com', llm=llm)
await agent.run()
agent.save_history('invoice_run.json')
print(agent.detect_variables())  # names come from the form's fields, e.g. 'name' and 'email'

# Later: the same clicks and typing with new values, no model call per step
results = await Agent(task='', llm=llm).load_and_rerun(
    'invoice_run.json', variables={'name': 'Grace Hopper', 'email': 'grace@example.com'}, skip_failures=False
)

• Use the variable names detect_variables() prints. An unknown name is skipped with a warning, and the recorded value is typed instead.
• Extract steps and the closing summary still call the model.
• If the page changed, the replay raises RuntimeError at the first step it cannot match. The steps before it already ran, so check whether the form was sent before you run the agent again.
• Keep the saved file private. With sensitive_data, typed secrets are saved as <secret>key</secret> placeholders, but page snapshots and results are saved as they were and can still contain them. Give the replaying agent the same sensitive_data; without it, the placeholder text is typed.

Example