Drives a Brave browser instance via the Chrome DevTools Protocol to open URLs, take full-page screenshots, read saved screenshots back as images, close the browser, and report browser status, with headless background capture by default.
Drives Google Chrome via the Chrome DevTools Protocol to open URLs, capture full-page screenshots, read saved screenshots back as images, close the browser, and report browser status, with headless background capture by default.
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., "@fullpageshot-mcp screenshot https://en.wikipedia.org/wiki/Web_browser and read it back to me"
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.
An MCP server that gives an agent the ability to:
open a website (open_url)
take a screenshot of it (screenshot) — full-page by default
read the screenshot back as an image (read_screenshot)
Capture runs in the background by default (headless Chromium), so it needs no open window and no browser extension. It drives a Chromium-based browser you already have via the Chrome DevTools Protocol — zero npm dependencies.
Companion to the FullPageShot browser extension. The extension is for humans clicking the toolbar; this server is for agents and scripts.
Node.js | >= 22 (uses the built-in |
Browser | Any Chromium-based browser: Google Chrome, Brave, Chromium, Microsoft Edge |
OS | macOS, Linux, Windows |
Dependencies | none |
The server finds a browser automatically. Override with FULLPAGESHOT_CHROME=/path/to/browser.
Related MCP server: webshot-mcp
git clone https://github.com/TanasiDesigns/fullpageshot-mcp
cd fullpageshot-mcp
node src/server.mjs --version # sanity check, no install step neededOr run it straight from a checkout in any MCP client config (below). No npm install is required.
Generic stdio configuration (Claude Desktop, Cursor, Cline, Continue, pi, etc.):
{
"mcpServers": {
"fullpageshot": {
"command": "node",
"args": ["/absolute/path/to/fullpageshot-mcp/src/server.mjs"]
}
}
}With the optional bin link:
{
"mcpServers": {
"fullpageshot": { "command": "fullpageshot-mcp" }
}
}Tool | What it does |
| Navigate to a URL. |
| Capture the current page, or a |
| Read a saved screenshot file back as image content. |
| Shut the browser down and remove its throwaway profile. |
| Show running/headless/version/output-dir state. |
"Open https://example.com and screenshot it."
"Take a full-page screenshot of https://en.wikipedia.org/wiki/Web_browser and tell me what the infobox says."
"Screenshot https://stripe.com/pricing at 1440×900 and read it back."
"Capture https://github.com and crop-check the footer." (capture, then read_screenshot)
Capture is headless by default (--headless=new) so it works with no visible window:
screenshot({ url, headless: true }) → background, no window.
open_url({ url, headless: false }) → visible window (useful for debugging).
Env FULLPAGESHOT_HEADLESS=0 forces a visible window for every call.
Each run uses a throwaway profile under the system temp dir, so it never touches your real browser profile or logins.
Env var | Default | Meaning |
| auto-detected | Path to the browser binary. |
|
|
|
| temp dir | Where screenshots are saved. |
MCP stdio -> fullpageshot-mcp -> launches Chromium (headless)
-> CDP over WebSocket
Target.createTarget
Page.navigate
Page.getLayoutMetrics
Page.captureScreenshot{captureBeyondViewport}
-> PNG on disk + base64 image back to the agentFull-page capture uses captureBeyondViewport with a clip sized to the page's content, scaled down if it would exceed the 16384 px screenshot ceiling. screenshot also scrolls the page once (settle) to trigger lazy-loaded content before measuring.
Runs entirely locally. No telemetry, no accounts, no network calls except the pages you ask it to open.
Never attaches to your everyday browser or its profile — it launches a separate throwaway instance.
The only "remote control" surface is the browser it starts itself.
Tested with Brave 154.0.8037.93 (Chromium 154) on macOS, headless. The CDP methods used (Target.*, Page.navigate, Page.getLayoutMetrics, Page.captureScreenshot) are long-stable and supported by Chromium 100+; Chrome/Brave/Edge/Chromium all work.
MIT — see LICENSE. Do whatever you want with it: use, modify, fork, sell, ship in your own product. Just keep the copyright notice.
Report whether the browser is running, whether it is headless, its version, and the screenshot output directory.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it does disclose the returned behavioral facts (running state, headless flag, version, screenshot dir). It does not explicitly state that the call is side-effect-free or whether it launches a browser, but 'Report' strongly implies a passive read.
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 tight sentence with no filler, and the four returned facts are front-loaded in one clause. 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?
There is no output schema, so the description must enumerate return values, and it does so completely for a zero-parameter read tool. Nothing an agent needs to call it correctly is 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 tool takes zero parameters, so the baseline is 4. There is nothing for the description to disambiguate beyond what the empty schema already conveys.
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 a specific verb ('Report') and enumerates exactly what is reported: running state, headless mode, version, and screenshot output directory. This clearly separates it from the action siblings (open_url, screenshot, read_screenshot, close_browser), though it never names or contrasts those siblings explicitly.
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?
Usage is only implied – an agent can infer this is the tool to call to check browser state, but the description gives no explicit when-to-use, when-not-to-use, or prerequisite (e.g. call before screenshotting). No alternatives are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Shut down the controlled browser and clean up its temporary profile.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it does disclose a real side effect: the temporary profile is cleaned up (i.e., destroyed). However it says nothing about idempotency or what happens if no browser is running, so behavioral coverage is partial.
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 front-loaded sentence with zero waste; the primary action and its cleanup side effect are stated together.
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 parameterless lifecycle tool with no output schema, the description says what it does and the side effect. It is nearly complete, though it omits failure/idempotency behavior for repeated calls.
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 tool takes zero parameters, so there is no parameter semantics to document; the baseline for a no-param tool is 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?
States a specific verb (shut down) plus the resource (controlled browser) and an additional effect (clean up its temporary profile). An agent can distinguish this teardown operation from open_url, screenshot, and browser_status without opening any schema.
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?
Usage is implied — you call this when finished with the browser — but there is no explicit when/when-not guidance or reference to a sibling. The teardown intent is clear enough from the verb to be actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Open a website in a controlled Chromium browser. Runs headless (background) by default; set headless=false for a visible window.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | URL to open (https:// is assumed if no scheme is given). | |
| width | No | Viewport width in CSS px. | |
| height | No | Viewport height in CSS px. | |
| settle | No | Scroll through the page first to trigger lazy content. Default true. | |
| headless | No | Run without a visible window. Default true. | |
| timeoutMs | No | Navigation timeout in ms. Default 30000. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It usefully discloses the headless default and how to get a visible window, but says nothing about session persistence across sibling calls, whether existing pages are replaced, auth requirements, or side effects. No output schema exists, so return behavior is also undisclosed.
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 compact sentences with zero filler, and the key operational fact (headless by default) is front-loaded after the purpose statement. Slightly terse for a six-parameter tool, but nothing is wasted.
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 annotations and no output schema in a multi-tool browser session, the description omits what happens after navigation — whether the session persists for screenshot/close_browser, and what is returned. It covers the core act of opening a URL but leaves session lifecycle behavior to inference.
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 every parameter is already documented in the schema. The description repeats the headless default rather than adding new semantics (e.g., how settle interacts with lazy loading, or timeout behavior on failure). Baseline 3 is appropriate when the schema does the heavy lifting.
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?
States a specific verb and resource ('Open a website in a controlled Chromium browser'), which is unambiguous about what the tool does. It does not explicitly differentiate itself from siblings like screenshot or close_browser, but as the obvious session entry point the distinction is reasonably clear.
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, no prerequisites, and no mention of the sibling tools (screenshot, read_screenshot, close_browser, browser_status) that share the browser session. Usage is only inferable from the browser-session context, not stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read a previously saved screenshot file back as image content.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Path to a PNG/JPEG/WebP/GIF file. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It usefully discloses the output form ('as image content'), which tells the agent what to expect back, but it says nothing about error behavior for missing files, permission needs, or side effects.
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 front-loaded sentence with no filler or redundancy. It is efficiently sized, though the terseness leaves room it could have used for behavioral context rather than being bloated.
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 one-parameter read tool with no output schema, the description covers what it does and the return form. Minor gaps remain around failure modes (e.g., nonexistent path), but nothing critical to invoking it correctly is 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?
With a single parameter and 100% schema description coverage, the schema already documents the path and its allowed formats (PNG/JPEG/WebP/GIF). The description adds no semantic detail beyond what the schema provides, 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?
States a specific verb (Read) and resource (a previously saved screenshot file), and the phrase 'previously saved' implicitly distinguishes it from the sibling 'screenshot' tool that captures new images. It does not name any sibling explicitly, so it falls short of a 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?
'Previously saved screenshot file' implies this is the follow-up to a capture operation, giving implied usage context. However, there is no explicit when-to-use, when-not-to-use, or naming of alternatives such as the 'screenshot' sibling.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Capture a full-page screenshot (default) of the current page or of a URL. Saves a PNG/JPEG/WebP to disk and returns the image so it can be read.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | If set, navigate here before capturing. Otherwise captures the current page. | |
| path | No | Output file path. Defaults to the system temp dir. | |
| read | No | Return the image bytes in the response. Default true. | |
| maxPx | No | Max image dimension; larger pages are scaled down. Default 16384. | |
| width | No | Viewport width in CSS px. | |
| format | No | Image format. Default png. | |
| height | No | Viewport height in CSS px. | |
| settle | No | Scroll through the page first to trigger lazy content. Default true. | |
| quality | No | 0-100, JPEG/WebP only. | |
| fullPage | No | Capture the whole page beyond the viewport. Default true. | |
| timeoutMs | No | Navigation timeout in ms. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it does disclose real behavior: it writes a file to disk (a side effect) and also returns the image bytes. However, it omits whether an existing file at 'path' is overwritten, permission/auth requirements, and scaling behavior, leaving meaningful behavioral context unstated.
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 short sentences, zero filler, with the default behavior (full-page) and output behavior front-loaded. Every clause 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 an 11-parameter, zero-annotation tool with no output schema, the description covers the core action and the disk-write plus image-return behavior, which is solid. It still leaves the read vs read_screenshot relationship and file-overwrite/concurrency semantics unexplained, so it is adequate but not complete.
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 all 11 parameters are already documented in the schema, setting the baseline at 3. The description only adds light framing ('full-page (default)', format options, image returned for reading) and no syntax or default details 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?
States a specific verb and resource ('Capture a full-page screenshot') plus the scope (current page or a URL), so the action is unambiguous. It does not differentiate itself from siblings, notably read_screenshot, and the phrase 'returns the image so it can be read' arguably muddies rather than clarifies the boundary.
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?
Usage is implied: use when you want to capture the current page or navigate to a URL and grab a screenshot. There is no explicit when-not guidance and no routing against siblings like read_screenshot or open_url, which is the main gap given the potential overlap.
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.
v0.1.0browser_statusclose_browseropen_urlread_screenshotscreenshotScored across 5 tools
Each tool targets a distinct action on the controlled browser: open, capture, read file, close, and report status. The only mild overlap is that screenshot can accept a URL directly, which slightly blurs the line with open_url, but otherwise the boundaries are clear.
Most tools follow a verb_noun pattern (open_url, read_screenshot, close_browser) which is consistent and readable. screenshot and browser_status deviate (noun-only), but the set is still predictable.
Five tools is a snug, well-scoped set for a headless-browser screenshot server, covering the core lifecycle without bloat. It sits at the lower end but each tool earns its place.
The browser lifecycle is well covered: open, capture, read back, close, and status. Minor gaps like page interaction (click, scroll, navigate) exist, but for a screenshot-focused purpose the surface is essentially complete.
Capture website screenshots, run bulk captures, and manage screenshot schedules and history.
Generate images, GIFs, videos, and PDFs from HTML, URLs, or templates — from your AI agent.
Pixel-perfect webpage screenshots rendered in a real browser, full-page or viewport, via one POST.
Screenshot any URL/HTML as PNG/JPEG/WebP, or read it as clean Markdown/text for LLMs.
