How to Take a Full-Page Website Screenshot with Apify

To take a full-page website screenshot with Apify, choose a screenshot Actor in the Apify Store, provide the target URL, and enable that Actor’s full-page option. You can run it in Apify Console or send JSON input to its Apify API endpoint. The input names, output format, and available controls depend on the Actor you choose; there is no single screenshot input schema shared by every Actor.

This guide uses the documented Website Screenshot Capture — Full Page & Custom Viewport Actor as a concrete API example. Apify currently marks that Actor as deprecated, so treat its input and endpoint as an illustration of the API pattern, and choose an active Actor before building a new workflow. For any selected Actor, use its live Input and API pages as the source of truth.

1. Choose an Actor and check its schema

Open the Actor’s Store page and inspect its input schema, output fields, and API example. Confirm that it supports full-page capture and check how it accepts URLs. Some Actors use a singular url; others accept a urls array. Do not mix settings copied from different Actors.

Compare the available options against your task:

Capture mode: full page, viewport, or a selected element, if supported.
Input shape: one URL or a list of URLs.
Output: an image file, a stored file reference or URL, or structured dataset records.
Rendering: viewport size, device preset, image format, lazy-load scrolling, and maximum page height.
Timing: navigation wait condition, extra delay, and per-page timeout.

These are comparison points, not universal Apify options. For example, one Actor documents full-page mode, PNG output, a viewport, a delay, and concurrent-page settings; another documents device presets and lazy-load scrolling. Verify each field on the Actor you actually run. See the Store’s full-page screenshot example for one documented configuration.

2. Run the Actor in Apify Console

Open the chosen Actor in the Apify Store and select its Console run option.
Enter the URL or URLs in the format shown by that Actor’s input form.
Set the full-page capture option. If the Actor offers lazy-load scrolling, enable it for pages that reveal images or sections as you scroll.
Choose the output format and viewport settings the Actor supports. Start with the documented defaults if you do not need a specific device size.
Start the run, then inspect its dataset or output view. Check both the run status and the per-URL result or error field.

A full-page capture is intended to include the page’s scrollable content rather than only the initial viewport. It can still be limited by the Actor’s maximum height, the site’s behavior, or content that appears only after interaction.

3. Run a documented Actor through the API

Programmatic use requires an Apify account and API token. Find the token in Apify Console’s Integrations settings and keep it in an environment variable rather than committing it to source control. The example below matches the documented input and endpoint for wsgcjj/screenshot-capture; that Actor is deprecated, so use the selected active Actor’s ID, input fields, and endpoint in production.

Its documented minimal input is a urls array. The synchronous endpoint waits for the run and returns dataset items as JSON. That response is the Actor’s dataset output; it is not necessarily the screenshot’s raw image bytes. Inspect the chosen Actor’s output schema to find the image file or download URL.

cURL

export APIFY_TOKEN='YOUR_API_TOKEN'
curl --fail-with-body -X POST \
  "https://api.apify.com/v2/acts/wsgcjj~screenshot-capture/run-sync-get-dataset-items?token=${APIFY_TOKEN}" \
  -H 'Content-Type: application/json' \
  -d '{"urls":["https://example.com"]}'

Python

import os
import requests

api_token = os.environ["APIFY_TOKEN"]
endpoint = (
    "https://api.apify.com/v2/acts/"
    "wsgcjj~screenshot-capture/run-sync-get-dataset-items"
)
response = requests.post(
    endpoint,
    params={"token": api_token},
    json={"urls": ["https://example.com"]},
    timeout=300,
)
response.raise_for_status()
items = response.json()
print(items)

Node.js

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

const endpoint = new URL(
  "https://api.apify.com/v2/acts/" +
  "wsgcjj~screenshot-capture/run-sync-get-dataset-items"
);
endpoint.searchParams.set("token", token);

const response = await fetch(endpoint, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ urls: ["https://example.com"] }),
  signal: AbortSignal.timeout(300_000),
});
if (!response.ok) {
  throw new Error(`Apify returned ${response.status}: ${await response.text()}`);
}
console.log(await response.json());

For an asynchronous run, POST to the Actor’s /runs endpoint instead. That returns run information; use the returned run ID and the Actor’s documented run and storage endpoints to check completion and retrieve its dataset. The Apify API page documents both the run endpoint and the synchronous dataset-items endpoint for the example Actor. See its API reference and the current Apify API documentation.

4. Tune full-page capture for real pages

Full-page mode alone does not guarantee that every visible component has finished rendering. Use the Actor’s supported options to match the page:

Lazy-loaded images: enable scroll-to-load or lazy-load handling if available. Otherwise, lower sections may be captured before their images load.
Slow client rendering: use the Actor’s documented wait condition or a modest extra delay. A navigation event such as DOM content loaded does not necessarily mean a client-rendered page is visually complete.
Long pages: check for a maximum capture height. A truncated output may be an intentional limit rather than a failed run.
Device-specific layout: select the intended preset or viewport. Responsive breakpoints can change page length and composition.
Multiple URLs: use the Actor’s documented list input and concurrency setting. Start with low concurrency when pages are large or the target site applies rate limits.
Element capture: if you need one component, use an Actor that documents a CSS selector option. In at least one Actor schema, an element selector takes precedence over full-page capture; confirm how the chosen Actor handles this.

Possible output formats across screenshot Actors include PNG, JPEG, WebP, and PDF, but availability and field names vary. PNG is useful when preserving sharp text or edges matters; compressed formats can reduce stored or transferred file size. Choose based on the Actor’s actual schema and your downstream use.

5. Troubleshooting

Symptom	Likely cause	What to check or change
Input validation error	The JSON field names or types do not match this Actor’s schema.	Copy the input shape from the selected Actor’s Input or API page. Check singular versus plural URL fields and boolean spelling.
Only the first screen appears	Full-page mode is disabled, unsupported, or overridden by an element selector.	Confirm the Actor’s full-page field and check whether another option overrides it.
Images or lower sections are missing	Content loads on scroll or after client-side rendering.	Enable documented scroll-to-load behavior, wait for a relevant selector if supported, or increase the documented delay.
Screenshot ends before the page ends	The Actor may enforce a maximum height, or the page may use unusual scrolling.	Inspect output metadata for height or truncation fields. Check the Actor’s maximum-height option and its handling of nested scroll containers.
Run is slow or times out	The site is slow, the page is long, resources are heavy, or the selected timeout is too short.	Check the Actor’s per-URL timeout and wait settings. Avoid unnecessary delay, and reduce concurrency for large pages.
API returns an authorization error	The token is missing, invalid, or not being sent as the endpoint expects.	Confirm the token in Integrations settings, verify the query parameter or supported authentication method, and avoid including whitespace.
Run succeeds but no image is in the response	The endpoint returned dataset records, not image bytes, or the Actor stores files separately.	Inspect the output schema for a file key, screenshot URL, or key-value-store reference, then retrieve the asset using the documented method.
Actor cannot be started	The Actor may be deprecated, unavailable, or its interface may have changed.	Choose an active Store Actor and check its current API tab and input schema before updating the Actor ID and payload.

6. Performance, reliability, and cost

A full-page image takes more work and storage than a viewport image, especially for long pages and high-resolution output. Batch size, page weight, wait conditions, and concurrency all affect run duration. For repeatable capture, record the Actor ID and input settings alongside the result, inspect per-URL errors rather than treating a completed batch as proof every URL succeeded, and rerun only the URLs that failed.

Apify screenshot Actors are individually published Store tools. Their pricing and billing depend on the selected Actor and its current listing. The research available for this guide does not establish a universal Apify screenshot price or a common billing rule, so check the Actor’s pricing page before running a large batch. For scheduled jobs, also plan how your workflow handles slow runs, temporary failures, and output retention.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. One GET request returns a PNG, JPEG, WebP, or PDF; see the API documentation.

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

Cookie banners are accepted like a visitor and removed before capture; the service also removes known consent platforms, newsletter popups, and chat widgets, with each step configurable. Bot checks, blank pages, failed loads, timeouts, and cache hits are not billed, and response headers identify the page verdict and billing status. Its MCP server lets AI agents use screenshot tools. The free plan includes 1,000 shots each month with no card; paid plans start at $5 for 3,000 shots.

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

FAQ

Does full-page mean one image of the entire site?

It means the Actor attempts to capture the page’s scrollable document in one capture. It does not capture every route on a website, and height limits or page behavior can constrain the result.

Can I capture a list of URLs in one run?

Some Actors accept batch input, while others are designed around one URL. Check the chosen Actor’s schema and concurrency controls.

Will the API response itself be a PNG?

Not necessarily. Some endpoints return dataset items describing the run output. Follow the Actor’s output schema to retrieve its image file or asset URL.

Can I use these exact Apify fields with any screenshot Actor?

No. Actor inputs and output formats are publisher-specific. Copy the full-page field and URL format from the exact Actor you select.