What can you do with this server?

This server gives an AI assistant direct control of a real Chromium browser via Playwright, enabling natural-language-driven web testing, automation, and live failure analysis. * Navigate: direct the browser to any URL, retrieving the page title, final URL after redirects, and configurable wait status. * Read page state: extract the current page’s title, URL, visible text, interactive elements, console errors, and optionally scope to a CSS selector or include raw HTML. * Take screenshots: capture the full page or a specific element as a base64-encoded PNG, with an option to save to disk. * Click elements: interact by CSS selector or visible text, with optional wait for post‑click navigation. * Fill forms: type into input fields, textareas, or contenteditable elements, with optional clearing before typing. * Evaluate JavaScript: run arbitrary JavaScript in the page context for DOM reading, custom interactions, or data extraction. * Assert conditions: verify test expectations using types like title_contains, url_contains, text_visible, element_exists, element_hidden, input_value, element_count, returning pass/fail with context. * Close browser: gracefully shut down the browser and release resources. Architecturally, it enforces single-tool execution to avoid race conditions, includes launch locks, token-lean page state retrieval, and logging. It supports multiple transports (stdio and SSE) and works with hosts like Claude Desktop, Cursor, and LibreChat.

How do I use playwright-mcp?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@playwright-mcp Test login on the-internet.herokuapp.com with tomsmith and SuperSecretPassword!" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

playwright-mcp

by ademdeniz

Overview Schema Source Related Servers Discussions Admin

TypeScript

Local

playwright-mcp

An MCP server that gives Claude direct control of a real browser via Playwright — enabling AI-driven web testing, autonomous test execution, and live failure analysis through natural language.

TypeScript Playwright MCP License

What It Does

Connect this server to Claude Desktop or Cursor and Claude gains the ability to:

Navigate to any URL and read the full page state
Click elements, fill forms, and submit data
Take screenshots and attach them to its reasoning
Run arbitrary JavaScript in the page context
Assert expected conditions — pass/fail with full context
Analyze failures autonomously without you touching a test script

Example prompt to Claude:

"Test the login flow on the-internet.herokuapp.com. Use username 'tomsmith' and password 'SuperSecretPassword!'. Verify the success message and take a screenshot."

Claude will navigate, fill the form, click submit, assert the result, and take a screenshot — all without you writing a single line of test code.

Related MCP server: MCP Playwright Server

Architecture

┌──────────────────────────────────────────────────────┐
│              Claude Desktop / Cursor                  │
│                                                       │
│   "Test the login flow on example.com"                │
└──────────────────────┬───────────────────────────────┘
                       │ MCP (stdio)
┌──────────────────────▼───────────────────────────────┐
│               playwright-mcp server                   │
│                                                       │
│  Tools:                                               │
│   navigate       → page.goto(url)                    │
│   get_page_state → title + text + elements + errors  │
│   screenshot     → page.screenshot() → base64        │
│   click          → locator.click()                   │
│   fill           → locator.fill(value)               │
│   evaluate       → page.evaluate(js)                 │
│   assert         → built-in assertions (8 types)     │
│   close_browser  → browser.close()                   │
└──────────────────────┬───────────────────────────────┘
                       │ Playwright CDP
┌──────────────────────▼───────────────────────────────┐
│           Chromium (headless)                         │
└──────────────────────────────────────────────────────┘

Tools

Tool	Description
`navigate`	Go to a URL, returns title + status code
`get_page_state`	Read title, URL, visible text, interactive elements, console errors
`screenshot`	Capture full page or specific element as base64 PNG
`click`	Click by CSS selector or visible text
`fill`	Type into input fields
`evaluate`	Run JavaScript in the page context
`assert`	Verify title, URL, text, element presence/absence, input values
`close_browser`	Close browser and release resources

Setup

Prerequisites

Node.js 18+
Claude Desktop or any MCP-compatible host

Install

git clone https://github.com/ademdeniz/playwright-mcp.git
cd playwright-mcp
npm install
npm run install-browsers   # downloads Chromium
npm run build

