SCHEDULED CAPTURE

Run website screenshots on the schedule you already trust

Use cron, CI, a serverless timer, or an automation platform to trigger Snapshot Site. Keep scheduling outside the capture API, then add a URL queue, stable request options, idempotent storage, retries, and optional visual comparison around each run.

Any trigger
Cron, CI, serverless, n8n
One API
Capture, compare, analyze
Your cadence
Event-driven or recurring
Install:curl -X POST https://api.prod.ss.snapshot-site.com/api/v1/screenshot
Auth:x-snapshotsiteapi-key: YOUR_API_KEY
Get started for free
Scheduled capture queue
External calendar trigger feeding a queue of URLs into a screenshot API and chronological capture outputs
Good fits
Daily or hourly website review queues
Post-deployment screenshot evidence
Recurring report and documentation assets
Competitor, ecommerce, SEO, and brand monitoring

The scheduler triggers; Snapshot Site renders

Snapshot Site does not maintain a native recurring-job calendar. Your scheduler owns time and retries. The API owns browser rendering and, when requested, visual comparison or page analysis.

1

Choose the trigger

Use an existing cron service, CI schedule, cloud timer, or n8n workflow rather than adding another scheduler to the stack.

2

Build a deterministic job

Store URL, viewport, format, timing, cleanup, and expected output together so each run can be reproduced.

3

Prevent duplicate runs

Use a job key based on target, configuration, and schedule window so retries or overlapping triggers do not create unrelated output.

4

Route the result

Archive the asset, compare it with a baseline, analyze the page, or notify a reviewer according to the workflow.

Quick start

Schedule one controlled capture

1

Create a server-side script that reads the API key from its environment

2

Run the script manually and validate the output

3

Attach the script to cron, CI, a cloud timer, or n8n

4

Add locking, retry policy, storage, and alerts before expanding the URL list

Scheduled screenshot example

Shell

Capture a page from a cron-safe shell script

The scheduler supplies the environment and invokes this request. The API itself does not hold the recurring schedule.

#!/usr/bin/env sh
set -eu

: "${SNAPSHOT_SITE_API_KEY:?Missing API key}"

curl --fail-with-body --request POST \
  --url https://api.prod.ss.snapshot-site.com/api/v1/screenshot \
  --header 'Content-Type: application/json' \
  --header "x-snapshotsiteapi-key: ${SNAPSHOT_SITE_API_KEY}" \
  --data '{
    "url": "https://example.com/pricing",
    "format": "webp",
    "width": 1440,
    "fullSize": true,
    "hideCookie": true,
    "delay": 2
  }'

A screenshot schedule is an operational workflow

Running a request every hour is easy. Running it reliably for months requires decisions about ownership, duplicate triggers, retries, storage, page state, and what happens after a result arrives. A useful scheduler is therefore more than a cron expression.

Snapshot Site deliberately separates those responsibilities. Cron, CI, a cloud timer, or n8n decides when a job starts. The screenshot API renders the requested page. Your workflow decides whether to archive the image, compare it with a baseline, analyze the page, or notify a reviewer.

This boundary avoids pretending that one built-in calendar fits every team. It also lets event-driven jobs—such as a CMS publish webhook or deployment completion—use the same capture code as recurring jobs.

Choose the right trigger

System cron or a worker scheduler

Cron is a good fit when a service already owns background work and the team can observe the machine or container running it. Put capture logic in a script or worker command, then keep the cron entry small. The command should exit nonzero on an operational failure and emit a job identifier that can be traced.

Do not store the API key in the crontab line. Load it through the host's secret mechanism or the worker environment.

CI schedules

Scheduled GitHub Actions or another CI system work well for small route lists, release evidence, and jobs whose output belongs beside source code. Use the platform secret store, cap concurrency, and upload a manifest or selected images as artifacts.

CI is less attractive for high-frequency monitoring or large queues because runner startup and artifact retention become part of the workflow. Use a worker or automation platform when the job behaves more like a service than a build.

Serverless timers

Cloud schedules can invoke a function without a long-running process. Keep the trigger lightweight: enqueue work or process a bounded batch, then finish. Large page lists should not depend on one function completing before a hard runtime limit.

n8n and other workflow platforms

A visual workflow is useful when the output needs to flow into Slack, email, Google Sheets, storage, or a review system. It also makes the trigger and branching logic visible to non-developers. Use the verified Snapshot Site n8n node where it matches the operation, or call the REST API from an HTTP step.

Define the scheduled job contract

