Why Is My Full-Page Website Screenshot Cut Off in Chrome?

If your screenshot ends partway down a page, first check whether the capture method actually requested a full-page screenshot. A viewport or clipped-region capture includes only the visible area or selected rectangle. Browser automation tools have explicit full-page modes; exceptionally large pages can also exceed implementation limits. The exact cause depends on how you captured the page, so use the checks below to narrow it down.

1. Identify what produced the screenshot

Was it Chrome’s built-in interface, an extension, a desktop capture tool, a screenshot API, or browser automation code? Each route can have different capture behavior. Find the tool’s setting or API option that specifies full-page capture, and check whether it is enabled. A setting such as “visible area,” a clip rectangle, or an element target is not the same as capturing the entire document.

If you do not know which mode was used, reproduce the screenshot with a browser automation API that documents its full-page option. That gives you a clear way to distinguish a viewport capture from a full-page request.

2. Check the capture mode and dimensions

In Chrome DevTools Protocol, screenshot capture has a clip parameter for a region and a captureBeyondViewport parameter for content beyond the viewport. The documented default for captureBeyondViewport is false, so a protocol call that omits it may not capture the full document. Check the [Chrome DevTools Protocol Page reference](https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-captureScreenshot) for the current API details.

Also check whether the capture was constrained to a particular width and height. A clip rectangle, viewport-sized output, or selected element can make a screenshot look like a failed full-page capture when the tool did exactly what it was asked to do.

3. Use a documented full-page option

For repeatable developer workflows, Puppeteer and Playwright both document full-page capture. Puppeteer’s fullPage option requests a screenshot of the full page. Playwright documents full-page, viewport, and target-element capture modes; its full-page option cannot be combined with a target element. See the official [Puppeteer screenshot options](https://pptr.dev/api/puppeteer.screenshotoptions) and [Playwright screenshot guide](https://playwright.dev/docs/screenshots).

Puppeteer: runnable Node.js example

Install Puppeteer in a Node.js project, save this as screenshot.mjs, then run node screenshot.mjs. Puppeteer manages a compatible Chrome or Chromium browser for the script.

import puppeteer from 'puppeteer';

const url = 'https://example.com';
const browser = await puppeteer.launch({ headless: true });

try {
  const page = await browser.newPage();
  await page.goto(url, { waitUntil: 'networkidle2', timeout: 60000 });
  await page.screenshot({ path: 'full-page.png', fullPage: true });
} finally {
  await browser.close();
}

fullPage: true is the key setting. networkidle2 waits for network activity to settle, but pages with polling or persistent connections may never become idle; in that case choose a different readiness condition or wait for a specific selector. Puppeteer documents additional screenshot options, including output type, quality, clipping, and transparency, in its [ScreenshotOptions reference](https://pptr.dev/api/puppeteer.screenshotoptions).

Playwright: runnable Node.js example

Install Playwright and its browser for your project, save as screenshot.mjs, and run it with Node.js.

import { chromium } from 'playwright';

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

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

Use fullPage: true for the scrollable page. Use page.screenshot({ path: 'viewport.png' }) when the visible viewport is what you want, or locator.screenshot() when you want one element. Playwright’s full-page and element options are distinct: do not combine fullPage with a target element.

4. Consider page-size limits on exceptionally tall pages

If a very long page is still cut off or capture fails at a repeatable size, the screenshot implementation may be hitting a dimension limit. Chromium source reviewed for this article checks full-page dimensions and contains implementation-specific limits, including a “Page is too large” failure path. Those checks are tied to a particular source revision and are not a universal cutoff for every Chrome version, operating system, or capture route. The source also discusses a 16K limit in headless mode. See the [Chromium page handler source](https://chromium.googlesource.com/chromium/src/+/main/headless/lib/browser/protocol/page_handler.cc).

For an exceptionally long document, capture sections or individual elements and assemble the results if your output format allows it. Another option is to produce a PDF or use a capture service that supports long-page handling. Do not assume a particular pixel threshold applies to your Chrome build.

5. Troubleshoot common symptoms

Symptom	Likely explanation	What to check
Output ends at the viewport boundary	The capture used viewport mode or did not enable capture beyond the viewport.	Enable the tool’s explicit full-page option. In a protocol call, inspect captureBeyondViewport and any clip setting.
Output ends at the same height on a very long page	A browser or capture implementation size limit may have been reached.	Try section captures or another output path. Treat limits as implementation-specific.
Only one part of the page appears	The request may target an element or clipped rectangle.	Remove the target or clip if you intend to capture the full document; use full-page mode.
Automation times out before an image is saved	The selected page readiness condition may never occur, or navigation may be slow.	Check the navigation timeout and readiness condition. Wait for a relevant selector when network activity does not settle.
Screenshot succeeds but misses content expected lower on the page	The full-page request may not have been made, or the page may exceed that route’s limits.	Confirm the mode first; if it is full-page, test a shorter section and inspect the tool’s error or output dimensions.

CSS layout, lazy-loaded content, and browser extensions can also affect a particular page or workflow, but the available browser documentation does not establish them as the cause of a given cutoff. Investigate them only after confirming the capture mode and checking for size-related failures.

6. Make repeated captures more reliable

• Set the intended viewport width explicitly so responsive layout changes do not surprise you.
• Wait for a meaningful page-ready condition, such as a content selector, rather than relying blindly on network-idle behavior.
• Use a timeout appropriate for the target page and report navigation or screenshot errors distinctly.
• For huge documents, split captures into sections and record the boundaries so there are no gaps or overlaps.
• Keep the browser lifecycle in a try/finally block so it closes even when navigation or capture fails.

Full-page capture can use more memory and produce larger image files as document dimensions grow. If the image is unwieldy, consider a PDF or section captures. The exact performance and size depend on the page and the capture implementation; no single output-size or speed figure applies across sites.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. One GET request returns an image or PDF; the API accepts common screenshot parameter names, which can make switching straightforward. See the ScreenshotNeo API documentation for its options.

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);

ScreenshotNeo removes known cookie and consent banners, newsletter popups, and chat widgets before capture; each cleanup step can be turned off. Bot checks, blank pages, timeouts, and failed loads are not billed, and cache hits cost nothing; response headers say the page verdict and whether the request was billed. Its MCP server provides take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, and other MCP clients. 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 1,000 screenshots a month, with no card required.

FAQ

Does Chrome have a universal full-page screenshot limit?

No universal threshold is established here. Limits depend on the browser build and capture implementation.

Can I capture just one element instead?

Yes. Puppeteer and Playwright support element-oriented screenshots. Use that mode when the whole document is not needed.

Should I use full-page mode for a very long page?

Try it, but if capture fails or ends consistently, split the page into sections or choose an output route suited to long documents.