WebdriverIO MCP Server

Official

Drive browsers and iOS/Android apps with WebDriverIO via MCP

How to install ↓ Compare GitHub source repository ↗

Category: Browser #6 of 32
Stars: ★ 42 Popular
Transport: stdio (local process) · Streamable HTTP
Runtime: Node.js
Credentials: Optional API key
License: MIT
Last commit: 14 days ago
Tools: 31

62FMRS · C

An official, well-documented, and feature-rich browser and mobile automation MCP server from the WebDriverIO team, covering local and major cloud device platforms with session recording and code export. Best suited to testing, with limitations from its single-session model and mobile platform prerequisites (macOS + Xcode, Appium).

Strongest · Documentation 17/20 Weakest · Reliability 9/20

Reliability

9/20

Security and permissions

11/20

Maintenance

11/20

Documentation

17/20

Setup experience

14/20

Why each score

Reliability 9/20: server.json only declares the npm package (@wdio/[email protected], stdio transport) without listing tools inline; the tool table in the README (start_session, navigate, tap_element, etc.) is textually consistent with the package description and the stated stdio/HTTP transport modes, and no outright contradictions were found. However, none of the supplied material shows a CI workflow or committed tests, so there is no way to verify actual tool behavior, error handling, or the controllability of dependencies (Appium, browser drivers, cloud provider APIs) in a live environment. Per the static calibration rule this cannot exceed 12. Scored 9, reflecting a plausible happy path but thin evidence on tests/error handling.
Security and permissions 11/20: No red-line violation found: credentials are passed via environment variables (e.g., BROWSERSTACK_ACCESS_KEY) and examples use placeholders rather than real secrets; HTTP transport defaults restrict the Host header to localhost and ships with no allowed CORS origins by default, showing some DNS-rebinding awareness. But real risk surface exists: the execute_script tool can run arbitrary JavaScript in the browser or arbitrary Appium mobile commands, and no explicit user-confirmation gate for dangerous operations is documented; autoGrantPermissions/autoAcceptAlerts default to true, silently dismissing OS permission and alert dialogs; the local tunnel feature exposes the local network to a cloud provider; and the storage/transmission boundaries for uploaded app binaries and cloud credentials are not detailed. This sits in the 'main risks visible but permission-minimization/confirmation/data-boundary disclosure incomplete' band.
Maintenance 11/20: The repo is not archived, uses the MIT license, and is at version 3.3.0 with a feature set (TOON format, trace recording, web-extension support, etc.) that suggests multiple iterations. However, the supplied material provides no verifiable maintenance evidence — no commit history, release notes, issue-response times, dependency-update cadence, or a security-response channel (e.g., SECURITY.md). Stars/open-issue counts are discovery signals only and are excluded from scoring. This lands as 'active-looking but with governance/versioning evidence gaps.'
Documentation 17/20: The README is extensive: install instructions for over a dozen clients with copy-pasteable config snippets, a global-install alternative, an HTTP-transport flag table, credential setup and behavioral differences across five cloud providers, complete tool/resource tables, several real-world usage scenarios, and even a deep technical walkthrough of the trace-recording timestamp algorithm plus a troubleshooting section. Deductions: no disclosure of cloud-testing cost/billing, no documented rate limits or timeout behavior, and no separate changelog/version-history link. Overall this is high-quality, layered documentation with only minor undisclosed limitations.
Setup experience 14/20: Setup is straightforward: a single npx command works across mainstream clients (VS Code, Claude Desktop, Cursor, Cline, Codex, Goose, Windsurf, Zed, etc.) with matching JSON/TOML/YAML config examples, plus a global-install option and an HTTP-transport fallback for non-subprocess clients. Mobile automation adds real complexity (Appium server, platform drivers), though it is documented. Because the static calibration rule caps setup at 15 absent verifiable execution evidence (real CI plus committed tests covering key paths), the score is capped at 14 despite the otherwise clean setup flow.

Static review · not runListed 2026-09-07

Read the FMRS scoring method →

Fit and risk

What it can accessRuns commands or codeUses the networkControls a browser

Best for

QA engineers who need unified web and mobile automation
developers who want to drive browsers and generate test scripts in natural language
Teams already using the WebdriverIO/Appium ecosystem who want cloud device integration

Not for

