How to Take a Full-Page Website Screenshot with ScreenshotOne

To take a full-page website screenshot with ScreenshotOne, send an HTTPS request to its /take endpoint with the target url, your access_key, and full_page=true. For pages that render incorrectly when stretched to their full height, try full_page_algorithm=by_sections. Tune scrolling and wait settings when lazy-loaded content is missing, and cap the height of very long pages.

1. Make the basic full-page request

Replace the example URL and placeholder key with your target page and ScreenshotOne access key. Keep the key private; do not put a real key in source code or a public repository.

https://api.screenshotone.com/take?url=https://example.com&full_page=true&access_key=<your-access-key>

For example, save the response as a PNG with cURL:

curl --fail --silent --show-error --get \
  'https://api.screenshotone.com/take' \
  --data-urlencode 'url=https://example.com' \
  --data-urlencode 'full_page=true' \
  --data-urlencode 'access_key=YOUR_ACCESS_KEY' \
  --output screenshot.png

ScreenshotOne accepts options as URL parameters on GET requests or in a JSON body on POST requests. Use HTTPS. See the official Getting Started guide and options reference for the current API details.

2. Use a POST request when you prefer a JSON body

A POST request keeps the options out of the URL. This can be convenient when the request has many settings. The documented maximum POST body size is 100 MiB; that is a request-body limit, not a recommended screenshot size.

curl --fail --silent --show-error \
  --request POST 'https://api.screenshotone.com/take' \
  --header 'Content-Type: application/json' \
  --data '{
    "url": "https://example.com",
    "full_page": true,
    "access_key": "YOUR_ACCESS_KEY"
  }' \
  --output screenshot.png

Protect the access key in either method. For production applications, load it from an environment variable or a secret manager rather than committing it to code.

3. Runnable Python and Node.js examples

Python

Install the HTTP client with python -m pip install requests. This example checks for an HTTP error before writing the image.

import os
import requests

access_key = os.environ["SCREENSHOTONE_ACCESS_KEY"]
response = requests.get(
    "https://api.screenshotone.com/take",
    params={
        "url": "https://example.com",
        "full_page": "true",
        "access_key": access_key,
    },
    timeout=120,
)
response.raise_for_status()

with open("screenshot.png", "wb") as image_file:
    image_file.write(response.content)

Node.js

This example uses the built-in fetch available in current Node.js versions. Set SCREENSHOTONE_ACCESS_KEY in the environment before running it.

const accessKey = process.env.SCREENSHOTONE_ACCESS_KEY;
if (!accessKey) throw new Error("Set SCREENSHOTONE_ACCESS_KEY first");

const params = new URLSearchParams({
  url: "https://example.com",
  full_page: "true",
  access_key: accessKey,
});

const response = await fetch(
  `https://api.screenshotone.com/take?${params}`,
  { signal: AbortSignal.timeout(120_000) },
);
if (!response.ok) {
  throw new Error(`ScreenshotOne returned HTTP ${response.status}: ${await response.text()}`);
}

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

4. Choose the full-page capture behavior

The basic full_page=true option captures beyond the initial viewport. ScreenshotOne documents two full-page approaches with different tradeoffs:

Setting	How it behaves	When to try it
Default algorithm	Stretches the rendered viewport to the page height.	Start here for a typical page.
full_page_algorithm=by_sections	Scrolls through the page and combines section captures. Viewport height controls section size.	Try it when the default has layout issues or the page relies on content appearing as it scrolls.

The documented default viewport is 1280 pixels wide by 1024 pixels high. Width affects the responsive layout and final image width. With the section-based algorithm, height also determines the size of each captured section: smaller sections can trigger more lazy-loading events, but may take longer to capture. The best choice depends on the target page; verify the resulting image rather than assuming one algorithm suits every site.

curl --fail --silent --show-error --get \
  'https://api.screenshotone.com/take' \
  --data-urlencode 'url=https://example.com' \
  --data-urlencode 'full_page=true' \
  --data-urlencode 'full_page_algorithm=by_sections' \
  --data-urlencode 'viewport_width=1280' \
  --data-urlencode 'viewport_height=1024' \
  --data-urlencode 'access_key=YOUR_ACCESS_KEY' \
  --output screenshot.png

5. Load content that appears while scrolling

Full-page capture enables full-page scrolling by default to help load lazy content. If images or sections are still missing, adjust the scroll step and the delay between steps. ScreenshotOne’s guide gives 500 pixels and 1500 milliseconds as example values; treat them as starting points, not universal settings. Some pages also need an additional page delay of 5 to 10 seconds.

curl --fail --silent --show-error --get \
  'https://api.screenshotone.com/take' \
  --data-urlencode 'url=https://example.com' \
  --data-urlencode 'full_page=true' \
  --data-urlencode 'full_page_scroll_by=500' \
  --data-urlencode 'full_page_scroll_delay=1500' \
  --data-urlencode 'delay=5' \
  --data-urlencode 'access_key=YOUR_ACCESS_KEY' \
  --output screenshot.png

Use a smaller scroll step or a longer interval when a page reveals content only after gradual scrolling. Increase the overall delay when the site needs time for scripts or data requests. Avoid adding long waits without checking the output: extra waiting increases capture time and cannot guarantee that a site’s content has finished loading.

6. Bound or split very tall captures

Set a maximum height

For unusually long or infinite-scroll pages, set full_page_max_height to keep the capture bounded. Choose a limit appropriate to your downstream use and confirm where the image ends.

curl --fail --silent --show-error --get \
  'https://api.screenshotone.com/take' \
  --data-urlencode 'url=https://example.com/long-page' \
  --data-urlencode 'full_page=true' \
  --data-urlencode 'full_page_max_height=12000' \
  --data-urlencode 'access_key=YOUR_ACCESS_KEY' \
  --output screenshot.png

