How to Fix Chrome Full-Page Screenshot Timing Out on Windows

If Chrome can capture the visible viewport but a full-page screenshot times out, the failure is likely in the beyond-viewport capture path, the page’s changing or slow rendering, or the tool waiting for Chrome. First record the exact error and identify which tool reports the timeout. A timeout is different from Chrome’s explicit Page is too large. error, and there is no single timeout setting that applies to every Chrome workflow.

This guide applies to Chrome on Windows whether you start a capture from DevTools, an extension, an automation library, or headless Chrome. The steps below use the Chrome DevTools Protocol (CDP) directly so you can compare a viewport screenshot with a full-page screenshot and see which operation fails.

1. Identify which operation timed out

Before changing settings, write down these details:

The exact error text, including whether it says “timed out” or “Page is too large.”
How long the capture waited before failing.
Your Chrome version, the page URL, and whether the page was still loading or animating.
What started the capture: DevTools, a particular extension, an automation library, or headless Chrome.
Whether a normal viewport screenshot succeeds on the same page.

“Timed out” can be the calling tool giving up while Chrome is still working, or a browser-side failure. The caller and Chrome can have separate waits. Changing a timeout in one workflow will not necessarily affect another.

2. Compare viewport and full-page captures with CDP

Chrome’s CDP method is Page.captureScreenshot. Full-page behavior is controlled by the captureBeyondViewport flag; the method also accepts image format, encoding, and an optional clip. A viewport capture succeeding while a full-page capture fails is a useful clue to investigate page dimensions and rendering, but it does not by itself identify the cause. See the CDP Page.captureScreenshot reference.

The following runnable Python example launches headless Chrome through Selenium, saves a viewport PNG, then requests a full-page PNG using CDP. It uses ChromeDriver, which Selenium Manager can obtain when needed. Install Selenium with python -m pip install selenium, ensure Chrome is installed, and run the script. If your environment manages ChromeDriver separately, provide its path through Selenium’s standard setup.

from pathlib import Path
from selenium import webdriver
from selenium.webdriver.chrome.options import Options

URL = "https://example.com"

options = Options()
options.add_argument("--headless=new")
options.add_argument("--window-size=1365,900")

driver = webdriver.Chrome(options=options)
try:
    driver.get(URL)

    # Save the visible viewport as a baseline.
    Path("viewport.png").write_bytes(driver.get_screenshot_as_png())

    # Ask Chrome for the document's current full content dimensions.
    metrics = driver.execute_cdp_cmd("Page.getLayoutMetrics", {})
    content = metrics["cssContentSize"]

    # Request a beyond-viewport capture of the measured document.
    result = driver.execute_cdp_cmd(
        "Page.captureScreenshot",
        {
            "format": "png",
            "captureBeyondViewport": True,
            "clip": {
                "x": 0,
                "y": 0,
                "width": content["width"],
                "height": content["height"],
                "scale": 1,
            },
        },
    )
    import base64
    Path("full-page.png").write_bytes(base64.b64decode(result["data"]))
finally:
    driver.quit()

For CDP clients that connect to an existing Chrome session, the equivalent core request is Page.captureScreenshot with captureBeyondViewport: true. The exact calling syntax and its timeout controls depend on the client library. Keep the viewport request as a baseline and compare the returned error from each operation.

3. Check for a page-size failure

If Chrome returns Page is too large., treat it as a size failure rather than a timeout. A Chromium source snapshot has a full-page dimension check that rejects width or height at or above 128 * 1024 pixels. That is an implementation detail from a particular source revision, not a guarantee about every Chrome version or a universal timeout threshold. See the Chromium headless implementation.

When the page exceeds what the capture can handle, use a clip for the region you actually need, or capture separate sections if your workflow supports it. CDP’s clip rectangle specifies the area to capture. A clip is useful when the task only needs a particular section; it is not a general fix for a slow or unstable page.

4. Check whether the page is still changing

Full-page capture depends on the page’s dimensions and rendered content. Lazy-loaded images, infinite scroll, animations, client-side updates, and expanding content can change the page while it is being measured or captured. Chromium browser tests account for the possibility that full-page content size differs during capture; this supports checking for changing content, but does not establish a universal failure cause.

Open the page normally and wait until the content you need has appeared.
Retry the viewport capture, then the full-page capture.
If the page is still changing, wait for the relevant section to settle and try again.
If the tool supports clipping or selector-based capture, capture the stable region you need.

Do not assume that waiting longer will solve every case. If the page keeps growing or changing, a longer caller timeout may only make the same unstable capture take longer.

5. Use DevTools to inspect slow rendering or memory use

If the page is visibly slow, record its behavior while reproducing the issue. Chrome DevTools provides performance recording and memory metrics that can help you look for sustained work or high resource use. These tools are diagnostic: they do not automatically identify the cause of a screenshot timeout. Use evidence from the recording before attributing the failure to memory pressure or changing Windows settings. See the Chrome DevTools Performance overview.

