How to Use ScreenshotAPI.net for Website Change Monitoring

ScreenshotAPI.net can take recurring screenshots of a webpage on an hourly, daily, weekly, or custom cron schedule and keep captures available for later review or comparison. A scheduled job gives you a visual history; it does not, by itself, establish that meaningful changes are detected or that alerts are sent. For notifications, add a separate comparison and alert step around the captures.

This guide covers choosing what to monitor, configuring and managing a schedule, comparing visual or textual results, and handling common failure cases. The examples keep the boundary clear: use ScreenshotAPI.net for scheduled captures, then use your own review or workflow to decide what counts as a change.

1. Decide what counts as a change

Start with the decision you need to make. A full-page screenshot can reveal layout changes, a viewport capture can focus on the first screen, and extracted text can make changes to a price or headline easier to compare. If the target is a dynamic section, the page may need a selector interaction or other rendering settings before the relevant content appears.

Monitoring goal	Evidence to capture	Comparison approach
Layout or visual redesign	Screenshot of the same page region each run	Visual comparison, followed by review of likely differences
Price, headline, or wording	Extracted text, optionally with a screenshot for context	Compare normalized text and review the changed lines
Content revealed after interaction	Capture after clicking the relevant CSS selector	Check that the intended section is present, then compare it
Localized rendering	Capture configured with the relevant cookies, geolocation, or timezone	Compare captures made with the same settings
Search result position	Rendered screenshot plus structured rank data	Use the rank data for numeric position tracking; use screenshots as visual context

Monitor the smallest useful set of URLs first. Record the exact URL, region or element of interest, expected page state, and the person or workflow that will review a detected difference. A screenshot is visual evidence, not a structured ranking feed or a guarantee that a page was unchanged between scheduled runs.

2. Configure a recurring capture

1. Open ScreenshotAPI.net’s Query Builder and enter the exact page URL you want to monitor.
2. Choose the capture output and scope. Decide whether you need a full-page capture or a viewport, and whether text or HTML extraction will help with the comparison.
3. Set page-specific rendering options. The documented options include fresh renders, CSS, cookies, geolocation, timezone, and cloud storage. For content that appears only after an interaction, configure a click on its CSS selector. Check the result on the actual page rather than assuming a setting worked.
4. Choose the scheduled screenshot action and select an hourly, daily, weekly, or custom cron interval. Cron controls when recurring jobs run. Use a cadence that matches how quickly the page can change and how soon you need to know; this is a workflow choice, not a service guarantee.
5. Activate the job and find it in the dashboard’s Schedule Requests area. Use View Screenshots to review its captures.
6. Compare a new capture with an earlier one. For text monitoring, compare extracted text; for layout monitoring, compare images. Decide whether a human review or an automated rule should confirm a difference before it triggers an alert.

For a volatile price page, hourly or daily observations may be useful. For a stable archive, a weekly or custom interval may be enough. Choose the shortest cadence that serves the decision: more captures can mean more results to review and store, while a longer interval can miss short-lived changes.

3. Review, pause, and preserve screenshot history

Review captures against an earlier version of the same URL made with equivalent settings. Keep viewport, interaction, cookies, and localization consistent; otherwise, a changed capture may reflect a changed setup rather than a changed page. For important records, download captures you need to preserve before deleting a job.

• Start: resume or activate scheduled work.
• Stop: pause future captures while retaining the job and its history.
• View Screenshots: inspect captures associated with the job.
• Delete: permanently delete the job and its related screenshots, according to the schedule documentation. Download important captures before deletion.

The documentation supports stored captures for later review, but it does not establish a fixed retention period, tamper-proof storage, legal admissibility, or uninterrupted monitoring. Keep copies in a storage system you control if your own recordkeeping requirements call for them.

4. Add a separate change-detection and alert step

A scheduled screenshot is an observation. A diff-and-alert workflow is a separate component that compares observations, decides what qualifies as a change, and sends a notification. ScreenshotAPI.net’s technical guide describes extracting text, comparing it with an earlier capture, and triggering an alert in a surrounding workflow; configure and maintain that workflow yourself.

For a text-based monitor, the comparison can follow this sequence:

1. Obtain the extracted text for the new capture and the previous capture.
2. Normalize only changes that do not matter to your use case, such as known timestamps or rotating identifiers. Avoid broad cleanup that could hide a real change.
3. Compare the normalized values or lines.
4. Apply a rule appropriate to the page, such as alerting when a price line changes. There is no universal threshold that fits every page.
5. Send the difference and the relevant capture reference to your chosen notification destination, and retain enough context to review a false positive.

For a visual monitor, compare images made with consistent settings and review the areas that differ. Dynamic timestamps, rotating promotions, personalization, and asynchronous content can generate noise. If an automated visual rule is too sensitive, narrow the capture region, stabilize the page state, or route the difference to a human review before notifying a wider audience.

Keep the capture and comparison responsibilities distinct in your implementation. The scheduler supplies recurring observations. Your workflow owns comparison logic, thresholds, notification delivery, retries, and alert history.

