How to Fix Clipped Full-Page Screenshots from an MCP Browser Server

If a Playwright MCP screenshot stops at the browser viewport, call browser_take_screenshot with fullPage: true. For a whole-page capture, omit target: it selects a single element and cannot be combined with full-page capture. Save the image to a named file so you can inspect the artifact separately from the MCP response. These instructions describe Playwright MCP; another browser MCP server may use a different tool schema.

1. Request the full scrollable page

In your MCP client, ask for a screenshot of the entire page and inspect the actual tool arguments the client sends. The important argument is spelled fullPage, with a capital P:

browser_take_screenshot {
  "fullPage": true,
  "filename": "full-page.png"
}

The current [Playwright MCP screenshot documentation](https://playwright.dev/mcp/tools/screenshots) uses this pattern. The tool captures the viewport by default; fullPage: true requests the full scrollable page. If the call also contains target, remove it for a whole-page capture. target is for capturing a specific element, and the documentation says element targeting cannot be combined with fullPage.

A named filename makes the returned artifact easier to locate and inspect. It does not alter the capture scope. The MCP tool documentation says that without a filename the server saves to its output directory using a timestamped name.

2. Check the arguments and capture scope

1. Confirm which MCP server is running. The tool name and settings below refer to Microsoft Playwright MCP.
2. Open the client’s tool-call details and check the arguments sent to the server. Confirm fullPage is true and there is no target for a whole-page screenshot.
3. Save a named image, then open that file. This distinguishes a clipped image file from an incomplete inline image response.
4. Compare the image boundary with the page. A cut at the viewport boundary suggests the request may have remained a viewport capture; a cut around a component suggests an element target may be involved. This is a diagnostic clue, not proof of the cause.
5. If the file is still missing content, check whether that content existed in the page’s scrollable extent when capture ran. Wait for the page’s known loading state; if the site loads more content as you scroll, scroll through it and inspect again before capturing. These are page-specific diagnostics, not universal fixes.

3. Use the current element argument name

For an element screenshot, the current Playwright MCP schema uses target. Do not combine an element target with fullPage. A reported documentation issue described an earlier example using ref, which the implementation did not recognize; the issue is evidence of a reported parameter mismatch, not proof that it explains every clipped screenshot. Check the live schema for the version you run and use target where that schema requires it. See the [reported issue](https://github.com/microsoft/playwright/issues/42517).

// Whole page: omit target
browser_take_screenshot {
  "fullPage": true,
  "filename": "full-page.png"
}

// Element only: use target, omit fullPage
browser_take_screenshot {
  "target": "main article",
  "filename": "article.png"
}

The precise target value must match the server’s accepted reference or selector. If you need the entire page, do not use the element example.

4. Direct Playwright code as a cross-check

If you can reproduce the issue outside MCP, a direct Playwright screenshot helps isolate whether the problem is in the MCP call or in page rendering. This runnable Node.js example opens a page and saves the full scrollable page:

import { chromium } from 'playwright';

const browser = await chromium.launch({ headless: true });
const page = await browser.newPage();

try {
  await page.goto('https://example.com', { waitUntil: 'load' });
  await page.screenshot({ path: 'full-page.png', fullPage: true });
} finally {
  await browser.close();
}

The documented screenshot pattern is await page.screenshot({ path: 'screenshot.png', fullPage: true });. See the [Playwright screenshot guide](https://playwright.dev/docs/screenshots). If this direct capture is complete while MCP is clipped, compare the MCP tool arguments, server version, and response handling. If both are clipped, inspect the page content and loading behavior at capture time.

5. Options that affect the result

Option	Effect	When to use it
fullPage: true	Requests the full scrollable page rather than just the visible viewport.	Use for a page-length capture. Omit element targeting.
target	Selects a specific element for capture.	Use for one element only; do not combine with fullPage.
filename	Saves the screenshot under a named file.	Use to inspect and share a reproducible artifact.
type	Chooses an image format; if unset, the tool infers it from the filename extension and otherwise uses PNG.	Set when you need a specific supported format.
scale	css uses CSS pixel dimensions and is the default; device uses device pixel ratio for a higher-resolution image.	Choose based on resolution needs. Scale changes resolution, not page scope.

Use the current [tool documentation](https://playwright.dev/mcp/tools/screenshots) as the source of truth for the running server’s accepted arguments. A different MCP server may use different names or behavior.

6. Troubleshooting

Symptom	Likely check	Fix or next diagnostic
Image ends at the visible viewport	The actual tool call may omit fullPage, misspell it, or send it as a string.	Inspect the arguments and send boolean true as fullPage.
Only one section or component appears	The call may include target.	Remove target for a full-page capture.
Element selection behaves like a viewport capture	The call may use an outdated argument such as ref.	Check the running schema; current Playwright MCP documentation uses target for element screenshots.
Lower content is absent even with fullPage: true	The expected content may not yet exist in the page’s scrollable content when capture occurs.	Wait for the relevant page state. For pages that load on scroll, scroll and inspect the page before capturing. Reproduce with the page and timing recorded.
The tool response looks incomplete, but the saved image may be fine	The file and inline image response are separate things to inspect.	Open the named screenshot file directly. Playwright MCP documents imageResponses modes including allow, omit, and only; omitting inline image data can reduce response payload, but does not change capture dimensions or scope.
Behavior differs between machines or runs	Server version, browser selection, client, arguments, or page state may differ.	Record the MCP package/server version, client, browser engine, sanitized URL or reproduction, exact arguments, and whether the file itself is clipped. Consult the [Playwright MCP repository](https://github.com/microsoft/playwright-mcp) for server configuration.

7. Performance and reliability notes

A full-page image contains more page area than a viewport screenshot, so the resulting image and any inline image payload may be larger. If the image response makes the client unwieldy, the Playwright MCP repository documents the imageResponses configuration; omit affects response delivery, not what the screenshot captures. Keep a named artifact when diagnosing so you can verify the image independently.

Full-page capture can only capture the page’s scrollable extent at capture time. The documentation does not promise that a wait or scroll will resolve all page-specific rendering issues. If the page populates content only after interaction or scrolling, reproduce that behavior explicitly and compare before and after captures. Do not treat a higher scale as a fix for missing page content: it changes pixel resolution, not capture scope.

No universal maximum screenshot height or guaranteed capture time is established by the cited documentation. Avoid assuming a clipped image means a fixed browser limit; first verify the tool arguments and the content present at capture time.

Or skip the browser setup

ScreenshotNeo provides a screenshot API and MCP server. A single request can capture a URL as an image or PDF. Here is the API call in cURL, Python, and Node.js; replace YOUR_API_KEY with your key. See the [ScreenshotNeo API documentation](https://screenshotneo.com/docs/) for request options.

cURL

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

Python

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
r.raise_for_status()
open("shot.webp", "wb").write(r.content)

Node.js

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}`);
const bytes = new Uint8Array(await res.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', bytes));

ScreenshotNeo removes cookie banners, newsletter popups, and chat widgets before the shot. Bot checks, blank pages, failed loads, timeouts, and cache hits are not billed. Its MCP server gives AI agents tools to take screenshots, inspect page information, and capture PDFs. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 shots. Sign up free for ScreenshotNeo.

FAQ

Does scale: "device" include content below the fold?

No. Scale controls image resolution. Set fullPage: true to request the full scrollable page.

Can I capture one element and the whole page in one Playwright MCP screenshot call?

No. The documented tool does not allow fullPage with an element screenshot target.

Does omitting inline image responses make the screenshot smaller?

It can reduce response payload, but it does not change the captured page area or image dimensions.

Do these argument names apply to every browser MCP server?

No. They are for Playwright MCP. Check the tool schema for whichever server you use.