OpenBrowser

Let an LLM write Python code that drives a real browser via raw CDP, autonomously navigating, interacting with, and extracting data from web pages at a fraction of the usual token cost.

Stars
★ 279
Last updated
1mo ago
License
MIT
Primary language
Python

At a glance

How it runs
CLILibrary / SDKMCP server
Works with
Universal · cross-platformCodex · Claude Code · Claude.ai · OpenAI API · Claude API
Cost
Free tier plus a paid hosted plan
Setup effort
Low · running in minutes
You'll need
Python 3.12+Chromium-based browser (Chrome, Edge, Brave, or Chromium)LLM API key (e.g. GOOGLE_API_KEY)ffmpeg (for video recording)Docker (for backend/frontend deployment)PostgreSQL (for backend deployment)Shell / CLINetwork accessLocal filesystemMCP Server
Typical use
A data engineer scraping product listings from e-commerce sites like Walmart, handling pagination and structured extraction
Not a fit if
  • Teams needing a fully hosted SaaS with no local browser processes (the cloud version is waitlist-only)
  • Non-Python projects that cannot run Python 3.12+
  • Environments where installing any Chromium-based browser is not permitted
Source review
60/100 · Some gaps

What does this agent do, and when should you use it?

OpenBrowser (GitHub: billy-enrizky/openbrowser-ai, MIT licensed) is a framework for intelligent browser automation. Its core is a CodeAgent architecture: the LLM writes Python code in a persistent, Jupyter-like namespace that controls the browser through direct CDP (Chrome DevTools Protocol) communication. It ships as a PyPI package (openbrowser-ai) with a CLI daemon, an importable Python library, a built-in MCP server, and plugins/skills for Claude Code, Codex, OpenCode, and OpenClaw. It supports 15 LLM providers (OpenAI, Anthropic, Google, Groq, AWS Bedrock, Azure, Ollama, DeepSeek, etc.) and auto-detects any locally installed Chromium-based browser. The project's benchmarks report 2–6x fewer tokens than browser-use, Playwright MCP, and Chrome DevTools MCP on equal-accuracy tasks. A full-stack FastAPI backend plus Next.js frontend cloud deployment and two reinforcement-learning research studies on browser agents are also included.

OpenBrowser takes a natural-language task or raw code and executes it against a real browser. Via the CLI, uvx openbrowser-ai -p "task" launches an LLM agent, while the -c flag connects to a persistent browser daemon over a Unix socket for direct code execution. In MCP mode (uvx openbrowser-ai --mcp), a single execute_code tool is exposed to clients like Claude Desktop and Claude Code; the LLM writes Python in a persistent namespace calling pre-imported functions (navigate, click, input_text, click_xy, evaluate, download_file, done, etc.). In library mode you instantiate CodeAgent(task=..., llm=ChatGoogle(...)) or drive BrowserSession / BrowserProfile directly (headless, viewport, proxy, video recording dir). Outputs include extracted data, screenshots, exports to Jupyter notebooks or API crawler code, and ffmpeg-recorded session videos. Cookies and login state persist under ~/.config/openbrowser/profiles/; the cloud stack adds real-time VNC streaming, KMS-encrypted saved logins, EventBridge + SQS scheduled workflows, and SES email notifications.

  1. A data engineer scraping product listings from e-commerce sites like Walmart, handling pagination and structured extraction
  2. An operations user automating repetitive web flows such as flight booking and multi-step form filling
  3. A Claude Code user installing the plugin to gain 7 skills: deep research, web scraping, form filling, e2e testing, page analysis, accessibility audit, and file download
  4. A QA engineer using the e2e-testing skill to test web apps by simulating user interactions
  5. A researcher connecting any AI assistant through the MCP server, which requires no external LLM API keys since the MCP client provides the intelligence
  6. A developer recording a browser workflow and exporting it as a Jupyter notebook or API crawler code

How do you install or deploy this agent?

One-line install on macOS / Linux:

curl -fsSL https://raw.githubusercontent.com/billy-enrizky/openbrowser-ai/main/install.sh | sh

