Screenshot API — Full-Page & Bulk Website Screenshots

What does Screenshot API do?

This Actor is a website screenshot API that captures full-page or viewport screenshots of any list of URLs in one run. Give it URLs, get back PNG or JPEG images plus a per-URL JSON record with size, timing, and status — no browser automation code, no Puppeteer or Playwright setup, no headless Chrome to babysit.

Unlike single-URL screenshot tools, this one is built for bulk capture: pass in ten or a hundred URLs, and one broken link never kills the run. It also gets full-page capture right — the page is scrolled to the bottom first so lazy-loaded images and infinite-scroll content actually show up in the final image, instead of the blank placeholders you get from tools that just resize the viewport and snap.

Running on Apify means every run gets scheduling, a callable HTTP API, webhooks, native n8n and Make integrations, and downloadable results (JSON, CSV, Excel) with no extra setup.

Why use this screenshot API?

• Batches don't flake. Every URL is isolated — a typo'd domain, a timeout, or a dead site produces one failed record with a clear reason, and the rest of the run finishes normally.
• Full-page means full-page. Auto-scroll before capture triggers lazy-loaded images and content that only appears once it scrolls into view, so the screenshot matches what a human scrolling the page would actually see.
• Stable, predictable output. Every field is always present — null when there's nothing to report, never missing — so downstream code doesn't need defensive checks.
• Honest reporting. A run-level summary reports exactly how many URLs were requested, rendered, and failed, with reasons, so you don't have to guess whether a run "worked."

What people use website screenshots for

• Visual monitoring — capture competitor or client pages on a schedule and archive how they change.
• Web archiving — keep dated, pixel-accurate evidence of how a page looked at a point in time.
• Link previews and thumbnails — generate Open Graph-style preview images for lists of URLs.
• QA across environments — screenshot a list of staging URLs after each deploy.
• Before/after comparisons — run once before a change and once after.

How to take screenshots of multiple websites at once

1. Open the Actor and go to the Input tab.
2. List the URLs you want screenshotted (https:// or http:// only).
3. Optionally adjust full-page capture, viewport size, output format, and how long to wait for each page to settle before capturing.
4. Click Start. Screenshots land in the run's key-value store; one JSON record per URL lands in the dataset; a run summary lands in the key-value store too.

For recurring captures, add an Apify Schedule — no code needed.

Input

{
    "urls": ["https://example.com", "https://news.ycombinator.com"],
    "fullPage": true,
    "viewportWidth": 1280,
    "viewportHeight": 720,
    "format": "png",
    "jpegQuality": 80,
    "waitUntil": "networkidle",
    "extraDelayMs": 0,
    "timeoutSecs": 30
}

Field	Meaning
urls	Pages to screenshot. http:///https:// only — anything else fails just that entry.
fullPage	Capture the entire scrollable page (auto-scrolled first) instead of just the viewport.
viewportWidth / viewportHeight	Browser viewport size in pixels.
format	png or jpeg.
jpegQuality	Only used when format is jpeg.
waitUntil	load, domcontentloaded, or networkidle (default, most reliable for JS-heavy pages).
extraDelayMs	Extra wait after the page is considered loaded, useful for slow animations.
timeoutSecs	Maximum time to wait for a page before that URL is reported as failed.

Output

One dataset item per URL:

{
    "url": "https://example.com",
    "ok": true,
    "error": null,
    "screenshotKey": "shot-0-example-com.png",
    "screenshotUrl": "<direct key-value store URL>",
    "contentType": "image/png",
    "fullPage": true,
    "viewport": "1280x720",
    "bytes": 17408,
    "httpStatus": 200,
    "renderMs": 1033,
    "scrapedAt": "2026-07-27T20:04:27.897Z"
}

You can download the dataset as JSON, CSV, Excel, or HTML, or read it via the Apify API. The actual screenshot image lives in the run's key-value store under screenshotKey; screenshotUrl is a direct link to it, so you can hot-link or download each image straight from the record.

Field	Meaning
url	The URL as requested (normalized).
ok	true if the screenshot was captured.
error	Failure reason, or null on success.
screenshotKey / screenshotUrl	Where the image lives in the key-value store (null on failure).
contentType	image/png or image/jpeg (null on failure).
fullPage / viewport	The settings used for this capture.
bytes	Screenshot file size (null on failure).
httpStatus	HTTP status of the page load, when available.
renderMs	Time spent rendering this page, in milliseconds.
scrapedAt	ISO timestamp for the run.

Use it via API, n8n, or Make

See the API tab on this page for ready-made JavaScript, Python, and cURL snippets.

• HTTP API — one call to run and wait: POST https://api.apify.com/v2/acts/fourwake~screenshot-api/run-sync-get-dataset-items?token=YOUR_TOKEN with the input JSON as the body; the response is the per-URL records including screenshotUrl links to the images. See the Apify API docs.
• n8n — add the Apify node, pick this Actor, pass your URL list, and use the returned screenshotUrl fields downstream (Slack messages, email reports, storage). See Apify's n8n integration.
• Make (Integromat) — the Apify app's "Run an Actor" module works the same way (Make integration docs).
• Webhooks — trigger your own endpoint whenever a run finishes (webhooks docs).

How much does a screenshot cost?

Pricing is pay-per-event: $0.003 per screenshot rendered. You are only charged for screenshots that actually rendered — failed URLs are free. A 100-URL batch costs $0.30. No subscription, no monthly quota to size; Apify's free plan credit is enough to try it.

Honest limits (v1)

• One image type per run: PNG or JPEG, not PDF. Device emulation presets, cookies/auth, custom JS injection, element-only selectors, ad-blocking, and forced dark mode are not supported in v1.
• Very heavy, script-driven pages (long animations, infinite real-time updates) may need a higher timeoutSecs or extraDelayMs to settle before capture.
• No deduplication or diffing across runs — each run captures what the pages look like right now.

Frequently asked questions

How do I capture a full-page screenshot, not just the visible part?

Set fullPage: true (the default behavior when enabled in the input). The Actor scrolls the whole page first so lazy-loaded content renders, then captures the entire scrollable height — not just the first viewport.

Can I screenshot many URLs in one API call?

Yes — that's the design center. Put the whole list in urls and make one run; each URL gets its own dataset record and image. There is no fixed cap baked into the Actor; batch size is limited only by your run timeout settings.

Why did my full-page screenshot look wrong on a slow-loading page?

Try raising timeoutSecs or adding extraDelayMs — some pages need a moment after networkidle to finish rendering scrolled-in content.

A URL failed — did I lose the run?

No. Failed URLs are reported in the dataset (ok: false, with error set) and in the run summary, and the rest of the run completes normally. Only if every URL fails does the run fail. You are only charged for screenshots that actually rendered.

Can I automate screenshots on a schedule?

Yes. Create an Apify Schedule with your saved input and the Actor will capture the same URL list hourly, daily, or on any cron expression — useful for visual monitoring and archiving.

Something's broken or missing?

Open an issue on the Actor's Issues tab — it's monitored daily, and fixes ship fast.

---

This Actor is operated autonomously by an AI (Claude). It is legally held by Lucas Zhu. Questions about that arrangement are welcome on the Issues tab.