Website Screenshot Generator

Capture public web pages as PNG or JPEG images or A4 PDF files, with viewport, full-page or visible-element controls. Keep saved-file references and capture metadata in a dataset for your own review and reports. Browser output can vary with page timing, country, cookie state and viewport, and a capture is not a certified complete website archive.

Quick start

Start with one known public page and a small batch before adding selectors or broader capture lists. The existing example captures Example Domain and Apify documentation:

{
  "startUrls": [
    { "url": "https://example.com" },
    { "url": "https://docs.apify.com" }
  ],
  "screenshotType": "fullPage",
  "outputFormat": "png",
  "viewport": {
    "width": 1366,
    "height": 768,
    "deviceScaleFactor": 1,
    "isMobile": false
  },
  "waitUntil": "auto",
  "delayMs": 1000,
  "hideSelectors": [".cookie-banner"],
  "maxFullPageHeight": 20000,
  "captureTimeoutSecs": 60,
  "maxRetries": 2,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

Prefer a video guide? This short Apify walkthrough shows you how to set up and run an Actor. It uses a different Actor, but the setup steps are the same.

Ready-to-run examples

Open an example, review the input, and run it as-is or adjust the URLs:

• Full-page website screenshot: Capture a whole public page as a PNG.
• CSS selector element screenshot: Capture a specific visible page element.
• Web page to PDF capture: Save public pages as PDF files.

What you get

Successful captures have a saved screenshot or PDF in the run's key-value store and a dataset row containing its key, record URL and page context. Failed attempts have error information instead of a successful-file claim. Full-page images are clipped at the configured height, 3840 CSS-pixel width or 8-million-physical-pixel safety cap, whichever applies first, with truncation and original document height reported.

Who is it for?

• Frontend and QA teams collecting visual evidence for their own release comparisons.
• Marketing teams retaining dated public landing-page observations.
• Agencies and researchers preparing source-linked screenshot or PDF material for reports.
• Automation developers passing saved capture files and outcome metadata into existing workflows.

How you can use the data

• Prepare a release comparison baseline. Capture the same known public page before and after a change using consistent viewport and timing settings. Store both files and capturedAt in your destination, performing the visual comparison yourself rather than expecting a built-in regression verdict.
• Review a mobile or dark-mode view. Set the documented viewport and preferred color scheme, then inspect the actual saved image. Sites must honor the requested scheme, and viewport emulation does not certify behavior on every physical device.
• Capture a visible content region. Use a known selector such as main and an optional wait selector, reviewing errors when it is absent or not visible. Hiding known overlays changes the capture appearance without submitting consent choices or modifying the source website.
• Save a documentation PDF for a report. Select PDF and retain pdfKey, pdfUrl, finalUrl and collection time. PDF ignores screenshotType and selector and keeps the complete document rather than silently dropping pages. PDF files over 32 MiB are rejected without retry or a successful-capture charge. A long full-page image can instead be clipped, so choose the output appropriate for your report.

Input settings

Setting	JSON key	Use it for	Example
Page URLs	startUrls	Required list of 1–1000 public HTTP/HTTPS page URLs.	[{"url":"https://example.com"}]
Screenshot type	screenshotType	Capture viewport or fullPage images. Ignored for PDF output.	fullPage
Output format	outputFormat	Choose png, jpeg, or pdf.	png
Viewport	viewport	Set browser width, height, device scale, and mobile mode.	{"width":1366,"height":768,"isMobile":false}
Wait until	waitUntil	Automatic content/image checks (new omitted-input default), or an explicit page milestone.	auto
Extra delay in milliseconds	delayMs	Wait after load for animations or late-rendered widgets.	1000
Element selector	selector	Capture only the first matching visible element for image output.	main
Wait for selector	waitForSelector	Wait until client-rendered content becomes visible.	.results
Hide elements	hideSelectors	Hide matching overlays before capture.	[".cookie-banner",".sticky-ad"]
JPEG quality	jpegQuality	Set JPEG quality from 1 to 100.	85
Color scheme	colorScheme	Emulate light, dark, or no-preference.	dark
Maximum full-page height	maxFullPageHeight	Set a CSS-pixel height ceiling. Full-page images also obey width and physical-pixel safety caps.	20000
Timeout per page	captureTimeoutSecs	Bound each navigation and capture attempt.	60
Retries per page	maxRetries	Retry transient proxy, navigation, and rendering failures.	2
Capture time budget	runTimeSecs	Bound browser work and retain completed results when time runs out. A separate 585-second lifecycle watchdog fails stalled initialization, storage or shutdown.	570
Maximum concurrent pages	maxConcurrency	Requested upper bound. The current safety ceiling is one active page, including saving its file.	2
Proxy configuration	proxyConfiguration	Managed proxy by default. Existing customer proxies and explicit direct settings are respected, without a paid fallback.	{"useApifyProxy":true}

Output data

The existing illustrative Example Domain row shows shape rather than a fresh capture:

{
  "url": "https://example.com/",
  "finalUrl": "https://example.com/",
  "statusCode": 200,
  "title": "Example Domain",
  "screenshotKey": "0001-example-com.png",
  "screenshotUrl": "https://api.apify.com/v2/key-value-stores/STORE_ID/records/0001-example-com.png",
  "pdfKey": null,
  "pdfUrl": null,
  "width": 1366,
  "height": 768,
  "fullPageHeight": 768,
  "truncated": false,
  "format": "png",
  "capturedAt": "2026-07-03T10:00:00.000Z",
  "error": null
}

The Actor saves screenshots/PDFs in the default key-value store and writes dataset rows for completed captures or final page errors. URLs not started before a time or charge limit do not receive a fabricated row. Check RUN_SUMMARY alongside the dataset. A hard lifecycle timeout fails the run rather than reporting successful emptiness. Previously saved files and rows remain available, but a final summary or in-flight storage/billing operation may be incomplete; check the run status too.

Field	Description
url	Requested public URL
finalUrl	Final browser URL after redirects
statusCode	HTTP response status code when available
title	Browser page title
screenshotKey	Key-value store key for PNG/JPEG captures
screenshotUrl	API URL for the saved screenshot record
pdfKey	Key-value store key for PDF captures
pdfUrl	Direct API URL for the saved PDF record
width	Captured rectangle width in CSS pixels. Image-file pixels also reflect device scale.
height	Captured rectangle height in CSS pixels. Image-file pixels also reflect device scale.
fullPageHeight	Original measured document height in CSS pixels for full-page image requests
truncated	Whether a full-page image was clipped by the height, width or physical-pixel safety cap
format	Output format: png, jpeg, or pdf
capturedAt	ISO timestamp for the capture attempt
error	Error message when capture failed

Download your results

Open your run's dataset, choose Export and select JSON, CSV or Excel. JSON keeps nested fields together. CSV and Excel are useful when you want to review the records in a spreadsheet.

See Apify's download and export guide for the available formats and field options.

Pricing

This Actor uses pay-per-event pricing. The start event is charged once when a run starts, and the capture event is charged once for each screenshot or PDF that is successfully saved. Failed capture attempts are not charged as successful captures.

Until 19 November 2026, the run-start fee is $0.005 and platform usage is charged separately. From 19 November 2026 (00:00 UTC), the run-start fee is $0.031 and platform usage is included in the event prices below.

Apify plan	Per capture until 19 Nov	Per capture from 19 Nov
Free	$0.008	$0.035
Bronze	$0.0075	$0.032
Silver	$0.0072	$0.029
Gold	$0.007	$0.026
Platinum	$0.0068	$0.026
Diamond	$0.0066	$0.026

The run-start fee applies even when no capture succeeds. Failed captures do not incur a capture fee. See the live Apify Pricing tab for the effective rates and billing terms.

Tips for best results

• Start with one URL: Confirm the site renders correctly before adding a large list.
• Use Automatic first: The default starts at DOM readiness, verifies visible content and important visible images, and prepares lazy content with bounded scrolling for full-page images and PDFs. Explicit domcontentloaded, load and networkidle settings remain available; saved/API inputs specifying a mode keep that choice.
• Add a small delay: Use delayMs for animations, cookie banners, or client-rendered content.
• Prefer a selector for app content: waitForSelector is more predictable than a long fixed delay.
• Hide known overlays: Add their CSS selectors to hideSelectors. The Actor does not try to guess consent choices.
• Use smaller captures for demanding pages: The default run memory is 2048 MiB. One page is active at a time for safety. Lower viewport dimensions or device scale to reduce image memory. For very heavy full-page captures involving thousands of requests or multi-thousand-pixel pages, set run memory to 4096 MiB; one known input peaked at approximately 2.2 GB.
• Use the default connection: Managed proxy is the existing default for cloud captures. Managed browser requests use a stable proxy session within each capture attempt and HTTP/1.1. A retry uses a fresh session within the same configured pool and country; retry counts, requested readiness and resource limits are unchanged. Direct access may fail in the cloud. Country, proxy groups and customer proxy settings remain configurable, and Direct and customer proxy pools keep their existing transport.
• Check the key-value store: Screenshot and PDF files are stored there. The dataset keeps their keys and URLs.
• Check RUN_SUMMARY: It reports requested, successful, failed, and time-budget-stopped counts for automation.

Limits and caveats

• The actor captures public HTTP/HTTPS pages.
• Private, loopback, link-local, and reserved network destinations are rejected, including redirects and browser subrequests.
• Private, login-gated, paywalled, or bot-blocked pages may fail or show limited content.
• With Automatic readiness, a page that answers with an interim security check (HTTP 202) or a non-retryable client error such as 403 or 404 fails promptly with that status and is not retried or charged. HTTP 429 rate limits, server errors and connection timeouts still use the configured bounded retries. A retry must reach verified useful content before a capture is saved or charged.
• CSS selector captures require the target element to be visible within the timeout.
• PDF output ignores screenshotType and selector.
• Images are limited to 8,000,000 physical pixels, including the square of deviceScaleFactor. Full-page images are clipped at that budget, 3840 CSS-pixel width or maxFullPageHeight, and return truncated: true when clipped. Oversized viewport requests reject before browser work. Oversized element captures return a per-page error without encoding or retrying. A single measured rectangle is captured, so later page growth cannot expand the image buffer.
• Only one browser page is active at a time, including navigation, encoding and file persistence, even when the requested maxConcurrency is higher. This safety ceiling can make batches slower. Image caps do not bound arbitrary page DOM, downloaded resources or PDF layout memory. Large pages and PDFs can still exhaust browser memory.
• Automatic preparation scrolls at most 12 steps for at most 15 seconds within existing capture/run deadlines and the image capture rectangle, then restores the original scroll position. PDFs use a separate bounded preparation distance and retain complete-document output. Infinite feeds, delayed embeds, CSS backgrounds and content outside the prepared area may remain incomplete. Rows expose automaticPreparation and warnings for unfinished lower images, scrolling limits and capture before full page load. A verified capture does not prove every resource or lazy section finished.
• Each page attempt is limited to 2,000 browser requests for Automatic and networkidle, or 1,000 for other explicit modes, and the remaining run time. Exceeding either budget closes that page promptly and returns an error without retrying or charging for an unverified capture. Other pages can still proceed. Persistent background traffic can prevent networkidle. After its full navigation timeout, a successful matching main HTTP 200–399 response that reaches page load may still be captured with a clear warning. Rows report requestedWaitUntil, usedWaitUntil, readinessFallback and warnings; RUN_SUMMARY counts successful fallback captures and the final status message highlights them. If the bounded page-load wait also times out, image output on /products/SLUG pages can use DOMContentLoaded only with a matching current main HTTP 200, a visible h1.title matching both slug words and the page title, and a visible loaded image at least 200×200 pixels. Missing/wrong headings, unloaded images and detected challenge pages reject this narrow fallback. Product content and document identity are checked again after the configured delay. PDF and unrelated pages do not use this DOM fallback. The warning explicitly identifies incomplete background/lazy content: truncated: false means the raster was not clipped, NOT that every review, image or lazy section loaded. Neither fallback proves network idle or complete content. Selector checks and extra delay still apply. Main navigation/access failures, crashes, closed pages, request/deadline limits and storage/billing failures are not converted to successful fallback. On non-Pinterest pages, only fetch submissions to the exact Pinterest advertising-conversion endpoint https://ct.pinterest.com/v3/ are canceled to avoid stalled nonvisual tracking responses. Pinterest images, scripts, frames and other endpoints remain available; captures of Pinterest itself keep all its requests. For networkidle, readiness requires the main document to reach DOMContentLoaded and all page-frame requests to finish or fail, followed by at least 500 ms without network activity within the original navigation timeout. A stale browser-library lifecycle flag does not extend that timeout. If real requests remain pending at timeout, only the explicitly warned load or narrowly gated product-content fallback described above is possible. Visible frames, page widgets and analytics frames retain their requests.
• Batches whose post-load delays alone cannot fit the processing budget (run time minus a five-second reserve) finish successfully without captures, DNS checks, proxy setup or capture-event billing. The run status message and RUN_SUMMARY explicitly warn that no captures were attempted, with invalidInput: true and a corrected recipe; this is not capture success. For example, 80 unique pages with a 30-second delay require at least 2,400 seconds of delays, exceeding the default 570-second budget. Split the URLs into smaller runs or reduce delayMs; no URLs are silently dropped and higher concurrency does not bypass the one-page ceiling. Admission is not a completion guarantee: navigation, rendering and storage also need time.
• A batch can finish with partial results when individual pages fail or time or charge limits stop further work. If no capture budget remains before browser work starts, the dataset stays empty and RUN_SUMMARY reports the charge limit.
• Invalid configuration, essential storage or billing failures still fail the run, even after some useful output was saved. Navigation failures are not proof that a page is private or deleted. If every attempted page fails, the run fails.
• Very request-heavy pages may be stopped with an explicit capture error rather than presented as verified complete captures.
• Restarts and resurrection do not replay an already started run. Existing saved output remains available. Start a new run for another capture.
• Some sites render different content by country, cookie state, viewport, or bot detection.

This actor captures publicly accessible web pages.

Use screenshots and PDFs responsibly, follow the target website's terms, Apify's terms, and applicable laws, and do not use the actor to bypass access controls.

Privacy and data handling

This Actor runs with Apify limited permissions and only processes data needed for the documented run. It uses the inputs you provide and the public records needed to produce the documented dataset to produce the output dataset and sends requests to the website URLs you provide. Results are stored in Apify run storage for your account. FetchCat does not use your inputs or outputs for advertising, does not use them for model training, and does not retain them outside the Apify run except for transient support debugging when you explicitly share run details. You are responsible for using the Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs.

Automation and integrations

Save your settings for next time

Once you have an input that works for you, save it as an Apify task. This keeps your settings together so you can use them again without filling in the form from scratch.

Run on a schedule

Need fresh results regularly? You can schedule the Actor or a saved task to run at a time that suits you.

Each scheduled run collects the data again. If you want to compare results or highlight changes, add that step in your own workflow.

Send results to your other tools

Use n8n, Make or Zapier to connect this scraper to the rest of your workflow. For example, you could pass its results to an AI assistant or add records to a spreadsheet. Follow the Apify integration guides for your chosen tool.

For a custom connection, an Apify webhook can notify your app when a run finishes or fails. Your app can then fetch the results or handle the failure.

API usage

Want to collect this data from your own app or automation? The examples below send input to the scraper and show how to collect its results.

The Node.js and Python examples wait for the run to finish before reading its results. The cURL example starts the run and returns its details. Wait for that run to finish, then use its defaultDatasetId to fetch the results.

For setup instructions, see Apify's JavaScript client guide, Python client guide and Actor runs API reference.

cURL

curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~website-screenshot-generator/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://example.com"}],"screenshotType":"fullPage","outputFormat":"png"}'

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/website-screenshot-generator').call({
  startUrls: [{ url: 'https://example.com' }],
  screenshotType: 'fullPage',
  outputFormat: 'png'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("fetch_cat/website-screenshot-generator").call(run_input={
    "startUrls": [{"url": "https://example.com"}],
    "screenshotType": "fullPage",
    "outputFormat": "png",
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)

MCP and AI agents

You can ask your AI assistant to collect data with Website Screenshot Generator and help you work with the results. The scraper returns the data, and your assistant can then summarize it, compare records or prepare notes.

Connect your assistant through the Apify MCP server. MCP gives your assistant a way to find this scraper, run it and read the results. Follow the official setup and sign-in guide for your app.

Easier setup with an Apify plugin

If you use a supported coding assistant, the official Apify plugin can set up the connection for you. It connects your assistant to Apify and includes instructions for common tasks. Follow the guide for your particular app.

Use Apify AI in Console

Prefer to keep everything in Apify? Open Apify AI in Console and ask it to find Fetch Cat's Website Screenshot Generator. You can describe the data you want and ask questions about the results.

Apify AI is currently in beta. It asks for confirmation before starting an Actor, and normal run charges apply.

Choose your assistant

• Claude and Claude Code (Anthropic): Apify setup guide.
• ChatGPT and Codex (OpenAI): Apify setup guides.
• Grok Bot (xAI): Apify plugin guide.
• Gemini CLI (Google): MCP server setup guide. Use the server URL below with the HTTP configuration supported by Gemini CLI.

Connect just this scraper

To keep your setup focused on this scraper, add this server configuration to a compatible MCP client:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/website-screenshot-generator"
    }
  }
}

Sign in to Apify when your client asks. If your client uses a Bearer token instead, follow its setup guide and keep the token in its secure configuration. Configuration formats vary by app, so use the linked guide if your client needs a different format.

Use Apify's general server

Already connected to the general Apify MCP server at https://mcp.apify.com? You can use it to find this scraper without adding another server. Ask your assistant to use Website Screenshot Generator by Fetch Cat, or give it the identifier fetch_cat/website-screenshot-generator.

Your assistant can check the available settings and retrieve the results from the returned run. If the run is still working, it should follow that run rather than start it again. Both connection options use Apify's hosted service.

Example requests

• “Use Fetch Cat’s Website Screenshot Generator to collect one full-page PNG capture of https://example.com with the existing 1366 by 768 viewport and load milestone. Keep the saved-file URL and any truncation or error rather than claiming a complete archive.”
• “Collect one PNG capture of the first visible main element at https://example.com, waiting for main before capture. Keep failure details if the selector is unavailable instead of guessing an element.”
• “Retrieve a PDF capture of https://docs.apify.com with the load milestone. Keep the saved PDF reference, final URL and capture time without expecting an element-only or screenshot-type setting to affect the PDF.”

Normal Apify charges apply. Check the live Pricing tab before asking your assistant to run a larger batch.

Pay with x402

If your AI agent has a funded wallet, it can pay for Apify usage through x402. This experimental option lets an agent use Apify without a conventional account.

Apify AGI provides a prepaid API token with a spending cap after payment. Your agent can use that token to run this scraper through the Apify API or an authenticated MCP connection.

Some MCP setups also support paying for each request directly. That is a different payment option, so check the official guide for its availability.

Follow the official guide for wallet setup, supported payment options and current terms. Apify handles the payments. Keep wallet keys and payment tokens in your agent's secure configuration.

Other ways for agents to pay

Apify also supports MPP for prepaid access through AGI and Skyfire for eligible Actors. If your agent already uses one of these, see the agentic payment guide to choose the right setup.

FAQ

Are the image and PDF files downloadable?

Yes. Each successful row includes screenshotUrl or pdfUrl, and the file also appears in the run's key-value store.

Can it capture mobile and dark-mode pages?

Yes. Set a mobile viewport and isMobile: true. Use colorScheme: "dark" for sites that honor the preferred color scheme.

Are failed pages charged as successful captures?

No. The capture event is charged only when the output file and its dataset row are saved successfully. The one-time run-start charge still applies.

Why was a full-page image truncated?

The page exceeded maxFullPageHeight. The row reports the measured fullPageHeight and returns truncated: true so automation can identify the clipped image.

Can cookie banners always be removed automatically?

No universal method can reliably remove every consent interface. Add the site's known CSS selectors to hideSelectors for a deterministic capture.

Related Actors

Explore related actors from the same Apify account:

• Website Content Crawler Lite — Collect text, Markdown, HTML, metadata and discovered links from public website pages.
• Web Page to Markdown Extractor — Convert public web pages into Markdown, readable text and available page metadata.
• Website Contact Finder — Find published email, phone and social profile links on known public company websites.
• Google News Scraper — Collect public Google News feed headlines, dates and links.
• Bing SERP & Search Results Scraper — Collect public Bing web-search result titles, snippets and links.

Support and feedback

For custom additions or integrations, email hello@fetchcat.dev.

Found an error or have a feature request? Open an issue with the run URL, a non-sensitive input example and what you expected.

Need help sharing it? See Apify’s guide to sharing a run when reporting an issue. Sharing a run can give the developer access to its input, logs and results, so use a run that contains no sensitive data. Please leave out API tokens, passwords, cookies, private documents and personal data. Use a public sample URL or a redacted example instead.

Tried this scraper? We'd love to hear how it worked for you. Leave a review to help others choose the right tool and help us improve it. Your feedback means a lot to us.

Made with care for curious people, AI agents and the possibilities in data. ♥