Every job should carry more than a URL. Store the viewport, output format, full-page behavior, timing, cleanup options, locale where relevant, and the action expected after capture. This configuration is the difference between a reproducible monitor and a folder of unexplained images.

Create a stable target identifier that is independent of the URL when URLs contain temporary query parameters. Use a schedule-window identifier such as an hourly or daily bucket. Together they can form an idempotency key: if the same trigger is delivered twice, the second worker can see that the intended result already exists.

Record the job start time, completion time, response status, resulting link, and any error classification. Avoid logging secrets or full URLs containing private tokens.

Retry without creating a storm

Network interruptions and temporary browser failures can justify a retry. Invalid URLs, unsupported values, and authorization errors generally do not. Classify the error before retrying and stop after a small maximum attempt count.

Use exponential backoff with jitter so a large scheduled batch does not retry every failed target at the same moment. Respect plan throughput and limit concurrent workers. If the next scheduled interval arrives while the previous run is still active, choose whether to skip, queue, or replace it—do not allow accidental overlap by default.

Turn captures into monitoring

A historical archive answers “what did this page look like?” A visual comparison answers “did it change?” To build the second workflow, store an approved baseline or previous image and call the Visual Diff API on each scheduled run.

Apply thresholds carefully. A mismatch percentage is a triage signal, not a business conclusion. A rotating banner can create many changed pixels while a one-character price edit creates few. Hide known volatile regions, keep settings stable, and attach the diff image to alerts so a person can understand the signal.

For semantic questions, use the AI Website Analysis API on the rendered page and store only the documented fields required by the workflow. Visual comparison and analysis complement each other; they should not be conflated.

Scheduling use cases

SEO and content verification

Capture templates after deployment or on a cadence justified by their publishing rate. Review mobile and desktop states separately, and route broken rendering to the team that owns the template. The SEO Monitoring page describes a focused route set.

Competitor and market pages

Maintain an approved watch list, respect site terms and robots directives, and avoid excessive polling. Use screenshots as review evidence rather than automatically interpreting every difference. See Competitor Monitoring for scope and governance.

Ecommerce and brand operations

Product pages, campaign landings, and partner pages can be captured during business-critical windows. Tighten the interval only when someone is available to respond. Outside the campaign or event window, return to a lower cadence.

Security and retention

Keep keys in a scheduler secret store and restrict who can edit target lists or injected page code. Use synthetic accounts for authenticated staging checks and avoid capturing personal information unless the workflow has an explicit lawful basis and retention policy.

Store assets in the region and access tier appropriate to their content. Define when old captures expire, who can retrieve them, and whether a diff or thumbnail is enough instead of retaining every full-resolution page forever.

Scheduler checklist

  1. Assign an owner to the schedule and its alerts.
  2. Store a complete, versioned capture configuration.
  3. Use idempotency keys and overlap protection.
  4. Retry only transient failures with bounded backoff.
  5. Cap concurrency and spread large batches.
  6. Validate and archive the response with its source metadata.
  7. Route meaningful changes with visual context.
  8. Review cadence, target permissions, and retention regularly.

Screenshot scheduler FAQ

Does Snapshot Site include a built-in screenshot scheduler?

No. Trigger the API from cron, CI, a serverless schedule, n8n, or another workflow platform. This keeps timing and job ownership in the system your team already operates.

How often should I schedule screenshots?

Match the interval to page change rate and response needs. More frequent capture creates more cost, storage, and transient differences without helping if nobody can review them.

Can I schedule full-page and mobile captures?

Yes. Store the intended width, height, and fullSize option in each job. Treat every viewport as a separate repeatable configuration.

How do I avoid overlapping runs?

Use a distributed lock or idempotency record based on the target, configuration, and schedule window. Skip work already completed for that key.

Should a failed capture be retried?

Retry only errors marked or known to be transient, use bounded exponential backoff with jitter, and set a maximum attempt count. Invalid requests should be corrected rather than retried.

Can a scheduled job alert only when a page changes?

Yes. Compare the live page with an approved image or another URL using the Visual Diff API, then apply your review threshold to the returned mismatch information.

Where should scheduled screenshots be stored?

Store the returned asset or download it into storage owned by the workflow. Keep the source URL, capture time, configuration, and job identifier with the file.

How do I keep the scheduler secure?

Use the scheduler's secret manager, restrict the target list, sanitize logs, and never include the API key in client-side code, a repository, or a target URL.

Schedule one page before scheduling one hundred

Prove the request, storage path, retry behavior, and ownership model with one representative page, then scale the same job contract.