1. Home
  2. Servers
  3. Browser Automation
  4. Browser Use MCP Server

Server profile

Browser Use MCP Server

Browser Use MCP Server connects AI agents to browser-use for browser control. It supports SSE and proxied stdio connections, asynchronous tasks, and VNC viewing so users can watch browser automation as it happens.

View repositoryInstall & configure

Server facts

Browser Use MCP Server

Tech

Runtime / language
pythonPython
Transports
stdio
Remote available
No
Authentication
Not specified

Activity

GitHub stars
848
Last commit
Data as of

Tags

  • Async Tasks
  • Browser Control
  • Browser Use
  • Playwright
  • Vnc

Overview

Browser Use MCP Server exposes browser automation to AI agents using the browser-use project. The README presents it as a bridge for controlling a web browser from MCP clients rather than as a standalone scraping-only utility. It supports asynchronous operations and provides a PATIENT setting for callers that want API requests to wait until a task finishes. VNC streaming lets users watch browser activity in real time. An example asks the assistant to open a news site and identify its highest-ranked article, illustrating the intended natural-language browsing workflow without defining individual MCP tool names.

The Python setup uses uv, Playwright, and a Chromium installation with its required dependencies. An OpenAI API key is part of the documented environment, and an optional Chrome path can be configured. SSE mode runs from the source checkout and exposes a local endpoint. Standard-input/output operation requires mcp-proxy plus a built and globally installed package; the README supplies a client configuration with separate server and proxy ports. Docker is another option, with ports exposed for the server and VNC. Its default VNC password is documented, alongside a method that reads a replacement password from a mounted file. Client examples cover common editor and desktop configuration locations. The supplied input lists an MIT license, while the README does not provide a license section.

Install & configure

Requirements

  • Python and uv
  • Playwright and its Chromium browser dependencies
  • mcp-proxy for stdio mode
  • A built and globally installed browser-use-mcp-server package
Documented launch / install command
browser-use-mcp-server run server --port 8000 --stdio --proxy-port 9000

The README installs mcp-proxy with uv, synchronizes dependencies, installs Chromium through Playwright, builds a wheel, and installs it globally before this launch. Its source SSE alternative uses uv run server --port 8000 and http://localhost:8000/sse. CHROME_PATH and PATIENT are optional settings.

Config file · macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

Windows: %APPDATA%\Claude\claude_desktop_config.json

Use Settings → Developer → Edit Config when available. Do not assume a Linux configuration path; check the client documentation for your platform. Remote servers use the app’s connector flow when supported, not the local stdio file shown here. Merge this example with existing settings; do not overwrite unrelated servers.

Claude Desktop configuration
{
  "mcpServers": {
    "browser-use-mcp-server": {
      "command": "browser-use-mcp-server",
      "args": [
        "run",
        "server",
        "--port",
        "8000",
        "--stdio",
        "--proxy-port",
        "9000"
      ],
      "env": {
        "OPENAI_API_KEY": "<OpenAI API key>"
      }
    }
  }
}

Read the Claude Desktop setup guide

Config file · Project: .cursor/mcp.json

User: ~/.cursor/mcp.json

The project path is relative to the workspace root. The tilde denotes your user home directory. Use Cursor’s MCP settings to confirm which configuration and scope your installed version is reading. Merge this example with existing settings; do not overwrite unrelated servers.

Cursor configuration
{
  "mcpServers": {
    "browser-use-mcp-server": {
      "command": "browser-use-mcp-server",
      "args": [
        "run",
        "server",
        "--port",
        "8000",
        "--stdio",
        "--proxy-port",
        "9000"
      ],
      "env": {
        "OPENAI_API_KEY": "<OpenAI API key>"
      }
    }
  }
}

Read the Cursor setup guide

Config file · Workspace: .vscode/mcp.json

For user scope, use the “MCP: Open User Configuration” command if available. Do not guess a user configuration path across operating systems, profiles, containers, or remote workspaces; check the client documentation. Merge this example with existing settings; do not overwrite unrelated servers.

VS Code configuration
{
  "servers": {
    "browser-use-mcp-server": {
      "type": "stdio",
      "command": "browser-use-mcp-server",
      "args": [
        "run",
        "server",
        "--port",
        "8000",
        "--stdio",
        "--proxy-port",
        "9000"
      ],
      "env": {
        "OPENAI_API_KEY": "<OpenAI API key>"
      }
    }
  }
}

Read the VS Code setup guide

