Apify Screenshot Actor Free Plan: What Can You Capture?

Short answer: Apify’s apify/screenshot-url Actor, listed as Website Screenshot Generator, captures screenshots of one or more supplied web pages. Its input settings let you choose PNG or PDF, control when capture happens, set viewport width, optionally scroll to the bottom, configure a proxy, and hide elements with CSS selectors. Screenshot files go to a key-value store, with file links and page metadata in a dataset. The Actor listing is free to use, but Apify platform usage can still cost money. Apify does not promise a universal number of screenshots for every free account.

Start with the Apify Website Screenshot Generator listing and its input schema. For current free-plan terms, check Apify pricing.

What you can capture

The Actor accepts one or more web URLs. It is designed to capture specified pages; the listing does not guarantee that every site, login flow, bot check, cookie wall, or dynamic component will render successfully.

Setting or output	What the documented option means
File format	PNG is the default; PDF is also available.
Viewport width	Configurable from 100 to 3840 pixels; default is 1280. This is a width setting, not a catalog of physical phone or tablet profiles.
Wait condition	Choose `load`, `domcontentloaded`, `networkidle2`, or `networkidle0`.
Delay before capture	0 to 3,600,000 milliseconds; the schema default is 0.
Scroll to bottom	Optional. The default is false. This scroll behavior can help trigger content that loads lower on a page, but the docs do not state a universal full-page guarantee.
After-scroll wait	Use a delay (default 2,500 ms) or enable network-idle waiting. When enabled, network-idle waiting overrides the after-scroll delay; its timeout defaults to 30,000 ms and supports 1,000 to 3,600,000 ms.
Proxy	Optional proxy configuration. The documented default enables Apify Proxy.
Selectors to hide	Provide CSS selectors for elements to hide before capture, such as a page component that obstructs the image.
Output	Screenshot files are stored in a key-value store. A dataset contains page metadata and links to the files.

These options are documented in the Actor input schema and Actor listing. The listing describes this Actor as a simple example and points to Website Content Crawler for more advanced crawling and rendering options, including automatic cookie-banner handling.

What “free” means on Apify

There are two separate questions: whether the Actor itself has a price and whether running it uses paid platform resources. Apify says, “Using the Website Screenshot Generator is free; you’re only charged for using the Apify platform.” The current pricing page lists the Free plan at $0, with $5 to spend in Apify Store or on your own Actors, and says no credit card is required. Those terms do not translate into a fixed screenshot count.

Actual usage can depend on page weight, wait settings, scrolling, platform compute, storage, any Actor-specific pricing, and the balance left in your account. Actor pricing models vary across the Store. Check the current Actor pricing section and your Apify usage or billing view before scheduling repeated runs. Apify’s reviewed pages do not specify a universal file-retention period for these screenshots.

Run the Actor from the Apify console

Create or sign in to an Apify account.
Open the Website Screenshot Generator.
Enter one or more URLs and choose the format, viewport width, and wait behavior.
Enable scroll-to-bottom only if the page needs scrolling to reveal content. Choose an after-scroll delay or network-idle wait based on how the page loads.
Optionally set a proxy and selectors to hide, then start the run.
Inspect the run output: files are in the key-value store, and the dataset contains links and page metadata. Download or export the data you need.

For repeat monitoring, the Actor listing says it can be scheduled. Begin with a small run, inspect the resulting images and usage, and only then set a recurring schedule.

Example input

This JSON illustrates the documented input fields; paste it into the Actor’s input editor and adjust the URL, timing, and selectors for your target. The proxy object shown follows the documented default.

{
  "urls": [
    "https://example.com/"
  ],
  "format": "png",
  "waitUntil": "networkidle2",
  "delay": 1000,
  "viewportWidth": 1280,
  "scrollToBottom": true,
  "delayAfterScrolling": 2500,
  "waitUntilNetworkIdleAfterScroll": false,
  "waitUntilNetworkIdleAfterScrollTimeout": 30000,
  "proxy": {
    "useApifyProxy": true
  },
  "selectorsToHide": [
    ".cookie-banner"
  ]
}

Field names and supported values come from the input schema. If you switch to format: "pdf", validate the resulting file in your workflow. The schema documents the choice of PNG or PDF but does not establish a particular PDF page layout.

Choose settings for the page you have

Set the viewport width first. Use a width that matches the layout you want to inspect. Changing width can change responsive breakpoints and the screenshot content.
Pick a wait condition. Use domcontentloaded when you need an earlier capture and the page is mostly static; use load to wait for the load event; try networkidle2 or networkidle0 when network activity affects the rendered page. Pages with polling or long-lived requests may not become idle promptly.
Add a delay only for a known need. A delay can give client-side rendering or animations more time, but it also keeps a run open longer. Start with a small delay and inspect the result.
Enable scrolling for content below the fold. Some pages load images or sections when scrolled. The Actor offers a scroll-to-bottom option and a post-scroll delay or network-idle wait. Very long pages may take longer to render and produce larger files.
Hide only the elements that obstruct your capture. Use selectors for known elements. A selector that does not match has no useful effect; a broad selector can hide page content you wanted to keep.
Use the output format that fits the next step. PNG is suitable for image workflows; PDF is available for document output. Verify downstream compatibility and file size.

