ScreenshotAPI screenshot is cut off: how to fix full-page capture

If a ScreenshotAPI.com screenshot shows only the top of a page, first check whether your request sets fullPage=true. ScreenshotAPI.com documents fullPage as optional and false by default. Increasing the viewport height is a different setting and is not documented as a substitute for full-page mode. If full-page mode is already on, check whether you selected or cropped an element, whether the missing content loads only after scrolling, and whether the capture waits for that content to render.

This guide refers specifically to ScreenshotAPI.com at api.screenshotapi.com. Several similarly named screenshot services have different hosts and parameter names, so confirm the endpoint before copying a request.

1. Enable full-page capture

Set fullPage to true in the ScreenshotAPI.com request. The setting asks for the entire scrollable page instead of just the browser viewport. The API documents viewport width and height separately: for GET requests they are width and height; in POST JSON they are viewport.width and viewport.height.

A taller viewport changes the visible browser area. It does not, by itself, turn on the documented full-document capture mode.

Runnable cURL example

curl -G 'https://api.screenshotapi.com/screenshot' \
  --data-urlencode 'token=YOUR_SCREENSHOTAPI_TOKEN' \
  --data-urlencode 'url=https://example.com' \
  --data-urlencode 'fullPage=true' \
  --output page.png

Use the authentication parameter and endpoint format from your ScreenshotAPI.com account or current API reference. The dossier establishes the host and parameter behavior, but does not provide an authentication parameter or exact request path; replace the illustrative request path and token parameter with the values specified for your account.

Python with requests

import requests

endpoint = "https://api.screenshotapi.com/screenshot"  # Confirm the path in your account docs
params = {
    "token": "YOUR_SCREENSHOTAPI_TOKEN",  # Use your documented auth parameter
    "url": "https://example.com",
    "fullPage": "true",
}
response = requests.get(endpoint, params=params, timeout=90)
response.raise_for_status()
with open("page.png", "wb") as image_file:
    image_file.write(response.content)

Node.js with fetch

const endpoint = new URL('https://api.screenshotapi.com/screenshot'); // Confirm path in your account docs
endpoint.search = new URLSearchParams({
  token: 'YOUR_SCREENSHOTAPI_TOKEN', // Use your documented auth parameter
  url: 'https://example.com',
  fullPage: 'true',
}).toString();

const response = await fetch(endpoint);
if (!response.ok) {
  throw new Error(`Screenshot request failed: ${response.status} ${response.statusText}`);
}
const image = Buffer.from(await response.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('page.png', image));

ScreenshotAPI.com also documents POST JSON viewport dimensions. The exact POST path, authentication field, image response handling, and format parameters should be taken from its current account documentation; do not infer them from another provider.

2. Check selectors and cropping

If your request targets a CSS selector, the capture may be limited to that element by design. Check for a selector option and remove it when you need the whole document. Also review any crop or clip settings supported by your provider. Do not assume clip parameter names from a different service apply to ScreenshotAPI.com.

3. Make scroll-triggered content appear

Some pages add images or sections only after the visitor scrolls near them. ScreenshotAPI.com documents doScroll as a way to scroll before capture and trigger lazy-loaded content. A wait alone does not perform that scroll action.

# Add this to the ScreenshotAPI.com GET parameters when needed:
fullPage=true&doScroll=true

Use this when the missing content appears after scrolling in a normal browser. If the page does not use scroll-triggered loading, this setting may not address the cause.

4. Wait for the content you need

ScreenshotAPI.com documents three separate ways to control render timing:

Control	What it waits for	When to try it
`waitUntil`	A navigation state: `load`, `domcontentloaded`, `networkidle0`, or `networkidle2`.	When the page is still loading resources or running its initial scripts.
`waitForSelector`	A specific CSS selector to appear.	When the missing section has a stable element that marks readiness.
`delay`	A post-load delay in milliseconds; the reference documents an input range of 0–20,000 ms.	When content appears shortly after a known event and no selector is suitable.

Choose the condition that matches the page. For example, waitForSelector can target a section that is inserted asynchronously, while doScroll addresses content that loads because of scrolling. A longer delay is not guaranteed to fix either problem.

