Screenshot API Limits for Page Load Time and Maximum Capture Size

There is no universal screenshot API limit for page load time or maximum capture size. The answer depends on the provider, endpoint, and sometimes your account tier. Check the provider’s documentation for the exact timeout parameter and whether it covers navigation, browser actions after load, or the entire render. For size, distinguish viewport dimensions, full-page height, and final output pixels after device scaling.

This guide shows how to read those limits, compare documented examples, and choose settings that avoid unnecessary timeouts or oversized captures. Treat the vendor values below as examples for those specific services, not as a shared industry range.

1. What “page load timeout” means

Screenshot APIs use similar-sounding timeout settings for different parts of a capture:

Timeout scope	What it measures	Example parameter
Navigation timeout	How long the browser waits for a page-navigation condition, such as a load event or network idle.	timeoutMs in screenshot-api.org’s REST API reference.
Post-load browser-action timeout	How long browser work may continue after the page has loaded, including taking a screenshot or extracting content.	actionTimeout in Cloudflare Browser Rendering.
Whole-render timeout	The allowance for the entire render operation. The documentation may not define it as navigation-only.	timeout in screenshot-api.net’s documentation.

Do not compare these values as if they measured the same interval. A page can finish navigation quickly but still take time to wait for a selector, load lazy images, run scripts, or encode a large screenshot. Check whether those steps are included in the vendor’s timeout definition.

2. What “maximum capture size” means

Size limits can refer to different dimensions of a capture:

• Viewport width and height: the browser’s visible CSS-pixel dimensions.
• Full-page height: the maximum vertical extent captured when the page is stitched or rendered beyond the viewport.
• Output pixel dimensions: the resulting image size, which can be larger than CSS dimensions when device scaling or a device scale factor is applied.

A provider may accept a certain viewport but impose a separate cap on full-page height. Device scale factor can also increase output pixels and memory requirements without changing the CSS viewport. Verify each field independently rather than treating “maximum screenshot size” as one number.

3. Documented examples from separate providers

These current documentation examples illustrate why the provider and parameter matter:

Provider and documented setting	Published value	Scope
Screenshot API (screenshot-api.net)	timeout: 1–30 seconds; 25 seconds by default	Whole-render allowance, as described in that provider’s docs.
Screenshot API (screenshot-api.net)	Viewport maximum 3840 × 4320 CSS pixels; full-page height capped at 4320 pixels	Viewport and full-page height are separately documented dimensions.
Cloudflare Browser Rendering	actionTimeout: up to 120000 milliseconds	Maximum browser-action duration after page load, not a general navigation timeout.
ScreenshotEngine	Width 100–3840 pixels; height 100–10000 pixels	Documented numeric dimensions for its GET parameters.
Screenshot API (screenshot-api.org)	timeoutMs: 30000 milliseconds by default	Navigation timeout; the reference also documents multiple waitUntil strategies.

These figures belong to different APIs and have different scopes. They are not a universal minimum-to-maximum range, and the research does not establish shared plan, endpoint, or geographic conditions across them. Recheck the provider’s parameter reference before relying on a value.

4. How to find the applicable limit

1. Identify the exact service and endpoint. Product names can be similar. Record the hostname and API route you call.
2. Find the endpoint’s parameter reference. Search for timeout, wait strategy, width, height, full-page capture, and device scaling.
3. Read the timeout definition. Establish whether it covers navigation, post-load actions, or the complete render, and whether waits count toward it.
4. Separate viewport from document size. Look for a full-page setting and an explicit maximum full-page height.
5. Check units and pixel type. Confirm seconds versus milliseconds and CSS pixels versus output pixels.
6. Check account and endpoint context. Limits can vary by plan or route; use the documentation for the endpoint and account you actually use.
7. Run a representative capture. Test a page with the same scripts, lazy content, and approximate length as production. Use the provider’s returned error or metadata to distinguish a timeout from a size rejection.

5. Configure captures to fit the limits

Set the smallest useful viewport

Use the dimensions needed for the target layout. A larger viewport may change responsive behavior and increase output dimensions, memory use, and image encoding work. If the API has a device scale factor, account for it when estimating output pixels.

Choose a wait condition deliberately

Waiting for full network idle can be a poor fit for pages with analytics, live updates, or long-running requests. When supported, a specific selector or a bounded delay can make the capture more predictable. Keep the wait within the documented timeout budget.

Use full-page capture only when needed

Full-page screenshots can exceed a provider’s height cap and may require more rendering and encoding work. For long pages, capture sections or individual elements if the API supports them. If the provider clips at a documented maximum, split the page rather than assuming the result contains everything.

Reduce unnecessary page work

Block resources that are not needed in the image when the provider supports request or resource blocking. Avoid injecting expensive scripts or waiting on third-party activity unless it affects the content you need.

6. Minimal request examples for inspecting your provider’s contract

The following examples demonstrate the request pattern for a hypothetical screenshot endpoint that accepts timeoutMs, width, height, and fullPage. Those parameter names are not universal. Replace the hostname, authentication, parameter names, and values with the exact documented contract for your provider before running them.

cURL

