How to Capture Screenshots of Websites at a Fixed Time with Apify

To capture a website screenshot at a recurring fixed time with Apify, first run and verify a screenshot Actor or task, then create an Apify Schedule with a cron expression and the timezone for the intended local time. Check the schedule preview before enabling it. A scheduled time is a target, not a guarantee of execution at the exact second: Apify says events are usually fired within one second, but system overload or server shutdown can delay a run. Apify schedule documentation.

1. Choose and verify an Apify screenshot Actor

For a single URL, Apify’s maintained Website Screenshot Generator (apify/screenshot-url) is a simple example Actor. Its input accepts one or more URLs, and options include scrolling to the bottom and adding a delay before capture. Run it manually once with the real target and settings so you can confirm the page loads and the output is useful. Apify requires an Actor to have run at least once before you schedule it.

The Actor stores screenshot files in a Key-Value Store and publishes their links along with page metadata to a dataset. You can inspect the run output there and retrieve the screenshot link for downstream use. For advanced crawling, rendering strategies, automatic cookie-banner closing, or extensive customization, Apify points users to its Website Content Crawler. Choose the Actor based on the capture behavior you actually need; options on community Actors are specific to those Actors, not universal Apify schedule settings.

2. Pick the cron expression and timezone

Apify schedules use cron expressions. For a daily capture at 8:00 AM, use 0 8 * * * and select the timezone that defines that 8:00 AM. Apify supports timezone settings and daylight-saving shifts. Use the preview to confirm the next runs in the intended local time, especially around daylight-saving changes.

Goal	Cron expression	Meaning
Daily at 8:00 AM	`0 8 * * *`	Minute 0, hour 8, every day
Weekdays at 9:30 AM	`30 9 * * 1-5`	Minute 30, hour 9, Monday through Friday
Every hour	`0 * * * *`	At minute 0 each hour
Every 15 minutes	`/15 * * *`	At 0, 15, 30, and 45 minutes past each hour

Apify’s cron format accepts five required fields—minute, hour, day of month, month, and day of week—and an optional leading seconds field. It also documents shortcuts such as @daily and @weekly. The minimum interval between runs is 10 seconds; if the next run is scheduled less than 10 seconds after the previous run, Apify says it will be skipped. For a fixed daily time, five fields are easiest to review.

3. Create the schedule in Apify Console

Open Schedules in Apify Console and choose Create new.
Name the schedule and configure its frequency with the schedule builder or cron expression.
Set the timezone, then inspect the displayed next run and expand the preview to review upcoming runs.
Add the Actor or task. For an Actor, configure its input and any available run options. For a task, select the prepared task.
Supply schedule-specific input if needed. If input is omitted, the Actor’s default input is used. If only some fields are supplied, missing fields are filled from the default input.
Review the schedule’s enabled state. New schedules are created disabled by default, so enable it when the preview and input are correct.

Actor run options in the schedule can include build, timeout, and memory. Timeout is specified in seconds; a value of 0 means no timeout. Use a task when you want a prepared, reusable configuration and override its input only when the recurring capture needs different values. A schedule can be associated with up to 10 Actors and 10 Actor tasks.

4. Create a schedule through the API

Use the Apify API when schedule creation needs to be part of deployment or automation. The example below creates a daily schedule at 8:00 in UTC for an existing Actor task. Replace the placeholders with your account’s user ID and task ID, and replace the input with fields supported by the task you chose. Apify’s schedule API accepts a timezone and actions; authenticate with the token in the Authorization header rather than putting it in the URL.

curl -X POST "https://api.apify.com/v2/schedules" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "daily-website-screenshot",
    "userId": "YOUR_USER_ID",
    "isEnabled": true,
    "cronExpression": "0 8 * * *",
    "timezone": "UTC",
    "description": "Capture the site every day at 08:00 UTC",
    "actions": [
      {
        "type": "RUN_ACTOR_TASK",
        "actorTaskId": "YOUR_TASK_ID",
        "input": {
          "startUrls": [{ "url": "https://example.com" }]
        }
      }
    ]
  }'

