ScreenshotNeo
Sign in Get a free key

BlogAI agents

Best MCP servers for capturing website screenshots from AI agents

Compare screenshot-capable MCP servers for AI agents: choose a local Playwright browser, a hosted Browserbase session, or a screenshot API.

By the ScreenshotNeo team4 October 202610 min read

Short answer: Start with Playwright MCP if you want an MCP-configured browser running in your client environment and need viewport, element, or full-page screenshots alongside page interaction. Choose Browserbase MCP when you specifically want a cloud-hosted browser session; its documented setup requires a Browserbase API key. If your agent only needs an image of a URL and not a browser to interact with the page, ScreenshotNeo is the screenshot API to try first: it removes known cookie banners, popups, and chat widgets before capture, and only bills clean screenshots.

These are capability-based recommendations from official documentation, not results of hands-on testing. The reviewed sources do not establish comparative screenshot fidelity, speed, reliability, or total cost.

1. Choose by the job your agent needs to do

Need Good fit Why
Visual evidence plus browser navigation and interaction Playwright MCP Its screenshot tool captures the viewport, a selected element, or the full scrollable page, and its core tools include navigation and accessibility snapshots.
A cloud-hosted browser operated over MCP Browserbase MCP Browserbase documents hosted headless browser sessions with navigation, interaction, extraction, and screenshots. Setup uses an API key.
A screenshot of a URL, with no need for the agent to operate a browser ScreenshotNeo A single API request returns an image or PDF. Clean shots are billed; bot checks, blank pages, timeouts, failed loads, and cache hits are not.
Structured page reading or dependable control selection Accessibility snapshot Structured roles, text, and element references are better suited to reading and interaction than visual coordinates.

A screenshot and an accessibility snapshot answer different questions. Use a screenshot to inspect layout, charts, canvas content, or a visual bug. Use a snapshot to understand page structure, read text, and locate elements for interaction. Playwright’s screenshot documentation summarizes the distinction: “Screenshots are for looking at, not for acting on.” Playwright screenshot documentation.

2. Playwright MCP: local browser setup and screenshot capture

Playwright MCP is the clearest general starting point in the reviewed documentation for an agent that needs a browser plus screenshots. It uses the Model Context Protocol to expose browser automation tools to an MCP client. The documented setup requires Node.js 20 or newer and supports clients including VS Code, Cursor, Windsurf, Claude Desktop, and others. The browser is downloaded on first use.

Minimal client configuration

Add this server entry to the MCP configuration format used by your client. The exact settings location varies by client; consult its MCP configuration instructions.

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    }
  }
}

After saving the configuration, restart or refresh the MCP client if needed, then ask the agent to navigate to a URL and take a screenshot. The minimal configuration exposes core browser tools, including navigation, accessibility snapshots, and screenshots.

Run headless or choose a browser

The documented default is headed mode. For a headless session or another browser, add arguments:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest", "--headless", "--browser=firefox"]
    }
  }
}

Documented browser choices are Chrome, Firefox, WebKit, and Microsoft Edge. Other useful configuration examples include --device="iPhone 15" for a device preset, --mobile for generic mobile emulation, and --viewport-size=1280x720 for a fixed viewport. Add only the options that apply to the capture task.

Ask the agent for the right capture scope

Once connected, plain instructions can invoke the screenshot tool. For example:

Navigate to https://example.com, wait for the page to finish loading, then capture a full-page screenshot as WebP named example.webp.

The underlying tool is named browser_take_screenshot. Its documented options are:

Option Meaning Edge case
target Element reference from a snapshot or a selector; captures that element. Cannot be combined with fullPage.
fullPage Captures the full scrollable page rather than only the viewport. May produce a very tall image; consider targeted capture for large pages.
type png, jpeg, or webp. If omitted, the type is inferred from the filename extension, or defaults to PNG.
filename Output file name; relative paths resolve from the workspace root. If omitted, a timestamped file is saved in the output directory and the image is returned inline.
scale css captures CSS-pixel dimensions; device uses device-pixel ratio for a high-resolution image. Device scale can increase image dimensions and output size.

Examples of tool requests the agent can translate into tool calls:

Capture the current viewport as PNG.
Capture only the pricing table using its CSS selector.
Capture the entire scrollable page as homepage.webp.
Capture this element at device scale as JPEG.