curl -G "https://YOUR_PROVIDER.example/v1/screenshot" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  --data-urlencode "url=https://example.com" \
  --data-urlencode "timeoutMs=30000" \
  --data-urlencode "width=1440" \
  --data-urlencode "height=900" \
  --data-urlencode "fullPage=false" \
  -o capture.png

Python

import requests

endpoint = "https://YOUR_PROVIDER.example/v1/screenshot"
params = {
    "url": "https://example.com",
    "timeoutMs": 30000,
    "width": 1440,
    "height": 900,
    "fullPage": "false",
}
response = requests.get(
    endpoint,
    params=params,
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    timeout=45,  # Client-side timeout; set above the API render allowance.
)
response.raise_for_status()
with open("capture.png", "wb") as output:
    output.write(response.content)

Node.js

const endpoint = new URL("https://YOUR_PROVIDER.example/v1/screenshot");
endpoint.search = new URLSearchParams({
  url: "https://example.com",
  timeoutMs: "30000",
  width: "1440",
  height: "900",
  fullPage: "false",
});

const response = await fetch(endpoint, {
  headers: { Authorization: "Bearer YOUR_API_KEY" },
  signal: AbortSignal.timeout(45_000), // Client-side timeout, in milliseconds.
});
if (!response.ok) {
  throw new Error(`Screenshot request failed: ${response.status} ${await response.text()}`);
}
const bytes = new Uint8Array(await response.arrayBuffer());
await (await import("node:fs/promises")).writeFile("capture.png", bytes);

There are two timeout layers in these examples: the API’s render or navigation setting and the HTTP client’s own deadline. Keep the client deadline longer than the server-side allowance plus network and response-transfer time. A client timeout does not raise the provider’s render limit.

7. Troubleshooting

Symptom	Likely cause	Fix
Request rejects the timeout value	Wrong parameter name, units, or a value outside the endpoint’s range.	Use the exact endpoint documentation; check whether the field uses seconds or milliseconds.
Client reports a timeout while the API allows more time	The HTTP client, proxy, or job runner deadline is shorter than the server render allowance.	Increase the client deadline within your system’s limits, or use an asynchronous job endpoint if available.
Page loads but the screenshot misses content	The chosen navigation event fires before client-rendered or lazy content appears.	Wait for a relevant selector or bounded delay where supported; ensure the timeout includes enough time for that wait.
Capture is clipped vertically	Viewport height was mistaken for full-page height, or the provider’s full-page cap was reached.	Check the full-page limit separately; capture sections or elements if the document exceeds it.
Image dimensions are unexpectedly large	Device scaling multiplies output pixels beyond the CSS viewport dimensions.	Check the scale setting and estimate output dimensions before requesting a large full-page image.
Only some pages time out	Those pages may have slower scripts, blocked resources, or requests that prevent a chosen network-idle condition.	Use a more specific readiness condition, block nonessential requests if supported, and avoid raising timeouts without measuring the cause.
Response is an error document instead of an image	The endpoint returned an API error, but the client saved its body as an image.	Check HTTP status and content type before writing the response; log the provider’s error body for diagnosis.

8. Performance, reliability, and cost

Longer timeout values can reduce failures on genuinely slow pages, but they also keep requests and workers occupied longer. Large full-page captures increase rendering, memory, transfer, and encoding work. Start with a realistic viewport and wait condition, then raise limits only when the provider permits it and the target page needs the extra time or size.

For reliable production capture, record the endpoint, parameter values, response status, and provider error details. Use bounded retries for transient network errors, with backoff; do not repeatedly retry deterministic size or parameter validation failures. If captures are part of a batch, isolate failures so one slow URL does not hold the whole workload past its deadline.

Pricing and billing behavior are provider-specific. Confirm whether failed renders, retries, cache hits, and oversized requests are billable before designing a high-volume workflow. The cited limit documentation does not establish a common billing model.

9. Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server from Yorker Media. Its API accepts a URL in one GET request and can return PNG, JPEG, WebP, or PDF. See the ScreenshotNeo API documentation for its parameters and 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)
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}`);

ScreenshotNeo’s clean-shot flow accepts cookie and consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each cleanup step can be turned off. Bot checks, blank pages, failed loads, timeouts, and cache hits are not billed, and responses identify the page verdict and billing status in headers. Its MCP server provides take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients. The free plan includes 1,000 shots per month without a card; paid plans start at $5 for 3,000 shots, and every feature is on every plan.

Create a free ScreenshotNeo account for 1,000 screenshots a month, with no card required.

10. FAQ

Is 30 seconds the standard screenshot API timeout?

No. It is a documented default for one API reference, while other providers use different timeout fields and scopes. Use the limit for your exact endpoint.

Does a larger viewport always capture more of a page?

No. It changes the visible browser area. Full-page capture and its height cap are usually separate settings.

Can I compare two providers by their maximum timeout number?

Only after confirming that both values measure the same phase of rendering and use the same units.

What should I do when a site is taller than the full-page cap?

Capture sections or specific elements, or use an API that documents a sufficient full-page limit for your use case.

Does the browser client timeout control the server’s render duration?

No. It controls how long your client waits for the HTTP response. The API’s own parameter controls the provider-side operation, subject to its documented maximum.