Supports interaction with web elements using CSS selectors for operations like clicking, hovering, filling form fields, and capturing specific elements in screenshots.
Offers the ability to use Firefox instead of Chrome as the browser engine through custom Puppeteer configuration options.
Enables execution of JavaScript code in the browser context through the puppeteer_evaluate tool, allowing for dynamic interaction with web page content.
Provides browser automation capabilities with configurable options, enabling navigation to websites, capturing screenshots, clicking elements, filling forms, and executing JavaScript in a real browser environment.
Click on "Deploy 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., "@Configurable Puppeteer MCP Server take a screenshot of the homepage at example.com"
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 server that provides browser automation capabilities using Puppeteer with configurable options. This server enables LLMs to interact with web pages, take screenshots, and execute JavaScript in a real browser environment, with the ability to customize Puppeteer launch options through environment variables.
puppeteer_navigate
Navigate to any URL in the browser
Input: url (string)
puppeteer_screenshot
Capture screenshots of the entire page or specific elements
Inputs:
name (string, required): Name for the screenshot
selector (string, optional): CSS selector for element to screenshot
width (number, optional, default: 800): Screenshot width
height (number, optional, default: 600): Screenshot height
puppeteer_click
Click elements on the page
Input: selector (string): CSS selector for element to click
puppeteer_hover
Hover elements on the page
Input: selector (string): CSS selector for element to hover
puppeteer_fill
Fill out input fields
Inputs:
selector (string): CSS selector for input field
value (string): Value to fill
puppeteer_select
Select an element with SELECT tag
Inputs:
selector (string): CSS selector for element to select
value (string): Value to select
puppeteer_evaluate
Execute JavaScript in the browser console
Input: script (string): JavaScript code to execute
The server provides access to two types of resources:
Console Logs (console://logs)
Browser console output in text format
Includes all console messages from the browser
Screenshots (screenshot://<name>)
PNG images of captured screenshots
Accessible via the screenshot name specified during capture
Related MCP server: Steel Puppeteer
Browser automation
Console log monitoring
Screenshot capabilities
JavaScript execution
Basic web interaction (navigation, clicking, form filling)
Configurable Puppeteer options through environment variables
You can configure Puppeteer launch options by providing a JSON string in the PUPPETEER_ARGS environment variable. This allows you to customize browser behavior without modifying the server code.
{
"mcpServers": {
"puppeteer": {
"command": "npx",
"args": ["-y", "github:afshawnlotfi/mcp-configurable-puppeteer"],
"env": {
"PUPPETEER_ARGS": "{\"browser\": \"firefox\"}"
}
}
}
}{
"mcpServers": {
"puppeteer": {
"command": "npx",
"args": ["-y", "github:afshawnlotfi/mcp-configurable-puppeteer"],
"env": {
"PUPPETEER_ARGS": "{\"defaultViewport\": {\"width\": 1280, \"height\": 800}}"
}
}
}
}{
"mcpServers": {
"puppeteer": {
"command": "npx",
"args": ["-y", "github:afshawnlotfi/mcp-configurable-puppeteer"]
}
}
}You can also specify a branch, tag, or commit:
{
"mcpServers": {
"puppeteer": {
"command": "npx",
"args": ["-y", "github:afshawnlotfi/mcp-configurable-puppeteer#main"]
}
}
}This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.
Click an element on the page
| Name | Required | Description | Default |
|---|---|---|---|
| selector | Yes | CSS selector for element to click |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description is a tautology of the name and adds no behavioral details beyond 'click'. It does not specify side effects (e.g., navigation trigger), waiting behavior, or error conditions. With no annotations, this is insufficient for safe invocation.
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 concise (one sentence) but lacks necessary detail. It is front-loaded but does not earn its place by providing substantive information beyond the tool name.
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 simplicity (one parameter, no output schema), the description fails to cover essential context like post-click behavior, return value, or error handling. For a click action, crucial details (e.g., navigation wait) are missing.
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 describes the selector parameter (CSS selector for element to click). The description adds no further meaning, but schema coverage is 100%, meeting the baseline. No extra value is provided.
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 action ('click') and the target ('an element on the page'), making the purpose obvious. It distinguishes from sibling tools like fill, hover, or navigate, which have different actions.
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 (e.g., puppeteer_hover or puppeteer_fill). It does not mention prerequisites or context, leaving the agent to infer usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Execute JavaScript in the browser console
| Name | Required | Description | Default |
|---|---|---|---|
| script | Yes | JavaScript code to execute |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility. It mentions execution in the browser console but does not specify whether the script runs synchronously, how return values are handled, or potential side effects on the page state.
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?
A single, direct sentence that immediately conveys the tool's purpose. It is front-loaded and contains no unnecessary words.
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 description is minimal given the tool's potential complexity. It does not explain what the execution returns, how to handle asynchronous code, or any security considerations. No output schema exists to compensate.
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 single parameter 'script' has a clear description in the schema ('JavaScript code to execute'), and the tool description adds no extra meaning. With 100% schema coverage, 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 clearly states the action ('Execute') and the target ('JavaScript in the browser console'), distinguishing it from sibling tools that perform specific UI interactions like clicking, filling, or navigating.
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 on when to use this tool versus alternatives such as puppeteer_click or puppeteer_fill. The description lacks context about typical use cases for executing arbitrary JavaScript.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fill out an input field
| Name | Required | Description | Default |
|---|---|---|---|
| selector | Yes | CSS selector for input field | |
| value | Yes | Value to fill |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description does not disclose behavioral traits such as whether the field is cleared before filling, whether events are triggered, or what happens if the selector is invalid. With no annotations, the description carries the full burden but fails to provide any behavioral context.
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 that is front-loaded and concise. However, it could be slightly improved by adding more context without losing brevity.
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 simplicity of the tool (fill input field), the description is minimally adequate. However, the lack of output schema and behavioral details (e.g., does it clear existing values?) leaves gaps for the agent.
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 'selector' and 'value' having descriptions. The description adds no additional meaning beyond what the schema provides, 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?
Description states 'Fill out an input field' which clearly identifies the action (fill) and resource (input field). However, it does not differentiate from sibling tools like puppeteer_select or puppeteer_click, which could also interact with input 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 like puppeteer_select or puppeteer_click. The description does not mention prerequisites, exclusions, or typical use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Hover an element on the page
| Name | Required | Description | Default |
|---|---|---|---|
| selector | Yes | CSS selector for element to hover |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It only states the action without disclosing behavior like asynchronous execution, event side effects, or whether the hover is a one-time 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. It is front-loaded and wastes no words, but could benefit from slightly more detail without losing 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?
Given the simplicity (1 param, no output schema), the description omits important context like return behavior (likely void) or side effects (e.g., triggering event listeners). Not complete for an agent.
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% (selector described), so baseline is 3. The description adds no new meaning beyond the schema; it merely restates the action.
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 states the specific verb 'Hover' and resource 'an element on the page', clearly distinguishing it from sibling tools like click, fill, or navigate. However, it lacks nuance about what 'hover' entails, such as triggering mouseover events.
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 like puppeteer_click for interactions or puppeteer_evaluate for custom actions. There is no mention of prerequisites or context.
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 or a specific element
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Name for the screenshot | |
| selector | No | CSS selector for element to screenshot | |
| width | No | Width in pixels (default: 800) | |
| height | No | Height in pixels (default: 600) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It does not disclose what happens to the screenshot (e.g., saved to disk, returned as base64), nor any side effects or permissions needed.
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, which is concise, but it lacks essential context such as output format or usage details. It is under-specified.
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 lack of output schema and annotations, the description should explain what happens with the screenshot. It fails to mention return value or storage, making it incomplete.
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%, and the description adds no additional meaning beyond the schema. 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 takes a screenshot of the current page or a specific element, with a specific verb and resource. It differentiates from sibling tools like puppeteer_navigate or puppeteer_click.
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 on when to use this tool versus alternatives, no preconditions, and no mention of when to capture a full page versus an element.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Select an element on the page with Select tag
| Name | Required | Description | Default |
|---|---|---|---|
| selector | Yes | CSS selector for element to select | |
| value | Yes | Value to select |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the burden of behavioral disclosure. It only states the intended action but does not mention side effects (e.g., page state change), error conditions, or if it waits for the element.
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. However, it is so brief that it sacrifices clarity; slightly more detail would be beneficial without losing 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 well-described parameters, the description is adequate but incomplete. It does not explain change events, support for multiple select, or error handling, which would be useful for full completeness.
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 clear parameter descriptions. The tool description adds the context that it works with a 'Select tag', which clarifies the element type beyond the schema, but this is minimal additional value.
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 states 'Select an element on the page with Select tag', which identifies the target element type (select tag) and action, but it is vague about selecting an option from a dropdown. It does not clearly distinguish from sibling tools like puppeteer_click or puppeteer_fill.
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 (e.g., puppeteer_click for generic clicks, puppeteer_fill for input fields). There is no mention of use cases or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
puppeteer_clickpuppeteer_evaluatepuppeteer_fillpuppeteer_hoverpuppeteer_navigatepuppeteer_screenshotpuppeteer_selectScored across 7 tools
Every tool has a clearly distinct purpose with no ambiguity. Clicking, evaluating JavaScript, filling inputs, hovering, navigating, taking screenshots, and selecting dropdown elements are all separate browser automation operations that an agent can easily distinguish. The descriptions clearly differentiate each action.
All tools follow a perfect verb_noun pattern with consistent snake_case naming (puppeteer_click, puppeteer_evaluate, etc.). The 'puppeteer_' prefix creates a clear namespace, and the action verbs (click, evaluate, fill, hover, navigate, screenshot, select) are consistently descriptive and parallel in structure.
Seven tools is well-scoped for a Puppeteer automation server. This provides core browser interaction capabilities without being overwhelming. Each tool earns its place by covering essential operations like navigation, interaction, evaluation, and capture that form a complete automation workflow.
The toolset covers most essential Puppeteer operations well, including navigation, interaction, evaluation, and screenshots. Minor gaps exist - there's no explicit tool for waiting/loading states, keyboard input, or cookie/session management - but agents can work around these using evaluate or other tools. Core browser automation workflows are well-supported.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
A Model Context Protocol server for Wix AI tools
Enable secure connectivity between Sentry issues and debugging data, and LLM clients, using a Model Context Protocol (MCP) server.
Undetectable cloud browser sessions for AI agents and scrapers. Navigate, extract, click, captcha.
