Apify Website Screenshot Actor Review: Limits, Output, and Setup

Short answer: Apify’s official Website Screenshot Generator is the apify/screenshot-url Actor. You give it one or more page URLs, start a run, then find screenshot files in a Key-Value Store and rows with page metadata and file links in a dataset. Its project README calls it a simple example Actor. It can suit occasional captures or a workflow you want to adapt; for more advanced crawling and rendering requirements, the project points users to Website Content Crawler. Read the official project README.

This review covers that official Actor only. Apify also has a distinct community-maintained Actor named i-scraper/website-screenshot; its listing and pricing do not describe apify/screenshot-url.

1. What the official Actor does

The Actor opens a specified web page in a headless browser and saves a screenshot. The README describes scheduling screenshots to track changes, exporting structured metadata, and using the platform’s APIs, SDKs, webhooks, and workflow integrations.

The project explicitly describes Website Screenshot Generator as a simple Actor primarily intended as an example. That matters when evaluating fit: the README does not promise a particular success rate, browser version, maximum page height, login flow, fixed timeout, or output size. Check the live Actor input tab and current platform documentation for details before relying on a setting or limit.

2. Setup: run a screenshot in the Apify Console

Create an Apify account and open the Website Screenshot Generator Actor page.
Enter one or more web page URLs in the input form. The project README also describes input for whether to scroll to the bottom of a page and the delay before capturing.
Review the live input tab for exact field names, accepted values, and any additional current options. Do not assume undocumented defaults.
Start the run and wait for it to finish. The Actor saves image files to Key-Value Store and pushes file links plus page metadata to a dataset.
Inspect the dataset, then download the file from the linked Key-Value Store record or export results. The README lists JSON, XML, CSV, Excel, and HTML exports.

For a first run, use a public URL you control or a page that does not require authentication. Check that the resulting file is a valid image and that the dataset row points to the matching stored record.

3. Input options and practical limits

The documented core input is one or more URLs. The README mentions two capture controls:

Scroll to the bottom: useful when content appears farther down the page. The source does not specify the scrolling algorithm or guarantee that every lazy-loaded element will finish rendering.
Delay before capture: useful when a page needs extra time after navigation. The README does not state a default, unit, maximum, or guarantee that a fixed delay handles every dynamic page.

Other input parameters may exist; consult the current Actor input tab. The inspected project documentation does not establish viewport dimensions, image format or quality settings, selector capture, authentication support, cookie controls, proxy configuration, concurrency, retries, or timeout guarantees. Treat those as unknown unless the live interface or current documentation explicitly confirms them.

A URL that depends on a logged-in session, a consent interaction, a client-side application booting slowly, or a site’s bot checks may not produce the result you expect. The README’s reference to using the Actor on many websites is not a guarantee for every site or a promise that access restrictions can be bypassed.

4. Where screenshots are saved and what output contains

The image itself is stored as a file in a Key-Value Store. A dataset holds page metadata and links to the stored screenshot. In the project README’s example, a row has these fields:

startUrl: the URL submitted as the starting page.
url: the page URL associated with the result.
screenshotUrl: a URL pointing to the stored screenshot record.
screenshotKey: the record key for locating the file in the store.

The URL shown in the repository is an example, not a link to your run. Use the dataset returned by your own run to find the right record. Keep the dataset metadata and image file conceptually separate: a metadata export is useful for indexing and downstream processing, while the stored record is the actual screenshot.

5. Run it programmatically with Apify

The official README documents API access and links to the Apify Node.js and Python clients. Its overview does not provide a verified, complete request body or current SDK method signature for this particular Actor, so avoid copying guessed field names into production. The safe workflow is to take the input schema from the live Actor page, pass it to an Actor run using the current API reference or supported client, then read the run’s dataset and Key-Value Store identifiers from the returned run information.

In the Console, open the Actor’s API or integrations documentation and use its generated example for the current input schema. Store your Apify token in an environment variable or secret manager, never in source control. Apify describes its platform as providing REST API endpoints for running Actors and accessing datasets and other run resources; see the Apify Actors documentation and the API reference.

The project also lists webhooks and integrations such as Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, and Google Drive. Availability and terms for integrations can change; confirm them in the current Apify interface. The README describes MCP usage through Apify’s MCP tab, where an SSE session provides a session ID for messages that start the Actor.

6. Cost: free Actor, paid platform usage

