How to Schedule Website Screenshots with Apify Actors

To schedule website screenshots with Apify, first choose a screenshot Actor and confirm its input schema and output behavior. Run it manually once, save the working configuration as a task if you will reuse it, then create and enable a schedule with a cron expression, timezone, and Actor or task action. Apify supplies the recurring run mechanism; the screenshot URL, viewport, wait conditions, authentication, and output settings depend on the Actor you choose.

1. Choose and verify a screenshot Actor

Apify schedules start Actors or tasks; they do not define a universal screenshot input format. Before automating, open the selected Actor’s documentation and input schema. Verify that it supports the capture you need and learn how it returns or stores the result.

Target: how the Actor accepts the website URL or URLs.
Capture scope: viewport or full page, and whether it supports a CSS element selector.
Rendering: browser support, viewport dimensions, device scale, and any device presets.
Readiness: supported wait conditions, delay controls, or selector waits for dynamic pages.
Access: whether it supports cookies, login, custom headers, or other authentication needed for the target.
Output: image format, where files or metadata are stored, and how long the Actor retains them.
Run behavior: required input fields, defaults, memory or timeout settings, and the Actor build you intend to use.

Do not copy input property names from another Actor. Screenshot options are Actor-specific, and the research available for this guide does not establish a particular screenshot Actor or its schema.

2. Run it manually and save a reusable task

Open the Actor in Apify Console and inspect its current input schema and documentation.
Enter one target and the capture settings required by that Actor.
Start a manual run. Inspect the run status, logs, and stored output. Confirm that the screenshot exists, depicts the expected page state, and can be retrieved in the way your downstream process needs.
Fix any rendering or access issues before scheduling. A scheduled run repeats the configured work; it does not make an incorrect input or unreliable capture correct.
If you want to reuse the same input and run options, create an Actor task with that configuration. A task is a reusable Actor configuration that can be run on its own, by a schedule, or through the API and client libraries.

Apify’s schedule guide says an Actor must have been run at least once before it can be scheduled. Treat the successful manual run as a required validation step, not just a convenience. See Apify’s Actor tasks documentation.

3. Create the recurring schedule

You can create schedules in Apify Console or through the Schedules API. In Console, the visual schedule builder can show upcoming run times; cron expressions give you control over the recurrence.

Create a schedule and add an action for the Actor or task you validated. A schedule can contain multiple Actor and task actions, subject to Apify’s current limits.
Set the cron expression for the intended cadence. Check its upcoming run times in the schedule builder.
Select the timezone deliberately. Confirm what local wall-clock time you want the capture to run, and account for daylight-saving changes if the target timezone observes them.
Set the action’s Actor input and run-option overrides as needed. Use only fields documented by that Actor. If you omit input, the Actor’s defaults apply; omitted fields in an override are filled from the default input.
Choose whether the action runs the Actor directly or runs the saved task. Use the task when you want the tested input and run options reused.
Save the schedule, explicitly enable it, and check the next scheduled run. New schedules are disabled by default according to Apify’s schedule guide.

Example cron patterns

Intent	Example cron	What to verify
Every day at 09:00	`0 9 * * *`	Set the intended timezone; otherwise the capture may run at an unexpected local time.
Every Monday at 09:00	`0 9 * * 1`	Confirm the schedule preview shows Monday in the selected timezone.
At 09:00 on the first day of each month	`0 9 1 * *`	Check how the scheduler previews the next monthly occurrence.

These are standard five-field cron examples. Use the Console’s preview and Apify’s current schedule documentation to confirm the expression and next runs before enabling it.

4. Configure inputs, run options, and versions

The schedule is the trigger, while the Actor schema defines the screenshot job. Supply the URL, capture settings, and any credentials only through fields and secret-handling mechanisms the Actor documents. Do not assume that a property such as url, fullPage, or viewport exists on every screenshot Actor.

When the schedule provides an input override, fields that are not included fall back to the Actor’s default input. Review the complete effective input so a missing override does not silently restore an unwanted default. Run options can also be configured for the action; use options supported by Apify and appropriate to the selected Actor.

Actor builds can change available features and inputs. If repeatability matters, pin the specific build you validated. That reduces the chance a later build changes behavior, but it also means you will not automatically use newer builds. If you use a moving tag, review changes before relying on the scheduled result. Apify documents runs, builds, logs, storage, and terminal statuses in its Actor runs and builds guide.

5. Monitor results and handle missed or failed captures

After the first scheduled execution, open its run details and check status, logs, and output. Documented terminal statuses include success, failure, timeout, and abortion. Confirm the Actor’s actual output and retention behavior instead of assuming every screenshot is kept in the same storage location.

Check the schedule’s next-run time after editing its cron or timezone.
Review run logs when the run fails, times out, or succeeds without the expected image.
Use schedule notifications for the failure-to-start cases they cover, and still inspect run outcomes for capture-level problems.
Make sure downstream consumers can access the Actor’s output before its storage or retention window ends.

