Browser Use: What It Is and How to Build a Browser Agent

Browser Use lets you give a website task to an AI agent while keeping the automation in your application. Its open-source library requires Python 3.11 or newer; Browser Use Cloud can host the browser or the whole agent. Start with a task you can verify, such as reading a portal record, before giving it permission to submit changes.

Verified against the Browser Use GitHub README and the linked official documentation on 2 November 2026. The walkthrough below is adapted from those docs; it is not a hands-on performance test.

What Browser Use Does

Browser Use connects a language model to a browser so your application can describe a goal instead of prescribing every click. It fits work such as finding a record in a supplier portal, reading a dashboard or navigating a form whose next screen depends on the previous answer. The open-source library supplies the agent, the software that repeatedly chooses and performs actions toward that goal. Library README

Think of the language model as a driver, Browser Use as the controls and feedback around the driver, and the browser as the vehicle. The road is still somebody else's website. A capable driver cannot make a closed road accessible or decide that a delivery authorizes an unrelated purchase.

The loop works like this:

1. Observe: collect the current page state, including its interactive elements. Browser Use can also provide screenshots to the model.
2. Decide: the large language model, or LLM, uses the task and current state to select the next action.
3. Act: the browser navigates, clicks, types or performs another available operation.
4. Observe again: the next decision uses the changed page, continuing until the agent stops or a configured limit interrupts it.

The DOM, a page's structured tree of elements, helps expose controls the agent can act on; screenshots add visual context. Browser Use documents both DOM processing and configurable vision, so it is misleading to describe it as only a model looking at pictures. Browser controls, agent settings

For a founder building a procurement assistant, the useful task might be “find the shipment status for this order.” The acceptance check is the correct order and its status, with a source record. A convincing paragraph from the agent is not that check.

Browser Use Open Source: What You Install

The core installation is the browser-use Python package, a browser to control and access to a supported model. The library is MIT-licensed. Its README specifies Python 3.11 or newer, while the quickstart uses Python 3.12. You can run the agent in your own process and choose a local or remote browser. README and installation

“Local” describes where that process or browser runs. If you select a remote model API, observations still go to that model service; a local browser does not make the whole system local.

Which Models Can Drive It?

Browser Use supports several provider adapters, so you do not have to choose its own model:

• Browser Use BU2: ChatBrowserUse(model="bu-2-0"), using BROWSER_USE_API_KEY.
• OpenAI models: ChatOpenAI, using OPENAI_API_KEY.
• Anthropic Claude models: ChatAnthropic, using ANTHROPIC_API_KEY.
• Google Gemini models: ChatGoogle, using GOOGLE_API_KEY.
• Local models through Ollama: ChatOllama, connected to your local model service.

The supported-models documentation also lists integrations for DeepSeek, Mistral, Microsoft Azure OpenAI, Amazon Web Services Bedrock and OpenRouter. Check the provider's current model availability rather than treating an old example ID as a recommendation.

An adapter is not a quality guarantee. The same documentation warns that some Qwen models produce an incorrect action schema, meaning instructions in a format the agent cannot execute, and currently recommends qwen-vl-max for that integration. Evaluate a model on your actual pages and required outputs before expanding its responsibilities.

Browser Use Web UI

Browser Use Web UI is a separate project with a Gradio interface, a web front end for interacting with the agent. It has its own installation and dependencies. For an application integration, start with the Python library's current docs; do not mix the Web UI repository's setup with the hosted service SDK.

What Browser Use Cloud Adds

Browser Use Cloud lets you outsource the browser infrastructure, the whole agent, or both. Those choices change how much code you operate. The current Cloud quickstart separates them explicitly:

With your own agent, Browser(use_cloud=True) selects Browser Use's hosted browser and requires BROWSER_USE_API_KEY. The managed browser adds stealth features, proxies and a live preview; the README also describes CAPTCHA handling, with an explicit caveat that results depend on the site and challenge. Cloud browser guide, README

CDP, the Chrome DevTools Protocol, is the remote-control connection used by the documented infrastructure route. A hosted browser can therefore support code that you continue to run yourself.

For the fully hosted route, the package is browser-use-sdk, not browser-use. Current Cloud examples use API V4 and the Python import from browser_use_sdk.v4 import BrowserUse. Your program submits a task and retrieves the result instead of running the local Agent loop. Hosted-agent quickstart

For a developer, this is a deployment choice. For an operator, the remaining responsibility is the same: decide what the agent may access and what evidence counts as a completed job.

When a Browser Use Alternative Fits Better

Pick the layer you need to own. Browser Use is a strong starting point when the task stays inside websites and you want a packaged browser-agent loop with model choice. A computer-use API fits when you want to build around its action interface or need work beyond web pages.

OpenAI also offers a separate Agents API with an OpenAI-hosted browser, so “computer use always means hosting your own browser” is no longer a useful rule. Browserbase likewise has agent products beyond its browser infrastructure.

Browser Use and Browserbase are not necessarily exclusive choices: Browser Use accepts a cdp_url, and Browserbase exposes a CDP connection URL. Those documented interfaces provide a route to combining the agent library with that runtime, although this article does not claim to have tested the integration. Browser Use connection settings

Keep an existing reliable API or fixed browser script when it already does the job. A stable form does not benefit from asking a model to rediscover the same sequence. The broader computer-use-agent guide covers the control decision; browsers for AI agents compares infrastructure.

