Detect visual changes, catch layout regressions, and monitor competitor pages automatically.
Scheduled screenshot captures give you a pixel-level audit trail of any website over time.
What Can You Monitor?
Your own site: catch deployment regressions before users report them. Take screenshots
of critical pages after every deploy — homepage, pricing, checkout, login — and compare against
a known-good baseline. Any significant pixel diff triggers an alert before you affect real customers.
Competitor pricing: schedule daily captures of competitor pricing pages.
Extract the text content and store it in a database. When pricing changes — a new plan tier,
a price increase, a promotion — your pipeline detects it and alerts your team automatically.
Content compliance: for regulated industries, screenshot key pages on a schedule
to maintain an audit trail. Capture the exact rendered state that users see — including
JavaScript-rendered disclaimers and consent banners — not just the raw HTML source.
Cron-Based Monitoring Script
// monitor.mjs — run via cron every hour
import { writeFile, readFile, access } from 'fs/promises';
const KEY = process.env.SNAPAPI_KEY;
const PAGES = [
{ name: 'homepage', url: 'https://yoursite.com' },
{ name: 'pricing', url: 'https://yoursite.com/pricing' },
{ name: 'checkout', url: 'https://yoursite.com/checkout' },
];
async function capture(url) {
const res = await fetch('https://api.snapapi.pics/v1/screenshot', {
method: 'POST',
headers: { 'X-Api-Key': KEY, 'Content-Type': 'application/json' },
body: JSON.stringify({ url, width: 1280, height: 800, waitUntil: 'networkidle' }),
});
return (await res.json()).url;
}
for (const page of PAGES) {
const screenshotUrl = await capture(page.url);
console.log(`${page.name}: ${screenshotUrl}`);
// Store to your database with timestamp
// await db.insert({ page: page.name, url: screenshotUrl, capturedAt: new Date() });
}
Change Detection with Text Extraction
// Extract text content and detect changes
const res = await fetch('https://api.snapapi.pics/v1/scrape', {
method: 'POST',
headers: { 'X-Api-Key': KEY },
body: JSON.stringify({
url: 'https://competitor.com/pricing',
waitUntil: 'networkidle',
}),
});
const { text } = await res.json();
// Compare against previous snapshot from DB
const previous = await db.getLatest('competitor-pricing');
if (previous && previous.text !== text) {
await sendAlert(`Competitor pricing changed! Review: ${screenshotUrl}`);
}
await db.save({ page: 'competitor-pricing', text, screenshotUrl });
Pricing
Free: 200 captures/month (enough for daily monitoring of 6 pages). Starter $19/mo: 5K (hourly monitoring of 6 pages). Pro $79/mo: 50K (5-minute monitoring of multiple sites).
Start free.
Visual Monitoring — Architecture Patterns
A complete website monitoring system has three components: a scheduler that triggers captures on a cron schedule, a capture layer that calls SnapAPI and stores the resulting URLs, and a diff engine that compares consecutive captures and alerts when changes exceed a threshold. Here is how to build each layer.
Scheduler Options
GitHub Actions: Free for public repos, generous minutes for private. Use a cron trigger (schedule: cron: "0 * * * *") to run hourly captures. Store baseline images as GitHub artifacts.
Node-cron or APScheduler: Run a lightweight Node.js or Python process on a cheap VPS. node-cron (Node) and APScheduler (Python) both support cron expressions with sub-minute precision.
Managed cron services: Trigger.dev, Inngest, Quirrel, or EasyCron can call a webhook on your schedule without managing a server. The webhook calls SnapAPI and stores results.
Storage Strategy
SnapAPI returns a hosted URL valid for 24 hours. For monitoring, download the PNG immediately and store it in your own S3 bucket or Cloudflare R2. This gives you a permanent, queryable archive of every capture with timestamps.
A simple PostgreSQL table: captures(id, page_name, url, screenshot_url, captured_at, diff_score, alerted). Query it to generate trend reports, identify which pages change most frequently, and build a dashboard showing the last 30 days of captures for any monitored page.
Alert Channels
When a diff exceeds your threshold, send alerts via Slack (webhooks), email (Postmark, Resend), or PagerDuty. Include the screenshot URL and diff percentage in the alert. For Slack, the screenshot URL renders as an inline image in the message, making it immediately clear what changed.
For content monitoring (competitor pricing, product announcements), use SnapAPI's scrape endpoint to extract text alongside the screenshot. Diff the extracted text rather than pixels — text diffs are more reliable for detecting meaningful content changes vs. layout shifts from A/B tests or personalization.
Pricing for Monitoring Workloads
Free (200/mo): daily capture of 6 pages for one month. Starter $19/mo (5K): hourly monitoring of 6 pages, or daily monitoring of 160 pages. Pro $79/mo (50K): 5-minute monitoring of 6 pages, or hourly monitoring of 68 pages continuously.
E-commerce agencies monitor client sites nightly and send a screenshot summary report every morning. If any page looks broken — a hero image not loading, a CTA button missing — the agency catches it before the client does.
SaaS companies run visual regression checks after every production deployment. Screenshots of the key customer-facing pages (onboarding flow, billing page, settings) are compared against pre-deploy baselines. A diff above threshold pages the on-call engineer immediately.
Market research firms track competitor pricing pages daily. SnapAPI extracts the text content alongside the screenshot, which is stored in a database. Analysts query the database to identify pricing trends, detect promotional periods, and track which competitors have changed their positioning.
Compliance teams in regulated industries schedule weekly captures of their own public-facing pages. The screenshots serve as evidence of what was shown to users on specific dates — useful for regulatory audits and litigation. Unlike server logs or database records, a screenshot is intuitive evidence that non-technical stakeholders can immediately understand.
All of these workflows use the same SnapAPI screenshot endpoint. The differentiation is in how you schedule, store, and act on the captures. Start free.
Can I monitor pages that require login? Yes — use a signed URL pattern or pass session cookies via the customJs parameter to inject auth cookies before capture.
What diff threshold should I use? Start at 2-5% for general monitoring. For critical pages (checkout, payment), use 1%. For pages with dynamic content (ads, timestamps), use 10-15% or hide dynamic elements with customCss before capture.
How often can I monitor? Starter (5K/mo) supports hourly monitoring of 6 pages. Pro (50K/mo) supports 5-minute monitoring of 6 pages or hourly monitoring of 68 pages continuously all month.
Can I monitor competitor sites? Yes — SnapAPI's stealth mode handles sites with bot protection. Use the scrape endpoint for text extraction alongside screenshot capture.
Alerting Integrations and SLA Tracking
Capturing screenshots is only half the job: routing alerts to the right people closes the loop. Connect your monitoring pipeline to PagerDuty, Opsgenie, or VictorOps for on-call escalation. For lightweight setups, a Slack webhook or email via SendGrid covers most needs. Include the diff image as an attachment so the on-call engineer can assess severity without logging into a separate dashboard.
For SLA tracking, store every monitoring run in a time-series database such as InfluxDB or TimescaleDB. Record the timestamp, URL, diff percentage, and pass or fail status. Query over rolling 7-day and 30-day windows to produce uptime percentages and mean time to detection metrics. These numbers feed directly into engineering OKRs and customer-facing status pages.
Cost Efficiency at Scale
SnapAPI's Business plan provides 500,000 API calls per month, making it cost-effective even for large URL portfolios. Monitoring 1,000 URLs every 15 minutes amounts to roughly 96,000 screenshots per day, well within the Business tier. Pair this with S3 Intelligent-Tiering for screenshot storage and your total infrastructure cost for enterprise-grade visual monitoring remains far lower than building and maintaining a Playwright fleet in-house.