Apify says scheduled events usually fire within one second of their scheduled time, but overload or a server shutting down can delay a run. Treat the schedule as a recurring trigger, not a hard real-time guarantee. Its schedule guide also documents a 10-second minimum interval; a run scheduled sooner after the previous one is skipped. The guide states a limit of 10 Actors and 10 tasks per schedule. These platform limits can change, so verify them in the current Apify schedule documentation before building around them.

6. Create a schedule through the API

The API supports managing schedules and their actions. A schedule action can start an Actor or a task; the Actor’s screenshot-specific input must match its own current schema. The example below shows the request shape, not a universal screenshot input. Replace the placeholder values with the schedule fields and action structure in the current API reference, and include the validated Actor or task input in the action.

curl -X POST "https://api.apify.com/v2/schedules?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "scheduled-website-capture",
    "cronExpression": "0 9 * * 1",
    "timezone": "UTC",
    "isEnabled": true,
    "actions": [
      {
        "type": "ACTOR",
        "actorId": "YOUR_SCREENSHOT_ACTOR_ID",
        "input": {}
      }
    ]
  }'

Confirm exact field names, accepted timezone format, action shape, and enablement fields against Apify’s Manage schedules API reference before using an API request in production. The empty input above is a placeholder only; provide the required fields from your selected Actor’s schema. You can also configure a task action and task-specific input when using a saved task.

7. Performance, reliability, and cost considerations

Cadence: choose a frequency based on how often the page changes and how quickly you need to detect it. Respect the documented minimum interval and possible skipped runs.
Page readiness: wait conditions that are too short can capture an incomplete page; unnecessarily long waits consume more run time. Validate the Actor’s wait controls against the target site.
Large or slow pages: full-page rendering, heavy scripts, authentication, and delayed content can increase run duration or contribute to timeouts. Check actual logs and Actor limits.
Time accuracy: use the intended timezone and inspect upcoming runs across daylight-saving transitions. Scheduled firing can be delayed under platform conditions.
Version stability: pin a tested build for consistent behavior, or follow a tag and review updates when you want newer behavior.
Storage: plan how to retrieve and retain output based on the chosen Actor’s storage and retention behavior. Apify scheduling documentation alone does not establish screenshot retention or per-run price.
Cost: estimate from the selected Actor’s current pricing and the number and duration of runs, plus any storage or downstream processing charges that apply. The research for this guide does not establish pricing for a specific screenshot Actor.

8. Troubleshooting

Symptom	Likely cause	What to do
No run starts at the expected time	The schedule is still disabled, the cron or timezone is wrong, or platform conditions delayed firing.	Enable the schedule, inspect the next-run preview and timezone, then check schedule status and notifications.
The schedule cannot be created	The Actor has not been run yet, an action is malformed, or a required schedule field is missing.	Run the Actor manually, validate the action and schedule fields against current Apify docs, and try again.
Run starts but fails validation	The scheduled input does not match the chosen Actor’s schema.	Compare the full effective input with the Actor’s current schema, including defaults and overrides.
Run succeeds but screenshot is absent	The Actor may return output in a different store or format, or its input did not request the expected capture.	Inspect logs and output records, then follow the Actor’s documentation for retrieving files and metadata.
Screenshot shows a loading state or incomplete content	The Actor’s wait condition is insufficient for that page, or content appears after the capture point.	Use a documented selector, delay, or readiness option supported by that Actor and validate with another manual run.
Screenshot differs after an update	The Actor build or its defaults changed.	Review the run’s build, compare inputs, and pin a known build if stable repeatability is more important than automatic updates.
A run is skipped or overlaps are unexpected	The requested interval may be below Apify’s documented minimum, or a prior run may still be running.	Use a longer interval and account for run duration; verify current scheduler rules in Apify documentation.
Scheduled result times shift seasonally	The chosen timezone observes daylight-saving changes.	Check upcoming run times across the transition and choose UTC if a fixed UTC time is what the workflow requires.

Or skip the browser setup

ScreenshotNeo provides a one-request screenshot API and an MCP server for AI agents. Cookie and consent banners, newsletter popups, and chat widgets are removed before capture; each step can be turned off. Bot checks, blank pages, failed loads, timeouts, and cache hits are not billed, and response headers identify the page verdict and billing status. MCP tools include take_screenshot, get_page_info, and capture_pdf. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 screenshots. See the ScreenshotNeo website and API documentation.

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}`);
await Bun.write('shot.webp', res);

For the browser-free capture workflow, create a free ScreenshotNeo account.

FAQ

Can a schedule run a task instead of an Actor?

Yes. A schedule can start an Actor or a reusable task. A task is useful when you want a saved input and run configuration.

Does Apify define the screenshot URL and viewport fields?

No. Those fields belong to the screenshot Actor’s input schema. Check its documentation before setting schedule input.

Will a scheduled run always start at the exact cron second?

No. Apify describes runs as usually firing within one second, while noting that overload or server shutdown can delay them.

Can I schedule several screenshot jobs together?

A schedule can contain multiple Actor and task actions within the platform’s current limits. Verify those limits before relying on them.