The project README says the Website Screenshot Generator is free to use, while Apify platform usage is charged according to the user’s plan. It gives no fixed total cost per run. Your actual bill therefore depends on current plan terms and resource use; check Apify’s current pricing and the run configuration before budgeting. The README does not support quoting a fixed per-screenshot price for apify/screenshot-url.

Do not confuse this with the separate i-scraper/website-screenshot community listing, which has displayed a starting price per thousand results. That listing is a different Actor, and its price must not be attributed to Apify’s official example.

7. Fit: when this Actor is enough

Need	What the documented Actor offers	Decision
A basic capture of one or more pages	URL input, run in Apify, image files in Key-Value Store	A reasonable first option; validate output for your pages.
Metadata with links to image files	Dataset rows and structured export formats	Useful for downstream processing and indexing.
Scheduled captures or workflow automation	README describes scheduling, APIs, webhooks, and integrations	Check current setup and platform cost for your schedule.
Advanced crawling, rendering strategies, cookie-banner handling, or extensive customization	Project recommends Website Content Crawler for these broader needs	Evaluate that Actor and verify its current options and cost separately.

The README describes Website Content Crawler as having more sophisticated crawling options, adaptive anti-scraping and rendering strategies, automatic cookie-banner closing, and extensive customization. These are project descriptions, not guarantees that a particular site will render successfully or that restrictions will be overcome. The sources provide no benchmark or price comparison between the two Actors.

8. Troubleshooting

Symptom	Likely cause	What to check
No screenshot record appears	The run did not complete successfully, or the input URL was invalid or inaccessible.	Inspect the run status and logs, confirm the URL is public and correctly formed, then try one URL.
Screenshot looks incomplete	Content may load after the capture or below the initial viewport.	Try the documented scroll-to-bottom or delay input, if present in the current input form. Recheck dynamic pages individually.
Dataset has a row but the image is missing	The row contains a reference to a stored file; the record key or store may be wrong, or access may differ from expectations.	Use the run’s own `screenshotKey` and Key-Value Store. Do not reuse the README’s illustrative URL.
Export contains metadata but not image bytes	Dataset exports represent rows and links; screenshot files live in Key-Value Store.	Download the screenshot record separately using the file reference.
Page shows a consent overlay or bot check	The page may require interaction or restrict automated access; the basic Actor documentation does not promise consent handling or successful access.	Check whether the page permits automated access and evaluate a tool with the handling options your workflow requires.
Unexpected platform charge	The Actor is free, but Apify platform usage is plan-dependent.	Review current plan pricing and run resource usage; do not infer a fixed price from the Actor being free.

9. Performance and reliability considerations

The project materials provide no numerical performance benchmark, success rate, or uptime commitment for this Actor. For a reliable workflow, test representative pages, including the slowest and most dynamic ones; inspect actual run logs and output; and avoid assuming that a delay or scroll setting guarantees all content is ready. When scheduling captures, retain enough metadata to identify the requested URL and corresponding screenshot record, and monitor failed or incomplete runs through the platform tools you configure.

For larger workflows, run a small sample first and estimate platform usage from observed runs and current plan pricing. The dossier does not establish the Actor’s concurrency or retry behavior, so confirm those limits in current documentation rather than building around assumed throughput.

10. Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. One GET request can return an image or PDF; its clean-capture options accept cookie and consent banners and remove more than 60 known consent platforms, newsletter popups, and chat widgets before capture, with each step configurable. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed as clean shots. Response headers report the page verdict and billing status. Its MCP server provides take_screenshot, get_page_info, and capture_pdf for AI agent workflows.

See the ScreenshotNeo API documentation. This cURL example saves a WebP screenshot of Stripe:

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

The same GET request in Python:

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
r.raise_for_status()
open("shot.webp", "wb").write(r.content)

And Node.js:

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', Buffer.from(await res.arrayBuffer())));

Cookie banners, popups, and chat widgets are removed before the shot. Bot checks, blank pages, and failed loads are never billed. An 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. Create a free ScreenshotNeo account.

11. FAQ

Is Website Screenshot Generator the same as Website Content Crawler?

No. The README presents the screenshot generator as a simple example Actor and recommends Website Content Crawler for more advanced crawling and rendering needs.

Does the Actor save screenshots in the dataset?

The image file is in Key-Value Store. Dataset rows provide metadata and links or keys for locating the file.

Is each screenshot free?

The Actor is described as free, but platform usage is chargeable according to the current Apify plan and resource usage.

Does the README state a maximum screenshot size or timeout?

No fixed values for those limits are established in the inspected project README. Check the live Actor input and current platform documentation.