Open Browser Use

Open Browser Use

Overview

Open Browser Use connects an MV3 Chrome extension, a local native messaging host, a CLI, SDKs, and an optional stdio MCP server so agents can automate a real Chrome profile. It is not Codex.app-specific; adapt the commands, MCP config, and SDK examples to the agent runtime you are operating in.

Core Workflow

1. Check setup with open-browser-use ping or obu ping. If it fails because setup is missing, read references/installation.md. 2. Pick the right browser/profile if multiple are installed. See "Browser and profile handling" below before issuing browser commands. 3. Choose a unique browser session id for the current agent task before opening or claiming tabs. Prefer the surrounding runtime's conversation/session id when available; otherwise create a short unique id such as obu-<task-slug>-<timestamp>. Reuse that same id for every Open Browser Use command in this task. 4. Name the current browser task group before opening or claiming tabs. Use a short task label followed by - OBU; if no better task label is available, use Task - OBU. 5. Before opening a new tab, run user-tabs / user_tabs and check whether the task continues from an existing tab, including tabs in ✅ Open Browser Use or an earlier handoff task group. If the URL/title/group clearly matches the current task, claim that tab and continue from it instead of opening a duplicate. 6. Use the CLI for simple inspection or one-shot actions: info, tabs, user-tabs, history, open-tab, navigate, cdp, and call. 7. Use open-browser-use run / obu run for CLI-level multi-step orchestration when a small line-oriented action plan is enough and writing SDK code would be unnecessary. 8. If the surrounding agent runtime supports local MCP servers, configure obu mcp and call the exposed browser tools directly. Use the run_action_plan MCP tool for the same line-oriented orchestration from MCP. Read references/sdk-and-protocol.md. 9. Use the JavaScript, Python, or Go SDK for larger multi-step workflows, event subscriptions, richer control flow, or when the surrounding agent runtime already runs code. Read references/sdk-and-protocol.md. 10. Before ending browser work, release or keep session tabs with open-browser-use finalize-tabs --session-id "$OBU_SESSION_ID" --keep '<json-array>', the MCP finalize_tabs tool, or the SDK finalizeTabs / finalize_tabs / FinalizeTabs method. 11. If communication fails after setup, read references/troubleshooting.md.

Operating Rules

• Treat the browser as the user's real Chrome profile. Do not inspect cookies, passwords, session stores, or unrelated browser data.
• Ask the user before installing the extension, opening Chrome for them, enabling extension permissions, uploading local files, reading/writing clipboard data, submitting forms, purchasing, deleting, sending, or making other externally visible changes.
• Do not assume Codex.app helpers, Node REPL globals, or a bundled plugin UI are available. Use the installed open-browser-use / obu CLI or the published SDKs.
• Do not guess tab ids. List tabs first, then use ids returned by tabs, user-tabs, open-tab, or SDK calls.
• Prefer claim-tab / claimUserTab for existing user tabs. Claiming should be based on the current user-tabs result and visible evidence such as URL, title, recency, or group.
• For follow-up tasks, inspect user-tabs before opening a tab and reuse a matching tab from ✅ Open Browser Use or a previous handoff group. A deliverable tab can be claimed back into the new task session, worked on, and finalized as deliverable again when it remains the user-facing result. This keeps repeated work on the same page converged to one live tab.
• Do not claim unrelated deliverable tabs just because they are in ✅ Open Browser Use. If several tabs plausibly match, prefer the most recent exact URL/title match; ask the user when the match is ambiguous.
• Use --socket only when the user or runtime provides an explicit socket. Otherwise let the CLI and SDKs discover the active socket registry.
• Do not rely on the CLI fallback session obu-cli for agent tasks. Always pass a task-unique --session-id to CLI and MCP commands, or set sessionId / session_id / SessionID in SDK clients. The fallback exists for quick manual use and can reuse stale task groups across unrelated agent sessions.
• Direct CLI subcommands and open-browser-use run can share the same browser session only when they use the same explicit --session-id. Finalize that same session before ending browser work.
• Use call --method <method> --params '<json>' only when no safer convenience command or SDK wrapper exists.

Browser and profile handling

Some users run several supported browsers (for example Google Chrome, Google Chrome Beta, or BitBrowser) and may also have multiple profiles inside them. If more than one browser/profile target has the Open Browser Use extension installed, the agent must decide which target this task should operate on rather than silently picking whatever window happens to be active.

1. Before any browser command, list installed browser/profile targets:

   open-browser-use profiles --connected

