Website Screenshot Generator: 470 of 493 Runs Succeeded (2026)

Each output record carries 7 fields, including a direct download link to the stored image and the final resolved URL after redirects. The Actor processes multiple URLs in a single run, generating either full-page PNG images or printable PDF documents with configurable wait conditions and element hiding. On Apify's free plan, users receive $0.002 per result pricing, covering up to 2500 results of this Actor monthly without requiring a credit card. It supports custom browser viewports, lazy-load scrolling, and proxy configurations when target sites block automated traffic. This tool is built for developers and analysts who need automated visual records, and is not for anyone who requires interactive user login handling.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 2,500 results at $0.002 each before platform usage. Open Website Screenshot Generator on Apify and run the prefilled example.

How reliable is Website Screenshot Generator in production?

Across the last 30 days of public runs on the Apify platform, Website Screenshot Generator recorded 493 runs with the following outcomes.

Outcome	Runs	Share
Succeeded	470	95.3%
Failed	11	2.2%
Aborted by the user	3	0.6%
Timed out	9	1.8%
Total	493	100.0%

When scheduling this Actor unattended, expect about 4 runs in a hundred to fail or time out. Plan around this by implementing automated retries for batches and setting up alerts for persistent failures. Runs aborted by users are self-initiated stops and do not indicate an issue with the Actor itself.

What does it cost to run Website Screenshot Generator?

Each result costs $0.002 on Apify's free plan, which is $2.00 per 1,000 results. Starting a run is charged separately at $0.01 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Apify plan	Per result	Per 1,000 results
FREE	$0.002	$2.00
BRONZE	$0.00167	$1.67
SILVER	$0.00133	$1.33
GOLD	$0.001	$1.00
PLATINUM	$0.001	$1.00
DIAMOND	$0.001	$1.00

Worked example: collecting 10,000 results costs $20.00 in result charges before run-start fees and platform usage. With 4.0% of runs failing or timing out in the last 30 days, budget for re-running a portion of those batches rather than assuming every run completes.

The primary cost driver is the urls input control, as each provided address writes one result item to the dataset. The cheapest way to evaluate whether this Actor meets project requirements before spending is to test a single URL on Apify's free plan.

How do you run Website Screenshot Generator from the API?

The schema marks 1 of its 11 controls as required: urls. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~screenshot-url/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"urls":[{"url":"https://www.apify.com/"}]}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "urls": [
    {
      "url": "https://www.apify.com/"
    }
  ]
}

run = client.actor("crawlerbros~screenshot-url").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "urls": [
    {
      "url": "https://www.apify.com/"
    }
  ]
}

const run = await client.actor('crawlerbros~screenshot-url').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

Which Website Screenshot Generator inputs matter, and which can you skip?

The urls control is the only required input and accepts a list of web page targets to process in a single batch. For a first run, leave advanced options like proxyConfiguration and selectorsToHide alone and rely on the default viewport width and wait settings.

urls (array): List of web page URLs to capture as screenshots.
format (string): Screenshot output format. PNG captures a full-page image. PDF generates a printable document. Default: "png".
waitUntil (string): When to consider the page loaded before taking the screenshot. Default: "load".
delay (integer): Milliseconds to wait after the page loads before taking the screenshot. Useful for pages with animations or lazy-loaded content. Default: 0.
viewportWidth (integer): Browser viewport width in pixels. Height is fixed at 1080px. Default: 1280.
scrollToBottom (boolean): Scroll to the bottom of the page before taking the screenshot. Triggers lazy-loaded images and infinite scroll content. Default: false.
delayAfterScrolling (integer): Milliseconds to wait after scrolling to bottom. Only applies when Scroll to Bottom is enabled and Wait for Network Idle After Scroll is disabled. Default: 2500.
waitUntilNetworkIdleAfterScroll (boolean): After scrolling, wait until no network requests are made for 500ms. Ensures all lazy-loaded content finishes loading. Overrides Delay After Scrolling. Default: false.
waitUntilNetworkIdleAfterScrollTimeout (integer): Maximum time to wait for network idle after scrolling. Only applies when Wait for Network Idle After Scroll is enabled. Default: 30000.
proxyConfiguration (object): Optional proxy settings. The actor works without proxy for most websites.
selectorsToHide (string): Comma-separated CSS selectors of elements to hide before taking the screenshot. Example: '.cookie-banner, #popup, .ads'

