Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problemsSome links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
Short answer: 16,384 pixels was a real screenshot-height limit reported for particular headless Chromium rendering setups, but it is not established as a universal limit for current Chrome. In an April 2017 developer discussion, Chromium contributor Eric Seckler attributed the cap to the compositor’s maximum texture size. The practical workaround described there is to capture the page in vertical sections and stitch the images together.
What the 16,384-pixel figure means
The figure comes from specific historical reports, not a current Chrome specification. In an April 2017 Chromium headless-dev discussion, contributor Eric Seckler explained: “The 16384px limit stems from the maximum texture size used by the compositor.” He said the limit depended on the rendering backend and described a 16,384-pixel cap for the software GL and pure software rendering implementations used in that setup. Read the Chromium discussion.
A Puppeteer issue opened in August 2017 likewise reports that changing the viewport did not remove the 16,384-pixel ceiling in the affected environment. See Puppeteer issue #359. Those reports explain why developers encountered the number; they do not prove that every current Chrome build, operating system, graphics backend, or screenshot route has the same maximum.
Current Puppeteer ScreenshotOptions documentation describes fullPage and clip, but does not specify a universal maximum screenshot height. Check the current ScreenshotOptions API. Treat limits as dependent on the exact browser build, rendering backend, host and total image size, and validate the capture in the environment that will run it.
#1 Best Overall
Why increasing the viewport may not help
A full-page screenshot asks the browser to capture beyond the visible viewport; it does not necessarily change the rendering backend’s texture limit. Similarly, requesting a taller viewport or a clip taller than the page’s supported capture surface may still return a truncated image or fail. The 2017 reports describe precisely this kind of ceiling: changing dimensions did not make a single capture exceed the reported cap.
Height is not the only constraint. A tall image also has a large total pixel area, and the browser must render, store, and encode it. In a January 2020 report using Puppeteer 2.0.0 and Chromium 79, a user described experimental failures above approximately 11 million pixels, along with clipping and viewport-resize complications. That is a version-specific report, not a current universal threshold. See Puppeteer issue #5300.
Recommended workaround: capture vertical tiles
When one full-page bitmap is too tall, capture multiple vertical regions and combine them. This avoids relying on one oversized output surface, but the result depends on the page and the browser’s clipping behavior. The Chromium discussion recommends multiple screenshots at different vertical offsets and stitching; it does not prescribe a currently tested library or a universal code recipe.
Plan tile dimensions
Use a tile height comfortably below any limit observed in your own environment. Choose a consistent viewport width and preserve the same browser context, zoom, device scale factor, cookies, and page state across captures. If your target is a particular output width, set that first, because changing width changes total pixels and may affect responsive layout.
Load content before capturing
Scroll through the page before capture when it uses lazy-loaded images or other scroll-triggered content. Wait for the content to appear, then return to the intended starting position. If the page alters content when scrolled or resized, capture tiles in a controlled sequence and check the seams. Fixed headers, sticky navigation, animations, and live feeds can appear repeatedly or change between tiles.
Capture and stitch carefully
- Record the page’s target width and the document height in CSS pixels. Confirm that the page has finished loading and that any required consent interaction is handled.
- Choose a tile height the tested browser can capture reliably. If the page height is not an exact multiple, make the final clip end at the document bottom rather than extending past it.
- Capture each tile at its intended vertical offset, keeping width and rendering settings consistent. If clipping or viewport changes trigger responsive behavior, prefer a fixed viewport with a clip region where your capture library supports it.
- Use a small overlap only if needed to avoid missing content at tile boundaries. When stitching, remove the duplicated overlap rather than leaving repeated lines or text.
- Inspect the finished image for gaps, duplicated sticky elements, missing lazy-loaded content, and unexpected scaling. Also verify that the output dimensions and image format match your downstream use.
There is no universally reliable tile size in the cited material. Test the exact page, browser version, backend, and host; smaller tiles can reduce per-capture pressure but require more calls and more stitching work.
Should you change Chromium’s rendering limit?
The 2017 discussion describes modifying a software-rendering constant and forcing software rendering as something that appeared to work in the contributor’s test. It is not a simple runtime setting or a current general recommendation. It entails changing the implementation and may require building Chromium yourself.
There is also a fidelity trade-off: Seckler warned that forcing software rendering could affect WebGL and some CSS that requires GL. Consider such a modification only if you control the browser build, can validate the pages you need, and accept the rendering differences. For most screenshot jobs, tiled capture is the more practical starting point.
What to test in your own capture pipeline
- Browser and backend: Record the Chrome or Chromium version, automation-library version, operating system, and graphics or software-rendering configuration. A historical threshold should not be assumed to apply to a different setup.
- Dimensions and pixel area: Test the intended width and height together. A capture may run into memory or encoding trouble before reaching a particular height.
- Page behavior: Look for lazy loading, sticky or fixed elements, resize handlers, animation, and content that changes as it scrolls.
- Output handling: Verify that your image encoder and the rest of your pipeline can process the resulting dimensions and file size. Browser capture succeeding does not guarantee that every downstream tool accepts the image.
- Repeatability: Capture more than once when the page is dynamic. Check whether tile boundaries shift or content differs between calls.
Troubleshooting long-page captures
The image stops at 16,384 pixels
This is consistent with the historical cap reported for certain headless Chromium backends, but it does not identify the cause in your current environment by itself. Record the browser build and backend, then try vertical tiles below the observed ceiling. Increasing the requested page or viewport height alone may not bypass a backend limit.
A tile is clipped or blank
Check that the requested clip lies within the rendered document and that the page has completed its load. The Puppeteer 2.0.0 and Chromium 79 report illustrates that clipping and viewport behavior can interact; reproduce with your actual versions rather than assuming the same issue exists today. If the page reacts to viewport resizing, keep the viewport fixed and capture region clips if your tooling allows it.
The full-page capture fails despite being shorter than 16,384 pixels
Check total pixel area, available memory, output encoding, and any downstream image-size limits. The 2020 report indicates that failures were discussed in terms of total image area as well as dimensions. Its approximate 11-million-pixel observation applies only to the reporter’s historical setup, not as a general cutoff.
Free tools Windows power users keep installed
One-click scans. No signup required.
Tiles have seams, missing images, or repeated headers
Scroll the page to trigger lazy loading before capturing, allow images to load, and capture with stable dimensions. Use overlaps only when necessary and remove duplicated pixels when assembling the image. Fixed and sticky elements may be rendered in every tile; decide whether to preserve them or remove the repeated regions during stitching.
Rendering differs after switching to software rendering
Compare the page’s WebGL and GL-dependent CSS output. The Chromium contributor’s warning was that those features might not render correctly under forced software rendering. If fidelity is important, avoid treating the modified renderer as a drop-in replacement.
Or skip the browser setup
ScreenshotNeo is a screenshot API and MCP server for developers. For ordinary captures, its one-call API returns an image or PDF; for extremely long pages, first confirm the required dimensions and whether a single output is appropriate, since a service cannot make a browser backend’s limits disappear. Cookie banners are accepted and removed before the shot, along with known newsletter popups and chat widgets; bot checks, blank pages, timeouts, failed loads, and cache hits are not billed. AI agents can capture through its MCP server, and the free plan includes 1,000 shots per month without a card; paid plans start at $5 for 3,000 shots. See the ScreenshotNeo API documentation.
Example cURL request:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpFor other formats, capture behavior, or an alternative target page, see the API documentation. Sign up for 1,000 free screenshots a month with no card.
Recommended Free Tools
Frequently Asked Questions
Does Puppeteer’s fullPage option guarantee a screenshot taller than 16,384 pixels?
No. The current API documentation defines full-page capture behavior but does not promise a maximum dimension or guarantee that a backend can produce an image of any particular height.
Is the approximately 11-million-pixel failure threshold a Chrome limit?
No. It was an experimental report tied to Puppeteer 2.0.0 and Chromium 79 in 2020, not a published or current universal limit.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