Windows PowerShell:

irm https://raw.githubusercontent.com/billy-enrizky/openbrowser-ai/main/install.ps1 | iex

Homebrew:

brew tap billy-enrizky/openbrowser
brew install openbrowser-ai

pip or uv (recommended):

pip install openbrowser-ai
uv pip install openbrowser-ai

No separate browser install is needed: OpenBrowser auto-detects installed Chrome/Edge/Brave/Chromium, and installs Chromium automatically on first run if none is found and uvx is available. Requires Python 3.12+ and at least one LLM API key, e.g.:

export GOOGLE_API_KEY="..."

Install as a Claude Code plugin:

claude plugin marketplace add billy-enrizky/openbrowser-ai
claude plugin install openbrowser@openbrowser-ai

How do you use this agent?

Run a CodeAgent as a Python library:

import asyncio
from openbrowser import CodeAgent, ChatGoogle

async def main():
    agent = CodeAgent(
        task="Go to google.com and search for 'Python tutorials'",
        llm=ChatGoogle(model="gemini-3-flash"),
    )

    result = await agent.run()
    print(f"Result: {result}")

asyncio.run(main())

Execute code directly via the persistent CLI daemon:

uvx openbrowser-ai -c "await navigate('https://example.com')"
uvx openbrowser-ai -c "print(await evaluate('document.title'))"

Variables persist across daemon calls; the daemon auto-shuts down after 10 minutes of inactivity. Manage it with daemon start/stop/status/restart. To connect Claude Code via MCP, add to your project's .mcp.json:

{
  "mcpServers": {
    "openbrowser": {
      "command": "uvx",
      "args": ["openbrowser-ai", "--mcp"]
    }
  }
}

Key environment variables: OPENBROWSER_HEADLESS (default true), OPENBROWSER_ALLOWED_DOMAINS (domain whitelist), OPENBROWSER_USER_DATA_DIR (persistent Chrome profile directory), OPENBROWSER_MAX_OUTPUT (max output characters per execution, default 10000).

What are this agent's strengths and limitations?

Pros
  • CodeAgent batches actions as whole Python programs instead of step-by-step decisions; the official 4-way CLI benchmark shows 2.1–2.6x fewer tokens than browser-use, agent-browser, and playwright-cli (≈$0.12 per 6 tasks vs $0.24–$0.29)
  • MCP token efficiency is even more pronounced: 3.2x fewer tokens than Playwright MCP and 6.0x fewer than Chrome DevTools MCP, with 144x smaller MCP response payloads
  • 15 LLM providers including Ollama local models, and the MCP mode works with zero external LLM API keys
  • Persistent logins and cookies (KMS-encrypted in the hosted plan), with automatic cleanup of disposable Chromium caches to control disk usage
  • Built-in workflow recording and video recording, exportable to Jupyter notebooks or API crawler code
Limitations
  • Requires Python 3.12+ and a local Chromium-based browser, constraining runtime environments
  • The hosted cloud dashboard (saved cookies, scheduled tasks) is waitlist-only; full current functionality is local CLI/library/MCP
  • Apart from local Ollama models, the agent mode requires your own paid LLM API keys billed per use
  • Full cloud deployment depends on Docker Compose, PostgreSQL, and AWS services (EventBridge, SQS, SES, KMS, Cognito), a nontrivial infrastructure footprint
  • Benchmarks are self-published (Claude Sonnet 4.6 on Bedrock, 6 tasks, N=3/5 runs); no independent third-party validation is cited

How does this agent compare with similar options?