The Risks That Still Belong to Your Application

The hardest production boundary is what the signed-in browser is allowed to do. Hosting it elsewhere does not make page instructions trustworthy or remove the consequences of a mistaken submission.

Prompt Injection From Page Content

Prompt injection happens when content the agent reads tries to redirect its instructions. In a portal, that content could be a customer-entered note telling the agent to upload a report to another destination. Treat the note as data, even when it claims to be an administrator's instruction.

Use dedicated accounts with only the permissions the task needs. Restrict navigation with Browser Use's allowed_domains, and enforce approval for consequential actions in your application or execution environment. An allowed site can still display hostile user-generated content, so a domain list alone cannot establish trust. Browser restrictions, computer-use safety guidance

A prompt saying “ask before submitting” is not an enforced permission boundary. If your integration cannot reliably intercept the relevant action, keep that action outside the agent's permissions and have a person complete it. The prompt-injection guide explains how to bind approval to the exact action being authorized.

Logins, Session Storage and Logs

A saved login carries access. Browser Use can reuse Chrome through Browser.from_system_chrome() or load saved cookies and local storage with Browser(storage_state="auth.json"). Protect that state file as a credential, exclude it from source control and avoid using a personal browser profile for an unattended business task. Authentication documentation

There is a specific migration limit: the README says local profile sync transfers cookies, not local storage, IndexedDB or extensions. IndexedDB is another browser-side data store. Separately, Cloud profiles can persist cookies, local storage and login state across cloud browsers. That persistence does not mean the local sync copied every storage mechanism. Some websites will require a fresh login. Sync caveat

Keep profiles separate for each end user. Also review what reaches model inputs, screenshots and saved conversation histories before handling private portal data. Browser Use exposes screenshot and conversation-saving controls; configure them deliberately. Agent settings

Rate Limits and Uncertain Retries

A cloud browser slot does not grant unlimited access to the target site. Plan separately for model-service limits, Browser Use Cloud capacity and request limits, and the website's own throttling or challenges.

Limit simultaneous work per target site, back off when it requests a delay and stop repeated blocked attempts. For Cloud API errors, inspect whether the failure concerns capacity or request frequency and honor the returned retry guidance. Cloud limits

Most importantly, do not start a duplicate submission because your client timed out. Check the existing run and the destination record first. A timeout can leave you uncertain about an action that already happened.

Browser Use Documentation: A Short First Run

Start with a public page and a read-only task. This proves that the package, browser and model can connect without involving a login or a business transaction. The commands follow the open-source quickstart; this example uses its Python 3.12 environment and the README's explicit BU2 model selection.

Browser-Use Python Setup

1. 1

   Install the package and browser

   On macOS or Linux, with Python and pip available, open a Bash shell in a new project directory:

   pip install uv
   uv venv --python 3.12
   source .venv/bin/activate
   uv pip install browser-use
   uvx browser-use install

   The final command installs the browser. On Windows, use the environment activation command shown in the quickstart instead of source.

2. 2

   Configure the model credential

   Create a Browser Use API key in the dashboard linked from the quickstart. In the same Bash shell, enter it without displaying it:

   read -rsp "Browser Use API key: " BROWSER_USE_API_KEY
   printf '\n'
   export BROWSER_USE_API_KEY

   This key enables the selected model service. It does not automatically move the browser to Cloud.

3. 3

   Run a small read-only task

   Save this as agent.py:

   import asyncio
   from browser_use import Agent, ChatBrowserUse
   
   async def main():
       agent = Agent(
           task=(
               "Open https://example.com and report the page heading. "
               "Do not follow links or submit anything."
           ),
           llm=ChatBrowserUse(model="bu-2-0"),
       )
       history = await agent.run()
       print(history.final_result())
   
   if __name__ == "__main__":
       asyncio.run(main())

   Then run:

   python agent.py

   Check the reported heading against the page yourself. The task instruction is a suitable starting constraint for this harmless example; production restrictions need enforcement outside the prompt.

If it fails, read the error before changing models: browser installation, model authentication and website access are different failure points. Once it works, retain the dependency versions you used and move to a test account on the intended site.

What Is Overhyped?

A completed agent run is not proof of a completed business transaction. Browser Use's output documentation makes the distinction explicit: is_done() means the agent emitted a done action; is_successful() is the agent's own assessment. Important external outcomes still need verification against the destination system. Output semantics

For an address change, inspect the saved address. For a downloaded report, inspect the file and reporting period. For a submission, capture the destination's confirmation and reconcile uncertain outcomes before retrying.

The same restraint applies to “works on any website.” Managed browser features can reduce access friction, but the project's README does not promise that every CAPTCHA can be avoided or solved. A better model also cannot grant account permissions the user does not possess. Build around the site's actual behavior, including the point where a person must take over.

Your Monday Move

For a technical founder, the first useful pilot is one narrow portal-reading task with a clear answer. Use a separate test account, identify the permitted pages, and write down how you will verify the returned record. Record failures as well as completed runs.

Expand to form preparation only after you understand those failures. Leave submission with a person until your application can enforce approval, inspect the saved result and recover without duplicating the action. If a supported API or stable script covers the workflow, keep that simpler integration.

For practical notes on building dependable AI workflows, join the newsletter.