Columns include BROWSER, DIRECTORY (stable profile id like Default, Profile 1), DISPLAY NAME (what the user sees in the browser avatar menu), VERSION, and CONNECTED (whether that target's host is currently reachable). JSON output is available via --json and includes a stable target such as chrome:Default, chrome-beta:Default, or bitbrowser:<instance>:Default.

2. If exactly one target is installed and connected, proceed without asking. If it is installed but not connected, ask the user to open Chrome on that browser/profile before running browser commands.

3. If multiple targets are installed and the user did not already specify which one to use, ask before the first browser command. List both directory name and display name plus the browser name so the user can recognize them, and include whether each target is connected.

4. If the chosen target is not connected, ask the user to open that browser and profile before retrying. Do not silently fall back to a different connected browser/profile.

5. After the user has chosen, pass --browser <selector> and, when needed, --profile <selector> to every CLI / MCP command for the rest of the task. Browser selectors accept ids such as chrome, chrome-beta, bitbrowser, browser display names, or a BitBrowser instance id. Profile selectors accept either the directory name (Default, Profile 1) or the display name (Eva, cookiy.com), case-insensitive. Do not switch browser/profile mid-task.

6. If --browser / --profile does not match any running host, the CLI prints which targets are currently connected. Ask the user to open the chosen browser/profile, then retry; do not silently fall back to a different target.

7. For MCP, lock the browser/profile at server start:

   [mcp_servers.open_browser_use]
   command = "obu"
   args = ["mcp", "--session-id", "obu-<task-id>", "--browser", "<browser>", "--profile", "<profile>"]

Do not pass browser/profile as per-tool-call arguments — the MCP server applies the start-time selectors to every call.

8. Do not remember the user's browser/profile choice across unrelated tasks. A future task may belong to a different target; ask again rather than assuming.

Common CLI Actions

export OBU_SESSION_ID="obu-docs-scan-$(date +%Y%m%d%H%M%S)"
open-browser-use ping --session-id "$OBU_SESSION_ID"
open-browser-use info --session-id "$OBU_SESSION_ID"
open-browser-use name-session --session-id "$OBU_SESSION_ID" --name "Task - OBU"
open-browser-use tabs --session-id "$OBU_SESSION_ID"
open-browser-use user-tabs --session-id "$OBU_SESSION_ID"
open-browser-use history --session-id "$OBU_SESSION_ID" --query "example" --limit 20
open-browser-use open-tab --session-id "$OBU_SESSION_ID" --url https://example.com
open-browser-use navigate --session-id "$OBU_SESSION_ID" --tab-id <tab-id> --url https://example.com
open-browser-use cdp --session-id "$OBU_SESSION_ID" --tab-id <tab-id> --method Runtime.evaluate --params '{"expression":"document.title"}'
open-browser-use finalize-tabs --session-id "$OBU_SESSION_ID" --keep '[]'

For CLI-level orchestration without writing SDK code, use a line-oriented action plan:

open-browser-use run --session-id "$OBU_SESSION_ID" -c '
name-session "Docs scan - OBU"
open-tab https://docs.browser-use.com
wait-load domcontentloaded
page-info
finalize-tabs []
'

Each action line shares one session/turn. open-tab and claim-tab set the default tab for later tab-scoped actions such as wait-load, page-info, navigate, cdp, move-mouse, and wait-file-chooser.

Use obu as the short alias when available.

MCP Usage

For runtimes that can launch local MCP servers over stdio, use:

[mcp_servers.open_browser_use]
command = "obu"
args = ["mcp", "--session-id", "obu-<task-or-conversation-id>"]

Use a fresh --session-id value per agent task or conversation. If the runtime has a stable conversation/session id, derive the MCP --session-id from it.

The MCP server exposes tools including user_tabs, open_tab, claim_tab, navigate, wait_load, page_info, cdp, history, run_action_plan, finalize_tabs, and unrestricted call.

Use run_action_plan when the runtime wants to execute the same compact action plan format available through open-browser-use run without shelling out for each individual browser operation.

Tab Lifecycle

• Session tabs are tabs Open Browser Use has created or claimed for the current agent workflow.
• Use one unique session id per agent task or conversation. Do not share the fallback obu-cli session across unrelated tasks.
• Task session groups should be named from the task, using the pattern <short task> - OBU. Use Task - OBU as the fallback name.
• At the start of a related follow-up task, list all user tabs and check tabGroup, title, and url before creating anything new. Claim an existing matching deliverable or handoff tab into the current session; only open a new tab when no suitable tab exists.
• Keep no tabs by default: open-browser-use finalize-tabs --session-id "$OBU_SESSION_ID" --keep '[]'.
• Keep a tab only when the user needs that live page after the turn. Omit research, source, search, intermediate, duplicate, blank, error, and login/navigation tabs after extracting what you need.
• Keep a tab with status: "deliverable" when the tab itself is the user-facing output or requested open page, such as a created or edited document, dashboard, checkout/cart, submitted form result, or a page the user explicitly asked to inspect directly.
• Keep a tab with status: "handoff" only when the task is still in progress and the user or a later turn should continue from the current task group, such as a page waiting for user input, login, approval, payment, CAPTCHA, or an unfinished workflow.
• Handoff tabs stay in the task session group. Deliverable tabs move to the shared ✅ Open Browser Use tab group.
• Run finalization as the last Open Browser Use browser action for the turn. Do not call Open Browser Use browser tools after finalizing; if more browser work is needed, do it first and finalize once with the final tab disposition.

File Choosers, Downloads, And Clipboard

• File uploads use the intercepted file chooser flow: start waiting, trigger the chooser in the page, then set absolute local paths with set-file-chooser-files or the SDK equivalent.
• Downloads can be observed with SDK notification handlers or Browser Use methods such as waitForDownload and downloadPath.
• Clipboard helpers operate through the current controlled tab and should be treated as sensitive user actions.

References

• references/installation.md: one-time CLI and browser extension setup, including cases where user cooperation is required.
• references/sdk-and-protocol.md: JavaScript, Python, Go, socket, and JSON-RPC usage details.
• references/troubleshooting.md: connection failures, stale sockets, extension/native host checks, and permission issues.

Open Browser Use Installation

Read this reference when the user asks to install, verify, repair, or explain Open Browser Use setup.

Components

• Chrome extension: the browser-side controller. Installing or enabling it may require the user to approve Chrome prompts.
• Native host and CLI: the local open-browser-use binary, also exposed as obu when installed from supported packages.
• SDKs: JavaScript, Python, and Go clients that connect to the active native host socket.

Install The CLI

Use one of the supported package routes:

npm install -g open-browser-use

brew install iFurySt/open-browser-use/open-browser-use

Verify:

open-browser-use version
obu version

If the short alias is unavailable, use open-browser-use. Running open-browser-use with no subcommand prints the CLI version, browser extension detection status, extension version when available, and the next setup or upgrade command.

Set Up A Browser

After installing the CLI, register the native messaging host and open the Chrome Web Store page for the matching extension:

open-browser-use setup

Ask the user to install or enable Open Browser Use from the opened store page. Chrome may ask the user to confirm, enable the extension, or restart. Do not bypass this user step.

For Chrome Beta, register that browser explicitly:

open-browser-use setup --browser chrome-beta

For BitBrowser, install or load the extension in the target BitBrowser instance, then register the native host manifest into that instance's user-data directory:

open-browser-use install-manifest --browser <bitbrowser-instance-id>

Use open-browser-use profiles --connected --json to see BitBrowser instance ids in the browserInstance field once the instance is detectable.

While the Chrome Web Store item is unavailable or pending review, use the release ZIP path:

open-browser-use setup beta

This downloads the latest keyed open-browser-use-chrome-extension-*.zip from GitHub Releases and registers the native host for that stable extension id. It opens chrome://extensions/ and reveals the ZIP in Finder or the system file manager only when the browser extension is missing or older than the CLI-expected version. Ask the user to enable Developer mode and drag that ZIP into the Chrome extensions page when setup prints that next step.

For Chrome Beta, use open-browser-use setup beta --browser chrome-beta.

Repair only the native host manifest:

open-browser-use install-manifest

Use --browser chrome-beta or --browser <bitbrowser-instance-id> to repair a non-default browser.

Print the manifest without installing:

open-browser-use manifest

Platform Notes

• macOS and Windows can require the user to approve or enable the extension after Chrome sees it.
• Linux external extension registration can require elevated permissions depending on Chrome installation paths.
• Chrome native messaging host name is com.ifuryst.open_browser_use.extension.
• The default socket registry is under /tmp/open-browser-use/ on Unix-like systems.

Verification

Run:

open-browser-use ping --session-id "$OBU_SESSION_ID"
open-browser-use info --session-id "$OBU_SESSION_ID"
open-browser-use user-tabs --session-id "$OBU_SESSION_ID"

For one-off installation checks, a temporary session id is enough. Agent browser tasks should still create and reuse a task-unique session id before opening or claiming tabs.

If ping cannot communicate with Chrome, ask the user whether Chrome is installed and running, whether the extension is enabled, and whether they approved any Chrome prompt. Then use troubleshooting.md.

Open Browser Use SDK And Protocol

Read this reference when the task requires multi-step automation, integration into another agent runtime, or direct Browser Use style JSON-RPC calls.

Connection Model

The Chrome extension starts the native host through Chrome Native Messaging. The native host exposes a local socket and writes the active socket registry so the CLI and SDKs can discover it.

Default route:

agent runtime
  -> open-browser-use CLI, MCP server, or SDK
  -> active Open Browser Use socket
  -> native messaging host
  -> Chrome extension
  -> Chrome tabs / debugger / history / downloads

Pass an explicit socket only when the runtime provides one:

open-browser-use ping --socket /tmp/open-browser-use/example.sock

For SDKs, create a client with socketPath / socket_path / SocketPath.

Browser Session Scope

Use a unique browser session id for each agent task or conversation. Prefer a stable session/conversation id from the surrounding runtime when it exists; otherwise create a short unique id such as obu-<task-slug>-<timestamp>.

Pass that same id through every CLI command, MCP server, or SDK client used for the task. Do not rely on the CLI fallback obu-cli in agent workflows; it is a manual convenience fallback and can reuse stale Chrome tab groups from unrelated tasks.

Install the SDK package from the package registry for your runtime:

npm install open-browser-use-sdk
pip install open-browser-use-sdk
go get github.com/ifuryst/open-browser-use/packages/open-browser-use-go

The Python distribution is named open-browser-use-sdk, while the import module is open_browser_use. Go code usually imports the package as obu.

JavaScript SDK Pattern

Use the high-level browser helper for common multi-step flows:

import { connectOpenBrowserUse } from "open-browser-use-sdk";

const browser = await connectOpenBrowserUse({
  socketPath: "/tmp/open-browser-use/example.sock",
  sessionId: "obu-docs-scan-20260510",
});

try {
  await browser.client.nameSession("Task - OBU");
  const tab = await browser.newTab();
  await tab.goto("https://example.com", { waitUntil: "domcontentloaded" });
  const text = await tab.playwright.domSnapshot();
  console.log(text.slice(0, 4000));
} finally {
  await browser.client.finalizeTabs([]);
  browser.close();
}

Use the low-level client when you need direct Browser Use JSON-RPC/CDP calls:

import { OpenBrowserUseClient } from "open-browser-use-sdk";

const client = new OpenBrowserUseClient({
  socketPath: "/tmp/open-browser-use/example.sock",
  sessionId: "obu-docs-scan-20260510",
});

await client.connect();
await client.nameSession("Task - OBU");
const tab = await client.createTab() as { id: number };
await client.executeCdp(tab.id, "Page.navigate", { url: "https://example.com" });
await client.finalizeTabs([]);
client.close();

The JavaScript SDK supports notification handlers:

const unsubscribe = client.onNotification((event) => {
  if (event.method === "onDownloadChange") {
    console.log(event.params);
  }
});

Python SDK Pattern

import json
from pathlib import Path

from open_browser_use import connect_open_browser_use

registry = json.loads(Path("/tmp/open-browser-use/active.json").read_text())
browser = connect_open_browser_use(
    socket_path=registry["socketPath"],
    session_id="obu-issue-scan-20260510",
)

try:
    browser.client.name_session("Issue scan - OBU")
    tab = browser.new_tab()
    tab.goto("https://github.com/iFurySt/open-codex-computer-use/issues", wait_until="domcontentloaded")
    tab.playwright.wait_for_load_state(state="domcontentloaded", timeout=15)
    tab.playwright.wait_for_timeout(1500)

    text = tab.playwright.locator("body").inner_text(timeout_ms=10000)
    result = {
        "title": tab.title(),
        "url": tab.url(),
        "text": text[:4000],
    }
    print(result)
finally:
    browser.client.finalize_tabs([])
    browser.close()

Use the low-level client when you need raw JSON-RPC/CDP calls:

from open_browser_use import OpenBrowserUseClient

client = OpenBrowserUseClient(
    socket_path="/tmp/open-browser-use/example.sock",
    session_id="obu-docs-scan-20260510",
)

client.name_session("Task - OBU")
tab = client.create_tab()
client.execute_cdp(tab["id"], "Page.navigate", {"url": "https://example.com"})
client.finalize_tabs([])
client.close()

Go SDK Pattern

package main

import (
	"fmt"
	"log"
	"time"

	obu "github.com/ifuryst/open-browser-use/packages/open-browser-use-go"
)

func main() {
	browser, err := obu.ConnectActive(obu.Options{
		SessionID: "obu-issue-scan-20260510",
		Timeout:   20 * time.Second,
	})
	if err != nil {
		log.Fatal(err)
	}
	defer browser.Close()
	defer browser.Client.FinalizeTabs(nil)

	if _, err := browser.Client.NameSession("Issue scan - OBU"); err != nil {
		log.Fatal(err)
	}
	tab, err := browser.NewTab()
	if err != nil {
		log.Fatal(err)
	}
	if _, err := tab.Goto("https://example.com", obu.GotoOptions{
		WaitUntil: obu.LoadStateDOMContentLoaded,
		Timeout:   15 * time.Second,
	}); err != nil {
		log.Fatal(err)
	}
	title, err := tab.Title()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(title)
}

Use the low-level client when you need raw JSON-RPC/CDP calls:

client := obu.NewClient(obu.Options{
	SocketPath: "/tmp/open-browser-use/example.sock",
	SessionID:  "obu-docs-scan-20260510",
})
defer client.Close()

tab, err := client.CreateTab()
if err != nil {
	log.Fatal(err)
}
tabID := int(tab.(map[string]any)["id"].(float64))
if _, err := client.ExecuteCDP(tabID, "Page.navigate", obu.Params{"url": "https://example.com"}); err != nil {
	log.Fatal(err)
}
_, _ = client.FinalizeTabs(nil)

Core Methods

Common Browser Use JSON-RPC methods:

• ping
• getInfo
• createTab
• getTabs
• getUserTabs
• getUserHistory
• claimUserTab
• finalizeTabs
• nameSession
• attach
• detach
• executeCdp
• moveMouse
• waitForFileChooser
• setFileChooserFiles
• waitForDownload
• downloadPath
• readClipboardText
• writeClipboardText
• readClipboard
• writeClipboard
• turnEnded

CLI unrestricted call:

open-browser-use call --session-id "$OBU_SESSION_ID" --method getInfo --params '{}'
open-browser-use call --session-id "$OBU_SESSION_ID" --method executeCdp --params '{"target":{"tabId":123},"method":"Runtime.evaluate","commandParams":{"expression":"document.title"}}'

CLI action plan:

export OBU_SESSION_ID="obu-docs-scan-$(date +%Y%m%d%H%M%S)"
open-browser-use run --session-id "$OBU_SESSION_ID" -c '
name-session "Docs scan - OBU"
open-tab https://docs.browser-use.com
wait-load domcontentloaded
page-info
finalize-tabs []
'

The action plan format is intentionally small: one action per line, comments with #, shell-like quotes, shared session/turn, and a default tab set by open-tab or claim-tab. Supported actions include ping, info, tabs, user-tabs, history, name-session, open-tab, claim-tab, navigate, wait-load, page-info, cdp, move-mouse, wait-file-chooser, set-file-chooser-files, finalize-tabs, turn-ended, and call.

MCP Server

Use the stdio MCP server when the surrounding runtime supports local MCP tools:

[mcp_servers.open_browser_use]
command = "obu"
args = ["mcp", "--session-id", "obu-<task-or-conversation-id>"]

obu mcp speaks newline-delimited JSON-RPC on stdin/stdout. It handles initialize, ping, tools/list, and tools/call, and exposes tools that mirror the CLI action surface:

• ping, info, tabs, user_tabs, history
• open_tab, claim_tab, navigate, wait_load, page_info
• cdp, move_mouse, wait_file_chooser, set_file_chooser_files
• name_session, finalize_tabs, turn_ended, call, run_action_plan

Pass --socket or --socket-dir in the MCP args only when the runtime needs an explicit Open Browser Use socket. Otherwise the server uses the same socket discovery as the CLI. Pass a fresh --session-id for each agent task or conversation.

SDK request escape hatch:

await browser.client.request("executeCdp", {
  target: { tabId: 123 },
  method: "Runtime.evaluate",
  commandParams: { expression: "document.title" },
});

browser.client.request("executeCdp", {
    "target": {"tabId": 123},
    "method": "Runtime.evaluate",
    "commandParams": {"expression": "document.title"},
})

_, err := browser.Client.Request("executeCdp", obu.Params{
	"target":        obu.Params{"tabId": 123},
	"method":        "Runtime.evaluate",
	"commandParams": obu.Params{"expression": "document.title"},
})

User Tab Claiming

1. List open user tabs with open-browser-use user-tabs --session-id "$OBU_SESSION_ID" or SDK getUserTabs. 2. Select the tab from returned data using visible evidence: title, URL, recency, and group. 3. Claim it with open-browser-use claim-tab --session-id "$OBU_SESSION_ID" --tab-id <id> or SDK claimUserTab / claim_user_tab / ClaimUserTab. 4. Use the returned controllable tab for later commands.

Never invent or reuse stale tab ids.

Tab Cleanup

Before ending browser work, finalize exactly once for the active session:

open-browser-use finalize-tabs --session-id "$OBU_SESSION_ID" --keep '[]'

Omit tabs by default. Keep a tab only when the user needs that live page after the turn. Use status: "deliverable" for a user-facing output or requested open page. Use status: "handoff" only when the task is still in progress and the user or a later turn should continue from the current task group, such as a page waiting for login, approval, payment, CAPTCHA, or other user input.

Treat finalization as the last Open Browser Use browser action of the turn. If more browser work is needed, do it before finalizing, then finalize once with the final tab disposition.

File Chooser Pattern

1. Start waiting with wait-file-chooser --tab-id <id> or SDK waitForFileChooser / wait_for_file_chooser / WaitForFileChooser. 2. Trigger the file picker in the page, usually through a click driven by CDP or a higher-level automation layer. 3. Set absolute file paths:

open-browser-use set-file-chooser-files --file-chooser-id <id> --file /absolute/path/file.txt

Use repeated --file values or comma-separated paths for multiple files.

Open Browser Use Troubleshooting

Read this reference when setup, connection, browser control, file upload, download, or socket discovery fails.

First Checks

Start with:

open-browser-use ping --session-id "$OBU_SESSION_ID"
open-browser-use info --session-id "$OBU_SESSION_ID"
open-browser-use user-tabs --session-id "$OBU_SESSION_ID"

For connection checks, set OBU_SESSION_ID to a temporary unique value first. Do not reuse the CLI fallback session for agent browser work.

If these fail:

1. Confirm Chrome is installed. 2. Confirm Chrome is running. 3. Confirm the Open Browser Use extension is installed and enabled. 4. Confirm the native host manifest is installed with open-browser-use install-manifest or rerun open-browser-use setup. 5. Ask the user to approve any Chrome extension prompt.

Do not silently install, enable, or repair browser integration when the action needs user approval.

Stale Socket Or Missing Active Host

The CLI first discovers the active socket from the registry. If the registry is missing, recent CLI versions scan --socket-dir for *.sock files and connect to the newest usable socket, then repair the registry. If the registry points to a stale socket, the CLI removes the stale entry and stale socket file, then tries the same socket-dir scan.

Useful flags:

open-browser-use ping --socket /tmp/open-browser-use/example.sock
open-browser-use ping --socket-dir /tmp/open-browser-use
open-browser-use ping --timeout 20s

If no active host exists, opening Chrome with the extension enabled can allow Chrome to start the native host.

Extension Or Native Host Mismatch

The native host manifest must allow the installed extension id. The default Web Store id is built into the CLI, while setup beta uses the keyed GitHub Release ZIP, registers that stable id, and reveals that same ZIP for manual installation.

Use:

open-browser-use manifest
open-browser-use install-manifest
open-browser-use setup
open-browser-use setup beta

If the user installed a custom extension build, pass the extension id explicitly:

open-browser-use install-manifest --extension-id <chrome-extension-id>
open-browser-use setup --extension-id <chrome-extension-id>

File Upload Issues

Use the Open Browser Use file chooser flow rather than native OS picker automation where possible.

If Chrome blocks local file access for the extension, ask the user to open chrome://extensions, open Open Browser Use extension details, and enable file URL access if the task requires local file URLs.

Permission And Safety Issues

• History, debugger, downloads, tab groups, and broad host access are high-privilege browser capabilities.
• Clipboard reads/writes should happen only for the user-requested task.
• If the user is on a login, payment, approval, CAPTCHA, or destructive workflow, pause and ask before continuing.

When To Escalate To The User

Ask the user for help when:

• Chrome is not installed.
• Chrome is closed and opening it would interrupt their session.
• Chrome requires extension confirmation or enablement.
• The page requires login, CAPTCHA, hardware key, payment confirmation, or another human-only step.
• The requested browser action affects external systems.