How to Capture a Full-Page Screenshot with ScreenshotAPI.net

To capture the entire scrollable page with ScreenshotAPI.net, make a GET request to its v3 screenshot endpoint and set full_page=true. Provide your API token and the target URL; choose a viewport width and output format for the layout you want to capture. A basic request looks like this:

https://shot.screenshotapi.net/v3/screenshot?token=YOUR_API_KEY&url=https%3A%2F%2Fwww.wikipedia.org%2F&file_type=png&full_page=true&width=1680&height=867

The endpoint and parameters below follow ScreenshotAPI.net’s render documentation and full-page screenshot tool. Check its current documentation before deploying, because service options can change.

1. Get a full-page screenshot using the web tool

Open ScreenshotAPI.net’s full-page screenshot tool.
Enter the page URL, including https://.
Choose a viewport preset or dimensions that match the layout you want: desktop, tablet, or mobile.
Select PNG, JPG, or WebP, then enable full-page capture and run the capture.
Review the result from top to bottom. If content is missing, use the dynamic-content guidance below.

A full-page image preserves the selected viewport’s layout and extends it vertically. It does not mean the page is rendered at an arbitrarily wide desktop size: choose the width first, since responsive sites may rearrange their content at different widths.

2. Capture through the ScreenshotAPI.net API

The documented request is GET https://shot.screenshotapi.net/v3/screenshot. Pass your dashboard token, the target URL, and full_page=true. The target URL must be URL-encoded when you construct a query string manually; HTTP clients generally encode query parameters for you.

cURL

curl -G 'https://shot.screenshotapi.net/v3/screenshot' \
  --data-urlencode 'token=YOUR_API_KEY' \
  --data-urlencode 'url=https://www.wikipedia.org/' \
  --data-urlencode 'file_type=png' \
  --data-urlencode 'full_page=true' \
  --data-urlencode 'width=1680' \
  --data-urlencode 'height=867' \
  -o page.png

Replace YOUR_API_KEY with the token from your account. Keep the token out of public source code and browser-side scripts. This command saves the response body to page.png.

Python

from urllib.parse import urlencode
from urllib.request import urlopen

params = {
    "token": "YOUR_API_KEY",
    "url": "https://www.wikipedia.org/",
    "file_type": "png",
    "full_page": "true",
    "width": 1680,
    "height": 867,
}
request_url = "https://shot.screenshotapi.net/v3/screenshot?" + urlencode(params)

with urlopen(request_url, timeout=90) as response:
    image_bytes = response.read()

with open("page.png", "wb") as image_file:
    image_file.write(image_bytes)

This uses only Python’s standard library. For production code, also check the HTTP status and confirm the response is an image before saving it, so an error response is not mistaken for a screenshot.

Node.js

const params = new URLSearchParams({
  token: 'YOUR_API_KEY',
  url: 'https://www.wikipedia.org/',
  file_type: 'png',
  full_page: 'true',
  width: '1680',
  height: '867'
});

const response = await fetch(
  `https://shot.screenshotapi.net/v3/screenshot?${params}`,
  { signal: AbortSignal.timeout(90_000) }
);

if (!response.ok) {
  throw new Error(`Screenshot request failed: HTTP ${response.status}`);
}

const image = Buffer.from(await response.arrayBuffer());
await import('node:fs/promises').then(({ writeFile }) => writeFile('page.png', image));

Run this in a Node.js version that supports built-in fetch and AbortSignal.timeout. Keep your token in a server-side environment variable in a real application.

3. Choose full-page, viewport, dimensions, and format

Setting	What it controls	How to choose
`full_page=true`	Captures beyond the initially visible viewport, producing a tall image of the document.	Use it when you need the whole scrollable page. Without it, a capture is limited to the viewport.
`width`	The browser viewport width used to render the page.	Use a desktop width for desktop layouts, or a narrow width to capture the mobile layout. The example uses 1680 pixels.
`height`	The browser viewport height used during rendering.	The tool example uses 867 pixels. For unusually tall content such as a spreadsheet, the vendor help recommends an appropriate browser height along with full-page mode.
`file_type`	Output image type.	Choose PNG for lossless output, JPG for photo-heavy pages where a smaller file is useful, or WebP for a size and quality balance. These are the vendor’s format recommendations; the best fit depends on your downstream use.

The web tool also offers desktop, tablet, and mobile presets. Pick based on the responsive layout you want to preserve, not just the device that will display the downloaded file. The API example uses PNG; change the requested file type and output filename together when selecting a different format.

4. Make dynamic pages more complete

A full-page setting controls the capture extent; it cannot guarantee that every element has finished loading. Pages may render images lazily, fetch data asynchronously, animate, or append items only as the visitor scrolls. ScreenshotAPI.net documents lazy-loading and delay controls for these cases. Consult its current parameter documentation for the exact parameter names and accepted values before adding them.