The project's own benchmarks directly compare browser-use, agent-browser, Playwright MCP (Microsoft), Chrome DevTools MCP (Google), and playwright-cli: on identical 6-task suites where all tools reached 100% pass rate, openbrowser-ai finished in 84.8s using 36,010 Bedrock tokens, lower than all four; in the MCP comparison, its advantage stems mainly from Python code batching and a compact DOM representation (7,853 response chars vs ~1.13–1.15M for competitors).

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
OpenBrowser This agent 60 · Some gaps CLIFreemium ★ 279 1mo ago Python Codex · Claude Code · Claude.ai · OpenAI API · Claude API
Uni-CLI 72 · Some gaps CLIFree ★ 228 2d ago TypeScript ChatGPT · Codex · Claude Code
lcc — Local Context Compiler 78 · Good CLIFree ★ 16 today Python Claude Code
Firecrawl Web Research MCP 66 · Some gaps MCP serverFreemium ★ 7.8k today JavaScript Claude.ai

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
60/ 100 5-point scale 3.0 / 5
Trust 12/29
Reliability 8/14
Adaptability 14/18
Convention 13/18
Effectiveness 9/13
Verifiability 4/8
Why each dimension lost points
Trust12 / 29 · 2.1/5

Least privilege: OPENBROWSER_ALLOWED_DOMAINS whitelist and per-instance MCP profiles exist, but no sandboxing or permission gates are shown by default; LLM-generated code executes directly in a persistent namespace with a large attack surface — deducted. User confirmation: no evidence of any pre-execution confirmation mechanism. Data flow transparency: posthog telemetry is a hard dependency yet the README never says what is collected or how to disable it; cookie/storage_state flow is documented in the MCP section (partial credit) but overall thin. Sensitive data: storage_state seeding, KMS-encrypted cloud logins, and profile-lease conflict rejection are described reasonably well — 2. Dependency security: most dependencies unpinned (playwright, langgraph have no upper bounds); only litellm is pinned; no lockfile or vulnerability mitigation evidence. External effects: arbitrary browsing, downloads, and JS execution; whitelist exists but is off by default. Rollback: only daemon stop and a 10-minute idle shutdown; no session recovery. Source attribution: MIT license with named copyright holder and MCP registry ID — 2.

Reliability8 / 14 · 2.9/5

Self-consistency: README and pyproject entry point align, but README uses CodeAgent while quickstart.mdx uses Agent with different model names — mild inconsistency. Dependency availability: sensible optional extras, browser auto-detection plus an install command — 2. Failure messages: 'clear error' for profile lease and Homebrew error handling noted, but the supplied sources are mostly tests and core runtime error handling is not evidenced — 1.

Adaptability14 / 18 · 3.9/5

Audience and scenarios: individuals, MCP-client users, and a hosted enterprise platform are all addressed — 3. Capability boundaries: function tables and devicePixelRatio guidance give some boundaries, but failure/abstention behavior is unspecified. Trigger precision: single execute_code tool plus 7 well-differentiated skills — 2. Environment fit: macOS/Linux/Windows, many install paths, headless config, local Ollama support — 2.

Convention13 / 18 · 3.6/5

Information architecture: complete ToC, project structure map, docs site, layered plugin/skills — 3. Install notes: exhaustive multi-platform coverage — 3. Naming stability: package openbrowser-ai vs import openbrowser, and CodeAgent vs Agent across docs — deducted. Examples and FAQ: rich examples and benchmarks, but inconsistent class names between the two quickstarts and no FAQ. Known limitations: no dedicated limitations section. License: full MIT — 3. Versioning/changelog: hatch-vcs and CI version sync exist but no CHANGELOG file. Maintenance: mature release pipeline (PyPI, MCP Registry, Homebrew automation) by an individual maintainer — 2.

Effectiveness9 / 13 · 3.5/5

Output usability: MCP returns only explicitly requested data with a 10k-character cap and compact DOM — 2. Marginal value: claims 2.1–6x token efficiency over competitors with published raw JSON, but self-reported — 2. Cost benefit: concrete token/cost tables and re-runnable benchmark scripts in-repo — 2.

Verifiability4 / 8 · 2.5/5

Claim traceability: benchmark claims link to JSON results and methodology, but core behavioral/safety claims cannot be verified because no mcp/ or code_use/ source was supplied for this review. Cross-source corroboration: badges are external references unverifiable within this evidence; the included tests cover only LLM serialization — 1. Fact vs inference: product facts and cloud marketing are mostly separated — 2.

