Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Playwright MCP open github.com and find the top repository name"
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.
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.
This package provides MCP interface into Playwright. If you are using a coding agent, you might benefit from using the CLI+SKILLS instead.
CLI: Modern coding agents increasingly favor CLI–based workflows exposed as SKILLs over MCP because CLI invocations are more token-efficient: they avoid loading large tool schemas and verbose accessibility trees into the model context, allowing agents to act through concise, purpose-built commands. This makes CLI + SKILLs better suited for high-throughput coding agents that must balance browser automation with large codebases, tests, and reasoning within limited context windows.Learn more about Playwright CLI with SKILLS.
MCP: MCP remains relevant for specialized agentic loops that benefit from persistent state, rich introspection, and iterative reasoning over page structure, such as exploratory automation, self-healing tests, or long-running autonomous workflows where maintaining continuous browser context outweighs token cost concerns.
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.
Node.js 18 or newer
VS Code, Cursor, Windsurf, Claude Desktop, Goose, Grok, Junie or any other MCP client
First, install the Playwright MCP server with your client.
Standard config works in most of the tools:
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": [
"@playwright/mcp@latest"
]
}
}
}
Add via the Amp VS Code extension settings screen or by updating your settings.json file:
"amp.mcpServers": {
"playwright": {
"command": "npx",
"args": [
"@playwright/mcp@latest"
]
}
}Amp CLI Setup:
Add via the amp mcp add command below
amp mcp add playwright -- npx @playwright/mcp@latestAdd via the Antigravity settings or by updating your configuration file:
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": [
"@playwright/mcp@latest"
]
}
}
}Use the Claude Code CLI to add the Playwright MCP server:
claude mcp add playwright npx @playwright/mcp@latestFollow the MCP install guide, use the standard config above.
Follow the instruction in the section Configuring MCP Servers
Example: Local Setup
Add the following to your cline_mcp_settings.json file:
{
"mcpServers": {
"playwright": {
"type": "stdio",
"command": "npx",
"timeout": 30,
"args": [
"-y",
"@playwright/mcp@latest"
],
"disabled": false
}
}
}Use the Codex CLI to add the Playwright MCP server:
codex mcp add playwright npx "@playwright/mcp@latest"Alternatively, create or edit the configuration file ~/.codex/config.toml and add:
[mcp_servers.playwright]
command = "npx"
args = ["@playwright/mcp@latest"]For more information, see the Codex MCP documentation.
Use the Copilot CLI to interactively add the Playwright MCP server:
/mcp addAlternatively, create or edit the configuration file ~/.copilot/mcp-config.json and add:
{
"mcpServers": {
"playwright": {
"type": "local",
"command": "npx",
"tools": [
"*"
],
"args": [
"@playwright/mcp@latest"
]
}
}
}For more information, see the Copilot CLI documentation.
Go to Cursor Settings -> MCP -> Add new MCP Server. Name to your liking, use command type with the command npx @playwright/mcp@latest. You can also verify config or add command like arguments via clicking Edit.
Use the Factory CLI to add the Playwright MCP server:
droid mcp add playwright "npx @playwright/mcp@latest"Alternatively, type /mcp within Factory droid to open an interactive UI for managing MCP servers.
For more information, see the Factory MCP documentation.
Follow the MCP install guide, use the standard config above.
Go to Advanced settings -> Extensions -> Add custom extension. Name to your liking, use type STDIO, and set the command to npx @playwright/mcp. Click "Add Extension".
Use the Grok CLI to add the Playwright MCP server:
grok mcp add playwright -- npx @playwright/mcp@latestAlternatively, create or edit the configuration file ~/.grok/config.toml and add:
[mcp_servers.playwright]
command = "npx"
args = ["@playwright/mcp@latest"]For more information, see the Grok MCP documentation.
To add the Playwright MCP server in Junie CLI:
Type /mcp
Press Ctrl+A to add a new MCP server
Select Playwright from the list
Alternatively, add to .junie/mcp/mcp.json:
{
"mcpServers": {
"Playwright": {
"command": "npx",
"args": [
"-y",
"@playwright/mcp@latest"
]
}
}
}For more information, see the Junie MCP configuration documentation.
Follow the MCP Servers documentation. For example in .kiro/settings/mcp.json:
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": [
"@playwright/mcp@latest"
]
}
}
}
Go to Program in the right sidebar -> Install -> Edit mcp.json. Use the standard config above.
Follow the MCP Servers documentation. For example in ~/.config/opencode/opencode.json:
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"playwright": {
"type": "local",
"command": [
"npx",
"@playwright/mcp@latest"
],
"enabled": true
}
}
}
Open Qodo Gen chat panel in VSCode or IntelliJ → Connect more tools → + Add new MCP → Paste the standard config above.
Click Save.
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":"playwright","command":"npx","args":["@playwright/mcp@latest"]}'After installation, the Playwright MCP server will be available for use with your GitHub Copilot agent in VS Code.
Go to Settings -> AI -> Manage MCP Servers -> + Add to add an MCP Server. Use the standard config above.
Alternatively, use the slash command /add-mcp in the Warp prompt and paste the standard config from above:
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": [
"@playwright/mcp@latest"
]
}
}
}Follow Windsurf MCP documentation. Use the standard config above.
Playwright MCP server supports following arguments. They can be provided in the JSON configuration above, as a part of the "args" list:
Option | Description |
--allowed-hosts <hosts...> | comma-separated list of hosts this server is allowed to serve from. Defaults to the host the server is bound to. Pass '*' to disable the host check.env |
--allowed-origins | semicolon-separated list of TRUSTED origins to allow the browser to request. Default is to allow all. Important: does not serve as a security boundary and does not affect redirects.env |
--allow-unrestricted-file-access | allow access to files outside of the workspace roots. Also allows unrestricted access to file:// URLs. By default access to file system is restricted to workspace root directories (or cwd if no roots are configured) only, and navigation to file:// URLs is blocked.env |
--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. Important: does not serve as a security boundary and does not affect redirects.env |
--block-service-workers | block service workersenv |
--browser | browser or chrome channel to use, possible values: chrome, firefox, webkit, msedge.env |
--caps | comma-separated list of additional capabilities to enable, possible values: vision, pdf, devtools.env |
--cdp-endpoint | CDP endpoint to connect to.env |
--cdp-header <headers...> | CDP headers to send with the connect request, multiple can be specified.env |
--cdp-timeout | timeout in milliseconds for connecting to CDP endpoint, defaults to 30000msenv |
--codegen | specify the language to use for code generation, possible values: "typescript", "none". Default is "typescript".env |
--config | path to the configuration file.env |
--console-level | level of console messages to return: "error", "warning", "info", "debug". Each level includes the messages of more severe levels.env |
--device | device to emulate, for example: "iPhone 15"env |
--mobile | emulate a generic mobile device (Pixel 10 for Chromium, iPhone 17 for WebKit). Mobile pages are usually lighter, which saves tokens. Cannot be combined with --device.env |
--executable-path | path to the browser executable.env |
--extension | Connect to a running browser instance (Edge/Chrome only). Requires the "Playwright Extension" to be installed.env |
--endpoint | Bound browser endpoint to connect to.env |
--grant-permissions <permissions...> | List of permissions to grant to the browser context, for example "geolocation", "clipboard-read", "clipboard-write".env |
--headless | run browser in headless mode, headed by defaultenv |
--host | host to bind server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.env |
--ignore-https-errors | ignore https errorsenv |
--init-page <path...> | path to TypeScript file to evaluate on Playwright page objectenv |
--init-script <path...> | path to JavaScript file to add as an initialization script. The script will be evaluated in every page before any of the page's scripts. Can be specified multiple times.env |
--isolated | keep the browser profile in memory, do not save it to disk.env |
--image-responses | whether to send image responses to the client. Can be "allow" or "omit", Defaults to "allow".env |
--no-sandbox | disable the sandbox for all process types that are normally sandboxed.env |
--output-dir | path to the directory for output files.env |
--output-max-size | Threshold for evicting old output files, in bytes.env |
--output-mode | whether to save snapshots, console messages, network logs to a file or to the standard output. Can be "file" or "stdout". Default is "stdout".env |
--port | port to listen on for SSE transport.env |
--proxy-bypass | comma-separated domains to bypass proxy, for example ".com,chromium.org,.domain.com"env |
--proxy-server | specify proxy server, for example "http://myproxy:3128" or "socks5://myproxy:8080"env |
--sandbox | enable the sandbox for all process types that are normally not sandboxed.env |
--save-session | Whether to save the Playwright MCP session into the output directory.env |
--secrets | path to a file containing secrets in the dotenv formatenv |
--shared-browser-context | reuse the same browser context between all connected HTTP clients.env |
--snapshot-mode | when taking snapshots for responses, specifies the mode to use. Can be "full" or "none". Default is "full".env |
--storage-state | path to the storage state file for isolated sessions.env |
--test-id-attribute | specify the attribute to use for test ids, defaults to "data-testid"env |
--timeout-action | specify action timeout in milliseconds, defaults to 5000msenv |
--timeout-navigation | specify navigation timeout in milliseconds, defaults to 60000msenv |
--user-agent | specify user agent stringenv |
--user-data-dir | path to the user data directory. If not specified, a temporary directory will be created.env |
--viewport-size | specify browser viewport size in pixels, for example "1280x720"env |
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}-{workspace-hash}
# macOS
- ~/Library/Caches/ms-playwright/mcp-{channel}-{workspace-hash}
# Linux
- ~/.cache/ms-playwright/mcp-{channel}-{workspace-hash}{workspace-hash} is derived from the MCP client's workspace root, so different projects get separate profiles automatically.
A persistent profile can only be used by one browser instance at a time, so concurrent MCP clients sharing the same workspace will conflict. To run several clients in parallel, start each additional client with--isolated or point it at a distinct --user-data-dir.
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": [
"@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 microsoft/playwright › packages/extension for installation and setup instructions.
There are multiple ways to provide the initial state to the browser context or a page.
For the storage state, you can either:
Start with a user data directory using the --user-data-dir argument. This will persist all browser data between the sessions.
Start with a storage state file using the --storage-state argument. This will load cookies and local storage from the file into an isolated browser context.
For the page state, you can use:
--init-page to point to a TypeScript file that will be evaluated on the Playwright page object. This allows you to run arbitrary code to set up the page.
// init-page.ts
export default async ({ page }) => {
await page.context().grantPermissions(['geolocation']);
await page.context().setGeolocation({ latitude: 37.7749, longitude: -122.4194 });
await page.setViewportSize({ width: 1280, height: 720 });
};--init-script to point to a JavaScript file that will be added as an initialization script. The script will be evaluated in every page before any of the page's scripts.
This is useful for overriding browser APIs or setting up the environment.
// init-script.js
window.isPlaywrightMCP = true;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 @playwright/mcp@latest --config path/to/config.json{
/**
* The browser to use.
*/
browser?: {
/**
* The type of browser to use.
*/
browserName?: 'chromium' | 'firefox' | 'webkit';
/**
* Keep the browser profile in memory, do not save it to disk.
*/
isolated?: boolean;
/**
* Path to a user data directory for browser profile persistence.
* Temporary directory is created by default.
*/
userDataDir?: string;
/**
* Launch options passed to
* @see https://playwright.dev/docs/api/class-browsertype#browser-type-launch-persistent-context
*
* This is useful for settings options like `channel`, `headless`, `executablePath`, etc.
*/
launchOptions?: playwright.LaunchOptions;
/**
* Context options for the browser context.
*
* This is useful for settings options like `viewport`.
*/
contextOptions?: playwright.BrowserContextOptions;
/**
* Chrome DevTools Protocol endpoint to connect to an existing browser instance in case of Chromium family browsers.
*/
cdpEndpoint?: string;
/**
* CDP headers to send with the connect request.
*/
cdpHeaders?: Record<string, string>;
/**
* Timeout in milliseconds for connecting to CDP endpoint. Defaults to 30000 (30 seconds). Pass 0 to disable timeout.
*/
cdpTimeout?: number;
/**
* Remote endpoint to connect to an existing Playwright server. May be a
* WebSocket URL string, or a [ConnectOptions] object that mirrors the
* `connectOptions` shape used by the test runner. When passed as an object,
* `exposeNetwork`, `headers`, `slowMo`, and `timeout` are forwarded to the
* underlying connect call.
*/
remoteEndpoint?: string | playwright.ConnectOptions & { endpoint: string };
/**
* Paths to TypeScript files to add as initialization scripts for Playwright page.
*/
initPage?: string[];
/**
* Paths to JavaScript files to add as initialization scripts.
* The scripts will be evaluated in every page before any of the page's scripts.
*/
initScript?: string[];
},
/**
* Connect to a running browser instance (Edge/Chrome only). If specified, `browser`
* config is ignored.
* Requires the "Playwright Extension" to be installed.
*/
extension?: boolean;
server?: {
/**
* The port to listen on for SSE or MCP transport.
*/
port?: number;
/**
* The host to bind the server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.
*/
host?: string;
/**
* The hosts this server is allowed to serve from. Defaults to the host server is bound to.
* This is not for CORS, but rather for the DNS rebinding protection.
*/
allowedHosts?: string[];
},
/**
* List of enabled tool capabilities. Possible values:
* - 'core': Core browser automation features.
* - 'pdf': PDF generation and manipulation.
* - 'vision': Coordinate-based interactions.
* - 'devtools': Developer tools features.
*/
capabilities?: ToolCapability[];
/**
* Whether to save the Playwright session into the output directory.
*/
saveSession?: boolean;
/**
* Reuse the same browser context between all connected HTTP clients.
*/
sharedBrowserContext?: boolean;
/**
* Secrets are used to replace matching plain text in the tool responses to prevent the LLM
* from accidentally getting sensitive data. It is a convenience and not a security feature,
* make sure to always examine information coming in and from the tool on the client.
*/
secrets?: Record<string, string>;
/**
* The directory to save output files.
*/
outputDir?: string;
/**
* Threshold for evicting old output files, in bytes.
*/
outputMaxSize?: number;
console?: {
/**
* The level of console messages to return. Each level includes the messages of more severe levels. Defaults to "info".
*/
level?: 'error' | 'warning' | 'info' | 'debug';
},
network?: {
/**
* List of origins to allow the browser to request. Default is to allow all. Origins matching both `allowedOrigins` and `blockedOrigins` will be blocked.
*
* Supported formats:
* - Full origin: `https://example.com:8080` - matches only that origin
* - Wildcard port: `http://localhost:*` - matches any port on localhost with http protocol
*/
allowedOrigins?: string[];
/**
* List of origins to block the browser to request. Origins matching both `allowedOrigins` and `blockedOrigins` will be blocked.
*
* Supported formats:
* - Full origin: `https://example.com:8080` - matches only that origin
* - Wildcard port: `http://localhost:*` - matches any port on localhost with http protocol
*/
blockedOrigins?: string[];
};
/**
* Specify the attribute to use for test ids, defaults to "data-testid".
*/
testIdAttribute?: string;
timeouts?: {
/*
* Configures default action timeout: https://playwright.dev/docs/api/class-page#page-set-default-timeout. Defaults to 5000ms.
*/
action?: number;
/*
* Configures default navigation timeout: https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout. Defaults to 60000ms.
*/
navigation?: number;
/**
* Configures default expect timeout: https://playwright.dev/docs/test-timeouts#expect-timeout. Defaults to 5000ms.
*/
expect?: number;
};
/**
* Whether to send image responses to the client. Can be "allow", "omit", or "auto". Defaults to "auto", which sends images if the client can display them.
*/
imageResponses?: 'allow' | 'omit';
snapshot?: {
/**
* When taking snapshots for responses, specifies the mode to use.
*/
mode?: 'full' | 'none';
};
/**
* allowUnrestrictedFileAccess acts as a guardrail to prevent the LLM from accidentally
* wandering outside its intended workspace. It is a convenience defense to catch unintended
* file access, not a secure boundary; a deliberate attempt to reach other directories can be
* easily worked around, so always rely on client-level permissions for true security.
*/
allowUnrestrictedFileAccess?: boolean;
/**
* Specify the language to use for code generation.
*/
codegen?: 'typescript' | 'none';
}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 @playwright/mcp@latest --port 8931And then in MCP client config, set the url to the HTTP endpoint:
{
"mcpServers": {
"playwright": {
"url": "http://localhost:8931/mcp"
}
}
}Related MCP server: Playwright MCP
Playwright MCP is not a security boundary. See MCP Security Best Practices for guidance on securing your deployment.
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"]
}
}
}Or If you prefer to run the container as a long-lived service instead of letting the MCP client spawn it, use:
docker run -d -i --rm --init --pull=always \
--entrypoint node \
--name playwright \
-p 8931:8931 \
mcr.microsoft.com/playwright/mcp \
/app/cli.js --headless --browser chromium --no-sandbox --port 8931 --host 0.0.0.0The server will listen on host port 8931 and can be reached by any MCP client.
You can build the Docker image yourself.
docker build -t mcr.microsoft.com/playwright/mcp .import http from 'http';
import { createConnection } from '@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 } } });
const transport = new SSEServerTransport('/messages', res);
await connection.connect(transport);
// ...
});browser_click
Title: Click
Description: Perform click on a web page
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string): Exact target element reference from the page snapshot, or a unique element selector
doubleClick (boolean, optional): Whether to perform a double click instead of a single click
button (string, optional): Button to click, defaults to left
modifiers (array, optional): Modifier keys to press
Read-only: false
browser_close
Title: Close browser
Description: Close the page
Parameters: None
Read-only: false
browser_console_messages
Title: Get console messages
Description: Returns all console messages
Parameters:
level (string): Level of the console messages to return. Each level includes the messages of more severe levels. Defaults to "info".
all (boolean, optional): Return all console messages since the beginning of the session, not just since the last navigation. Defaults to false.
filename (string, optional): Filename to save the console messages to. If not provided, messages are returned as text.
Read-only: true
browser_drag
Title: Drag mouse
Description: Perform drag and drop between two elements
Parameters:
startElement (string, optional): Human-readable source element description used to obtain the permission to interact with the element
startTarget (string): Exact target element reference from the page snapshot, or a unique element selector
endElement (string, optional): Human-readable target element description used to obtain the permission to interact with the element
endTarget (string): Exact target element reference from the page snapshot, or a unique element selector
Read-only: false
browser_drop
Title: Drop files or data onto an element
Description: Drop files or MIME-typed data onto an element, as if dragged from outside the page. At least one of "paths" or "data" must be provided.
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string): Exact target element reference from the page snapshot, or a unique element selector
paths (array, optional): Absolute paths to files to drop onto the element.
data (object, optional): Data to drop, as a map of MIME type to string value (e.g. {"text/plain": "hello", "text/uri-list": "https://example.com"}).
Read-only: false
browser_evaluate
Title: Evaluate JavaScript
Description: Evaluate JavaScript expression on page or element
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string, optional): Exact target element reference from the page snapshot, or a unique element selector
function (string): () => { /* code / } or (element) => { / code */ } when element is provided
filename (string, optional): Filename to save the result to. If not provided, result is returned as text.
Read-only: false
browser_file_upload
Title: Upload files
Description: Upload one or multiple files
Parameters:
paths (array, optional): The absolute paths to the files to upload. Can be single file or multiple files. If omitted, file chooser is cancelled.
Read-only: false
browser_fill_form
Title: Fill form
Description: Fill multiple form fields
Parameters:
fields (array): Fields to fill in
Read-only: false
browser_find
Title: Find in page snapshot
Description: Search the accessibility snapshot of the current page for text or a regular expression. Returns matching snapshot nodes with a few lines of surrounding context (like search snippets), each shown under its path from the root of the tree, which is cheaper than capturing the whole snapshot when you only need to locate an element and its ref.
Parameters:
text (string, optional): Plain text to search for in the page snapshot (case-insensitive substring match). Provide either text or regex, not both.
regex (string, optional): Regular expression to search for in the page snapshot. Matching is case-sensitive by default; wrap the pattern in slashes to add flags, e.g. "/error/i" for case-insensitive. Provide either text or regex, not both.
Read-only: true
browser_handle_dialog
Title: Handle a dialog
Description: Handle a dialog
Parameters:
accept (boolean): Whether to accept the dialog.
promptText (string, optional): The text of the prompt in case of a prompt dialog.
Read-only: false
browser_hover
Title: Hover mouse
Description: Hover over element on page
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string): Exact target element reference from the page snapshot, or a unique element selector
Read-only: false
browser_navigate
Title: Navigate to a URL
Description: Navigate to a URL
Parameters:
url (string): The URL to navigate to
Read-only: false
browser_navigate_back
Title: Go back
Description: Go back to the previous page in the history
Parameters: None
Read-only: false
browser_network_request
Title: Show network request details
Description: Returns full details (headers and body) of a single network request, or a single part if part is set. Use the number from browser_network_requests.
Parameters:
index (integer): 1-based index of the request, as printed by browser_network_requests.
part (string, optional): Return only this part of the request. Omit to return full details.
filename (string, optional): Filename to save the result to. If not provided, output is returned as text.
Read-only: true
browser_network_requests
Title: List network requests
Description: Returns a numbered list of network requests since loading the page. Use browser_network_request with the number to get full details.
Parameters:
static (boolean): Whether to include successful static resources like images, fonts, scripts, etc. Defaults to false.
filter (string, optional): Only return requests whose URL matches this regexp (e.g. "/api/.*user").
filename (string, optional): Filename to save the network requests to. If not provided, requests are returned as text.
Read-only: true
browser_press_key
Title: Press a key
Description: Press a key on the keyboard
Parameters:
key (string): Name of the key to press or a character to generate, such as ArrowLeft or a
Read-only: false
browser_resize
Title: Resize browser window
Description: Resize the browser window
Parameters:
width (number): Width of the browser window
height (number): Height of the browser window
Read-only: false
browser_run_code_unsafe
Title: Run Playwright code (unsafe)
Description: Run a Playwright code snippet. Unsafe: executes arbitrary JavaScript in the Playwright server process and is RCE-equivalent.
Parameters:
code (string, optional): A JavaScript function containing Playwright code to execute. It will be invoked with a single argument, page, which you can use for any page interaction. For example: async (page) => { await page.getByRole('button', { name: 'Submit' }).click(); return await page.title(); }
filename (string, optional): Load code from the specified file. If both code and filename are provided, code will be ignored.
Read-only: false
browser_select_option
Title: Select option
Description: Select an option in a dropdown
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string): Exact target element reference from the page snapshot, or a unique element selector
values (array): Array of values to select in the dropdown. This can be a single value or multiple values.
Read-only: false
browser_snapshot
Title: Page snapshot
Description: Capture accessibility snapshot of the current page, this is better than screenshot
Parameters:
target (string, optional): Exact target element reference from the page snapshot, or a unique element selector
filename (string, optional): Save snapshot to markdown file instead of returning it in the response.
depth (number, optional): Limit the depth of the snapshot tree
boxes (boolean, optional): Include each element's bounding box as [box=x,y,width,height] in the snapshot. Coordinates are viewport-relative, in CSS pixels (Element.getBoundingClientRect)
Read-only: true
browser_take_screenshot
Title: Take a screenshot
Description: Take a screenshot of the current page. You can't perform actions based on the screenshot, use browser_snapshot for actions.
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string, optional): Exact target element reference from the page snapshot, or a unique element selector
type (string): Image format for the screenshot. Default is png.
filename (string, optional): File name to save the screenshot to. Defaults to page-{timestamp}.{png|jpeg} if not specified. Prefer relative file names to stay within the output directory.
fullPage (boolean, optional): When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Cannot be used with element screenshots.
scale (string): Image resolution scale. "css" produces a screenshot sized in CSS pixels (smaller, consistent across devices). "device" produces a high-resolution screenshot using device pixels (larger, accounts for the device pixel ratio). Default is css.
Read-only: true
browser_type
Title: Type text
Description: Type text into editable element
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string): Exact target element reference from the page snapshot, or a unique element selector
text (string): Text to type into the element
submit (boolean, optional): Whether to submit entered text (press Enter after)
slowly (boolean, optional): Whether to type one character at a time. Useful for triggering key handlers in the page. By default entire text is filled in at once.
Read-only: false
browser_wait_for
Title: Wait for
Description: Wait for text to appear or disappear or a specified time to pass
Parameters:
time (number, optional): The time to wait in seconds
text (string, optional): The text to wait for
textGone (string, optional): The text to wait for to disappear
Read-only: false
browser_tabs
Title: Manage tabs
Description: List, create, close, or select a browser tab.
Parameters:
action (string): Operation to perform
index (number, optional): Tab index, used for close/select. If omitted for close, current tab is closed.
url (string, optional): URL to navigate to in the new tab, used for new.
Read-only: false
browser_get_config
Title: Get config
Description: Get the final resolved config after merging CLI options, environment variables and config file.
Parameters: None
Read-only: true
browser_network_state_set
Title: Set network state
Description: Sets the browser network state to online or offline. When offline, all network requests will fail.
Parameters:
state (string): Set to "offline" to simulate offline mode, "online" to restore network connectivity
Read-only: false
browser_route
Title: Mock network requests
Description: Set up a route to mock network requests matching a URL pattern
Parameters:
pattern (string): URL pattern to match (e.g., "/api/users", "/*.{png,jpg}")
status (number, optional): HTTP status code to return (default: 200)
body (string, optional): Response body (text or JSON string)
contentType (string, optional): Content-Type header (e.g., "application/json", "text/html")
headers (array, optional): Headers to add in "Name: Value" format
removeHeaders (string, optional): Comma-separated list of header names to remove from request
Read-only: false
browser_route_list
Title: List network routes
Description: List all active network routes
Parameters: None
Read-only: true
browser_unroute
Title: Remove network routes
Description: Remove network routes matching a pattern (or all routes if no pattern specified)
Parameters:
pattern (string, optional): URL pattern to unroute (omit to remove all routes)
Read-only: false
browser_cookie_clear
Title: Clear cookies
Description: Clear all cookies
Parameters: None
Read-only: false
browser_cookie_delete
Title: Delete cookie
Description: Delete a specific cookie
Parameters:
name (string): Cookie name to delete
Read-only: false
browser_cookie_get
Title: Get cookie
Description: Get a specific cookie by name
Parameters:
name (string): Cookie name to get
Read-only: true
browser_cookie_list
Title: List cookies
Description: List all cookies (optionally filtered by domain/path)
Parameters:
domain (string, optional): Filter cookies by domain
path (string, optional): Filter cookies by path
Read-only: true
browser_cookie_set
Title: Set cookie
Description: Set a cookie with optional flags (domain, path, expires, httpOnly, secure, sameSite)
Parameters:
name (string): Cookie name
value (string): Cookie value
domain (string, optional): Cookie domain
path (string, optional): Cookie path
expires (number, optional): Cookie expiration as Unix timestamp
httpOnly (boolean, optional): Whether the cookie is HTTP only
secure (boolean, optional): Whether the cookie is secure
sameSite (string, optional): Cookie SameSite attribute
Read-only: false
browser_localstorage_clear
Title: Clear localStorage
Description: Clear all localStorage
Parameters: None
Read-only: false
browser_localstorage_delete
Title: Delete localStorage item
Description: Delete a localStorage item
Parameters:
key (string): Key to delete
Read-only: false
browser_localstorage_get
Title: Get localStorage item
Description: Get a localStorage item by key
Parameters:
key (string): Key to get
Read-only: true
browser_localstorage_list
Title: List localStorage
Description: List all localStorage key-value pairs
Parameters: None
Read-only: true
browser_localstorage_set
Title: Set localStorage item
Description: Set a localStorage item
Parameters:
key (string): Key to set
value (string): Value to set
Read-only: false
browser_sessionstorage_clear
Title: Clear sessionStorage
Description: Clear all sessionStorage
Parameters: None
Read-only: false
browser_sessionstorage_delete
Title: Delete sessionStorage item
Description: Delete a sessionStorage item
Parameters:
key (string): Key to delete
Read-only: false
browser_sessionstorage_get
Title: Get sessionStorage item
Description: Get a sessionStorage item by key
Parameters:
key (string): Key to get
Read-only: true
browser_sessionstorage_list
Title: List sessionStorage
Description: List all sessionStorage key-value pairs
Parameters: None
Read-only: true
browser_sessionstorage_set
Title: Set sessionStorage item
Description: Set a sessionStorage item
Parameters:
key (string): Key to set
value (string): Value to set
Read-only: false
browser_set_storage_state
Title: Restore storage state
Description: Restore storage state (cookies, local storage) from a file. This clears existing cookies and local storage before restoring.
Parameters:
filename (string): Path to the storage state file to restore from
Read-only: false
browser_storage_state
Title: Save storage state
Description: Save storage state (cookies, local storage) to a file for later reuse
Parameters:
filename (string, optional): File name to save the storage state to. Defaults to storage-state-{timestamp}.json if not specified.
Read-only: true
browser_annotate
Title: Annotate the current page
Description: Open the Playwright Dashboard in annotation mode for the current page and wait for the user to draw annotations. Returns the annotated screenshot, ARIA snapshot, and the list of annotations.
Parameters: None
Read-only: true
browser_hide_highlight
Title: Hide element highlight
Description: Remove a highlight overlay previously added for the element.
Parameters:
element (string, optional): Human-readable element description used when adding the highlight; must match the value passed to browser_highlight.
target (string, optional): Exact target element reference from the page snapshot, or a unique element selector
Read-only: true
browser_highlight
Title: Highlight element
Description: Show a persistent highlight overlay around the element on the page.
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string): Exact target element reference from the page snapshot, or a unique element selector
style (string, optional): Additional inline CSS applied to the highlight overlay, e.g. "outline: 2px dashed red".
Read-only: true
browser_resume
Title: Resume paused script execution
Description: Resume script execution after it was paused. When called with step set to true, execution will pause again before the next action.
Parameters:
step (boolean, optional): When true, execution will pause again before the next action, allowing step-by-step debugging.
location (string, optional): Pause execution at a specific :, e.g. "example.spec.ts:42".
Read-only: false
browser_start_tracing
Title: Start tracing
Description: Start trace recording
Parameters: None
Read-only: true
browser_start_video
Title: Start video
Description: Start video recording
Parameters:
filename (string, optional): Filename to save the video.
size (object, optional): Video size
Read-only: true
browser_stop_tracing
Title: Stop tracing
Description: Stop trace recording
Parameters: None
Read-only: true
browser_stop_video
Title: Stop video
Description: Stop video recording
Parameters: None
Read-only: true
browser_video_chapter
Title: Video chapter
Description: Add a chapter marker to the video recording. Shows a full-screen chapter card with blurred backdrop.
Parameters:
title (string): Chapter title
description (string, optional): Chapter description
duration (number, optional): Duration in milliseconds to show the chapter card
Read-only: true
browser_video_hide_actions
Title: Hide action overlays
Description: Stop annotating actions performed on the page.
Parameters: None
Read-only: true
browser_video_show_actions
Title: Show action overlays
Description: Annotate subsequent actions performed on the page with a callout that names the action and highlights the target element. Useful while video recording or screencasting.
Parameters:
duration (number, optional): How long each action annotation stays on screen, in milliseconds. Defaults to 500.
position (string, optional): Where to place the action title relative to the page. Defaults to top-right.
cursor (string, optional): Cursor decoration for pointer actions. "pointer" (default) animates a mouse pointer from the previous action point to the next one; "none" disables the cursor decoration.
Read-only: true
browser_mouse_click_xy
Title: Click
Description: Click mouse button at a given position
Parameters:
x (number): X coordinate
y (number): Y coordinate
button (string, optional): Button to click, defaults to left
clickCount (number, optional): Number of clicks, defaults to 1
delay (number, optional): Time to wait between mouse down and mouse up in milliseconds, defaults to 0
Read-only: false
browser_mouse_down
Title: Press mouse down
Description: Press mouse down
Parameters:
button (string, optional): Button to press, defaults to left
Read-only: false
browser_mouse_drag_xy
Title: Drag mouse
Description: Drag left mouse button to a given position
Parameters:
startX (number): Start X coordinate
startY (number): Start Y coordinate
endX (number): End X coordinate
endY (number): End Y coordinate
Read-only: false
browser_mouse_move_xy
Title: Move mouse
Description: Move mouse to a given position
Parameters:
x (number): X coordinate
y (number): Y coordinate
Read-only: false
browser_mouse_up
Title: Press mouse up
Description: Press mouse up
Parameters:
button (string, optional): Button to press, defaults to left
Read-only: false
browser_mouse_wheel
Title: Scroll mouse wheel
Description: Scroll mouse wheel
Parameters:
deltaX (number): X delta
deltaY (number): Y delta
Read-only: false
browser_pdf_save
Title: Save as PDF
Description: Save page as PDF
Parameters:
filename (string, optional): File name to save the pdf to. Defaults to page-{timestamp}.pdf if not specified. Prefer relative file names to stay within the output directory.
Read-only: true
browser_generate_locator
Title: Create locator for element
Description: Generate locator for the given element to use in tests
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string): Exact target element reference from the page snapshot, or a unique element selector
Read-only: true
browser_verify_element_visible
Title: Verify element visible
Description: Verify element is visible on the page
Parameters:
role (string): ROLE of the element. Can be found in the snapshot like this: - {ROLE} "Accessible Name":
accessibleName (string): ACCESSIBLE_NAME of the element. Can be found in the snapshot like this: - role "{ACCESSIBLE_NAME}"
Read-only: false
browser_verify_list_visible
Title: Verify list visible
Description: Verify list is visible on the page
Parameters:
element (string): Human-readable list description
target (string): Exact target element reference that points to the list
items (array): Items to verify
Read-only: false
browser_verify_text_visible
Title: Verify text visible
Description: Verify text is visible on the page. Prefer browser_verify_element_visible if possible.
Parameters:
text (string): TEXT to verify. Can be found in the snapshot like this: - role "Accessible Name": {TEXT} or like this: - text: {TEXT}
Read-only: false
browser_verify_value
Title: Verify value
Description: Verify element value
Parameters:
type (string): Type of the element
element (string): Human-readable element description
target (string): Exact target element reference from the page snapshot
value (string): Value to verify. For checkbox, use "true" or "false".
Read-only: false
Perform click on a web page
| Name | Required | Description | Default |
|---|---|---|---|
| button | No | Button to click, defaults to left | |
| target | Yes | Exact target element reference from the page snapshot, or a unique element selector | |
| element | No | Human-readable element description used to obtain permission to interact with the element | |
| modifiers | No | Modifier keys to press | |
| doubleClick | No | Whether to perform a double click instead of a single click |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate destructiveHint=true and readOnlyHint=false, but the description adds no further behavioral context. It does not say whether the click can trigger navigation, whether permission is required beyond the 'element' parameter, or what side effects might occur.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence with no redundancy or fluff. It is maximally concise and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 5 parameters, no output schema, and potentially destructive behaviors, the description is too sparse. It fails to mention important context like using a snapshot for target selection or the need for user permissions, making the tool under-described for its complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so each parameter is adequately described in the schema. The description itself adds no extra meaning beyond what the schema provides, hence the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Perform click on a web page' clearly states a specific action (click) on a resource (web page), which is unambiguous. However, it does not differentiate from sibling tools like browser_evaluate or browser_run_code_unsafe that could also simulate clicks, so it lacks explicit sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives. The description does not mention the need for a page snapshot to obtain target references, nor does it clarify when a click is appropriate compared to other interaction tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Close the page
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructiveHint=true and readOnlyHint=false, so the agent knows this is a destructive operation. The description adds no additional context about what is destroyed, whether unsaved state is lost, or what happens after closing. Since it adds no value beyond the annotation, a score of 2 is appropriate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is 'Close the page' – only three words, with no filler. It is perfectly concise and front-loaded, making it easy to read and process.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter close action, the description is minimally viable. However, it lacks specification of side effects (e.g., does it close the tab or the entire browser?) and return behavior. Given no output schema, more detail would be helpful for complete understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema shows zero parameters, and the description doesn't need to explain any. Per the guideline for 0-parameter tools, the baseline is 4, and the description doesn't miss anything.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Close the page' uses a specific verb and resource, clearly indicating a close operation. It is distinct from sibling tools like browser_navigate or browser_click. However, there is slight ambiguity about whether 'page' means the current tab or the entire browser window, so it's not a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool or how it compares to alternatives. It does not mention any exclusions or specific contexts, leaving the agent without decision support for selecting this tool over others.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns all console messages
| Name | Required | Description | Default |
|---|---|---|---|
| all | No | Return all console messages since the beginning of the session, not just since the last navigation. Defaults to false. | |
| level | Yes | Level of the console messages to return. Each level includes the messages of more severe levels. Defaults to "info". | info |
| filename | No | Filename to save the console messages to. If not provided, messages are returned as text. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. However, the description adds no behavioral context, such as the default behavior of returning only messages since the last navigation (unless all=true) or the ability to save to a file. This is a significant gap given the schema's richness.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, making it very concise. However, it is so terse that it omits key behavioral details, and the lack of structure means it doesn't front-load helpful information. It's not verbose, but it's minimally functional.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has three parameters, a required parameter, and no output schema, the description should explain return behavior and filtering semantics. It only says 'Returns all console messages' without mentioning level filtering, the 'all' flag, or file output, leaving the agent under-informed for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema fully explains each parameter. The description itself adds no parameter-level meaning beyond what the schema provides, which aligns with the baseline 3 for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a clear verb and resource ('Returns all console messages'), which distinguishes it from sibling tools like browser_network_requests. However, 'all' is slightly ambiguous because the tool can filter by level and time scope, so it's not fully specific.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No usage guidance is provided. The description doesn't mention when to use this tool versus alternatives like browser_network_requests, nor any scenario-specific advice. Users must infer its purpose solely from the name and brief description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Perform drag and drop between two elements
| Name | Required | Description | Default |
|---|---|---|---|
| endTarget | Yes | Exact target element reference from the page snapshot, or a unique element selector | |
| endElement | No | Human-readable target element description used to obtain the permission to interact with the element | |
| startTarget | Yes | Exact target element reference from the page snapshot, or a unique element selector | |
| startElement | No | Human-readable source element description used to obtain the permission to interact with the element |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already flag this as destructive with readOnlyHint=false, so the agent knows it is a mutating action. However, the description adds no further behavioral context, such as the sequence of mouse events, potential navigation triggers, or element visibility requirements. It provides no additional transparency beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence that immediately states the action without extraneous words. It is well-structured and front-loaded, making it easy for the agent to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having annotations and a detailed schema, the description itself is minimal. It does not explain the mechanics of the drag-and-drop, whether both elements must come from the same snapshot, or any post-conditions or side effects. The potential complexity of the action is not addressed, leaving the description incomplete for practical use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides full descriptions for all four parameters, including the distinction between target references and human-readable descriptions used for permission. With 100% schema coverage, the description does not need to add parameter semantics, and it does not, aligning with the baseline of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'drag and drop' and identifies the resource as 'two elements', clearly communicating the core action. However, it does not explicitly differentiate from the sibling tool browser_drop, which could also be interpreted as a drop action, so it lacks explicit sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no information on when to use this tool versus alternatives such as hover, click, or browser_drop. It does not mention prerequisites, exclusions, or scenarios where drag-and-drop is appropriate, leaving the agent without guidance on tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Drop files or MIME-typed data onto an element, as if dragged from outside the page. At least one of "paths" or "data" must be provided.
| Name | Required | Description | Default |
|---|---|---|---|
| data | No | Data to drop, as a map of MIME type to string value (e.g. {"text/plain": "hello", "text/uri-list": "https://example.com"}). | |
| paths | No | Absolute paths to files to drop onto the element. | |
| target | Yes | Exact target element reference from the page snapshot, or a unique element selector | |
| element | No | Human-readable element description used to obtain permission to interact with the element |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate destructiveHint=true, so the mutation risk is known. The description adds context that the drop is simulated as an external drag, and the 'At least one of paths or data' constraint is useful. It does not describe side effects (e.g., navigation) but with annotations present, this is acceptable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the action and key constraint. Every word earns its place without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no output schema, the description combined with the detailed input schema covers the essential semantics: what is dropped, on what, and the required data. It does not explain post-drop behavior, but given the simplicity of the action and existing annotations, this is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already covers all parameters with descriptions (100% coverage), so baseline is 3. The description adds semantic value by stating the dependency between 'paths' and 'data' (at least one required), which is not enforced by the schema's required array. This extra constraint earns a 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Drop') and resource ('files or MIME-typed data onto an element'), and clearly distinguishes from sibling tools like browser_drag by noting 'as if dragged from outside the page'. It also conveys essential constraints (must provide paths or data).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'as if dragged from outside the page' implies when to use this tool vs browser_drag (which is for in-page dragging), and the constraint 'At least one of paths or data must be provided' gives a precondition. However, it does not explicitly reference alternatives or state when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Evaluate JavaScript expression on page or element
| Name | Required | Description | Default |
|---|---|---|---|
| target | No | Exact target element reference from the page snapshot, or a unique element selector | |
| element | No | Human-readable element description used to obtain permission to interact with the element | |
| filename | No | Filename to save the result to. If not provided, result is returned as text. | |
| function | Yes | () => { /* code */ } or (element) => { /* code */ } when element is provided |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds minimal behavioral context by mentioning 'on page or element,' but it does not disclose potential side effects of executing arbitrary JavaScript, such as page modifications or navigation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that efficiently conveys the core purpose without unnecessary words. It is front-loaded and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's powerful JavaScript execution capability and the presence of a similar sibling (browser_run_code_unsafe), the description is insufficiently contextual. It lacks guidance on behavior, side effects, and relationship to other tools, making it incomplete for an agent deciding between alternatives.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description does not add any information about parameter semantics beyond what the schema already provides, such as how `function` should be structured or the role of `filename`.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool evaluates JavaScript, with an optional scope ('on page or element'). However, it does not distinguish this from the sibling tool browser_run_code_unsafe, which likely performs a similar function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No usage guidance is provided. There is no indication of when to prefer browser_evaluate over browser_run_code_unsafe or other browser tools, leaving the agent without decision support.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Upload one or multiple files
| Name | Required | Description | Default |
|---|---|---|---|
| paths | No | The absolute paths to the files to upload. Can be single file or multiple files. If omitted, file chooser is cancelled. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=false and destructiveHint=true, but the description adds no additional behavioral context such as file chooser behavior, side effects, or failure modes. It merely restates the action without revealing what happens beyond the upload.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence that immediately states the core function with no filler. It is appropriately minimal for a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no output schema and mutating/destructive behavior, the description provides minimal context. It doesn't mention that this operates on the active browser page, potential side effects, or error conditions. The schema and annotations cover some basics, but the description is insufficient for an agent to use confidently.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% – the paths parameter is fully documented in the schema, including the 'if omitted' cancellation behavior. The description itself adds no parameter information, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action ('Upload') and indicates it can handle one or multiple files, differentiating it from siblings like browser_drop. However, it's minimalist and doesn't explicitly state the destination or context beyond the tool name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like browser_drop, nor are there any prerequisites or exclusions mentioned. The description simply states the action without operational context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fill multiple form fields
| Name | Required | Description | Default |
|---|---|---|---|
| fields | Yes | Fields to fill in |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is not read-only and is destructive (readOnlyHint=false, destructiveHint=true). The description adds no additional behavioral context, but it is consistent with the annotations. No contradictions, but also no extra value beyond the annotation safety profile.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with zero filler words. It communicates the core action effectively and is immediately understandable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This tool has a complex nested schema and is part of a large sibling set, but the description gives no context about behavior beyond 'fill fields'. No output schema exists, and important details like whether existing values are cleared, whether the form is submitted, or how to target elements are absent. The schema covers parameters, but the description lacks operational context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides 100% coverage with descriptions for all fields, including target, name, type, and value. The description itself adds no additional parameter information, so it earns the baseline score of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a clear verb ('Fill') and specifies the resource ('multiple form fields'), which states the tool's function. However, it does not differentiate from sibling tools like browser_type or browser_select_option, which also interact with form fields.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description only states what it does, not when to prefer it over browser_type for a single field or browser_select_option for dropdowns. There are no exclusions or explicit use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the accessibility snapshot of the current page for text or a regular expression. Returns matching snapshot nodes with a few lines of surrounding context (like search snippets), each shown under its path from the root of the tree, which is cheaper than capturing the whole snapshot when you only need to locate an element and its ref.
| Name | Required | Description | Default |
|---|---|---|---|
| text | No | Plain text to search for in the page snapshot (case-insensitive substring match). Provide either text or regex, not both. | |
| regex | No | Regular expression to search for in the page snapshot. Matching is case-sensitive by default; wrap the pattern in slashes to add flags, e.g. "/error/i" for case-insensitive. Provide either text or regex, not both. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover readOnlyHint and destructiveHint. The description adds valuable behavior beyond that: it returns 'matching snapshot nodes with a few lines of surrounding context' and displays each under its 'path from the root of the tree.' No contradictions; the extra cost context is helpful.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the primary action. Each clause adds value: search target, return format, path display, and cost benefit. No fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given moderate complexity and the lack of an output schema, the description adequately explains the return format (matching nodes with context) and the specific use case. It does not cover edge cases like no matches, but the cost comparison with browser_snapshot adds useful context that goes beyond the schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with each parameter fully described (case-insensitive substring, regex flags). The description only reinforces the 'either/or' requirement without adding deeper parameter syntax details, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Search the accessibility snapshot... for text or a regular expression.' It also distinguishes from sibling browser_snapshot by noting it is 'cheaper than capturing the whole snapshot,' making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use this tool: 'when you only need to locate an element and its ref' and frames it as a cheaper alternative to capturing the whole snapshot, which implies browser_snapshot as the alternative. Also instructs to provide either text or regex, not both.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Handle a dialog
| Name | Required | Description | Default |
|---|---|---|---|
| accept | Yes | Whether to accept the dialog. | |
| promptText | No | The text of the prompt in case of a prompt dialog. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructiveHint=true and readOnlyHint=false, but the description adds nothing about the tool's behavior beyond that. It does not explain what happens when a dialog is handled, whether it types prompt text, or how it interacts with 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short, but it is under-specified rather than concise. A single vague sentence is not appropriately structured to convey essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This tool has two parameters and no output schema, but the description provides almost no context about its operation, return values, or scenarios. It is inadequate for an agent to correctly invoke the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides full descriptions for both parameters (accept and promptText), so the baseline is 3. The description adds no additional semantic meaning to the parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Handle a dialog' is essentially a restatement of the tool name and annotation title. It provides no specific verb or details about what handling entails, making it a tautology rather than a clear purpose statement.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool or how it compares to sibling tools. No exclusions, prerequisites, or alternative tool mentions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Hover over element on page
| Name | Required | Description | Default |
|---|---|---|---|
| target | Yes | Exact target element reference from the page snapshot, or a unique element selector | |
| element | No | Human-readable element description used to obtain permission to interact with the element |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds no behavioral information beyond the annotations already provided. Annotations indicate destructiveHint=true, but the description doesn't explain potential side effects like triggering mouseover events or requiring element visibility. It simply restates the action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence, 'Hover over element on page', with no redundant words. It is appropriately front-loaded and easy to parse, though sparse in content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple hover action, the description combined with rich schema and annotations is mostly adequate. However, it lacks context about when to use this tool and potential side effects, leaving some gaps in understanding the full implications of the action.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both target and element having meaningful descriptions. The tool description itself adds no parameter information, but the schema already provides sufficient meaning, justifying the baseline score of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Hover over element on page' clearly states the action (hover) and the target (element on page). It distinguishes itself from sibling tools like browser_click and browser_drag by naming the specific hover operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use hover versus other interaction tools (e.g., click, drag), nor any prerequisites such as obtaining a page snapshot first. The description gives no context for selecting this tool over alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns full details (headers and body) of a single network request, or a single part if part is set. Use the number from browser_network_requests.
| Name | Required | Description | Default |
|---|---|---|---|
| part | No | Return only this part of the request. Omit to return full details. | |
| index | Yes | 1-based index of the request, as printed by browser_network_requests. | |
| filename | No | Filename to save the result to. If not provided, output is returned as text. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds behavioral context by explaining the output includes headers and body, and that setting `part` limits the result to a single part. This goes beyond the annotations without contradicting them, though it does not mention error handling or invalid index behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the main action, and every word contributes. It avoids redundancy and clearly communicates the core behavior and the key parameter (`part`) without unnecessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With a small parameter set and no output schema, the description covers the essential behavior: what the tool returns, how to specify the request, and how to get a part. It could mention output format or potential errors, but the existing schema annotations and sibling reference make it sufficiently complete for a simple retrieval tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so parameters are already documented. The description adds meaning by explaining that the `index` comes from browser_network_requests, and that `part` selects a single part. This cross-reference and interpretation adds value beyond the schema's individual field descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns full details of a single network request, or a single part if specified. It uses a specific verb ('Returns') and resource ('single network request'), and distinguishes itself from the sibling tool browser_network_requests by focusing on a single request rather than listing multiple.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly instructs to use the number from browser_network_requests, establishing a clear prerequisite and workflow. It does not explicitly mention when not to use it or alternatives, but the reference to the sibling tool provides enough context for appropriate usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns a numbered list of network requests since loading the page. Use browser_network_request with the number to get full details.
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | Only return requests whose URL matches this regexp (e.g. "/api/.*user"). | |
| static | Yes | Whether to include successful static resources like images, fonts, scripts, etc. Defaults to false. | |
| filename | No | Filename to save the network requests to. If not provided, requests are returned as text. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that the list is numbered and scoped to the page load, but does not disclose additional behavioral details like filtering behavior or return format beyond the schema. This 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the primary purpose and followed by a reference to the related tool. Every sentence is necessary and there is no wasted text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple listing tool with no output schema, the description adequately covers what it returns (numbered list) and how to get details via the sibling tool. The schema covers all parameters, so the description is complete enough for an agent to use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the parameters (filter, static, filename) are fully documented in the schema. The description does not add any extra parameter semantics, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns a numbered list of network requests since page load, using a specific verb and resource. It also distinguishes itself from the sibling browser_network_request by explaining that the singular tool is used for full details.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides explicit guidance to use browser_network_request with the returned number for full details, establishing a clear workflow. It does not mention exclusions or when not to use this tool, but the context is clear enough for a listing tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Press a key on the keyboard
| Name | Required | Description | Default |
|---|---|---|---|
| key | Yes | Name of the key to press or a character to generate, such as `ArrowLeft` or `a` |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds no behavioral context beyond the annotations. While annotations already indicate destructiveHint=true and readOnlyHint=false, the description fails to mention potential side effects like triggering browser shortcuts or navigating away, which would be useful for the agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, extremely concise and front-loaded. Every word earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool marked as destructive with no output schema, the description is too minimal. It does not explain what happens when a key is pressed (e.g., key events dispatched, focus requirements, potential side effects), leaving the agent with insufficient context to anticipate the tool's impact.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with a clear description for the 'key' parameter including examples. The tool description itself does not add extra parameter information, 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Press' and resource 'key on the keyboard', clearly indicating the action. It does not explicitly distinguish from sibling tools like browser_type, but the focus on a single key press versus typing text is implicit in the phrasing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as browser_type or browser_click. The description simply states what the tool does without specifying context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Resize the browser window
| Name | Required | Description | Default |
|---|---|---|---|
| width | Yes | Width of the browser window | |
| height | Yes | Height of the browser window |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate destructiveHint=true and readOnlyHint=false, but the description adds no additional behavioral context. It does not explain potential side effects such as layout changes, viewport impacts, or implications for page interaction tests.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that effectively communicates the action. It is appropriately sized for a simple tool, though it could optionally add context about units or viewport semantics without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
While the description covers the basic action, it lacks usage guidelines and behavioral context. The destructiveHint annotation is not elaborated, and there is no mention of return values or side effects, leaving the agent under-informed for a tool that may significantly alter the browser state.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides full descriptions for both parameters (width and height), achieving 100% schema description coverage. The tool description adds no extra meaning beyond what the schema already conveys, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('resize') and resource ('browser window'), distinguishing it from sibling tools like navigate, click, or drag. It is unambiguous and directly indicates what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It merely states the action without any context on applicable scenarios, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run a Playwright code snippet. Unsafe: executes arbitrary JavaScript in the Playwright server process and is RCE-equivalent.
| Name | Required | Description | Default |
|---|---|---|---|
| code | No | A JavaScript function containing Playwright code to execute. It will be invoked with a single argument, page, which you can use for any page interaction. For example: `async (page) => { await page.getByRole('button', { name: 'Submit' }).click(); return await page.title(); }` | |
| filename | No | Load code from the specified file. If both code and filename are provided, code will be ignored. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate destructiveHint=true, but the description adds crucial context: code runs in the Playwright server process (not the browser page) and is equivalent to remote code execution. This goes well beyond the structured annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One sentence, front-loaded with the core action, followed by a sharp safety warning. No wasted words; the title and description are efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite no output schema, the description fully discloses the primary risk and execution environment. It does not explain return behavior, but for a code execution tool, the return is whatever the user's code returns. The warning about RCE is the essential context, and it is present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for both code and filename, with detailed examples in the code parameter. The description does not need to add more, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool runs a Playwright code snippet and explicitly notes it executes arbitrary JavaScript in the server process, distinguishing it from safer alternatives like browser_evaluate. The warning 'RCE-equivalent' makes the purpose unmistakable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage is only for advanced/unsafe scenarios via 'Unsafe' and 'RCE-equivalent', but it does not explicitly mention when to prefer this over browser_evaluate or other sibling tools. No clear alternatives or exclusions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Select an option in a dropdown
| Name | Required | Description | Default |
|---|---|---|---|
| target | Yes | Exact target element reference from the page snapshot, or a unique element selector | |
| values | Yes | Array of values to select in the dropdown. This can be a single value or multiple values. | |
| element | No | Human-readable element description used to obtain permission to interact with the element |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate the tool is not read-only and is destructive. The description adds no additional behavioral context, such as whether prior selections are replaced, or permission implications.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler, achieving maximum conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with a comprehensive schema and annotations, the description is minimally viable. It lacks usage guidance and deeper behavioral context, but structured data covers parameter semantics and safety. Thus it meets the minimum bar but is not rich.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema fully describes all three parameters with clear descriptions (target, values, element). The description does not add any parameter-specific meaning beyond the schema, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('select') and resource ('option in a dropdown'), clearly distinguishing it from siblings like browser_click or browser_type. However, it does not specify that it works on <select> elements or support multiple values, slightly reducing clarity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like browser_click or browser_fill_form. The description simply states the action without contextual cues or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Capture accessibility snapshot of the current page, this is better than screenshot
| Name | Required | Description | Default |
|---|---|---|---|
| boxes | No | Include each element's bounding box as [box=x,y,width,height] in the snapshot. Coordinates are viewport-relative, in CSS pixels (Element.getBoundingClientRect) | |
| depth | No | Limit the depth of the snapshot tree | |
| target | No | Exact target element reference from the page snapshot, or a unique element selector | |
| filename | No | Save snapshot to markdown file instead of returning it in the response. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds that it captures an 'accessibility snapshot' and claims it is 'better than screenshot', but it does not disclose return value format or any potential side effects. With annotations covering the safety profile, a score of 3 reflects that the description adds only minimal behavioral context beyond the structured metadata.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that immediately states the purpose and includes a comparative benefit. There is no redundant information or filler, and the structure is well-suited for quick reading by an AI agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema and only a minimal description. While the parameters are thoroughly documented in the schema and the read-only annotations are present, the description does not explain what the accessibility snapshot will contain or how the agent should interpret the response. This is a gap given the lack of an output schema, but the tool is relatively simple, so the description is minimally viable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 itself does not add any additional meaning to the parameters; the schema already explains boxes, depth, target, and filename. There is no extra context like parameter relationships or common usage patterns, so no credit beyond the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('Capture') and resource ('accessibility snapshot of the current page'). It also explicitly distinguishes it from the sibling tool browser_take_screenshot by claiming it is 'better than screenshot', which helps the agent choose correctly between these two related tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for capturing accessibility snapshots and suggests it is the preferred choice over screenshots for that purpose. It provides a clear context but does not explicitly state when not to use it or mention other alternative tools, such as browser_find or browser_evaluate, which might also serve similar inspection needs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List, create, close, or select a browser tab.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | URL to navigate to in the new tab, used for new. | |
| index | No | Tab index, used for close/select. If omitted for close, current tab is closed. | |
| action | Yes | Operation to perform |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description does not contradict the annotations (destructiveHint: true, readOnlyHint: false) and lists actions that align with those hints. However, it adds no extra behavioral context beyond what annotations and schema already provide, such as what happens when 'index' is omitted or how 'list' returns data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that lists all supported operations. It front-loads the core purpose and contains no fluff or redundant detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
While the schema and annotations provide solid coverage of parameters and safety hints, the description is thin on operational details like return formats, edge cases for 'index', and what 'select' does exactly. There is no output schema to fill this gap. The tool is simple enough to function, but not richly specified as a whole.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, meaning all three parameters are already documented with descriptions in the schema. The description adds no additional parameter meaning beyond restating the action names, 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the resource (browser tab) and specific actions (list, create, close, select). This distinguishes it from sibling tools that handle navigation, clicking, or snapshots. The verb+resource structure makes 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.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives like browser_navigate or browser_snapshot. There are no prerequisites, exclusions, or explicit context suggesting typical use cases beyond the bare action list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Take a screenshot of the current page. You can't perform actions based on the screenshot, use browser_snapshot for actions.
| Name | Required | Description | Default |
|---|---|---|---|
| type | Yes | Image format for the screenshot. Default is png. | png |
| scale | Yes | Image resolution scale. "css" produces a screenshot sized in CSS pixels (smaller, consistent across devices). "device" produces a high-resolution screenshot using device pixels (larger, accounts for the device pixel ratio). Default is css. | css |
| target | No | Exact target element reference from the page snapshot, or a unique element selector | |
| element | No | Human-readable element description used to obtain permission to interact with the element | |
| filename | No | File name to save the screenshot to. Defaults to `page-{timestamp}.{png|jpeg}` if not specified. Prefer relative file names to stay within the output directory. | |
| fullPage | No | When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Cannot be used with element screenshots. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations (readOnlyHint: true, destructiveHint: false) already establish the safety profile. The description adds a non-obvious behavioral constraint: screenshots cannot be used as a basis for actions. This is valuable context beyond the annotations. No contradictions exist.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with zero waste. It front-loads the core purpose and then provides a critical usage distinction. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a relatively simple screenshot tool with excellent schema coverage, the description is functionally complete. It covers the main caveat (actions require browser_snapshot) and the schema handles all parameter details. No output schema exists, but the return type (screenshot image) is self-evident from the tool's name and purpose.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with detailed descriptions for all six parameters (type, scale, target, element, filename, fullPage). The description itself adds no additional parameter context, so the baseline score of 3 is appropriate given that the schema carries the semantic burden.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource: 'Take a screenshot of the current page.' It clearly distinguishes the tool from browser_snapshot by noting that screenshots cannot be used for actions, which is a key differentiating detail.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance: 'You can't perform actions based on the screenshot, use browser_snapshot for actions.' This directly tells the agent when not to use this tool and names the alternative, making the usage context unambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Type text into editable element
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | Text to type into the element | |
| slowly | No | Whether to type one character at a time. Useful for triggering key handlers in the page. By default entire text is filled in at once. | |
| submit | No | Whether to submit entered text (press Enter after) | |
| target | Yes | Exact target element reference from the page snapshot, or a unique element selector | |
| element | No | Human-readable element description used to obtain permission to interact with the element |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark destructiveHint=true and readOnlyHint=false, so the safety profile is known. The description adds no behavioral detail, such as whether existing text is replaced or whether input events are triggered, but it does not contradict the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single six-word sentence, immediately stating the action and target. There is no fluff or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Annotations and schema cover safety and parameter details, but the description lacks usage context, alternative-tool differentiation, and mention of behavioral nuances. It is minimally adequate but not complete for a destructive tool with 5 parameters and no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with descriptions for all 5 parameters, so the baseline is 3. The description itself adds no additional parameter semantics beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Type text into editable element' clearly states the action and target resource. It distinguishes itself from sibling tools like browser_press_key and browser_fill_form.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as browser_fill_form or browser_press_key. There are no prerequisites, exclusions, or context hints.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Wait for text to appear or disappear or a specified time to pass
| Name | Required | Description | Default |
|---|---|---|---|
| text | No | The text to wait for | |
| time | No | The time to wait in seconds | |
| textGone | No | The text to wait for to disappear |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows it is a safe read-only operation. The description adds the specific wait conditions but does not disclose edge cases like behavior when no parameters are provided or when multiple conditions are combined. This is acceptable 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that front-loads the action and covers all three use cases. There is no wasted wording or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with three optional parameters and no output schema, the description is mostly complete. It covers the main functionality, though it leaves ambiguity about how parameter combinations (e.g., text + time) should be handled and what the return value is, so it is not a perfect 5.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%: each parameter already has a clear description ('text to wait for', 'time in seconds', 'text to disappear'). The tool description adds minimal extra meaning beyond that, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states what the tool does: waits for text to appear, disappear, or a specified time to pass. It uses a specific verb ('wait') and identifies the resources (text, time), but does not explicitly differentiate it from sibling tools, so it loses one point.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The usage context is implied: use this tool when you need to wait for a condition such as text appearing/disappearing or a time delay. However, there is no explicit guidance on when not to use it or mention of alternative tools (e.g., browser_find for checking text presence), so it is not fully explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool targets a distinct browser action or resource, with clear boundaries between similar functions like type vs press_key vs fill_form, and snapshot vs find. The descriptions further clarify any potential ambiguity.
All tools follow a consistent browser_<verb_noun> pattern in snake_case, such as browser_navigate, browser_click, browser_network_requests. The uniform prefix and verb style make the set predictable and easy to navigate.
With 24 tools, the server is on the heavier end, but the breadth is justified by the full range of browser automation capabilities. It feels slightly over the ideal 15-tool sweet spot yet not bloated.
The tool set covers the complete lifecycle of browser interaction: navigation, tab management, clicking, typing, form filling, file handling, dialogs, network inspection, screenshots, and accessibility snapshots. No major gaps for standard browser automation tasks.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Provides cloud browser automation capabilities using Stagehand and Browserbase, enabling LLMs to i…
Headless browser primitives for AI agents when sites need real JS rendering.
Stealth web automation for AI agents. Login, signup, navigate, screenshot.
Stealth web automation for AI agents. Login, signup, navigate, screenshot.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/jagadeshp/Playwright-Mcp1'
If you have feedback or need assistance with the MCP directory API, please join our Discord server