Fast Playwright Mcp

Fast Playwright MCP

This MCP server is a fork of the Microsoft one.

A Model Context Protocol (MCP) server that provides browser automation capabilities using Playwright. This server enables LLMs to interact with web pages through structured accessibility snapshots, bypassing the need for screenshots or visually-tuned models.

Key Features

• Fast and lightweight. Uses Playwright's accessibility tree, not pixel-based input.
• LLM-friendly. No vision models needed, operates purely on structured data.
• Deterministic tool application. Avoids ambiguity common with screenshot-based approaches.

Fast Server Features (This Fork)

• Token Optimization. All tools support an expectation parameter to control response content:
• includeCode: false - Suppress Playwright code generation to reduce tokens
• includeSnapshot: false - Skip page snapshot for minimal responses (70-80% token reduction)
• includeConsole: false - Exclude console messages
• includeTabs: false - Hide tab information
• Image Compression. Screenshot tool supports imageOptions:
• format: 'jpeg' - Use JPEG instead of PNG
• quality: 1-100 - Compress images (e.g., 50 for 50% quality)
• maxWidth: number - Resize images to max width
• Batch Execution. Use browser_batch_execute for multiple operations:
• Significant token reduction by eliminating redundant responses
• Per-step and global expectation configuration
• Error handling with continueOnError and stopOnFirstError options
• Snapshot Control. Limit snapshot size with snapshotOptions:
• selector: string - Capture only specific page sections (recommended over maxLength)
• format: "aria" - Accessibility tree format for LLM processing
• Diff Detection. Track only changes with diffOptions:
• enabled: true - Show only what changed from previous state (massive token saver)
• format: "minimal" - Ultra-compact diff output
• Perfect for monitoring state changes during navigation or interactions
• Diagnostic System. Advanced debugging and element discovery tools:
• browser_find_elements - Find elements using multiple search criteria (text, role, attributes)
• browser_diagnose - Comprehensive page analysis with performance metrics and troubleshooting
• Enhanced error handling with alternative element suggestions
• Page structure analysis (iframes, modals, accessibility metrics)
• Performance monitoring with execution time under 300ms
• Enhanced Selector System. Unified element selection with multiple strategies:
• Selector Arrays: All element-based tools now support multiple selectors with automatic fallback
• 4 Selector Types:
• ref: System-generated element IDs from previous tool results (highest priority)
• role: ARIA roles with optional text matching (e.g., {role: "button", text: "Submit"})
• css: Standard CSS selectors (e.g., {css: "#submit-btn"})
• text: Text content search with optional tag filtering (e.g., {text: "Click me", tag: "button"})
• Intelligent Resolution: Parallel CSS resolution, sequential role matching, automatic fallback
• Multiple Match Handling: When multiple elements match, returns candidate list for LLM selection
• HTML Inspection: New browser_inspect_html tool for intelligent content extraction with depth control

Requirements

• Node.js 18 or newer
• VS Code, Cursor, Windsurf, Claude Desktop, Goose or any other MCP client

Getting started

First, install the Playwright MCP server with your client.

Standard config works in most of the tools:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": [
        "@tontoko/fast-playwright-mcp@latest"
      ]
    }
  }
}