Connect to Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "playwright": {
      "command": "node",
      "args": ["/absolute/path/to/playwright-mcp/dist/server.js"]
    }
  }
}

Restart Claude Desktop. You'll see a 🔌 icon showing the server is connected.

Connect to Cursor

Add to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "playwright": {
      "command": "node",
      "args": ["/absolute/path/to/playwright-mcp/dist/server.js"]
    }
  }
}

QA Agent Setup (LibreChat + SSE)

Day-to-day operations (start, stop, health checks, logs) are collected in COMMANDS.md. The complete agent recipe (endpoint, model parameters, instructions, skills) is in examples/qa-agent-setup.md.

Beyond stdio hosts, this server ships an SSE transport so Docker-hosted MCP clients — like a self-hosted LibreChat — can drive the browser over HTTP. This powers a full AI QA Engineer agent: a chat UI where you type test steps in plain English and watch them execute against a real browser, with tunable model parameters, reusable skills, and a local audit log of every tool call.

Run the SSE server

npm run start:sse          # http://0.0.0.0:8931 — GET /sse, POST /messages, GET /health
PORT=9000 npm run start:sse

Binds 0.0.0.0 so containers reach it via host.docker.internal.

Register in LibreChat (`librechat.yaml`)

mcpSettings:
  allowedAddresses:        # SSRF exemption for the host-mapped address
    - 'host.docker.internal:8931'

mcpServers:
  playwright:
    type: sse
    url: http://host.docker.internal:8931/sse
    timeout: 300000

Then build an agent in LibreChat's Agent Builder: attach the playwright MCP tools, paste examples/librechat-agent-instructions.md into the Instructions field, and add the skills from examples/skills/ (app selector map, spec-writing conventions, executable regression scenarios).

Model notes (learned the hard way)

Context window matters: Ollama defaults to 4096 tokens, which silently truncates tool schemas — the model then hallucinates Selenium code instead of calling tools. Run OLLAMA_CONTEXT_LENGTH=8192 ollama serve minimum.
Thinking models stall: qwen3-style reasoning burns minutes of monologue per tool call on modest hardware. Use a non-thinking instruct variant, or a fast cloud endpoint (Groq / Gemini free tiers) for the agent brain while the browser and tests stay local.
Some models batch tool calls: llama-3.3 emits all steps at once, which arrive in scrambled order. The server rejects concurrent calls with an instructive error so such clients recover by re-issuing steps one at a time.

Hardening built into the server

One tool at a time — concurrent calls are rejected, not queued, so a stray close_browser can never execute mid-scenario
Launch lock — concurrent getPage() calls share one Chromium launch instead of racing several
Token-lean page state — get_page_state caps text and element output, since agent loops re-pay for every past tool result on each round
Call logging — every tool call is logged with its arguments; when the client's transcript and reality disagree, the server log is ground truth

Example Flows

You: "Test login on https://the-internet.herokuapp.com/login
      with tomsmith / SuperSecretPassword!"

Claude: navigate → fill username → fill password → click Login
        assert text_visible "You logged into a secure area!" → ✓ PASSED
        screenshot → saved to screenshots/login_success.png

Broken image analysis

You: "Check https://the-internet.herokuapp.com/broken_images
      and tell me which images failed to load"

Claude: navigate → get_page_state → evaluate (check naturalWidth)
        "2 of 3 images are broken — both return 404.
         Root cause: server paths do not exist."

Form validation

You: "Submit the contact form on example.com with empty fields
      and verify the validation errors appear"

Claude: navigate → click Submit → get_page_state
        assert element_exists ".error-message" → ✓
        assert text_visible "This field is required" → ✓

Project Structure