5. Diagnose the request and result

Confirm the hostname is api.screenshotapi.com and that the parameter names match ScreenshotAPI.com documentation.
Inspect the final encoded request or POST body and verify fullPage is true.
Check whether a selector or crop restricts the capture.
Determine whether the missing region appears only after scrolling; if so, try doScroll.
Choose an appropriate waitUntil, waitForSelector, or delay for content that is not ready at capture time.
Inspect the returned image dimensions and compare them with the expected page capture.

The reviewed ScreenshotAPI.com reference does not specify a maximum full-page height or a truncation response header. If the request is correct and the result still ends early, check current account-specific documentation or ask the provider about limits for your account. Do not assume a particular limit or error signal without documentation.

6. Common causes and fixes

Symptom	Likely cause	What to check
Only the initial screen is present	`fullPage` was omitted or false.	Set `fullPage=true`; viewport height is a separate option.
Only one card, panel, or section appears	A selector capture restricts the target.	Remove the selector if the goal is the whole document.
Lower images or sections are blank or absent	They load on scroll.	Try `doScroll`, then inspect whether the content becomes available.
Some dynamically rendered content is missing	The screenshot was taken before it appeared.	Wait for a relevant selector or use a suitable navigation condition; use delay only when appropriate.
Copied options seem ignored	The request targets a different Screenshot API product.	Verify the hostname and use that provider’s own parameter names.
Capture still ends early after these checks	Provider-specific behavior or an account limit may be involved.	Review current account documentation and provide the exact request and output dimensions to provider support.

7. Reliability, performance, and cost considerations

Prefer readiness signals over arbitrary waits. A selector associated with the missing content makes the capture condition easier to reason about. A delay adds waiting time and may still be too short or unnecessarily long.
Separate scrolling from waiting. Scrolling can trigger lazy loading; waiting gives triggered work time to finish. A page may need both.
Keep a record of the exact request. Save the endpoint, parameters or POST body, response status, and image dimensions when diagnosing intermittent results. This helps distinguish configuration mistakes from page-specific rendering.
Check provider limits rather than guessing. The reviewed reference does not establish a maximum page height, so consult current provider and account documentation before designing around a presumed limit.
Estimate cost from the provider’s current plan and billing rules. The dossier contains no ScreenshotAPI.com price details, so confirm those directly with the provider. Repeated captures while tuning waits or scroll behavior can add usage if the provider bills each request.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server for developers. One GET request can return an image or PDF. Its parameter names also work with those used by other screenshot APIs, which can make switching easier. See the ScreenshotNeo API documentation.

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

ScreenshotNeo accepts cookie and consent banners before capture and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each step can be turned off. Bot checks, blank pages, failed loads, timeouts, and cache hits are not billed, and the response identifies the page verdict and billing status in headers. Its MCP server gives AI agents tools for screenshots, page information, and PDF capture. The Free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 screenshots.

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

FAQ

Why is my ScreenshotAPI screenshot cut off?

The most direct check is whether ScreenshotAPI.com’s fullPage option is enabled. If it is, inspect selector or crop restrictions, scroll-triggered loading, and render timing.

Does increasing the height make the capture full-page?

No. Height sets the viewport dimension in the documented request formats. Full-page capture is controlled by fullPage.

Should I use a delay or scroll option?

Use scrolling when content is revealed by scrolling. Use a readiness condition or delay when content needs time to render. They address different conditions.

Can I assume every Screenshot API service uses `fullPage`?

No. Confirm the provider’s domain and API reference first. Similar product names do not imply compatible endpoints or parameters.

Sources

ScreenshotAPI.com API reference — full-page capture, viewport dimensions, selector capture, scrolling, and wait controls. The reference was displayed as updated seven months before it was reviewed; that marker is not an API release date.
Screenshot API documentation — a separate service and endpoint, included to distinguish similarly named products.
ScreenshotAPI.net documentation — another separate service; its selector, scroll-to-element, and clip details should not be attributed to ScreenshotAPI.com.