A Model Context Protocol (MCP) server that provides web automation capabilities through Selenium WebDriver. This server allows AI assistants to interact with web pages by providing tools for navigation, element interaction, taking screenshots, and more.

# Install
pip install mcp-server-selenium

# Run
python -m mcp_server_selenium --port 9222 --user_data_dir /tmp/chrome-debug

# Clone and setup
git clone https://github.com/PhungXuanAnh/selenium-mcp-server.git
cd selenium-mcp-server
uv sync

# Run
PYTHONPATH=src python -m mcp_server_selenium --port 9222 --user_data_dir /tmp/chrome-debug

• 2. Features
• 3. Available Tools
  • 3.1. Navigation and Page Management
  • 3.2. Element Interaction
  • 3.3. Element Styling
  • 3.4. JavaScript Execution
  • 3.5. Browser Logs
  • 3.6. Local Storage Management
• 4. Installation
  • 4.1. Prerequisites
  • 4.2. Installation Options
    • 4.2.1. Option A: Install as Python Package (Recommended)
    • 4.2.2. Option B: Run from Source Code
  • 4.3. Chrome Setup
• 5. Usage
  • 5.1. Running the MCP Server
    • 5.1.1. Option A: From Installed Package
    • 5.1.2. Option B: From Source Code
  • 5.2. Using MCP Inspector for Testing
    • 5.2.1. Start Inspector Server
    • 5.2.2. Access Inspector Interface
    • 5.2.3. Command Line Options
  • 5.3. Using with MCP Clients
    • 5.3.1. Configuration Examples
    • 5.3.2. Debug
• 6. Examples
  • 6.1. Basic Web Automation
  • 6.2. Advanced Usage
    • 6.2.1. JavaScript Examples
• 7. Logging
• 8. Troubleshooting
  • 8.1. Common Issues
    • 8.1.1. Installation-Related Issues
    • 8.1.2. Runtime Issues
    • 8.1.3. Configuration Issues
• 9. Architecture
• 10. Contributing
• 11. Support
• 12. Documentation
• 13. Reference

• Web Navigation: Navigate to URLs with timeout control and page readiness checking
• Element Discovery & Interaction: Find elements by multiple criteria (text, class, ID, attributes, XPath) and interact with them through clicking and input value setting
• Advanced Element Querying: Get single elements, multiple elements with pagination, and direct child nodes with comprehensive filtering options
• Screenshots: Capture full-page screenshots of the current browser window
• Element Styling: Retrieve CSS styles and computed style information for any element
• JavaScript Execution: Execute custom JavaScript code in browser console with optional console output capture
• Browser Logging: Access console logs (with level filtering) and network request logs (with URL filtering and error filtering)
• Local Storage Management: Complete CRUD operations for browser local storage (add, read, update, delete)
• iFrame Support: Work with elements inside iframes using iframe ID or name targeting
• XPath Support: Use XPath expressions for precise element targeting
• Chrome Browser Control: Connect to existing Chrome instances or automatically start new ones

The MCP server provides the following tools:

• navigate(url, timeout) - Navigate to a specified URL with Chrome browser
• check_page_ready(wait_seconds) - Check if the current page is fully loaded with optional wait
• take_screenshot() - Take a screenshot of the current browser window

• get_an_element(text, class_name, id, attributes, element_type, in_iframe_id, in_iframe_name, return_html, xpath) - Get an element identified by various criteria
• get_elements(text, class_name, id, attributes, element_type, in_iframe_id, in_iframe_name, page, page_size, return_html, xpath) - Get multiple elements with pagination support
• get_direct_children(text, class_name, id, attributes, element_type, in_iframe_id, in_iframe_name, return_html, xpath, page, page_size) - Get all direct child nodes of an element with pagination
• click_to_element(text, class_name, id, attributes, element_type, in_iframe_id, in_iframe_name, element_index, xpath) - Click on an element identified by various criteria
• set_value_to_input_element(text, class_name, id, attributes, element_type, input_value, in_iframe_id, in_iframe_name, xpath) - Set a value to an input element

• get_style_an_element(text, class_name, id, attributes, element_type, in_iframe_id, in_iframe_name, return_html, xpath, all_styles, computed_style) - Get style information for an element

• run_javascript_in_console(javascript_code) - Execute JavaScript code in the browser console
• run_javascript_and_get_console_output(javascript_code) - Execute JavaScript code and capture both return value and console output