Can it take a full-page screenshot or a mobile screenshot?

The schema documents an option to scroll to the bottom before capture. That is useful for pages where scrolling triggers content, but the available source does not promise a full-page image in every case. Test the exact page and inspect whether all sections appear in the saved output.

The schema documents a configurable viewport width, not named physical-device presets or a full mobile-device simulation. A narrow width can show a responsive layout, but do not assume it reproduces a particular device’s browser, pixel ratio, or hardware behavior.

Run programmatically

The Actor listing says Apify API access and Python and Node.js SDKs are available for starting runs and retrieving results. Use the Actor’s API tab and the official Apify API reference for the current endpoint, authentication, and result-retrieval details. This article does not assume a fixed screenshot count or a particular API response shape: retrieve the run’s dataset and key-value-store output as documented by Apify.

For a script, the general workflow is: submit the same input JSON shown above to the Actor, wait for the run to finish, then read the dataset items and fetch the screenshot file identified by the output metadata. Keep the API token in an environment variable or secret store, not in source control. Check current Apify documentation for exact SDK method names and API paths before deploying.

Cost, performance, and reliability

Estimate with real pages. Run a representative sample and check account usage. A text page and a long page with many images can have different rendering and storage needs.
Control waiting. Long delays and network-idle waits improve the chance that late content is present, but make runs take longer. Network-idle can be a poor fit for pages with continuous background requests.
Scale gradually. Batch only as much as your run and budget can tolerate. Check usage and failure output before increasing a recurring schedule.
Validate artifacts. Confirm the expected URL, format, page coverage, and file accessibility. Store any output you need according to your own retention requirements; the reviewed listing does not state a universal retention duration.
Do not assume every target is accessible. The listing says the Actor works for many websites, not all websites. It does not promise login automation or bypass of bot checks and cookie walls.
Recheck current terms. Plan credits, Actor pricing, and input fields can change. Use the live pricing page and Actor listing when calculating a recurring workload.

Troubleshooting

Symptom	Likely cause	What to try
The screenshot is blank or incomplete	The page had not rendered the needed content at capture time, or the site did not load successfully.	Try a different `waitUntil` setting, add a modest delay, and inspect the target page in a regular browser. Re-run one URL before increasing volume.
Content lower on the page is missing	The page was captured without scrolling, or lazy content did not load after scrolling.	Enable `scrollToBottom`; use an after-scroll delay or network-idle wait. Confirm the result, since scrolling is not a universal full-page guarantee.
The run waits too long	A strict network-idle condition or a page with ongoing requests may prevent a quick idle state.	Try `load` or `domcontentloaded`, reduce the delay, or adjust the post-scroll network-idle timeout when that option is enabled.
A banner or overlay remains visible	The element was not covered by a matching selector, or a consent flow requires interaction.	Use a selector that matches the obstructing element and verify it against the page’s current markup. This Actor’s documented hide option is selector-based; do not assume it automatically accepts consent or removes every banner.
Expected content is hidden	A selector in `selectorsToHide` may be too broad or match more than the intended overlay.	Narrow the selector and rerun a single page.
The output is not where expected	The image file and dataset metadata are separate outputs.	Inspect both the key-value store and dataset. The dataset contains the screenshot link and page metadata.
Free usage runs out or charges appear	“Free Actor” refers to the listing price; platform usage can still be charged, and the free allowance is not a fixed number of screenshots.	Review current plan terms, Actor pricing, and account usage before scheduling more runs.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. One GET request captures a URL as PNG, JPEG, WebP, or PDF. Cookie and consent banners, newsletter popups, and chat widgets are handled before the shot; each cleanup step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed, and responses identify the page verdict and billing status in headers. An MCP server provides take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients.

See the ScreenshotNeo API documentation for options and configuration.

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

import requests

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

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}`);
const image = Buffer.from(await res.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', image));

ScreenshotNeo includes 1,000 screenshots a month free with no card; paid plans start at $5 for 3,000 screenshots. Create a free ScreenshotNeo account.

FAQ

How many screenshots can I take on Apify’s free plan?

There is no universal screenshot quota stated in the reviewed sources. The current Free plan lists $5 of usage credit; the number of captures depends on actual usage and account terms.

Does the Actor save PDF files?

Yes. The input schema lists PNG and PDF, with PNG as the default.

The schema supports hiding elements by selector. The Actor listing points to Website Content Crawler for advanced features such as automatic cookie-banner handling.

Where are the screenshot files stored?

In a key-value store, with links and page metadata in a dataset.

Is there a guaranteed retention period?

The reviewed Actor sources do not establish a universal retention period. Check current Apify storage terms and save files you need to keep.