Config file · macOS/Linux: ~/.codeium/windsurf/mcp_config.json

Windows: %USERPROFILE%\.codeium\windsurf\mcp_config.json

Open the MCP configuration through Windsurf’s settings when possible to confirm the active file. Paths can differ in managed or future releases; check the client documentation if this location is not present. Merge this example with existing settings; do not overwrite unrelated servers.

Windsurf configuration
{
  "mcpServers": {
    "browser-use-mcp-server": {
      "command": "browser-use-mcp-server",
      "args": [
        "run",
        "server",
        "--port",
        "8000",
        "--stdio",
        "--proxy-port",
        "9000"
      ],
      "env": {
        "OPENAI_API_KEY": "<OpenAI API key>"
      }
    }
  }
}

Read the Windsurf setup guide

Config file · Project scope: .mcp.json at the repository root

The project file uses mcpServers. For user scope, use claude mcp add --scope user rather than assuming .mcp.json in your home directory is the user configuration. Check the client documentation for managed settings and storage details. Merge this example with existing settings; do not overwrite unrelated servers.

Claude Code configuration
{
  "mcpServers": {
    "browser-use-mcp-server": {
      "type": "stdio",
      "command": "browser-use-mcp-server",
      "args": [
        "run",
        "server",
        "--port",
        "8000",
        "--stdio",
        "--proxy-port",
        "9000"
      ],
      "env": {
        "OPENAI_API_KEY": "<OpenAI API key>"
      }
    }
  }
}

Read the Claude Code setup guide

Examples are translated from the published configuration. Supply your own credentials and verify requirements in the upstream README. Remote connectors are shown only where a supported configuration format is known.

Tools

No individual tool names were confirmed in the source material. Check the repository for its current tool list.

Names, permissions, and defaults can change. Check the current upstream documentation before granting access.

Use cases

  • Let an MCP assistant navigate websites through browser-use.
  • Watch an automated browsing session through VNC.
  • Run browser tasks asynchronously or wait for completion.
  • Connect a stdio-only client through the documented proxy workflow.

Strengths

  • Supports SSE and a proxied stdio workflow.
  • Provides live VNC visibility into browser activity.
  • Offers asynchronous task execution and a completion-wait setting.

Limitations

  • Stdio mode requires mcp-proxy and package build/install steps.
  • Requires Playwright browser setup and an OpenAI API key.
  • Docker's documented VNC default should be replaced for protected viewing.

Frequently asked questions

Yes. VNC streaming is documented, including Docker port exposure and a noVNC viewer workflow.

The README requires mcp-proxy, plus building and globally installing the server package before using its stdio launch command.

Yes. PATIENT can be set to true so API calls wait for task completion.

Not stated in the README. It describes browser-control capabilities and launch methods without a named tool inventory.

Independent listing, not an affiliation or security review. Grant the least access needed and verify the upstream instructions before running code.

Related MCP servers

BrowserTools MCP

Browser Automation

BrowserTools MCP brings browser logs, screenshots, selected elements, and Lighthouse audits into compatible AI editors. It uses a Chrome extension plus two local servers, and the project is no longer active.

nodestdio7,328 GitHub stars

Playwright MCP

Browser Automation

Playwright MCP lets AI assistants operate browsers using structured accessibility data. It suits agents that need persistent page context, interactive exploration, and browser inspection without a vision model.

nodestdio38,243 GitHub stars

Browserbase MCP Server

Browser Automation

Browserbase MCP Server lets assistants operate cloud browser sessions through Browserbase and Stagehand. Six tools handle sessions, navigation, page actions, observation, and extraction, with hosted and self-hosted connection options.

nodestdio3,399 GitHub stars

Playwright MCP Server

Browser Automation

ExecuteAutomation’s Playwright MCP Server lets AI clients automate real browsers, capture screenshots, scrape pages, and generate tests. It also provides device-profile emulation and local stdio or standalone HTTP operation.

nodestdio5,666 GitHub stars

Browser MCP

Browser Automation

Browser MCP combines an MCP server with a Chrome extension to automate your existing browser. It is aimed at AI applications that need local browsing and access to already signed-in sessions.

nodestdio7,189 GitHub stars

Hyperbrowser MCP Server

Browser Automation

Hyperbrowser MCP Server combines web scraping, crawling, structured extraction, and cloud browser agents. Assistants can choose Browser Use, OpenAI computer use, or Claude computer use and manage persistent profiles.

nodestdio789 GitHub stars