• get_console_logs(log_level) - Retrieve console logs from the browser with optional filtering by log level
• get_network_logs(filter_url_by_text, only_errors_log) - Retrieve network request logs from the browser with optional filtering

• local_storage_add(key, string_value, object_value, create_empty_string, create_empty_object) - Add or update a key-value pair in browser's local storage
• local_storage_read(key) - Read a value from browser's local storage by key
• local_storage_read_all() - Read all key-value pairs from browser's local storage
• local_storage_remove(key) - Remove a key-value pair from browser's local storage
• local_storage_remove_all() - Remove all key-value pairs from browser's local storage

• Python 3.10 or higher
• Chrome browser installed

You can use this MCP server in two ways:

Install directly from PyPI:

pip install mcp-server-selenium

Or using uv:

uv add mcp-server-selenium

1. Clone this repository:

git clone https://github.com/PhungXuanAnh/selenium-mcp-server.git
cd selenium-mcp-server

2. Install dependencies using uv:

uv sync

Or using pip with virtual environment:

python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate
pip install -e .

The MCP server can work with Chrome in two ways:

1. Connect to existing Chrome instance (recommended): Start Chrome with debugging enabled:

google-chrome --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-debug

2. Auto-start Chrome: The server can automatically start Chrome if no instance is found.

After installing via pip/uv, you can run the server directly:

# Basic usage with default settings
python -m mcp_server_selenium

# With custom Chrome debugging port and user data directory
python -m mcp_server_selenium --port 9222 --user_data_dir /tmp/chrome-debug

# With verbose logging
python -m mcp_server_selenium --port 9222 --user_data_dir /tmp/chrome-debug -v

# Using the installed command (if available)
selenium-mcp-server --port 9222 --user_data_dir /tmp/chrome-debug -v

When running from source, ensure the Python path includes the src directory:

# Navigate to the project directory
cd /path/to/selenium-mcp-server

# Activate virtual environment (if using one)
source .venv/bin/activate

# Run with proper Python path
PYTHONPATH=src python -m mcp_server_selenium --port 9222 --user_data_dir /tmp/chrome-debug -v

# Or using uv (recommended for development)
uv run python -m mcp_server_selenium --port 9222 --user_data_dir /tmp/chrome-debug -v

For development and testing, you can use the MCP inspector:

From Source Code:

# Using uv (recommended)
uv run mcp dev src/mcp_server_selenium/__main__.py

# Or with make command
make inspector

# With custom options
uv run mcp dev src/mcp_server_selenium/__main__.py --port 9222 --user_data_dir /tmp/chrome-debug --verbose

From Installed Package:

# Create a wrapper script or use directly
mcp dev python -m mcp_server_selenium

Open your browser and navigate to: http://127.0.0.1:6274/#tools

Check logs:

tailf /tmp/selenium-mcp.log

• --port: Chrome remote debugging port (default: 9222)
• --user_data_dir: Chrome user data directory (default: auto-generated in /tmp)
• -v, --verbose: Increase verbosity (use multiple times for more details)

The server communicates via stdio and follows the Model Context Protocol specification. You can integrate it with MCP-compatible AI assistants or clients.

For Claude Desktop (claude_desktop_config.json):

Using installed package:

{
  "mcpServers": {
    "selenium": {
      "command": "python",
      "args": [
        "-m", "mcp_server_selenium",
        "--port", "9222",
        "--user_data_dir", "/tmp/chrome-debug-claude"
      ],
      "env": {}
    }
  }
}

For VS Code Copilot (.vscode/mcp.json):

Using installed package:

{
  "servers": {
    "selenium-installed": {
      "command": "python",
      "args": [
        "-m", "mcp_server_selenium",
        "--user_data_dir=/home/user/.config/google-chrome-selenium-mcp",
        "--port=9225"
      ]
    }
  }
}

Using source code directly:

{
  "servers": {
    "selenium-source": {
      "command": "/path/to/selenium-mcp-server/.venv/bin/python",
      "args": [
        "-m", "mcp_server_selenium",
        "--user_data_dir=/home/user/.config/google-chrome-selenium-mcp-source",
        "--port=9226"
      ],
      "env": {
        "PYTHONPATH": "/path/to/selenium-mcp-server/src"
      }
    }
  }
}

Alternative source code configuration using full path:

{
  "servers": {
    "selenium-source-alt": {
      "command": "/path/to/selenium-mcp-server/.venv/bin/python",
      "args": [
        "/path/to/selenium-mcp-server/src/mcp_server_selenium/__main__.py",
        "--user_data_dir=/home/user/.config/google-chrome-selenium-mcp-alt",
        "--port=9227"
      ]
    }
  }
}

VS Code Copilot MCP Status: If you open the .vscode/mcp.json file, you can see the MCP server status at the bottom of VS Code.

View MCP Logs:

• In VS Code: Open Command Palette → "Developer: Show Logs..." → "MCP: selenium"
• Check log file: tail -f /tmp/selenium-mcp.log

1. Navigate to a website:

   • Tool: navigate
   • URL: https://example.com

2. Take a screenshot:

   • Tool: take_screenshot
   • Result: Screenshot saved to ~/selenium-mcp/screenshot/

3. Fill a form:

   • Tool: fill_input
   • Selector: #email
   • Text: user@example.com

4. Click a button:

   • Tool: click_element
   • Selector: button[type="submit"]

5. Execute JavaScript:

   • Tool: run_javascript_in_console
   • Code: return document.title;
   • Result: Returns the page title

6. JavaScript with console output:

   • Tool: run_javascript_and_get_console_output
   • Code: console.log('Hello from browser'); return window.location.href;
   • Result: Shows both console output and return value

• Wait for dynamic content: Use wait_for_element to wait for elements to load
• Get page information: Use get_page_title, get_current_url, get_page_content
• Element inspection: Use get_element_text, get_element_attribute, check_element_exists
• JavaScript automation: Use run_javascript_in_console for complex DOM manipulation and data extraction
• JavaScript debugging: Use run_javascript_and_get_console_output to capture console logs for debugging

Extract page data:

// Tool: run_javascript_in_console
var links = Array.from(document.querySelectorAll('a')).slice(0, 5).map(a => ({
    text: a.textContent.trim(),
    href: a.href
}));
return links;

Page performance monitoring:

// Tool: run_javascript_and_get_console_output
console.time('Page Analysis');
var stats = {
    title: document.title,
    links: document.querySelectorAll('a').length,
    images: document.querySelectorAll('img').length,
    scripts: document.querySelectorAll('script').length
};
console.timeEnd('Page Analysis');
console.log('Page stats:', stats);
return stats;

Form automation:

// Tool: run_javascript_in_console
document.querySelector('#username').value = 'testuser';
document.querySelector('#password').value = 'password123';
document.querySelector('#login-form').submit();
return 'Form submitted successfully';

The server logs all operations to /tmp/selenium-mcp.log with rotation. Use the -v flag to increase console verbosity:

• -v: INFO level logging
• -vv: DEBUG level logging

Package not found (installed package):

# Verify installation
pip list | grep mcp-server-selenium
# or
python -c "import mcp_server_selenium; print('OK')"

Module not found (source code):

# Ensure PYTHONPATH is set correctly
export PYTHONPATH=/path/to/selenium-mcp-server/src
# or run from project root with:
PYTHONPATH=src python -m mcp_server_selenium

1. Chrome not starting: Ensure Chrome is installed and accessible from PATH
2. Port conflicts: Use a different port with --port option
3. Permission errors: Ensure the user data directory is writable
4. Element not found: Increase wait times or use more specific selectors
5. JavaScript execution errors: Check browser console for syntax errors or security restrictions
6. Console output not captured: Ensure the JavaScript code runs successfully before checking console logs

MCP Client Connection Problems:

• Verify the command path is correct (use which python to find Python executable)
• For source code: Ensure PYTHONPATH environment variable is set
• For installed package: Ensure the package is installed in the same Python environment as the MCP client
• Check MCP client logs for detailed error messages

• FastMCP: Uses the FastMCP framework for MCP protocol implementation
• Selenium WebDriver: Chrome WebDriver for browser automation
• Synchronous Design: All operations are synchronous for reliability
• Chrome DevTools Protocol: Connects to Chrome via remote debugging protocol

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests if applicable
5. Submit a pull request

For issues and questions:

• Create an issue in the repository
• Check the logs at /tmp/selenium-mcp.log
• Use verbose logging for debugging

For detailed documentation on specific features:

• JavaScript Console Tools - Comprehensive guide for JavaScript execution tools
• Examples - JavaScript execution examples and use cases

• https://github.com/modelcontextprotocol/python-sdk
• https://github.com/modelcontextprotocol/servers