Users without macOS + Xcode who need iOS mobile automation
Workflows requiring multiple concurrent active sessions (single-session model)
Restricted clients that cannot spawn subprocesses and cannot use the HTTP mode

Required permissions

Runs local browsers (Chrome/Firefox/Edge/Safari) and their automation drivers
Executes npm/npx and an Appium server locally
Reads local app package paths (.apk/.app/.ipa)
Cloud provider credentials via environment variables (e.g., BROWSERSTACK_USERNAME/ACCESS_KEY, SAUCE_USERNAME/ACCESS_KEY)
Network access to cloud provider REST APIs; local tunnels for intranet URLs

Risks and side effects

The AI can operate real browsers and devices, potentially touching production accounts or logged-in sessions
execute_script allows arbitrary JavaScript execution in the browser
Cloud credentials stored in env vars or client config leak if exposed
On Digital.ai, pure client-side assertion failures may report as Passed
Reading the logs resource clears the log buffer per the WebDriver spec

Setup

Before you start

Runtime：Node.js

BROWSERSTACK_ACCESS_KEY optionalsecret BrowserStack access key (secret), found in your BrowserStack account settings.

SAUCE_ACCESS_KEY optionalsecret Sauce Labs access key (secret), found in your Sauce Labs account settings.

TESTMU_ACCESS_KEY optionalsecret LambdaTest (TestMu) access key (secret), found in your LambdaTest account profile.

TESTINGBOT_SECRET optionalsecret TestingBot secret (secret), found on your TestingBot account page.

DIGITALAI_ACCESS_KEY optionalsecret Digital.ai access key (secret), obtained from the Digital.ai Continuous Testing platform.

Other optional settings (5)

BROWSERSTACK_USERNAME optional BrowserStack account username, found in your BrowserStack account settings.

SAUCE_USERNAME optional Sauce Labs username, found in your Sauce Labs account settings.

TESTMU_USERNAME optional LambdaTest (TestMu) username, found in your LambdaTest account profile.

TESTINGBOT_KEY optional TestingBot API key, found on your TestingBot account page.

