How to Capture Screenshots of Multiple URLs with Apify

To capture screenshots of multiple URLs with Apify, choose a screenshot Actor that supports batch input, pass it the URL list in that Actor’s required schema, set the capture options, run it, and retrieve the screenshot files and any structured results. Apify does not impose one universal screenshot Actor schema or batch limit: community Actors differ in inputs, outputs, features, and pricing, so check the selected Actor’s live listing before submitting a large run.

1. Choose an Apify screenshot Actor

Apify Store includes community-maintained screenshot Actors. Compare their current input schema and listing rather than assuming one Actor’s fields or limits apply to another. For example, the Allscreenshots Website Screenshot Capture listing describes batch processing of up to 100 URLs per run and 30+ device presets; those are claims about that Actor, not Apify-wide limits. The Website Screenshot Actor by Fabio Suizu documents a different schema with width, height, and delay controls. Allscreenshots Website Screenshot Capture · Website Screenshot.

Check	Why it matters
Batch input and capacity	Confirm the exact field name, whether entries are strings or objects, and the current per-run limit.
Capture mode	Check for viewport, full-page, or element capture, as needed.
Output format and storage	Find supported formats and whether image files go to a key-value store while metadata goes to a dataset.
Viewport and device settings	Verify dimensions, device presets, scale factor, and dark-mode support in that Actor’s schema.
Wait and failure controls	Review delay, timeout, retry behavior, and how failed pages appear in results.
Price	Confirm the billing unit, whether Apify platform usage is included, and whether failures are charged.

Actor inputs and billing may change. Apify’s Store guidance explains that Actors can use different pricing models, and platform usage may be separate from an Actor’s price. Apify Store Actors and pricing.

2. Prepare the URL list and capture settings

Copy the selected Actor’s current input schema from its Store page. A batch input might be an array of URL strings or an array of objects, and the field might be named urls or something else. The following is illustrative only; use it only if the selected Actor expects this shape:

{
  "urls": [
    "https://example.com/",
    "https://example.org/"
  ],
  "width": 1440,
  "height": 900,
  "fullPage": true,
  "format": "png"
}

Before running, decide whether you need a viewport screenshot or a full-page image, the desired format, dimensions, and any supported device preset. If the Actor supports a delay, use it only when a page needs time for client-rendered content; a longer delay increases run time. Options are Actor-specific. For example, one Actor’s published input constraints list width from 320 to 3840 pixels, height from 240 to 2160 pixels, and delay up to 10,000 ms. Those bounds do not apply to other Actors.

1. Normalize the list: use complete URLs, remove accidental duplicates, and retain a copy of the original order.
2. Validate the schema and option values against the chosen Actor’s current input form or documentation.
3. Start with a small sample if the target sites or expected output are uncertain.

3. Run the Actor and retrieve results

You can start an Actor in the Apify Console by entering its input and starting a run. For automation, Apify’s API supports synchronous Actor runs that can return dataset items. The exact Actor identifier, authentication, input, and result fields depend on the Actor you selected. Consult the official Run Actor API and the Actor’s Store listing. The Website Screenshot Capture listing also documents starting a run through a POST request to its Run Actor endpoint.

A typical workflow is:

1. Submit the input to the Actor’s run endpoint, or start it in Console.
2. Wait for the run to finish, or record its run ID if using an asynchronous workflow.
3. Inspect the run’s dataset for per-URL metadata and any reported failures.
4. Retrieve image files from the storage location documented by that Actor. Some Actors place files in a key-value store and return references or metadata in the dataset.
5. Check that every requested URL has a corresponding success or failure result before treating the batch as complete.

Do not assume the dataset itself contains image bytes or that every Actor uses the same storage keys. Use its result documentation to map each input URL to the correct screenshot file.

4. Schedule recurring captures

For repeated monitoring, create an Apify schedule for the Actor or a task. Schedules support a cron frequency and optional input overrides; they are recurring automation, not a guarantee that a run begins at an exact second. Apify notes that scheduled events may be delayed by system conditions. See Actor and task schedules.