[](https://insiders.vscode.dev/redirect?url=vscode%3Amcp%2Finstall%3F%257B%2522name%2522%253A%2522fast-playwright%2522%252C%2522command%2522%253A%2522npx%2522%252C%2522args%2522%253A%255B%2522%2540tontoko%252Ffast-playwright-mcp%2540latest%2522%255D%257D) [](https://insiders.vscode.dev/redirect?url=vscode-insiders%3Amcp%2Finstall%3F%257B%2522name%2522%253A%2522fast-playwright%2522%252C%2522command%2522%253A%2522npx%2522%252C%2522args%2522%253A%255B%2522%2540tontoko%252Ffast-playwright-mcp%2540latest%2522%255D%257D)

Claude Code

Use the Claude Code CLI to add the Playwright MCP server:

claude mcp add fast-playwright npx @tontoko/fast-playwright-mcp@latest

Claude Desktop

Follow the MCP install guide, use the standard config above.

Cursor

Click the button to install:

[](cursor://anysphere.cursor-deeplink/mcp/install?name=fast-playwright&config=eyJjb21tYW5kIjoibnB4IEB0b250b2tvL2Zhc3QtcGxheXdyaWdodC1tY3BAbGF0ZXN0In0K)

Or install manually:

Go to Cursor Settings -> MCP -> Add new MCP Server. Name to your liking, use command type with the command npx @tontoko/fast-playwright-mcp@latest. You can also verify config or add command like arguments via clicking Edit.

Gemini CLI

Follow the MCP install guide, use the standard config above.

Goose

Click the button to install:

[](https://block.github.io/goose/extension?cmd=npx&arg=%40playwright%2Fmcp%40latest&id=playwright&name=Playwright&description=Interact%20with%20web%20pages%20through%20structured%20accessibility%20snapshots%20using%20Playwright)

Or install manually:

Go to Advanced settings -> Extensions -> Add custom extension. Name to your liking, use type STDIO, and set the command to npx @tontoko/fast-playwright-mcp. Click "Add Extension".

LM Studio

Click the button to install:

[](https://lmstudio.ai/install-mcp?name=playwright&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyJAcGxheXdyaWdodC9tY3BAbGF0ZXN0Il19)

Or install manually:

Go to Program in the right sidebar -> Install -> Edit mcp.json. Use the standard config above.

opencode

Follow the MCP Servers documentation. For example in ~/.config/opencode/opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "playwright": {
      "type": "local",
      "command": [
        "npx",
        "@tontoko/fast-playwright-mcp"
      ],
      "enabled": true
    }
  }
}

Qodo Gen

Open Qodo Gen chat panel in VSCode or IntelliJ → Connect more tools → + Add new MCP → Paste the standard config above.

Click Save.

VS Code

Click the button to install:

[](https://insiders.vscode.dev/redirect?url=vscode%3Amcp%2Finstall%3F%257B%2522name%2522%253A%2522fast-playwright%2522%252C%2522command%2522%253A%2522npx%2522%252C%2522args%2522%253A%255B%2522%2540tontoko%252Ffast-playwright-mcp%2540latest%2522%255D%257D) [](https://insiders.vscode.dev/redirect?url=vscode-insiders%3Amcp%2Finstall%3F%257B%2522name%2522%253A%2522fast-playwright%2522%252C%2522command%2522%253A%2522npx%2522%252C%2522args%2522%253A%255B%2522%2540tontoko%252Ffast-playwright-mcp%2540latest%2522%255D%257D)

Or install manually:

Follow the MCP install guide, use the standard config above. You can also install the Playwright MCP server using the VS Code CLI:

# For VS Code
code --add-mcp '{"name":"fast-playwright","command":"npx","args":["@tontoko/fast-playwright-mcp@latest"]}'

After installation, the Playwright MCP server will be available for use with your GitHub Copilot agent in VS Code.

Windsurf

Follow Windsurf MCP documentation. Use the standard config above.

Configuration

Playwright MCP server supports following arguments. They can be provided in the JSON configuration above, as a part of the "args" list:

> npx @tontoko/fast-playwright-mcp@latest --help
  --allowed-origins   semicolon-separated list of origins to allow the
                               browser to request. Default is to allow all.
  --blocked-origins   semicolon-separated list of origins to block the
                               browser from requesting. Blocklist is evaluated
                               before allowlist. If used without the allowlist,
                               requests not matching the blocklist are still
                               allowed.
  --block-service-workers      block service workers
  --browser           browser or chrome channel to use, possible
                               values: chrome, firefox, webkit, msedge.
  --caps                 comma-separated list of additional capabilities
                               to enable, possible values: vision, pdf.
  --cdp-endpoint     CDP endpoint to connect to.
  --config               path to the configuration file.
  --device             device to emulate, for example: "iPhone 15"
  --executable-path      path to the browser executable.
  --headless                   run browser in headless mode, headed by default
  --host                 host to bind server to. Default is localhost. Use
                               0.0.0.0 to bind to all interfaces.
  --ignore-https-errors        ignore https errors
  --isolated                   keep the browser profile in memory, do not save
                               it to disk.
  --image-responses      whether to send image responses to the client.
                               Can be "allow" or "omit", Defaults to "allow".
  --no-sandbox                 disable the sandbox for all process types that
                               are normally sandboxed.
  --output-dir           path to the directory for output files.
  --port                 port to listen on for SSE transport.
  --proxy-bypass       comma-separated domains to bypass proxy, for
                               example ".com,chromium.org,.domain.com"
  --proxy-server        specify proxy server, for example
                               "http://myproxy:3128" or "socks5://myproxy:8080"
  --save-session               Whether to save the Playwright MCP session into
                               the output directory.
  --save-trace                 Whether to save the Playwright Trace of the
                               session into the output directory.
  --storage-state        path to the storage state file for isolated
                               sessions.
  --user-agent      specify user agent string
  --user-data-dir        path to the user data directory. If not
                               specified, a temporary directory will be created.
  --viewport-size        specify browser viewport size in pixels, for
                               example "1280, 720"

User profile

You can run Playwright MCP with persistent profile like a regular browser (default), in isolated contexts for testing sessions, or connect to your existing browser using the browser extension.

Persistent profile

All the logged in information will be stored in the persistent profile, you can delete it between sessions if you'd like to clear the offline state. Persistent profile is located at the following locations and you can override it with the --user-data-dir argument.

# Windows
%USERPROFILE%\AppData\Local\ms-playwright\mcp-{channel}-profile

# macOS
- ~/Library/Caches/ms-playwright/mcp-{channel}-profile

# Linux
- ~/.cache/ms-playwright/mcp-{channel}-profile

Isolated

In the isolated mode, each session is started in the isolated profile. Every time you ask MCP to close the browser, the session is closed and all the storage state for this session is lost. You can provide initial storage state to the browser via the config's contextOptions or via the --storage-state argument. Learn more about the storage state here.

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": [
        "@tontoko/fast-playwright-mcp@latest",
        "--isolated",
        "--storage-state={path/to/storage.json}"
      ]
    }
  }
}