Risks and how to mitigate them
  • posthog telemetry is a default hard dependency, and the README does not document what is collected or how to disable it; privacy-sensitive users should audit and disable it.
  • LLM-written Python executes directly in a persistent namespace with no domain restriction and no pre-execution confirmation by default; always set OPENBROWSER_ALLOWED_DOMAINS and run in an isolated environment.
  • Stored cookies/storage_state are reused across automation sessions; misuse could cause logged-in accounts to be operated on your behalf.
  • Example class names are inconsistent between README (CodeAgent) and docs (Agent); verify the current API before installing.
  • Performance claims are self-reported benchmarks not independently verified; do not base procurement decisions solely on them.
Evidence confidence: Low Reviewed Oct 31, 2026 Reviewed revision 48ec5d9dccad
See the full review method →

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

  1. v0.1.54 v0.1.54: Fix daemon startup hangs with persistent browser profiles
    Release notes excerpt
    What's New - Fixes daemon startup hangs when a persistent Chrome profile contains a large storage snapshot. - Keeps daemon browser initialization and failed-start cleanup bounded. Details - Managed daemon profiles no longer replay an implicit storage-state snapshot into the same persistent Chrome profile. - Explicit storage-state configuration remains supported. - A stuck cleanup queues the normal forced browser-stop event and cannot hold the startup request indefinitely. - Plugin and MCP metadata are synchronized to version 0.1.54. …
    View on GitHub ↗
  2. v0.1.53 v0.1.53: MCP browser ownership and profile isolation
    Release notes excerpt
    What's New - Prevent concurrent MCP browser instances from interfering with or terminating one another. - Give managed MCP instances isolated browser profiles by default. - Enforce browser ownership during cleanup so only the owning instance can remove its processes. Details - Adds ownership markers and leases for managed browser profiles. - Rejects conflicting ownership of an explicitly shared profile. - Synchronizes the Claude plugin and MCP Registry metadata to version 0.1.53. Full Changelog: https://github.com/billy-enrizky/openbrowser-ai/compare/v0.1.52...v0.1.53
    View on GitHub ↗
  3. v0.1.52 v0.1.52: Cap MCP SDK at compatible major
    Release notes excerpt
    What's New - Fix CI and runtime compatibility by keeping OpenBrowser on the supported MCP SDK major version. - Add a regression test so future dependency updates cannot silently select an incompatible MCP SDK major. Details - MCP dependencies are constrained to >=1.0.0,<2.0.0. - The lockfile is regenerated with the compatible SDK range. - No migration steps are required for existing users. Full Changelog: https://github.com/billy-enrizky/openbrowser-ai/compare/v0.1.51...v0.1.52
    View on GitHub ↗

FAQ

Which LLMs does it support, and can it run fully locally?
It supports 15 providers, including Ollama local models (e.g. llama-4-scout, deepseek-r1). With Ollama no paid API key is needed; in MCP mode no external LLM key is required at all because the MCP client (e.g. Claude Desktop) supplies the intelligence.
Do logins and cookies persist across sessions?
Yes. The CLI daemon stores its profile in ~/.config/openbrowser/profiles/daemon; each MCP server process gets an isolated mcp-<instance-id> profile seeded once from the default profile's storage_state.json. Set OPENBROWSER_USER_DATA_DIR for a profile that survives restarts.
What is the difference between MCP mode and Agent mode?
MCP mode (--mcp) exposes a single execute_code tool and the connected AI assistant writes the code, requiring no LLM API key configuration. Agent mode (CodeAgent) has the framework call the LLM you configure to complete the task itself. Both execute Python in a persistent namespace.
What does it cost?
The software is MIT licensed and free. The project's benchmark estimates roughly $0.12 per 6-task run with Claude Sonnet 4.6 (≈$0.24 with Opus 4.6); actual costs depend on your model and workload. Pricing for the hosted cloud platform is not published and currently requires joining a waitlist.
Do I need to install Chrome?
Not necessarily. OpenBrowser auto-detects installed Chrome, Edge, Brave, or Chromium; if none is found and uvx is available, Chromium is installed automatically on first run. You can also pre-install manually with openbrowser-ai install.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents