# browser [Health: Active]

**Category:** 📂 Browser Automation  
**Repository:** https://github.com/cherchyk/MCPBrowser  
**GitHub Stars:** 9  
**npm Downloads (last month):** 1455  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/browser

## Description
MCP server for loading authenticated web pages using Chrome DevTools Protocol

## Tools
Capabilities this server exposes over MCP:

- **browser_fetch_webpage** — Fetches web pages using your Chrome/Edge/Brave browser. Handles authentication, CAPTCHA, SSO, anti-bot protection, and JavaScript-heavy sites. Opens the URL in a browser tab (reuses existing tab for same domain) and waits for the page to fully load before returning content. **Automatically detects…
- **browser_execute_javascript** — Executes a JavaScript snippet in the active page context and returns the result with metadata (execution time, truncation flag, URL-change detection). Use for structured data extraction (e.g., inbox rows) or JS-driven UI actions that are unreliable via protocol clicks.
- **browser_click_element** — Clicks on any clickable element (buttons, links, divs with onclick handlers, etc.). Can target by CSS selector or visible text content. Automatically scrolls element into view and waits for page stability after clicking.
- **browser_type_text** — Types text into one or more input fields in a single call. Supports filling entire forms at once for efficient automation. Automatically clears existing text by default.
- **browser_get_current_html** — Gets the current HTML from an already-loaded page **WITHOUT** navigating or reloading. Much faster than `browser_fetch_webpage` since it only extracts the current DOM state. Use this after interactions (click, type) to get the updated page content efficiently.
- **browser_scroll_page** — Scrolls within an already-loaded page. Use before `browser_take_screenshot` to capture different parts of the page, or to bring elements into view before interaction. Supports multiple scroll modes:
- **browser_take_screenshot** — Takes a screenshot of an already-loaded page for visual analysis. **Useful when HTML parsing is insufficient** — for example, pages with charts, images, complex layouts, popups, or visual content that's hard to understand from HTML alone. Returns a PNG image.
- **browser_close_tab** — Closes the browser tab for the given URL's hostname. Removes the page from the tab pool and forces a fresh session on the next visit to that hostname. Useful for clearing authentication state, managing memory, or starting fresh with a domain.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "browser": {
    "command": "npx",
    "args": ["-y","mcpbrowser@latest"]
  }
}
```

## Documentation

## What browser MCP server does

The browser MCP server gives an MCP-compatible assistant access to a real Chrome, Edge, or Brave browser. It can open a URL, wait for the page to load, and return page content from the browser's rendered state. This makes it suitable for sites that depend on JavaScript, require an authenticated session, or use SSO, CAPTCHA, or anti-bot controls.

The server keeps tabs organized by hostname. When a page from the same domain is requested again, it can reuse the existing tab and its session state. A tab can also be closed explicitly to clear that domain's browser state and force a new session on the next visit.

## How it works

The assistant communicates with the server over MCP, while the server controls the browser through the Chrome DevTools Protocol. A typical workflow is to load a page, enter values into one or more fields, click a visible control, and then read the updated DOM. The `browser_get_current_html` operation reads the current page without navigating or reloading, which is useful after an interaction.

JavaScript can be run in the active page context when selectors or protocol-level actions are not enough. The result includes execution metadata such as timing, truncation status, and whether the URL changed. Screenshots provide a PNG view of the loaded page for charts, images, popups, complex layouts, or other content that is difficult to interpret from HTML.

## Setup and configuration

The browser MCP server requires Chrome, Edge, or Brave and Node.js 18 or newer. The repository documents a standard configuration that runs the npm package with npx:

```json
{
  "mcpServers": {
    "mcpbrowser": {
      "command": "npx",
      "args": ["-y", "mcpbrowser@latest"]
    }
  }
}
```

Add this configuration through the MCP client you use. The project also documents installation paths for clients including Claude Desktop, Claude Code, Cline, Codex, Cursor, Gemini CLI, LM Studio, VS Code, and Windsurf.

## Tools and capabilities

The available tools cover navigation, inspection, interaction, and session cleanup:

- `browser_fetch_webpage` opens a URL, reuses a same-domain tab when possible, waits for loading, and returns content.
- `browser_execute_javascript` runs a script in the active page and returns its result with metadata.
- `browser_click_element` targets an element by CSS selector or visible text, scrolls it into view, and waits for page stability.
- `browser_type_text` fills one or more input fields and clears existing values by default.
- `browser_get_current_html` extracts the current DOM without another navigation.
- `browser_scroll_page` scrolls an already-loaded page.
- `browser_take_screenshot` captures the loaded page as a PNG.
- `browser_close_tab` removes the tab for a hostname and resets its next visit.

## Limitations and notes

The browser MCP server exposes webpage content to the connected AI assistant, which may send that content to its configured language-model provider. Avoid using it with sensitive or private pages unless the agent and provider are trusted. The project identifies this combination of private-data access, untrusted content, and external communication as a security risk and documents tool annotations for client safety controls.

A local compatible browser and Node.js installation are required. Screenshot capture is intended for an already-loaded page, while current HTML, scrolling, and element interaction also operate on an existing page rather than providing a separate HTTP-fetching interface.

_Full upstream README: https://allmcps.com/mcp/browser/readme_