Browser Extension

The Playwright MCP Chrome Extension allows you to connect to existing browser tabs and leverage your logged-in sessions and browser state. See [extension/README.md](extension/README.md) for installation and setup instructions.

Configuration file

The Playwright MCP server can be configured using a JSON configuration file. You can specify the configuration file using the --config command line option:

npx @tontoko/fast-playwright-mcp@latest --config path/to/config.json

Configuration file schema

{
  // Browser configuration
  browser?: {
    // Browser type to use (chromium, firefox, or webkit)
    browserName?: 'chromium' | 'firefox' | 'webkit';

    // Keep the browser profile in memory, do not save it to disk.
    isolated?: boolean;

    // Path to user data directory for browser profile persistence
    userDataDir?: string;

    // Browser launch options (see Playwright docs)
    // @see https://playwright.dev/docs/api/class-browsertype#browser-type-launch
    launchOptions?: {
      channel?: string;        // Browser channel (e.g. 'chrome')
      headless?: boolean;      // Run in headless mode
      executablePath?: string; // Path to browser executable
      // ... other Playwright launch options
    };

    // Browser context options
    // @see https://playwright.dev/docs/api/class-browser#browser-new-context
    contextOptions?: {
      viewport?: { width: number, height: number };
      // ... other Playwright context options
    };

    // CDP endpoint for connecting to existing browser
    cdpEndpoint?: string;

    // Remote Playwright server endpoint
    remoteEndpoint?: string;
  },

  // Server configuration
  server?: {
    port?: number;  // Port to listen on
    host?: string;  // Host to bind to (default: localhost)
  },

  // List of additional capabilities
  capabilities?: Array;

  // Directory for output files
  outputDir?: string;

  // Network configuration
  network?: {
    // List of origins to allow the browser to request. Default is to allow all. Origins matching both `allowedOrigins` and `blockedOrigins` will be blocked.
    allowedOrigins?: string[];

    // List of origins to block the browser to request. Origins matching both `allowedOrigins` and `blockedOrigins` will be blocked.
    blockedOrigins?: string[];
  };
 
  /**
   * Whether to send image responses to the client. Can be "allow" or "omit". 
   * Defaults to "allow".
   */
  imageResponses?: 'allow' | 'omit';
}

Standalone MCP server

When running headed browser on system w/o display or from worker processes of the IDEs, run the MCP server from environment with the DISPLAY and pass the --port flag to enable HTTP transport.

npx @tontoko/fast-playwright-mcp@latest --port 8931

And then in MCP client config, set the url to the HTTP endpoint:

{
  "mcpServers": {
    "playwright": {
      "url": "http://localhost:8931/mcp"
    }
  }
}

Docker

NOTE: The Docker implementation only supports headless chromium at the moment.

{
  "mcpServers": {
    "playwright": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "--init", "--pull=always", "mcr.microsoft.com/playwright/mcp"]
    }
  }
}

You can build the Docker image yourself.

docker build -t mcr.microsoft.com/playwright/mcp .

Programmatic usage

import http from 'http';

import { createConnection } from '@tontoko/fast-playwright-mcp';
import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';

http.createServer(async (req, res) => {
  // ...

  // Creates a headless Playwright MCP server with SSE transport
  const connection = await createConnection({ browser: { launchOptions: { headless: true } } });
  cons

…

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [tontoko](https://github.com/tontoko)
- **Source:** [tontoko/fast-playwright-mcp](https://github.com/tontoko/fast-playwright-mcp)
- **License:** Apache-2.0
- **Homepage:** https://www.npmjs.com/package/@tontoko/fast-playwright-mcp

Install and usage instructions live in the source repository linked above.