For the element case, first use an accessibility snapshot when possible, then target its reference or a selector. Full-page and element-targeted capture are separate modes.

Limit exposed tools to the workflow

Playwright MCP enables core browser tools by default. Optional capability groups add tools for areas such as vision, PDF, devtools, network, storage, and testing. You can add groups through the --caps argument, for example --caps=storage,network. The project says a smaller tool surface can reduce schema token cost and tool-choice confusion; treat that as the project’s design rationale, not an independent benchmark. See Playwright capability groups.

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest", "--caps=storage,network"]
    }
  }
}

3. Browserbase MCP: use a cloud-hosted browser

Browserbase describes its MCP server as cloud browser automation using Browserbase and Stagehand. Its listed functions include navigating, interacting with elements, extracting information, and taking screenshots through headless browsers. The setup documented on its MCP page uses an HTTP MCP endpoint and a Browserbase API key:

{
  "mcpServers": {
    "browserbase": {
      "url": "https://mcp.browserbase.com/mcp?browserbaseApiKey=YOUR_BROWSERBASE_API_KEY"
    }
  }
}

Replace the placeholder with a key from the Browserbase dashboard and follow your MCP client’s instructions for adding an HTTP server. Keep credentials out of prompts, source control, and logs. Browserbase is a fit when you want the browser session hosted remotely; the reviewed sources do not support a claim that it is faster, cheaper, more accurate, or more reliable than Playwright MCP. No current pricing comparison was established. See the Browserbase MCP server page.

4. ScreenshotNeo: take a screenshot without configuring a browser

If the agent needs a screenshot rather than an interactive browser session, ScreenshotNeo is the alternative to try first. It is a website screenshot API and MCP server from ScreenshotNeo. Its MCP tools include take_screenshot, get_page_info, and capture_pdf, for Claude, Cursor, and other MCP clients. The API takes one GET request for a URL and returns PNG, JPEG, WebP, or PDF. See the ScreenshotNeo API documentation.

For a simple URL capture, use the API directly. Substitute your API key and target URL:

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp
import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
open("shot.webp", "wb").write(r.content)
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
await Bun.write('shot.webp', res);

The Node.js example uses the given fetch request and Bun to save the response body to a file; in a Node-only project, use the built-in fs/promises module to write the returned bytes. The API supports options for full-page captures, element selectors, dark mode, device presets and custom viewports, retina scale, PDF settings, custom CSS and JavaScript, clicks, waits, hidden selectors, request blocking, headers, cookies, user agent, authorization, timezone, geolocation, transparent backgrounds, resizing, caching, signed public image links, asynchronous jobs with signed webhooks, bulk captures up to 100 URLs per call, and usage information. Parameter names used by other screenshot APIs also work, which can ease migration; check the docs for exact parameter values and response handling.

Or skip the browser setup

With ScreenshotNeo, cookie banners are accepted like a visitor and more than 60 known consent platforms, newsletter popups, and chat widgets are removed before the shot; each step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits are never billed. An MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. Sign up for 1,000 free screenshots a month, with no card.

5. Make the choice for your agent

  1. Does the agent need to interact with the website? Choose Playwright MCP for a client-configured browser with structured accessibility references, or Browserbase MCP if you need a cloud-hosted browser session.
  2. Does it only need an image or PDF? Use a screenshot API such as ScreenshotNeo to avoid maintaining a browser process for a one-shot capture.
  3. What must be visible? Select viewport, element, or full-page scope; choose image type and resolution for downstream use. Full-page capture can be costly in image size and context.
  4. Does the page require a session? Determine where login state and cookies should live. Playwright MCP documents persistent profiles by default, isolated sessions, and loading storage state. Browserbase uses hosted sessions; consult its current documentation for the session controls you need.
  5. What is your cost model? A local browser setup and a hosted browser service have different operational costs, but the reviewed sources do not provide a reliable comparison. ScreenshotNeo lists Free (1,000/month), Starter ($5 for 3,000), Growth ($15 for 15,000), Pro ($39 for 60,000), Scale ($99 for 250,000), and Business ($249 for 1,000,000); yearly billing gives two months free, and every feature is on every plan.
  6. How many tools should the agent see? Enable only Playwright capability groups needed by the workflow. This reduces unnecessary tool definitions in context according to Playwright’s stated rationale.

6. Reliability, performance, and cost considerations