5. A small runnable text-diff example

The following Python 3 script compares two text files that you have obtained from your capture workflow. It prints a unified diff and exits with status 1 when the files differ, which lets a scheduler or shell workflow branch on the result. It does not call ScreenshotAPI.net or send notifications; connect those pieces in your own workflow after confirming the documented integration details available to your account.

#!/usr/bin/env python3
"""Compare two saved text extracts and return a useful process status."""
import difflib
import sys
from pathlib import Path

if len(sys.argv) != 3:
    print(f"Usage: {sys.argv[0]} OLD.txt NEW.txt", file=sys.stderr)
    raise SystemExit(2)

old_path, new_path = map(Path, sys.argv[1:])
try:
    old_text = old_path.read_text(encoding="utf-8").splitlines(keepends=True)
    new_text = new_path.read_text(encoding="utf-8").splitlines(keepends=True)
except OSError as exc:
    print(f"Could not read comparison input: {exc}", file=sys.stderr)
    raise SystemExit(2)

if old_text == new_text:
    print("No text change detected.")
    raise SystemExit(0)

print("Text change detected:")
sys.stdout.writelines(difflib.unified_diff(
    old_text, new_text,
    fromfile=str(old_path), tofile=str(new_path)
))
raise SystemExit(1)

Save it as compare_text.py, then run python3 compare_text.py previous.txt current.txt. A result of 0 means the text is identical, 1 means it differs, and 2 indicates an input or usage error. A production alerting job should also record the capture time, URL, comparison result, and delivery outcome, and should retry transient notification failures without silently losing the difference.

6. Troubleshooting

Symptom	Likely cause	What to check
The capture misses the content you care about	The content is below the fold, loaded later, or appears only after interaction	Check full-page behavior, load timing, cookies, and whether a CSS-selector click is needed. Inspect the resulting capture.
Captures differ on every run	Dynamic timestamps, personalization, rotating content, or inconsistent capture settings	Keep settings stable, narrow the monitored region, normalize only known irrelevant text, and review differences before alerting.
The scheduled job is not producing new captures	The job may be stopped, misconfigured, or unable to load the target page	Check the job’s status in Schedule Requests, start it if paused, and inspect the latest available capture and configuration.
A text diff misses a visible change	The change is visual, image-based, or absent from extracted text	Use visual captures for layout and image changes; use text extraction for content that can be represented as text.
A text diff produces noisy alerts	Volatile text is being treated as meaningful	Identify the exact noisy field, normalize that field narrowly, and add a review step or a rule based on the content that matters.
History disappears after cleanup	The scheduled job was deleted	Stop a job to pause future captures while retaining its history. Download important screenshots before deleting it.
The alert did not arrive	Capture scheduling and notification delivery are separate workflow steps	Check the comparison result, the workflow’s notification configuration, delivery errors, and retry handling.
The comparison says the page changed but no meaningful content did	Rendering variation or transient page state altered the capture	Compare equivalent page states, inspect the differing region, and adjust capture settings or review rules.

7. Performance, reliability, and cost considerations

Choose cadence based on change frequency and response time. Capturing every monitored URL more often increases the volume of screenshots and comparisons your team must handle. Begin with the pages tied to a concrete decision, then expand when the review and alert workflow is working.

Dynamic pages are a reliability concern: cookies, selector clicks, localization, and page timing can change what renders. Validate each target and periodically inspect captures for missing content. Treat a missing or failed observation as an unknown result, not proof that the page is unchanged. The documentation reviewed here does not establish a service uptime figure or guarantee that every scheduled run succeeds.

Plan storage and retention around your own review needs. The schedule documentation says captures are stored for later review or comparison and that deleting a job also deletes its related screenshots. It does not establish a fixed retention period or a pricing figure in the information used for this guide; check current service terms before estimating cost or retention.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server for developers. Its one-call API can return an image or PDF, and its options include full-page captures, selector capture, custom waits, cookies, headers, geolocation, and more. See the ScreenshotNeo 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}`);

ScreenshotNeo removes cookie banners, newsletter popups, and chat widgets before the shot. Bot checks, blank pages, and failed loads are never billed. Its MCP server lets AI agents take screenshots. The Free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. Sign up for ScreenshotNeo’s free plan.

Frequently asked questions

Can I get an alert whenever a scheduled screenshot changes?

A schedule creates recurring captures. Configure a separate diff-and-alert workflow if you want notifications when your chosen comparison rule detects a change.

Should I compare screenshots or extracted text?

Use screenshots for visual changes and page-state evidence. Use extracted text for wording or values you want to process directly. Some workflows use both so an alert includes readable evidence and visual context.

How often should I monitor a page?

Pick an interval based on how quickly the page changes and how soon you need to respond. ScreenshotAPI.net documents hourly, daily, weekly, and custom cron schedules; there is no universally right cadence.

Can a screenshot prove exactly what a page showed at a particular time?

A capture can provide a visual record for review. The documentation used here does not establish tamper-proof evidence or legal admissibility, so do not treat those properties as guaranteed.