Fixed-choice controls: format accepts png (PNG Image), pdf (PDF Document); waitUntil accepts load (Page is opened (load)), domcontentloaded (Content is loaded (DOM)), networkidle (Network is idle).

What does Website Screenshot Generator return?

The returned records provide direct access to visual assets through the screenshotUrl field along with metadata like timestamps and final redirection URLs. They do not contain structural DOM trees, raw HTML source code, or performance metrics.

startUrl: string - The original URL provided as input
url: string - The final URL after any redirects
screenshotUrl: string - Public URL to download the screenshot file
screenshotKey: string - Key name in the key-value store
format: string - Screenshot format (png or pdf)
status: string - success or error description
timestamp: string - ISO 8601 timestamp

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How does the extraction work?

Launches a Chromium browser with the configured viewport width
Navigates to each URL and waits for the specified load condition
Optionally scrolls to the bottom to trigger lazy-loaded content
Optionally hides specified elements (cookie banners, popups, ads)
Captures a full-page screenshot as PNG or generates a PDF document
Stores the screenshot file in the key-value store with a public download URL
Records the result in the dataset with the original URL, final URL, and screenshot link

How do you build the workflow end to end?

Open Website Screenshot Generator and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

Enter the target URLs into the urls array control to specify which web pages to capture.
Select the desired output format using the format control, choosing either png or pdf depending on whether an image or document is needed.
Adjust the viewportWidth control to set the browser width in pixels if a custom layout size is required.
Set the waitUntil control to load, domcontentloaded, or networkidle to determine when the page is considered ready for capture.
Toggle the scrollToBottom control to true if the target page relies on lazy-loaded images or infinite scrolling content.
Add any unwanted interface elements like banners or popups into the selectorsToHide text area control.
Run the Actor and inspect the screenshotUrl field in the resulting dataset to verify the output before scaling up.

How do you apply it? Three worked playbooks

These are Website Screenshot Generator's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Website monitoring

Outcome: Website monitoring -- Schedule regular screenshots to track visual changes over time

Configure: Set urls to include target monitoring pages, set format to png, and enable scrollToBottom if dynamic elements load on scroll.

Working method: Run the Actor once manually to establish a baseline image link in the screenshotUrl field, then configure a scheduled run in Apify to capture daily or hourly changes without manual intervention.

Deliverable: A series of timestamped PNG or PDF files stored in the key-value store with corresponding dataset rows tracking each capture.

Stop condition: The status field returns an error description or the target site blocks requests due to missing proxy configurations.

Use case 2: Quality assurance

Outcome: Quality assurance -- Verify website appearance across different viewport widths

Configure: Set urls to the page under test and adjust viewportWidth to specific breakpoints such as 375 for mobile or 1920 for desktop.

Working method: Execute separate runs with distinct viewportWidth values, then compare the returned screenshotUrl assets side by side to check for layout overflows or misaligned elements.

Deliverable: A set of device-specific screenshot records in the dataset representing how the page renders at various widths.

Stop condition: Critical elements are cut off or hidden incorrectly due to an incompatible viewportWidth setting.

Use case 3: Competitive analysis

Outcome: Competitive analysis -- Capture competitor websites for design comparison

Configure: Populate urls with a list of competitor homepages, set waitUntil to networkidle, and use selectorsToHide to remove distracting promotional popups.

Working method: Run the batch capture with networkidle enabled to ensure complex tracking scripts and styles render fully before the image is saved to the store.