DIGITALAI_CLOUD_URL optional Digital.ai cloud host URL (e.g. https://your-cloud.example.com) provided by Digital.ai Continuous Testing.

Add {"mcpServers":{"wdio-mcp":{"command":"npx","args":["-y","@wdio/mcp@latest"]}}} to your MCP client settings, then fully restart the client. Or install globally: npm install -g @wdio/mcp and use command wdio-mcp. For non-subprocess clients, run npx @wdio/mcp --http --port 3000 to enable HTTP transport. For mobile automation, install Appium globally (npm install -g appium), install platform drivers (iOS: xcuitest, requires macOS + Xcode; Android: uiautomator2, requires Android Studio), and start the appium server first (default http://127.0.0.1:4723). iOS real-device testing requires the device UDID.

claude_desktop_config.json

{"mcpServers":{"wdio-mcp":{"command":"npx","args":["-y","@wdio/mcp@latest"]}}}

Shown for Claude Desktop. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json

{
  "servers": {
    "wdio-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@wdio/mcp@latest"
      ]
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal

claude mcp add wdio-mcp -- npx -y @wdio/mcp@latest

Run it in a terminal; replace any <…> placeholders with your own values first.

Generate and validate client config

Check that it works

After restarting the MCP client, check that tools like start_session and get_screenshot appear in the client's tool list; then prompt 'Open https://example.com and take a screenshot' — a returned screenshot confirms the connection works.

Troubleshooting

Browser automation failing: verify the browser is installed (Safari needs macOS), fully restart the client, and check for other WebDriver instances
Mobile automation failing: confirm the appium server is running, devices show in adb devices or Xcode, drivers are installed, and app paths are correct
Fully restart the MCP client after config changes
iOS real devices require the 40-character UDID
Only one active session is allowed; close the current session before switching between browser and mobile

Things to try

Once connected, you can ask your AI assistant things like:

Open worldofbooks.com, accept all cookies, then get the visible elements and report the navigation structure.
Start a headless Chrome session, navigate to https://example.com, take a screenshot, and list all cookies.
Launch my Android app /path/to/app.apk on emulator-5554 with auto-granted permissions, tap the Skip button, and take a screenshot.
List all apps I've uploaded to BrowserStack, then start an Android session using the app's bs:// URL.

Tools 31

start_session writes

Start a new browser or app session; supports local, cloud providers, and external WebDriver endpoints; attach: true connects to a running Chrome

attach_session writes

Attach to an existing remote WebDriver/Appium session by ID without creating a new session

launch_chrome writes

Launch a new Chrome instance with remote debugging enabled for attach sessions

close_session writes

Close the current session; supports detach: true to disconnect without terminating

emulate_device writes

Emulate a mobile/tablet device preset (viewport, DPR, UA, touch); requires a BiDi session

open_web_extension writes

Install a web extension via WebDriver BiDi and open one of its pages so normal page tools can drive its UI

navigate writes

Navigate to a URL

get_elements read-only

Get visible, interactable elements on the page with viewport filtering and optional layout containers

Show 23 more tools

get_accessibility_tree read-only

Get the page accessibility tree with roles, names, and selectors (browser only)

get_screenshot read-only

Take a base64 screenshot of the current page or screen (auto-resized to max 2000px / 1MB)

get_tabs read-only

List all open browser tabs with handle, title, URL, and active status

scroll writes

Scroll the page up or down by specified pixels

execute_script writes

Execute arbitrary JavaScript in the browser or Appium mobile commands on devices

switch_tab writes

Switch browser tabs by handle or index

switch_frame writes

Switch into an iframe by CSS/XPath selector or back to the top-level frame

click_element writes

Click an element

set_value writes

Type text into input fields

get_cookies read-only

Get all cookies for the session or a single cookie by name

set_cookie writes

Set a cookie with name, value, and optional attributes

delete_cookies destructive

Delete all cookies or a specific cookie

tap_element writes

Tap a mobile element by selector or coordinates

swipe writes

Swipe up/down/left/right on a mobile device

drag_and_drop writes

Perform a drag-and-drop gesture on mobile

get_contexts read-only

List available automation contexts (NATIVE_APP, WEBVIEW_*) and the active one

switch_context writes

Switch between native and webview contexts

get_app_state read-only

Get the current lifecycle state of a mobile app

rotate_device writes

Rotate the device to portrait or landscape

hide_keyboard writes

Hide the on-screen keyboard

set_geolocation writes

Set the device GPS location

upload_app writes

Upload a local .apk or .ipa to a cloud provider and get an app reference

list_apps read-only

List apps previously uploaded to a provider's app storage

Use cases

Have an AI assistant automate basic web workflows such as login and search flows

Test native and hybrid Android/iOS apps on emulators or real devices

Run browser and mobile tests on cloud devices via BrowserStack, Sauce Labs, LambdaTest, TestingBot, or Digital.ai

Attach to a running Chrome to test authenticated or pre-configured sessions

Record automation as runnable WebdriverIO JS scripts for regression testing

Supported clients

Claude Desktop

Claude Code

Cline

Cursor

Codex

Goose

Windsurf

Zed

GitHub Copilot

Listed from the project's documentation, not tested by this site.

Overview

WebdriverIO MCP Server is an open-source (MIT) MCP server maintained by the WebDriverIO team that lets AI assistants automate Chrome, Firefox, Edge, and Safari browsers plus iOS and Android mobile apps through a unified interface. Built with TypeScript, WebDriverIO, and Appium, it supports local browser sessions, mobile testing via Appium, five cloud device providers (BrowserStack, Sauce Labs, LambdaTest, TestingBot, Digital.ai), attaching to running Chrome or external WebDriver endpoints, device emulation, cookie management, and session recording with export to runnable WebdriverIO JS. It uses stdio transport by default and offers an --http mode (default port 3000). Only one session can be active at a time.

Similar servers

Playwright MCP 78 · B

Microsoft's official Playwright-based browser automation MCP server

★ 38.3k · Tools 10 Compare with this →

Chrome DevTools MCP 76 · B

The Chrome team's official MCP server exposing Chrome DevTools capabilities to AI assistants

★ 53.8k · Tools 22 Compare with this →

FSB MCP Server 66 · C

Control the FSB browser extension from any MCP client for DOM-first AI browser automation.

★ 195 · Tools 30 Compare with this →

Playwright MCP Server 66 · C

Playwright-based browser automation MCP server

★ 5.7k · Tools 1 Compare with this →

Compare with other MCP servers

Source revision 69e3ef643cda Data synced 2026-10-19 Read the FMRS scoring method