This is a request shape for the schedule API; confirm the exact input schema for your selected Actor or task before using it. The official screenshot Actor describes one or more web URLs as input, but different Actors may use different field names. The API returns the schedule details on success; a 4xx response means you should check the token, user ID, request body, and referenced task.

5. Retrieve and use each screenshot

After a scheduled run completes, open its dataset to inspect the page metadata and screenshot link. The screenshot file itself is in the run’s Key-Value Store. If another process needs the image, use the published link or access the storage through the Apify API. For notifications and workflow integration, Apify documents webhooks for task runs; configure a webhook on the task when a completion event needs to trigger another action.

For repeatable visual comparisons, keep the URL, viewport and Actor input consistent across runs, and retain timestamps alongside the resulting image links. The screenshot Actor’s page does not promise identical rendering across time: target-site content, dynamic data, fonts, ads, browser rendering, or network behavior may change the output. Decide whether your use case needs a viewport capture, page scrolling, or a delay before capture, and verify that choice in the initial manual run.

Timing, reliability, and cost

Timing: Apify says scheduled events are usually fired within one second of their target, with possible delays during system overload or server shutdown. Do not use the schedule as a frame-accurate trigger.
Timezone: The timezone determines how the cron time maps to local time and daylight-saving changes. Check several upcoming executions in the preview.
Start failures: Apify says schedule notifications are enabled by default and email notifications are sent when a scheduled Actor or task fails to start because of incorrect configuration. A successful start does not itself prove the screenshot has the expected contents, so inspect initial output.
Run duration: Set a timeout appropriate to the Actor and target page. The schedule time controls the run start, not when the screenshot will finish.
Cost: The Screenshot URL Actor page describes the Actor as free to use, with charges applying for Apify platform usage according to the account plan. Check current platform pricing and usage for your workload; this material does not establish a per-screenshot cost.

Common problems and fixes

Problem	Likely cause	What to check
The schedule does not run	It is disabled, or the Actor has not been run before.	Enable the schedule and complete a successful manual Actor run before scheduling.
It runs at the wrong local hour	The selected timezone does not match the intended location, or daylight-saving behavior was not checked.	Set the intended timezone and verify the next runs in the preview.
The scheduled run has the wrong URL	The schedule uses default Actor input, or the override uses a field the Actor does not recognize.	Compare schedule input with the Actor’s input schema and test the same input manually.
A field seems to disappear from the override	Apify fills omitted fields from default input, which may not be the settings you expected.	Inspect the Actor defaults and provide every field whose value must be explicit.
The schedule API responds with a 4xx	Invalid token, user ID, task ID, or JSON body.	Use a valid bearer token, verify IDs, and validate the action and input structure.
The capture is blank or incomplete	The page may need more load time, scrolling, or a different Actor/rendering setup.	Run it manually, test the Actor’s delay and scroll options, and consider Website Content Crawler for advanced rendering needs.
The run starts later than expected	Scheduled execution can be delayed by overload or server shutdown.	Allow for startup variability; use the run timestamps to assess actual behavior and avoid exact-second requirements.

Or skip the browser setup

If your goal is a screenshot on demand or as part of a workflow, ScreenshotNeo is a website screenshot API and MCP server for developers. One GET request returns an image or PDF; see the ScreenshotNeo API documentation for configuration and other capture options.

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

Python:

import requests

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

Node.js:

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://example.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 accepts cookie and consent banners like a visitor and removes 60+ known consent platforms, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and responses include X-Page-Verdict and X-Billed headers. Its MCP server offers take_screenshot, get_page_info, and capture_pdf for AI agents. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000.

FAQ

Can I schedule a one-time screenshot?

The documented schedule interface uses recurring cron expressions. For a one-off capture, start the Actor or task manually at the desired time, or create a schedule and disable or remove it after its intended run.

Can a single schedule run multiple captures?

Apify supports multiple Actor and task actions in one schedule. For many pages, check the selected Actor’s input support and the schedule’s limits before adding actions.

Does scheduling make screenshots identical every day?

No. Scheduling controls when the run is triggered. It does not freeze the website’s content or guarantee identical browser rendering.