Browser Use toolsets for Claude

Connect Claude to a local, Cloud, or existing CDP browser with Browser Use and the Anthropic Python SDK.

Browser Use toolsets for Claude is maintained by Browser Use and is compatible with Claude. It provides browser actions and a Bash tool through the Anthropic Python SDK. The SDK’s tool runner sends each of Claude’s tool calls to Browser Use, returns the result to Claude, and repeats until Claude finishes.

Open full-size diagram

Open full-size diagram

Installation

This integration requires a Browser Use version containing browser_use.integrations.toolsets_for_claude and an Anthropic SDK version containing anthropic.tools.browser and client.beta.messages.tool_runner. If either import is unavailable, your installed package version does not support this example. Check Anthropic’s browser-toolset release instructions for SDK availability.

You need Python 3.11 or newer on Linux or macOS with /bin/bash. On Windows, run the example inside WSL.

uv init --python 3.12
uv add "browser-use>=0.13.11" "anthropic>=1,<2"
uvx browser-use install

uvx browser-use install installs local Chromium. You can skip it if you only use Browser Use Cloud.

Create an Anthropic API key in the Claude Console, then export it in the terminal where you run the script. This key is required for every browser mode:

export ANTHROPIC_API_KEY=your-key

Before running the example, check that the installed SDK exposes the browser toolset:

uv run python -c "from anthropic.tools.browser import LocalFilePolicy; from browser_use.integrations.toolsets_for_claude import Bash, BrowserUse; print('Browser toolset imports OK')"

Browser Use 0.13.11 or newer includes this integration. The Anthropic 1.x version range alone does not guarantee browser-toolset support: you need the compatible release from Anthropic. If the check reports that anthropic.tools.browser is missing, follow Anthropic’s browser-toolset release instructions before continuing. Reinstalling Browser Use or adding a Cloud key cannot supply that SDK module.

A local browser only needs ANTHROPIC_API_KEY; it does not require a Browser Use Cloud key. Keep both keys exported when using Cloud: Anthropic runs Claude, while Browser Use provisions the browser. The shell export commands above apply to the current terminal; this script does not load a .env file automatically.

Quickstart

This example reads three Hacker News posts and saves their titles and URLs as Markdown and JSON in outputs/. It enables all 31 browser actions plus Bash, without approval prompts.

Save the following as run_browser.py:

"""Build a Hacker News reading list with Browser Use and Claude.

Requires Linux/macOS with /bin/bash, or WSL on Windows.
"""

import asyncio
from pathlib import Path

from anthropic import AsyncAnthropic
from anthropic.tools.browser import LocalFilePolicy  # pyright: ignore[reportMissingImports]

from browser_use.integrations.toolsets_for_claude import Bash, BrowserUse

TASK = 'Read the first three Hacker News posts and save their titles and URLs to hacker-news.md and hacker-news.json.'

SYSTEM_PROMPT = 'Complete the task with the browser tools and Bash.'


async def main() -> None:
	driver = BrowserUse(
		# use_cloud=True,  # Uncomment and set BROWSER_USE_API_KEY to use Cloud.
		# These tools are disabled by default.
		configs={
			'javascript_exec': {'enabled': True},
			'file_upload': {'enabled': True},
			'read_console': {'enabled': True},
			'read_network': {'enabled': True},
		},
		confirm=lambda _: True,  # Run without approval prompts.
		file_policy=LocalFilePolicy(upload_roots=[Path('uploads'), Path('outputs')]),
	)
	bash = Bash(output_dir=Path('outputs'))

	async with driver, AsyncAnthropic() as client:
		runner = client.beta.messages.tool_runner(
			model='claude-opus-5-5',
			max_tokens=32_768,
			max_iterations=100,
			tools=[driver, bash],
			system=SYSTEM_PROMPT,
			messages=[{'role': 'user', 'content': TASK}],
		)
		final = await runner.until_done()
		print('\n'.join(block.text for block in final.content if block.type == 'text'))


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

Run it:

uv run run_browser.py

The script prints Claude’s final answer with the three titles and the saved filenames. Set ANTHROPIC_LOG=info to include SDK request logs.

The system prompt is part of your application. Adapt it to your task.

Choose a browser

To run the browser in Browser Use Cloud, create a key at Browser Use Cloud, set BROWSER_USE_API_KEY, and uncomment use_cloud=True in the quickstart’s BrowserUse(...) call. Keep its configs and confirm arguments. For remote uploads, replace the local file_policy with the staged-document policy and resolver in Uploads to a remote browser. Local Chromium is not needed in this mode. Bash still runs on the SDK host.

Keep ANTHROPIC_API_KEY set for Claude and export the additional Cloud key in the same terminal:

export BROWSER_USE_API_KEY=your-cloud-key

BrowserUse supports three browser configurations:

Browser	Configuration	Lifecycle
Local Chromium	BrowserUse()	Owned: the driver starts and closes it
Browser Use Cloud	BrowserUse(use_cloud=True)	Owned: the driver creates and stops it
Existing CDP browser	BrowserUse(session)	Borrowed: your application manages it

To use a browser you already started, pass a connected BrowserSession. The driver does not close a borrowed session, so close it in your application’s cleanup block. See remote browser connections for CDP configuration.

Browser tools

The Browser Use integration provides BrowserUse for browser actions and Bash for shell commands. Register both with tools=[driver, bash]. Leave out bash if your application should not run shell commands.

Claude calls structured actions such as navigate, read_page, and left_click, and the driver runs them over CDP. javascript_exec runs JavaScript inside the page; it is not a general-purpose CDP code interpreter. Bash runs beside your Python process with output_dir as its working directory, where it can process extracted data and write reports.