playwright-mcp/
├── src/
│   ├── server.ts              # MCP server — tools, one-at-a-time execution, call log
│   ├── sse.ts                 # SSE transport — HTTP endpoint for Docker-hosted clients
│   ├── browser.ts             # BrowserManager — single browser/page, launch lock
│   └── tools/
│       ├── navigate.ts        # page.goto()
│       ├── getPageState.ts    # title + text + elements + errors (token-lean)
│       ├── screenshot.ts      # page/element screenshot → base64
│       ├── click.ts           # locator.click() — selector preferred over text
│       ├── fill.ts            # locator.fill()
│       ├── evaluate.ts        # page.evaluate(js)
│       ├── assert.ts          # 8 assertion types
│       └── closeBrowser.ts    # browser.close()
├── examples/
│   ├── claude_desktop_config.json
│   ├── librechat-agent-instructions.md   # QA agent system prompt for LibreChat
│   ├── skills/                # LibreChat skills — app map, spec conventions, scenarios
│   ├── login_flow.md
│   └── failure_analysis.md
├── package.json
└── tsconfig.json

This server is part of a broader AI-powered QA tooling portfolio:

appium-ai-agent — same MCP pattern for iOS/Android mobile test automation
flaky-guard — detect and score flaky tests from JUnit XML
self-healing-locator — automatic locator fallback chains for Selenium

What's Next

Trace recording — capture Playwright traces for failed sessions
Network interception — mock API responses mid-test
Multi-tab support
wait_for tool — wait for element, URL, or network idle

Author

Adem Garic — SDET / QA Engineer 6+ years in mobile and web test automation (Appium, Selenium, Playwright, Jenkins, BrowserStack) LinkedIn · GitHub

Available Tools

8 tools

assertA

Assert a condition about the current page state. Returns pass/fail with details — use this to verify test expectations.

ParametersJSON Schema

Name	Required	Description
`type`	Yes	The type of assertion to perform
`count`	No	Expected element count (for element_count type)
`expected`	No	Expected value or text to match against
`selector`	No	CSS selector (required for element_exists, element_hidden, input_value, element_count, text_visible with scope)

TDQS

A4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It discloses that the tool 'returns pass/fail with details,' which is a key behavioral trait. However, it does not mention whether the tool is read-only, how it behaves on failure (e.g., if it throws or just returns), or any side effects. The disclosure is adequate but not rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loaded with the tool's purpose, and every word earns its place. No fluff or unnecessary detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity and 100% schema coverage, the description is largely complete. It clarifies the return format ('pass/fail with details') even though there is no output schema. It could mention usage relative to get_page_state or waiting behavior, but these are not essential for an assert tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3. The description does not add any parameter-specific details beyond what the schema already provides. The schema's descriptions are clear, but the tool description itself offers no added semantic value for parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Assert a condition about the current page state.' It uses a specific verb (assert) and resource (current page state), and distinguishes itself from sibling tools like get_page_state by mentioning it returns pass/fail and is for verifying test expectations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear usage context: 'use this to verify test expectations.' It does not explicitly compare to alternatives or state when not to use, but this guidance is sufficient for an assertion tool in a test automation context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

clickB

Click an element on the page identified by a CSS selector or text content.

ParametersJSON Schema

Name	Required	Description
`text`	No	Visible text of the element to click (alternative to selector)
`selector`	No	CSS selector for the element to click
`waitForNavigation`	No	Wait for navigation after click (default: false)

TDQS

B3.4/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses the identification method but omits side effects (e.g., navigation, visibility requirements, return value, or error behavior). The description is minimally transparent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

A single sentence that conveys the essential purpose and identification method without any fluff or redundancy. Highly concise and front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has no annotations and no output schema, yet the description only covers the basic action. It fails to clarify that at least one of selector/text must be provided (both are optional in schema), nor does it explain return values or potential failure modes. For a 3-param tool, this leaves significant gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with each parameter (selector, text, waitForNavigation) having a clear description. The tool description echoes the selector/text content choice but adds no meaning beyond what the schema already provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (click), the resource (element on the page), and how it is identified (CSS selector or text content). This distinguishes it from siblings like fill or evaluate.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage (clicking an element) but offers no explicit guidance on when to choose this tool over alternatives such as fill for form inputs or evaluate for JavaScript. Context is clear but exclusions and alternative mentions are absent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

close_browserA