Return slices for downstream processing

If one very tall image is awkward for image analysis or another downstream step, request slices with full_page_slices=true as well as full_page=true. JSON responses include a slice array. The documented default slice height is 4000 pixels, and the allowed range is 1 to 16000 pixels. Overlap is optional, but slice height minus overlap must leave at least a 100-pixel step. Slices cannot be combined with store=true.

curl --fail --silent --show-error --get \
  'https://api.screenshotone.com/take' \
  --data-urlencode 'url=https://example.com/long-page' \
  --data-urlencode 'full_page=true' \
  --data-urlencode 'full_page_slices=true' \
  --data-urlencode 'full_page_slice_height=4000' \
  --data-urlencode 'access_key=YOUR_ACCESS_KEY' \
  --output response.json

Because this option returns JSON containing slices rather than a single image file, save the response with a .json extension and parse its slice array. Check the current slice guide for exact response fields and overlap options.

7. Make animation and page noise predictable

For motion-sensitive pages, reduce_motion=true attempts to reduce supported animation and pause supported looping media. This is best-effort: custom JavaScript, canvas, and animated image formats can still change between captures. The separate reduced_motion=true option sets a browser preference that only helps when the page honors it. These controls do not make every capture pixel-identical.

Some pages also include cookie banners, chat widgets, ads, or trackers. ScreenshotOne’s e-commerce guide documents options for blocking or removing such elements, including heuristic banner handling. Use those selectively: removing an overlay changes what the screenshot depicts, and a broad rule may hide content you need.

8. Troubleshoot common full-page problems

Symptom	Likely cause	What to try
Images or sections are missing below the fold	The page loads content only after scrolling, or needs more time.	Reduce full_page_scroll_by, increase full_page_scroll_delay, and consider a 5–10 second page delay. Check the output after each change.
Elements overlap, repeat, or appear misplaced	The page layout does not handle a viewport stretched to full height well.	Try full_page_algorithm=by_sections. Inspect sticky headers and other scroll-dependent elements, which can appear differently across sections.
Capture takes too long	Section capture, small scroll steps, long delays, or a very tall page increase work.	Use the default algorithm if it renders acceptably, increase the section height or scroll step where content still loads correctly, and set a maximum height for long pages.
Only the top portion is useful	The page may be infinite-scroll or the resulting image may be too tall for the next tool.	Set full_page_max_height or request slices and process them individually.
Animated content differs between runs	Animation, custom scripts, canvas, or animated images can change over time.	Try reduce_motion=true or reduced_motion=true, then account for remaining dynamic content in the workflow.
HTTP error or no usable image file	The API returned an error response, but the client saved or treated it as an image.	Check the HTTP status and response body before saving. Confirm the endpoint, URL encoding, access key, and option names against the current API docs.
Unexpected content is absent after hiding or blocking	A selector or blocking rule also matched content needed in the screenshot.	Remove the rule or narrow it, then capture again. Compare against a request without content-removal settings.

Full-page rendering has limits: complex pages can remain difficult to capture reliably after tuning. Treat the screenshot as an output to inspect, especially when it is used for visual review, archival, or automated analysis.

9. Performance, reliability, and cost considerations

• Viewport width is a layout choice. A different width can trigger different responsive breakpoints, so use the width that matches the experience you intend to capture.
• Section size and wait time trade speed for loading opportunities. Smaller sections and longer delays can help scroll-triggered content appear, while increasing capture time.
• Cap unbounded pages. A maximum height makes the result more predictable for infinite-scroll pages and limits how much content the next step must handle.
• Choose slices for the consumer. Slicing can make a tall result easier to process, but requires handling multiple pieces and cannot be combined with store=true.
• Expect site-dependent results. Sticky elements, animations, galleries, and scroll-triggered content can behave differently across captures. No single setting guarantees complete rendering on every site.
• Check current pricing separately. The supplied ScreenshotOne documentation establishes request behavior and options, but does not provide pricing figures. Do not infer a per-capture cost from the examples here.

10. Or skip the browser setup

ScreenshotNeo provides a website screenshot API and MCP server. One GET request returns a screenshot or PDF, with options for full-page capture, lazy images, viewport and device settings, element capture, waits, and more. Its parameter names also work with those used by other screenshot APIs to make switching easier. See the ScreenshotNeo documentation for the API options.

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

ScreenshotNeo removes cookie banners, newsletter popups, and chat widgets before the shot. Bot checks, blank pages, failed loads, timeouts, and cache hits are never billed, and response headers say which outcome occurred. Its MCP server lets AI agents use take_screenshot, get_page_info, and capture_pdf. 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.

FAQ

Does full-page capture include content below the initial viewport?

Yes. Set full_page=true. Content that only loads after scrolling may still require scroll and wait adjustments.

Should I use the default algorithm or by_sections?

Start with the default. Try by_sections when stretching the viewport causes layout problems or when scrolling is needed to reveal content, then compare the output and capture time.

Can I capture an infinite-scroll page completely?

There may be no natural end to capture. Set full_page_max_height to bound the result, or use slices if the downstream workflow handles multiple images.

Can I use slices and store the result?

No. ScreenshotOne documents that full_page_slices cannot be combined with store=true.

Will reduce_motion make repeat screenshots identical?

No. It only reduces supported motion; custom scripts, canvas, animated images, and other dynamic content may still vary.

Sources: ScreenshotOne full-page screenshots guide, ScreenshotOne options reference, Getting Started, slice guide, and e-commerce screenshot guide.