Open full-size diagram

Open full-size diagram

All 31 browser actions

• Navigation: navigate, new_tab, list_tabs, switch_tab, close_tab.
• Page state: screenshot, zoom, read_page, find, get_page_text, wait.
• Pointer: left_click, right_click, middle_click, double_click, triple_click, hover, mouse_move, left_mouse_down, left_mouse_up, left_click_drag, scroll, scroll_to.
• Input: type, key, hold_key, form_input, file_upload.
• Diagnostics: read_console, read_network, javascript_exec.

The quickstart enables all 31 browser actions plus Bash. A bare BrowserUse() follows Anthropic’s defaults: 27 actions enabled, with javascript_exec, file_upload, read_console, and read_network off. The quickstart turns those four on with configs:

configs={
    'javascript_exec': {'enabled': True},
    'file_upload': {'enabled': True},
    'read_console': {'enabled': True},
    'read_network': {'enabled': True},
}

Your application supplies the tools to Claude through tools=[driver, bash]. The SDK sends the browser toolset and its configs to Anthropic, and Claude chooses calls from the enabled actions. Disabled actions are withheld from Claude and rejected by the SDK if requested. Registering driver alone does not include Bash. javascript_exec runs JavaScript inside the page; Bash runs commands on the SDK host.

To opt out, set an action’s enabled value to False in the configs passed to BrowserUse(...). To remove Bash, use tools=[driver] and update the task and system prompt so they do not request shell commands.

File uploads and downloads

File paths in browser actions refer to the browser host. With local Chromium, that is the same machine as your Python process: an approved local file can be uploaded, and downloaded bytes can be read locally. A remote browser has its own filesystem.

Open full-size diagram

Open full-size diagram

Uploads to a remote browser

For a remote upload, your application must first copy the file’s bytes to the browser host. Then it can give Claude an approved document ID and map that ID to the staged path. file_upload selects the staged file in the page’s file input.

The transfer step is separate from the driver. The code below begins after report.pdf is already on the browser host:

from anthropic.tools.browser import LocalFilePolicy
from browser_use.integrations.toolsets_for_claude import BrowserUse

# session is an already connected remote BrowserSession.
# The file must already exist on that browser's machine.
remote_paths = {'report': '/staged/report.pdf'}

driver = BrowserUse(
    session,
    configs={'file_upload': {'enabled': True}},
    confirm=lambda _: True,
    file_policy=LocalFilePolicy(upload_document_ids=remote_paths.keys()),
    document_resolver=lambda document_id: remote_paths[document_id],
)

The resolver maps IDs to paths and does not copy bytes. BrowserUse(use_cloud=True) does not provide automatic upload staging or download retrieval. The open-source Agent has the same browser-host path requirement for uploads.

Downloads from a remote browser

A download notification reports that the browser finished a download. The reported path is metadata about the browser host and does not mean the file exists on the SDK host. Retrieve the file to the SDK host before asking Bash to read it.

The quickstart needs no transfer, because Bash writes the Markdown and JSON directly on the SDK host.

Approvals

Enabling file_upload or javascript_exec requires a confirmation callback. The SDK calls it before executing a browser action, after checking that the action is enabled and its inputs and file selection are allowed.

The quickstart uses confirm=lambda _: True to approve browser actions automatically. Replace it with the callback below to ask for approval when Claude uploads a file or runs page JavaScript. It approves other browser actions automatically. The callback can use a terminal prompt, a review screen in your app, or your own approval service.

Open full-size diagram · See the file-upload sequence

Open full-size diagram · See the file-upload sequence

import asyncio
from pathlib import Path

from anthropic.tools.browser import ConfirmContext, LocalFilePolicy
from browser_use.integrations.toolsets_for_claude import BrowserUse


async def confirm(context: ConfirmContext) -> bool:
    if context.member not in {'file_upload', 'javascript_exec'}:
        return True
    details = context.input.model_dump_json(exclude_none=True)
    answer = await asyncio.to_thread(
        input,
        f"Action: {context.member}\nPage: {context.tab_url}\n{details}\nAllow this action? [y/N] ",
    )
    return answer.strip().lower() == 'y'


driver = BrowserUse(
    configs={
        'file_upload': {'enabled': True},
        'javascript_exec': {'enabled': True},
    },
    confirm=confirm,
    file_policy=LocalFilePolicy(upload_roots=[Path('uploads'), Path('outputs')]),
)

For example, an upload request could show this prompt (the paths and page below are illustrative):

Action: file_upload
Page: https://example.com/application
{"target":{"type":"ref","ref":"ref_7"},"paths":["/your-project/uploads/report.pdf"]}
Allow this action? [y/N]

Callback outcome	What happens
User enters y or Y	Returns True; the driver executes this action.
User presses Enter or enters another answer	Returns False; the action does not execute.
The prompt or approval service raises an exception	The action does not execute; the SDK reports an error.

Approval applies to this action only. Later calls pass through the callback again. The file allowlist restricts local uploads to uploads/ and outputs/, so files written by Bash can also be approved for upload. Remote browsers require staging on the browser host, as described in Uploads to a remote browser.

This callback prompts for upload and JavaScript and approves all other browser actions. Add checks for actions with side effects, such as sending a message, submitting a purchase, or deleting a record.

Browser confirmation does not cover Bash. Omit Bash or apply a separate execution policy if shell commands need approval. Bash limits execution time and returned output, and removes ambient credentials from its child environment. Its working directory is not an operating-system sandbox, so run untrusted tasks in an isolated environment.

---

Read the Claude browser-toolset quickstarts for the upstream SDK contract.