5. Handle larger batches reliably

• Respect the selected Actor’s limit. Split the input into multiple runs if the live listing or schema sets a maximum.
• Keep a URL-to-result manifest. Preserve the input URL, run ID, output reference, and status so a partial run can be reconciled.
• Retry only failures. Avoid repeating successful captures when the Actor’s result data lets you isolate failed URLs.
• Expect site variation. Authentication walls, bot checks, slow scripts, redirects, and region-specific content can affect what the browser captures.
• Budget runtime as well as money. Full-page rendering and explicit delays can add time per page. A large batch can take longer than a single capture, especially when pages load slowly.
• Test representative pages. Include a short page, a long page, and a page with client-rendered content in a small trial run if those match your target set.

6. Troubleshooting

Symptom	Likely cause	What to do
Input validation error	The Actor expects a different field name or URL entry shape, or an option is outside its accepted range.	Copy the current input schema from the Actor listing and validate one URL before resubmitting the batch.
Fewer screenshots than URLs	Some pages failed, the run hit an Actor-specific limit, or output files are stored separately from dataset items.	Compare the dataset against the original URL manifest, inspect run logs, and follow the Actor’s storage instructions.
Blank or incomplete screenshot	The page had not rendered its content, a navigation failed, or the target blocks automated browsing.	Check the run log, use a supported wait option where justified, and verify the URL in an ordinary browser. Treat bot checks as a site-side limitation.
Capture is cut off	The Actor used viewport capture, or full-page capture is unsupported or disabled.	Enable the Actor’s full-page option if available; otherwise choose a supported alternative and confirm its output behavior.
Run takes too long	Large URL count, slow pages, full-page rendering, or excessive per-page delay.	Reduce unnecessary waits, split the batch, and check whether the Actor documents concurrency or timeout controls.
Unexpected charge	The Actor’s billing unit or Apify platform usage was misunderstood.	Review the live Actor pricing and Apify usage details; pricing models differ and platform usage may be billed separately.

7. Performance, reliability, and cost

Batching reduces manual repetition, but total run time still depends on page load behavior, capture mode, Actor implementation, and any delay or timeout setting. Full-page screenshots can require more page rendering and produce larger files than viewport captures. Use smaller test runs to estimate the behavior for your URL set; there is no universal Apify screenshot throughput figure established for these community Actors.

Reliability depends on both the target site and the Actor. Preserve run IDs and structured results, inspect failures, and retry selectively. Schedules are useful for recurring work, but Apify says system conditions can delay scheduled events. For cost planning, check the Actor’s current price and whether platform usage is included before a large batch. There is no single platform-wide price or URL cap for Apify screenshot workflows.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server from Yorker Media. One GET request captures a URL as PNG, JPEG, WebP, or PDF. Cookie and consent banners are accepted like a visitor and 60+ known consent platforms, newsletter popups, and chat widgets are removed before the shot; each step can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and response headers report the page verdict and billing status. Its MCP server provides take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, and other MCP clients. One thousand screenshots a month are free with no card; paid plans start at $5 for 3,000.

For multiple URLs, call the endpoint once per URL or use its bulk capture option for up to 100 URLs per call. See the ScreenshotNeo API documentation for the full options and response details.

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}`);

Sign up free for 1,000 screenshots a month, with no card required.

Frequently asked questions

How do I screenshot multiple URLs at once?

Use a screenshot Actor whose input accepts a URL array, then submit the list in its exact schema. If it does not support batch input, split URLs into supported runs or choose another Actor.

Is 100 URLs the Apify limit?

No. The cited 100-URL capacity belongs to one Store Actor listing. Check the current limit for the Actor you intend to run.

Can Apify run the captures every day?

Yes. Schedules can run Actors or tasks on a cron frequency, though scheduling does not promise an exact start time.

Where do the screenshots appear?

That depends on the Actor. Check whether its files are stored in a key-value store, returned as dataset records, or exposed through another documented result path.