Deliverable: A clean batch of competitor design screenshots linked directly through the dataset rows for review and archiving.

Stop condition: Target sites return blank pages or display anti-bot challenge screens instead of the intended layout.

What breaks, and how do you design around it?

Some websites may block screenshots from datacenter IPs. Use proxy configuration for these sites
Very long pages may produce large PNG files. Consider using PDF format for document-heavy pages
JavaScript-heavy single-page applications may need networkidle wait condition and additional delay
The actor cannot log into websites or handle authentication
PDF format uses the browser's print layout, which may differ from the visual page appearance

When targeting websites that block datacenter IP addresses, attach a proxy using the proxyConfiguration control. For extremely long pages that generate oversized PNG files, switch the format control to PDF to handle document-heavy layouts.

When should you not use Website Screenshot Generator?

Do not use this Actor if your primary objective involves extracting underlying DOM elements, parsing structured text data, or crawling deeply linked internal site hierarchies. For capturing comprehensive link networks and visual node diagrams, use the Website Links Graph Generator instead. If your workflow demands testing responsive layouts across real mobile devices with performance auditing, use the Responsive Website Checker instead. This Actor cannot handle interactive user authentication workflows, manage login cookies natively, or bypass advanced CAPTCHA protections. If you only need to capture social media posts without full browser rendering overhead, use the Twitter Screenshot Generator instead.

What should you check before trusting the output?

Check that the status field reads success for every item in the dataset and flag any rows containing error descriptions.
Verify that the screenshotUrl field contains a valid, non-null link pointing directly to the key-value store file.
Inspect the format field to confirm it matches the requested output format of png or pdf.
Ensure the timestamp field is populated with a valid ISO 8601 string corresponding to the run time.
Check the url field against the startUrl field to trace whether unexpected redirects occurred during navigation.

None of this proves a record is correct. It gives a scheduled Website Screenshot Generator run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

How are billing charges calculated for failed runs?

The run-start fee is charged every time a run starts, whether or not it returns results, while per-result charges apply strictly to items successfully written to the dataset. If a run fails before writing records, you incur only the run-start charge.

Can I capture pages that require scrolling for dynamic content?

Yes. Enable the scrollToBottom control to trigger lazy-loaded images and infinite scroll elements before the capture takes place. You can also configure a delayAfterScrolling value or use network idle waiting to ensure all assets render.

What is the maximum viewport width supported?

The viewportWidth control accepts numeric values up to 3840px, allowing you to test narrow mobile layouts or wide desktop screens. The viewport height remains fixed at 1080px while the screenshot captures the entire page length.

How do I remove cookie banners before capturing?

Use the selectorsToHide input field to pass a comma-separated list of CSS selectors matching unwanted elements like popups, ads, or cookie notices. The Actor removes these elements from the DOM before generating the screenshot.

What happens if a website redirects to a different URL?

The output dataset records both the original input in the startUrl field and the final destination in the url field. This allows you to track redirection chains accurately for every captured target.

Where to go next

When you are ready to run it, open Website Screenshot Generator on Apify; the free plan covers up to 2,500 results a month.

Start with the Website Screenshot Generator Actor page for the current input schema, pricing tier, and run history.

Readers running Website Screenshot Generator commonly pair it with:

Ultimate Website Screenshot / PDF / Video: Capture JPEG/PNG screenshots, PDFs, GIFs and MP4s of any website.
Twitter Screenshot Generator: Take clean, high-quality screenshots of any public Twitter/X post.
Website Links Graph Generator: Creates an oriented graph visualizing links between webpages.
Responsive Website Checker: Test and verify how websites render across multiple devices and screen sizes.

Related guides:

Resources

Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-23.
Actor last updated by its maintainers on 2026-03-23.
Run outcome figures cover the 30 day public window ending 2026-09-23.
Website Screenshot Generator on Apify