Visual monitoring catches problems that traditional uptime checks miss. A website can return HTTP 200 while displaying a broken layout, missing images, or an error message in the page body. Automated screenshot monitoring captures what users actually see.
Why Monitor with Screenshots?
- Visual regression detection — catch CSS breaks, missing images, and layout shifts that don't trigger HTTP errors.
- Content verification — confirm that pricing, product listings, or legal pages display the correct information.
- Competitor tracking — monitor competitor websites for design changes, new features, or pricing updates.
- Compliance records — maintain timestamped visual records of web pages for legal or regulatory purposes.
- Downtime evidence — screenshot captures provide visual proof of outages beyond simple ping checks.
No Code Required: Scheduled Captures
If you don't want to run a script at all, Site-Shot now does the scheduling for you: create a schedule in the browser — URL, capture settings, cadence — and it captures the page on the days you pick and the hours you tick, up to once an hour, files every shot in your library, and keeps a ledger of every run including failures and skips. It's included with any paid plan. See the walkthrough in How to Automatically Screenshot a Website Every Day.
Schedules do both halves: they capture and file every run, and they compare each capture with the one before it — measuring how much of the page moved and emailing you when it crosses a threshold you set. What they don't do is tell you which words or elements changed: that is a visual measurement, not a text diff. Alerts arrive by email, at most one per schedule per day, and the soonest you can hear about anything is the schedule's own cadence. If you need a list of the words that changed, alerts in Slack, or captures wired into your own pipeline and storage, the API route below is still the right one. The rest of this guide shows the captures and both comparisons; the alert itself is code you add.
Save screenshots from Node-RED
Already run Node-RED? The Site-Shot node turns a public web page URL into an image Buffer in msg.payload, ready for a write file node. Rendering happens on Site-Shot, so you do not install Chromium on your Node-RED host.
- In your Node-RED user directory, usually
~/.node-red, runnpm install @site-shot/node-red-siteshotand restart Node-RED. The node requires Node-RED 5.0 or later and Node.js 22.9 or later. - Open Menu > Import > Examples > @site-shot/node-red-siteshot. Choose the single-page or list-of-pages example, and replace its example URLs with your public pages.
- Add your API key in the Site-Shot account credential, deploy, then click the Inject button. The examples save images under
site-shot/in Node-RED's working directory, with a new filename for each capture.
The examples do not capture on deployment or startup. Start manually; configure the Inject node's Repeat setting only when you want recurring captures. Keep Node-RED running and manage storage and failures yourself. These flows save images; they do not compare them or send change alerts.
The node is MIT-licensed. The API needs a Site-Shot key, and a confirmed account's key comes with the free plan: 100 API captures a month, no card needed; paid plans start at $5/mo for 2,000. Accepted capture attempts can consume quota even when rendering fails. See the setup and limitations.
Basic Monitoring Script (Python)
Install requests (pip install requests) and set SITESHOT_API_KEY in the environment that runs the script. This example saves each screenshot with a timestamp:
import os
from datetime import datetime
import requests
API_URL = "https://api.site-shot.com/"
API_KEY = os.environ["SITESHOT_API_KEY"]
OUTPUT_DIR = "screenshots"
def capture(url, label="site"):
os.makedirs(OUTPUT_DIR, exist_ok=True)
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
filename = f"{label}_{timestamp}.png"
filepath = os.path.join(OUTPUT_DIR, filename)
response = requests.get(API_URL, params={
"url": url,
"userkey": API_KEY,
"width": 1280,
"height": 1024,
"format": "png",
"no_ads": 1,
"no_cookie_popup": 1,
}, timeout=70)
response.raise_for_status()
if not response.headers.get("Content-Type", "").lower().startswith("image/"):
raise RuntimeError(response.text)
with open(filepath, "wb") as f:
f.write(response.content)
print(f"Captured: {filepath}")
if __name__ == "__main__":
capture("https://your-website.com", label="homepage")
capture("https://your-website.com/pricing", label="pricing")
Scheduling Captures
With cron (Linux/macOS)
Run the script every hour, using the Python environment where you installed requests. Set the job's working directory so the relative screenshots/ output path is predictable:
0 * * * * cd /path/to/project && /path/to/project/.venv/bin/python monitor.py
With Task Scheduler (Windows)
Create a scheduled task that runs python monitor.py at your desired interval, with the project directory as its working directory and SITESHOT_API_KEY available to the task.
With GitHub Actions
name: Screenshot Monitor
on:
schedule:
- cron: '0 */6 * * *' # Every 6 hours
jobs:
capture:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.12'
- run: pip install requests
- run: python monitor.py
env:
SITESHOT_API_KEY: ${{ secrets.SITESHOT_API_KEY }}
- uses: actions/upload-artifact@v4
with:
name: screenshots-${{ github.run_number }}
path: screenshots/
Where this runs, and the catch: each run executes on a fresh, newly-provisioned GitHub-hosted VM, so nothing persists on the machine between runs — the screenshots survive only because upload-artifact attaches them to the workflow run, where you download them from the run's page. Three limits matter (GitHub's schedule rules and artifact retention, checked September 2026): artifacts are deleted after 90 days by default; the schedule trigger is best-effort — runs can be delayed at busy times and occasionally dropped; and in a public repository scheduled workflows are switched off automatically after 60 days without repo activity. Keep the API key in an Actions secret (as above), never in the file. In short: GitHub Actions is a decent scheduler but a poor archive — if you want a history that keeps itself, that's what scheduled captures are for.
Monitoring Multiple Pages
PAGES = [
("https://your-site.com/", "homepage"),
("https://your-site.com/pricing", "pricing"),
("https://your-site.com/docs", "docs"),
("https://competitor.com/", "competitor"),
]
for url, label in PAGES:
capture(url, label=label)
Detecting Visual Changes
Compare consecutive screenshots using image diffing. Install pillow and numpy for this simple pixel-comparison example:
from PIL import Image
import numpy as np
def images_differ(path_a, path_b, threshold=0.01):
"""Return True if more than `threshold` fraction of pixels differ."""
img_a = np.array(Image.open(path_a).convert("RGB"))
img_b = np.array(Image.open(path_b).convert("RGB"))
if img_a.shape != img_b.shape:
return True
diff_pixels = np.any(img_a != img_b, axis=2).mean()
return diff_pixels > threshold
This function only detects a change; call it after each capture and add your own notification code for email, Slack, or another channel.
Seeing Which Words Changed
A pixel diff tells you that something moved, not what. The HTTP API also supports rendered-page Markdown: request markdown=1 with response_type=json. The reply is then JSON, not an image, so capture() above needs a JSON branch in place of its image check: confirm that error is empty (in JSON mode a failed capture still answers HTTP 200), then decode image, a data URL (strip everything up to the first comma), and read the page's text from markdown; both come from the same capture. Save the Markdown next to each screenshot and compare two runs with Python's standard difflib module:
import difflib
def changed_lines(old_markdown, new_markdown):
"""Lines removed (-) and added (+) between two runs' Markdown."""
diff = difflib.unified_diff(
old_markdown.splitlines(), new_markdown.splitlines(), lineterm="", n=0
)
lines = list(diff)[2:] # drop the "---" and "+++" header lines
return [line for line in lines if not line.startswith("@@")]
markdown is present only when markdown_status is ok. Any other status means that run has no text, so skip the comparison instead of diffing against an empty string. Output is capped at 40,000 Unicode code points; when truncated is true, part of a long page is missing, and a change there can go unseen. Before you trust an empty diff, check that one run's Markdown contains the text you watch, such as a price: the conversion keeps the page's readable text, not every visible element. Rotating content, such as testimonials or dates, shows up as changed lines too.
Tips for Reliable Monitoring
- Use
no_ads=1andno_cookie_popup=1to remove dynamic elements that change between captures and create false positives. - Set a consistent viewport (e.g., 1280×1024) so screenshots are always comparable.
- Use
delay_time=3000to give JavaScript-rendered content three more seconds to load; a fixed delay cannot guarantee that every page is ready. - Capture from a fixed country using the
countryparameter (ISO code, e.g.country=US) to avoid geo-based content variations — see how country capture works. - Store screenshots with timestamps for audit trails and historical comparison.
Full Page Monitoring
For pages where content below the fold matters (e.g., long pricing pages), use full page capture:
response = requests.get(API_URL, params={
"url": url,
"userkey": API_KEY,
"full_size": 1,
"max_height": 10000,
"format": "jpeg", # JPEG for smaller files in archives
"no_ads": 1,
"no_cookie_popup": 1,
}, timeout=70)
FAQ
Can Site-Shot detect page changes for me?
Yes. Each scheduled capture is compared with the previous one, and Site-Shot measures how much of the shared image area moved. Turn on change alerts for a schedule, set your threshold, and it emails you when a capture crosses it — with a link that opens the two captures side by side. Two bounds worth knowing: it measures how much changed, not what changed (there is no text or element diff), and alerts go to email only, at most one per schedule per day. Alerts stay off until you switch them on. To see which words changed, request the page's Markdown from the Site-Shot API (markdown=1 with response_type=json) and compare two runs in your own code, which can also send alerts anywhere.
Do I need to write code to monitor a website with screenshots?
Not for the capture part. Site-Shot's built-in scheduled captures run from the browser: pick a URL, capture settings, and a cadence, and every shot lands in your library with a ledger of every run — included with any paid plan. Code is only needed for the custom parts: your own storage, a text diff of what changed, or routing alerts somewhere other than email.
How often should I capture a page for monitoring?
Match the cadence to how fast the page changes. With your own cron you can run the script hourly or more often, within your monthly capture quota. Site-Shot's built-in schedules run on the days you pick and the hours you tick, up to once an hour, within your plan's weekly capture allowance — the right fit for pricing pages, landing pages, and compliance records.
Next Steps
- Set up the Site-Shot API with your API key
- Create a monitoring script for your key pages
- Schedule it with cron, GitHub Actions, or your CI/CD pipeline — or skip the script and use scheduled captures
- Prefer a visual builder? The same monitoring loop is three nodes in n8n or three modules in Make, and a single code step in Pipedream
- Add image diffing and alerting for automated change detection
Try the free no-signup screenshot tool, read what the built-in scheduled screenshots do and do not do, or compare API plans on the pricing page.