6. Change only the timeout that belongs to your capture tool

Chrome’s headless command-line --timeout is a delay before headless --screenshot, --dump-dom, or --print-to-pdf captures content. It is not a universal CDP or extension timeout. Chrome DevTools Recorder has its own timeouts for workflow steps and waits. An automation library or extension can have a separate wait of its own.

For a headless CLI capture, use Chrome’s documented option in that workflow, for example:

chrome.exe --headless --timeout=5000 --screenshot="C:\captures\page.png" "https://example.com"

Here, --timeout=5000 requests a five-second delay before capture; it does not mean “allow the screenshot operation to run for five seconds longer.” Check the documentation for the exact Chrome version and command you use: Chrome Headless mode.

If you use Recorder, adjust its step or wait timeout for the specific workflow step. For an extension or automation wrapper, identify its name and version and find its own timeout setting. Do not apply the headless CLI setting to a different capture path and expect it to change that path’s wait.

7. Check managed-device restrictions for extension captures

If an extension initiates capture through Chrome’s debugger API on a work-managed PC, enterprise policy or data loss prevention (DLP) rules may restrict screenshot capture. Chrome documents a restriction error associated with the DisableScreenshots policy and DLP rules. This is especially relevant when capture fails on a managed device but works in an environment without those restrictions. Ask your administrator whether a policy applies; do not try to bypass organizational controls. See the Chrome debugger API documentation.

8. Troubleshooting common errors

Symptom	What it suggests	What to do
The caller reports a timeout, but there is no Chrome error	The automation client or extension may have stopped waiting before Chrome finished.	Record the caller’s timeout and version. Adjust that tool’s own wait, then compare viewport and full-page captures.
Viewport works; full page times out	The beyond-viewport path, page dimensions, or changing content may be involved.	Check document dimensions, wait for dynamic content to settle, and try a clip or smaller section.
Chrome says “Page is too large.”	This is an explicit size failure, distinct from a generic timeout.	Capture a smaller clip or split the page into sections if supported.
The page keeps growing or the result has missing lower content	Lazy loading or other dynamic rendering may be changing content during capture.	Wait for the needed content to load, then retry; consider a targeted region if the page does not stabilize.
Capture is slow and the page stutters	The page may be doing sustained work or using substantial resources; the symptom alone does not prove memory pressure.	Record the page in DevTools Performance and inspect available memory metrics while reproducing.
An extension reports a policy or restricted screenshot error	A managed Chrome policy or DLP rule may block that extension capture path.	Ask the administrator whether the restriction applies.
Changing headless `--timeout` has no effect on an extension or library	That flag belongs to headless CLI capture and is a pre-capture delay.	Find the timeout setting in the actual extension, library, or workflow that reports the failure.

9. Choose a reliable workaround for the page you need

Compare capture methods on the criteria that matter for your task:

Output scope: Does it capture one full-page image, the current viewport, or only a selected region?
Clipping: Can you capture a rectangle or section when the whole document is too large?
Waiting: Can the tool wait for dynamic content or a stable page state?
Timeout ownership: Is the relevant wait controlled by Chrome, the caller, or an extension?
Policy: Is the method allowed on your managed device?

CDP documents full-page capture options, and Chrome’s headless CLI supports its own screenshot workflow. Neither source establishes one method as the best choice for every page or a guaranteed fix for every timeout.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. A single GET request can return a PNG, JPEG, WebP, or PDF. Its API documentation covers the request options.

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

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

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://example.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', new Uint8Array(await res.arrayBuffer()));

Cookie banners are accepted and removed, along with known newsletter popups and chat widgets, before the shot.
Bot checks, blank pages, failed loads, timeouts, and cache hits are not billed; response headers report the page verdict and billing status.
An MCP server lets AI agents use screenshot tools, including take_screenshot, get_page_info, and capture_pdf.
1,000 screenshots a month are free with no card. Paid plans start at $5 for 3,000 screenshots; every feature is available on every plan.

FAQ

Is this a Windows-only Chrome problem?

The available evidence does not establish a Windows-specific defect or timeout rate. The troubleshooting steps focus on Chrome’s capture path, the page, and the tool that initiated the request.

Does a longer timeout guarantee a full-page screenshot will finish?

No. It can help only when the relevant caller is stopping its wait too soon. It will not resolve a page-size failure, a policy restriction, or a page that continues changing.

Can I rely on the 128K-pixel dimension check for my Chrome version?

No. The cited threshold comes from a Chromium source snapshot and may differ across versions. Use the actual error from your installed Chrome as the guide.

What should I include when asking for help?

Include the exact error, Chrome version, page URL if shareable, capture tool and version, elapsed time, and whether viewport capture succeeds. Those details help distinguish a caller timeout from a browser or page limitation.