Reliability

  • A screenshot is a record of one page state. Wait for the page or a specific element to settle before capture, especially when content is loaded asynchronously.
  • Use the accessibility snapshot to find page content and targets; visual screenshots alone do not provide stable interaction references.
  • Keep the browser session and authentication model explicit. Persistent state is useful for repeated logged-in work; isolated state helps avoid carrying cookies between tasks.
  • A remote browser adds a service dependency and network path. A locally configured browser depends on the client environment, installed runtime, browser availability, and network access to the target.
  • For automated pipelines, capture a known target page, save artifacts with meaningful names, and retain enough output to diagnose failures. The reviewed documentation does not establish service-level uptime or comparative error rates for these MCP options.

Performance and image size

  • Viewport capture is usually the smaller scope; full-page images may be tall, and device-scale capture increases pixel dimensions. Choose the smallest scope and scale that answer the question.
  • PNG, JPEG, and WebP are supported by Playwright’s screenshot tool. Select based on the consumer’s compatibility and image-size needs; no comparative compression benchmark is established here.
  • Keeping optional MCP capabilities disabled can reduce the tool schema sent to a model. This is a documented rationale, not a measured end-to-end latency claim.
  • For repeated static captures, consider whether caching is appropriate. ScreenshotNeo provides a cache TTL option; avoid caching when the page state must reflect fresh data or session-specific content.

Cost

Check current vendor pricing before deployment. Browserbase pricing was not established in the reviewed pages, and no cost comparison between Browserbase and Playwright is supported here. ScreenshotNeo’s published plan facts for this article are: Free 1,000 shots/month with no card; Starter $5/3,000; Growth $15/15,000; Pro $39/60,000; Scale $99/250,000; Business $249/1,000,000. Yearly billing gives two months free. All features are available on every plan.

7. Troubleshooting common setup and capture problems

Symptom Likely cause Fix
Playwright server does not start Node.js is missing or older than the documented 20+ prerequisite; the client configuration may also be malformed. Install a supported Node.js version, verify the JSON and command, then restart the MCP client.
Browser is not available on first use The browser download has not completed or the environment cannot download it. Allow the first-use browser installation to finish and confirm the environment has network access. For constrained environments, review Playwright’s installation and browser configuration documentation.
Screenshot is blank or shows a loading state The capture happened before client-side rendering or delayed content settled, or the target itself is blank. Ask the agent to wait for a meaningful element or page state before capturing; inspect the accessibility snapshot and console/network output if enabled.
Full-page screenshot request fails with an element target The two screenshot modes cannot be combined. Capture the element alone, or remove target and use fullPage: true.
Output format is unexpected The file extension or explicit type determines format; without either, PNG is the default. Set type explicitly or use a matching filename extension.
Agent cannot click based on what it sees in an image Screenshot output is visual evidence, not a structured interaction map. Request browser_snapshot, then use the element reference in a browser action.
Browserbase connection is rejected The API key is missing, invalid, or misplaced in the endpoint URL. Use a valid key from the Browserbase dashboard and confirm the HTTP MCP configuration matches the client format.
Repeated captures leak login state between tasks A persistent profile is being reused. For Playwright, use --isolated and, if needed, provide deliberate initial state with --storage-state. Review access to saved profile data.
Large capture consumes too much model context An inline full-page or device-scale image is unnecessarily large. Capture a smaller scope, choose CSS scale, save to a file instead of returning inline, or configure --image-responses=omit where appropriate.

8. Frequently asked questions

Can an MCP server capture a full-page website screenshot?

Yes. Playwright MCP’s browser_take_screenshot supports the full scrollable page through fullPage, separately from element-targeted capture.

Should an agent use a screenshot or an accessibility snapshot?

Use a screenshot to judge visual appearance. Use an accessibility snapshot to read structure and interact with referenced elements. Many tasks benefit from both, in that order only when visual inspection is needed.

Is Browserbase MCP better than Playwright MCP?

The reviewed documentation supports different deployment fits: Browserbase offers a cloud-hosted browser, while Playwright MCP is configured in the client environment. It does not support a general performance or quality winner.

Can I use ScreenshotNeo from an MCP client?

Yes. ScreenshotNeo provides an MCP server with take_screenshot, get_page_info, and capture_pdf tools, as well as a direct screenshot API.

Keep reading