Close the browser and release all resources. Call this when the test session is complete.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Without annotations, the description carries the burden of behavioral disclosure. It explicitly mentions 'release all resources,' which goes beyond the simple 'close' and indicates side effects such as freeing memory and connections. While it does not detail all consequences (e.g., state loss), the statement is sufficient for this simple tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence that front-loads the action and includes only essential information. Every word contributes to understanding the tool's purpose and usage.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with no parameters, no output schema, and a simple cleanup function, the description covers the necessary information: what it does, what happens (releases resources), and when to use it. It is complete for the tool's complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has no parameters, and the schema coverage is 100%. According to the baseline, a score of 4 is appropriate. The description does not need to explain parameters that do not exist.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool closes the browser and releases all resources, using a specific verb and resource. It distinguishes itself from the sibling tools which are all about navigation, inspection, and interaction rather than session cleanup.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly advises calling this tool when the test session is complete, providing clear timing guidance. There are no alternative tools for closing the browser, so no exclusions are needed.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

evaluateA

Execute JavaScript in the browser page context and return the result. Use for assertions, reading DOM values, or custom interactions.

ParametersJSON Schema

Name	Required	Description	Default
`expression`	Yes	JavaScript expression to evaluate. Must be a valid JS expression (not a statement). Example: "document.title" or "document.querySelector('h1').textContent"

TDQS

A3.7/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden for behavioral disclosure. It mentions 'Execute JavaScript in the browser page context and return the result,' but fails to disclose that arbitrary JavaScript may have side effects on the page, potential error behavior, or that the result format is unspecified. This is a significant gap for a tool that can modify the page.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, well-structured sentence that front-loads the core function and follows with use cases. Every word earns its place; there is no redundancy or unnecessary detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description provides enough to understand the tool's purpose and general usage, but lacks critical context about potential side effects, error handling, and return value shape. With no annotations and no output schema, the description should do more to fully set expectations for a JavaScript execution tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% with the 'expression' parameter fully described (valid JS expression, examples). The tool description adds usage context but no additional parameter-specific meaning. Per the rubric, high schema coverage sets a baseline of 3.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific action: 'Execute JavaScript in the browser page context and return the result.' This clearly distinguishes it from sibling tools like navigate, fill, and click, which handle other browser interactions. It also lists concrete use cases ('assertions, reading DOM values, or custom interactions'), making the tool's purpose unmistakable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says 'Use for assertions, reading DOM values, or custom interactions,' providing clear context for when to use this tool. However, it does not mention when not to use it or name alternative tools (e.g., assert or get_page_state), so it lacks explicit exclusions. This aligns with 'clear context, no exclusions.'

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

fillA

Type text into an input field, textarea, or contenteditable element.

ParametersJSON Schema

Name	Required	Description
`value`	Yes	Text to type into the field
`selector`	Yes	CSS selector for the input field
`clearFirst`	No	Clear the field before typing (default: true)

TDQS

A3.5/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden for behavioral disclosure. It only states the core action of typing text and does not mention the default clearing behavior (clearFirst=true) or any side effects like event triggering. This is a significant gap for a mutation operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single clear sentence, front-loaded with the verb, and contains no extraneous information. It is concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is adequate for a simple tool, but it omits key behavioral context such as the default clearing behavior. The schema compensates for parameter details, yet the overall context is still somewhat sparse given the lack of annotations or output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so each parameter has a description. The tool description does not add further parameter-specific meaning, but the baseline of 3 applies because the schema already documents the parameters effectively.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Type text' and the resource types ('input field, textarea, or contenteditable element'), distinguishing it from sibling tools like 'click' or 'navigate'. It is specific and unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The intended use is implied by the element types mentioned, but there is no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The description does not reference sibling tools or contrast with them.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_page_stateA

Get the current state of the page — title, URL, visible text, interactive elements, and console errors. Use this to understand what is on screen before deciding the next action.

ParametersJSON Schema

Name	Required	Description	Default
`selector`	No	Scope to a specific element — returns only that element's state
`includeHtml`	No	Include truncated outer HTML of the body (default: false)

TDQS