Lazy images: enable the documented lazy-loading behavior when images appear only near the viewport during scrolling.
Asynchronous content: add a suitable documented delay when the page needs time to fetch or render data. A longer delay can help, but cannot make content available if the site request fails.
Animations: allow enough time for the state you want to appear. Animated content can produce different frames across captures.
Infinite scrolling: the page may load more rows or cards only after scrolling. A full-page option does not necessarily mean an endless feed can be exhausted; define which loaded content matters and verify the result.
Very tall pages: for spreadsheets or other unusually tall pages, the vendor help recommends combining full-page mode with an appropriate browser height. Check the output for clipping or missing lower sections.

For reproducible captures, use the same viewport, wait settings, target URL, and output type each time. Test representative pages from your own site because completeness depends on how the target page behaves.

If consent banners or ads cover the page, ScreenshotAPI.net’s help documentation describes no_cookie_banners=true and block_ads=true. These are vendor-provided options, and their effect can vary by page. Add them only when appropriate for the capture and check the resulting image; do not assume every overlay or ad will be removed.

curl -G 'https://shot.screenshotapi.net/v3/screenshot' \
  --data-urlencode 'token=YOUR_API_KEY' \
  --data-urlencode 'url=https://www.wikipedia.org/' \
  --data-urlencode 'file_type=png' \
  --data-urlencode 'full_page=true' \
  --data-urlencode 'no_cookie_banners=true' \
  --data-urlencode 'block_ads=true' \
  -o page.png

See the vendor’s help page for these options and its guidance for unusually tall pages.

6. Troubleshooting

Symptom	Likely cause	What to try
The image shows only the first screen.	The request omitted full-page mode, or the parameter was not passed as a query parameter.	Include `full_page=true` and confirm the final request URL contains it.
The request fails or returns an error.	The token may be absent or invalid, or the target URL may be malformed.	Check the dashboard token, use the documented `token` parameter, and test with a complete HTTPS URL. Inspect the HTTP status and response before saving it as an image.
Some images or content are missing.	Lazy loading or asynchronous rendering may not have completed before capture.	Use the documented lazy-loading or delay controls, and verify the page at the chosen viewport.
A banner or ad obscures content.	The page displays an overlay during capture.	Try the documented `no_cookie_banners=true` or `block_ads=true` options, then inspect the result because behavior varies by site.
The image is unexpectedly narrow or rearranged.	The viewport width triggered a responsive layout.	Choose a width or device preset matching the layout you intend to capture.
The bottom of a spreadsheet or tall page is missing.	The rendered document may exceed the effective capture dimensions.	Use full-page mode and an appropriate browser height as described in the vendor help; check whether the page itself loads more content as you scroll.
The saved file cannot be opened as an image.	An error response may have been saved with an image extension.	Check the HTTP status and response content type before writing the response to the output file.

7. Performance, reliability, and cost

Full-page captures produce taller images than viewport captures, so the resulting file can be larger and take longer to transfer or process. Large pages also need more rendering and image-loading work. Use the smallest viewport and output format that still meet your needs; for tall pages, avoid adding excessive waits unless the page requires them.

Capture completeness depends on the target site: content may be delayed, unavailable, hidden behind interaction, or loaded only during scrolling. A successful HTTP request alone does not prove that the image contains every expected section. For repeat jobs, inspect representative output and handle request errors and timeouts explicitly. The research for this guide contains no independent performance benchmark or service reliability figure, so none is asserted here.

Check ScreenshotAPI.net’s current account and pricing information before estimating project cost. The reviewed documentation establishes how to request a capture but does not provide a verified price or quota for this article.

8. Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. Its one-call API can return a screenshot or PDF, and its capture options include full-page screenshots with lazy images loaded. The API also accepts parameter names used by other screenshot APIs, which can make switching easier.

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

For the ScreenshotNeo API documentation, including Python and Node.js examples, see the docs. ScreenshotNeo removes cookie banners, popups, and chat widgets before the shot. Bot checks, blank pages, and failed loads are never billed. Its MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 screenshots.

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

9. FAQ

Does full-page mode capture a mobile page?

It can capture the full page at a mobile viewport if you select a mobile preset or suitable narrow width. The site’s responsive layout will differ from its desktop layout.

Will full-page mode capture an infinite feed completely?

Not necessarily. Infinite feeds may add content only as the page is scrolled, so the captured extent depends on what has loaded and on the service’s capture behavior.

Which format should I use?

Use PNG when lossless output matters, JPG for photo-heavy content when smaller files are useful, or WebP when you want a size and quality balance. Confirm that your next tool accepts the chosen format.

Can I use the API from frontend code?

A request that includes your API token in browser code can expose the credential to visitors. Make authenticated requests from a server-side application or another environment where the token remains private.