A4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses what the tool returns (title, URL, visible text, etc.) and mentions truncated HTML, which gives useful context. However, it does not explicitly state that the tool is non-mutating or describe any side effects, permissions, or limitations beyond truncation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two concise sentences. The first states what it does and what it returns; the second provides usage guidance. There is no redundancy or extraneous detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read tool with no output schema, the description lists the main return components and usage context. It could be more explicit about response structure or the meaning of 'interactive elements', but it is sufficiently complete for an agent to select and invoke the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Both parameters have 100% schema coverage, so the baseline is 3. The description does not add significant meaning beyond the schema; it only mentions the tool's overall output, not how the parameters affect the result. The schema already explains selector and includeHtml.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool gets the current page state and enumerates specific components (title, URL, visible text, interactive elements, console errors). This is more specific than just 'get state' and distinguishes it from siblings like screenshot (visual) and evaluate (JavaScript).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly advises to use this tool to understand what is on screen before deciding the next action, providing a clear context. It does not explicitly name alternatives or exclusions, but the instruction is enough to guide appropriate use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

navigateA

Navigate the browser to a URL and return the page title and final URL after redirects.

ParametersJSON Schema

Name	Required	Description	Default
`url`	Yes	The URL to navigate to (must include protocol, e.g. https://)
`waitUntil`	No	When to consider navigation complete (default: load)

TDQS

A3.5/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the burden of disclosing behavior. It mentions returning the final URL after redirects, which is useful, but it does not disclose side effects like replacing the current page state or potential navigation failures. Still, the core behavior is reasonably transparent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence that front-loads the main action and returns information without any wasted words or redundant details.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple, with only two parameters and no output schema. The description covers purpose and return values but lacks guidance on when to use navigation versus other tools and does not mention state-changing side effects or error conditions. It is adequate but not fully complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents both parameters (url and waitUntil). The description adds no extra parameter-specific semantics beyond what the schema already provides, so the baseline score of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Navigate the browser to a URL') and the resource, plus the specific return values (page title and final URL after redirects). This distinguishes it from sibling tools like screenshot or click, which have different purposes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives no explicit guidance on when to use this tool versus the sibling tools (e.g., get_page_state, screenshot). It implies the use case of loading a page but does not state exclusions or alternatives, leaving the agent to infer.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

screenshotA

Take a screenshot of the current page or a specific element. Returns base64-encoded PNG.

ParametersJSON Schema

Name	Required	Description
`fullPage`	No	Capture full scrollable page (default: false)
`savePath`	No	Optional file path to save the screenshot to disk
`selector`	No	CSS selector to screenshot a specific element (optional — omit for full page)

TDQS

A3.5/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the return format (base64-encoded PNG) but does not disclose side effects, whether the screenshot captures the viewport or full page by default, implications of the savePath parameter, or any waiting/network behavior. This is a significant gap for a tool with no annotation safety hints.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise, consisting of two short sentences that front-load the core purpose. Every word earns its place: 'Take a screenshot of the current page or a specific element' immediately conveys scope, and the return type is specified in the second sentence. No filler or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is relatively simple, and the schema fully documents all three optional parameters, so the description does not need to repeat those details. However, with no output schema and no annotations, the description should provide more context on return value usage, potential errors, or behavior nuances (e.g., element screenshots may require visibility). The current description is minimal but not fully inadequate.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema covers 100% of the parameters with descriptions, so the baseline is 3. The tool description adds no additional meaning beyond the schema; it references 'specific element' which aligns with the selector parameter, but does not elaborate on fullPage or savePath semantics. It neither compensates for schema gaps nor adds extra value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Take a screenshot of the current page or a specific element.' It uses a specific verb ('take a screenshot') and names the resources (current page or element). This distinguishes it from sibling tools like navigate, fill, or evaluate, which serve different functions.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage by mentioning 'current page or a specific element,' but it does not explicitly state when to prefer screenshot over alternatives like get_page_state, nor does it provide exclusions or conditions. There is no 'use this instead of X' guidance, so the agent must infer usage from the tool's purpose.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

8 tool updatesv1.0.0Aug 5, 2026
- First observedassert
- First observedclick
- First observedclose_browser
- First observedevaluate
- First observedfill
- First observedget_page_state
- First observednavigate
- First observedscreenshot

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A4/5.0

Scored 2026-08-05 06:45 across 8 tools

Disambiguation5/5

Each tool has a clear, distinct purpose: navigating, reading state, capturing visuals, interacting, executing custom JS, asserting conditions, and closing the browser. No two tools overlap in function.

Naming Consistency5/5

All tool names follow an imperative verb pattern with consistent snake_case (e.g., get_page_state, close_browser). Even single-word names like navigate and click are verbs, maintaining a uniform style.

Tool Count5/5

8 tools is well-scoped for a browser automation server, covering navigation, interaction, inspection, visualization, scripting, verification, and teardown without bloat or redundancy.

Completeness4/5

The tool surface covers the core browser automation lifecycle (navigate, interact, observe, assert, cleanup). Missing explicit waits or advanced interactions (hover, dropdowns) but these are workable via evaluate, so gaps are minor.

Maintenance

ActivitySlowing

ResponsivenessNo issues

Resources

Need Help?

Related Servers

Related MCP Connectors

Remote Desktop CommanderOAuth
app.desktopcommander
Hosted MCP server connecting claude.ai, ChatGPT and other AI apps to your own computer
Shell Access OS Automation
237
mintqa-mcp
io.github.adamgusky
MCP server for Mint — AI-powered QA that runs your app in a real browser on every PR.
Testing & QA Tools CI/CD & DevOps
2
sncro A
io.github.scottconfusedgorilla
Live browser debugging for AI assistants — DOM, console, network via MCP.
Browser Automation Developer Tools Monitoring
2
anotherai
dev.anotherai
MCP server for building and testing AI agents with multi-model experimentation and insights.
Agent Orchestration Autonomous Agents Testing & QA Tools
2

Related MCP Servers

browser-devtools-mcp
Browser Automation Developer Tools Observability
serkan-ozal
A
license
Not graded
quality
Not graded
maintenance
A Playwright-based MCP server that exposes a live browser as a traceable, inspectable, debuggable and controllable execution environment for AI agents.
Updated 8 months ago (2026-01-27 17:50 UTC)
3,661 npm
57
-
MCP Playwright Server
Browser Automation Web Scraping Testing & QA Tools
MostafaRaafat91
A
license
Not graded
quality
D
maintenance
An MCP server that enables AI-powered browser automation, web scraping, and testing using Playwright across Chromium, Firefox, and WebKit. It allows users to perform actions like navigation, clicking, typing, and taking screenshots through natural language interfaces.
Updated a year ago (2025-06-30 20:19 UTC)
6 npm
MIT
Cloudflare Playwright MCP
Browser Automation Web Scraping App Automation
DAVIDwhitelabeledCA
F
license
Not graded
quality
C
maintenance
An MCP server that enables AI assistants to perform web automation tasks such as navigation, clicking, and taking screenshots by running Playwright on Cloudflare Workers. It allows models to interact with the web through a set of browser control tools across platforms like Claude Desktop and GitHub Copilot.
Updated 10 months ago (2025-11-19 10:46 UTC)
-
Glance
Browser Automation Web Scraping Testing & QA Tools
DebugBase
A
license
C
quality
D
maintenance
An MCP server that gives Claude Code real browser control for web automation, testing, and screenshots.
Updated 5 months ago (2026-04-16 13:41 UTC)
32
23 npm
151
MIT

playwright-mcp

What It Does

Architecture

Tools

Setup

Prerequisites

Install

Connect to Claude Desktop

Connect to Cursor

QA Agent Setup (LibreChat + SSE)

Run the SSE server

Register in LibreChat (librechat.yaml)

Model notes (learned the hard way)

Hardening built into the server

Example Flows

Login test

Broken image analysis

Form validation

Project Structure

Related Projects

What's Next

Author

Available Tools

Tool Schema Changelog

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

Register in LibreChat (`librechat.yaml`)