Automate visual website monitoring. Capture screenshots on a schedule, detect changes, and alert your team — all with one API call per check.
Start Free — 200 Screenshots/moTraditional uptime monitors check whether a URL returns a 200 status code. That tells you the server is responding — but not whether the page actually looks right. A site can return 200 while displaying a blank white page, a JavaScript error screen, a misconfigured layout, or a checkout button that's broken. Screenshot-based monitoring catches these visual regressions that status checks miss entirely.
SnapAPI makes it trivial to add visual monitoring to any tech stack. Schedule a screenshot of your key pages every hour, every 15 minutes, or on every deployment. Compare the results, diff the pixels, and alert your team when something looks wrong. No Selenium infrastructure, no browser farm to maintain — just HTTP calls and image URLs.
import requests, hashlib, time
API_KEY = "your_key_here"
URLs_TO_MONITOR = [
"https://yoursite.com",
"https://yoursite.com/pricing",
"https://yoursite.com/checkout",
]
def capture(url):
r = requests.get("https://snapapi.pics/v1/screenshot", params={
"access_key": API_KEY,
"url": url,
"width": 1280,
"full_page": True,
})
return r.json()["url"]
for url in URLs_TO_MONITOR:
screenshot_url = capture(url)
print(f"{url} => {screenshot_url}")
time.sleep(1)For production monitoring, run your screenshot check on a schedule. Any job scheduler works since SnapAPI is just an HTTP call. Cron on a VPS is the simplest option. AWS Lambda with EventBridge rules scales to hundreds of URLs. GitHub Actions with a scheduled workflow runs monitoring in CI for free.
# GitHub Actions: screenshot monitoring every 30 minutes
name: Visual Monitor
on:
schedule:
- cron: "*/30 * * * *"
workflow_dispatch:
jobs:
monitor:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- run: pip install requests Pillow
- run: python monitor.py
env:
SNAPAPI_KEY: ${{ secrets.SNAPAPI_KEY }}
SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}Compare screenshot pixels between runs to detect visual changes. Use Pillow in Python for simple pixel comparison, or integrate with a dedicated visual regression tool. Store baseline screenshots in S3 or any object storage — SnapAPI returns CDN URLs you can fetch and compare directly.
from PIL import Image, ImageChops
import requests
from io import BytesIO
def compare_screenshots(url1, url2, threshold=0.02):
img1 = Image.open(BytesIO(requests.get(url1).content)).convert("RGB")
img2 = Image.open(BytesIO(requests.get(url2).content)).convert("RGB")
diff = ImageChops.difference(img1, img2)
pixels = list(diff.getdata())
changed = sum(1 for p in pixels if max(p) > 10)
change_pct = changed / len(pixels)
return change_pct > threshold, change_pct
# Compare baseline vs current
changed, pct = compare_screenshots(baseline_url, current_url)
if changed:
alert_team(f"Visual change detected: {pct:.1%} of pixels differ")When a visual change is detected, fire an alert through your existing notification channels. The screenshot URL from SnapAPI embeds directly in Slack messages as a preview — your team can see exactly what changed without logging into any dashboard.
import requests
def alert_slack(webhook_url, page_url, screenshot_url, change_pct):
requests.post(webhook_url, json={
"text": f":warning: Visual change on {page_url} ({change_pct:.1%} pixels changed)",
"attachments": [{
"title": "Current Screenshot",
"image_url": screenshot_url,
"color": "warning"
}]
})Monitor authenticated pages by passing cookies or auth headers. This lets you check that logged-in views — admin dashboards, user portals, checkout flows — render correctly, not just your public-facing pages.
r = requests.get("https://snapapi.pics/v1/screenshot", params={
"access_key": API_KEY,
"url": "https://app.yoursite.com/dashboard",
"cookies": '[{"name":"session","value":"abc123","domain":"app.yoursite.com"}]',
"width": 1280,
"full_page": True,
})At 200 free screenshots per month, you can monitor up to 5 pages every hour. The Starter plan at $19/month (5,000 screenshots) covers 10 pages checked every 30 minutes around the clock. Growth at $79/month (50,000 screenshots) handles large-scale monitoring — 100 pages every 15 minutes, continuously. For enterprise monitoring infrastructure, custom plans are available with dedicated capacity and SLA guarantees.
One of the highest-value applications of screenshot-based monitoring is post-deployment verification. After every production deploy, automatically capture screenshots of your key pages and compare them to pre-deploy baselines. If the deploy broke something visually — a missing CSS file, a broken JavaScript bundle, an incorrectly migrated database field rendering wrong text — you catch it in seconds, before users do.
Integrate this into your CI/CD pipeline alongside your existing automated tests. A failed visual comparison can block the deploy from going live or trigger an immediate rollback. This is especially valuable for frontend-heavy applications where traditional test coverage doesn't catch visual regressions.
# Post-deploy verification script
#!/bin/bash
set -e
echo "Running visual verification..."
python3 verify_deploy.py --urls "$DEPLOY_URLS" --baseline-bucket s3://baselines
if [ $? -ne 0 ]; then
echo "Visual regression detected — triggering rollback"
./rollback.sh
fiFor e-commerce sites, visual monitoring is critical on revenue-generating pages. A broken checkout button, a missing product image, or a misconfigured discount display can cost thousands in lost revenue per hour. Monitor your cart page, checkout flow, product listing pages, and promotional banners on a tight schedule — every 5–15 minutes during peak hours.
SnapAPI's full-page screenshot capability is particularly useful here. Product pages with long image galleries, detailed specifications, and customer reviews need full-page captures to verify that content below the fold renders correctly. Partial screenshots miss the bottom half of the page where many rendering issues occur.
If your site serves users globally, visual monitoring from a single location may miss region-specific issues — CDN misconfigurations, geolocation-based content differences, or latency-related rendering problems. Run your monitoring script from multiple regions using cloud functions in different availability zones. SnapAPI handles the browser rendering consistently regardless of where your monitoring script runs, giving you reliable visual baselines across all regions.
Store every monitoring screenshot URL in a database with a timestamp and URL. This creates an automatic visual audit trail of your site over time. When a customer reports a bug that occurred last Tuesday, you can pull up exactly what the page looked like at that time. This is invaluable for debugging intermittent issues and for compliance documentation that requires evidence of page state at specific points in time.
# Store screenshot with metadata
import psycopg2, datetime
conn = psycopg2.connect(DATABASE_URL)
cur = conn.cursor()
cur.execute(
"INSERT INTO monitoring_log (url, screenshot_url, captured_at) VALUES (%s, %s, %s)",
(monitored_url, screenshot_url, datetime.datetime.utcnow())
)
conn.commit()Dedicated visual monitoring services like Percy, Chromatic, and Applitools are excellent for component-level visual regression testing in CI/CD. They integrate deeply with Storybook and testing frameworks. But they're priced for enterprise — Percy starts at $99/month, Applitools at several hundred dollars per month.
SnapAPI is not a replacement for these tools when you need component-level testing. But for page-level production monitoring — checking that your live site looks right every N minutes — SnapAPI at $19/month paired with a simple pixel comparison script delivers most of the value at a fraction of the cost. Many teams use both: SnapAPI for production monitoring, Percy for pre-merge visual regression testing.
Start monitoring your key pages today. Free account includes 200 screenshots per month — enough to monitor 5 pages every hour, around the clock.
The fastest path to production visual monitoring is a simple Python script using the requests library plus a cron job or GitHub Actions workflow. Write a function that captures a screenshot via SnapAPI, compares it to a stored baseline using Pillow, and sends a Slack alert if the pixel difference exceeds your threshold. This covers 90 percent of monitoring use cases. Start with your homepage, pricing page, and checkout page — the three highest-value URLs for most SaaS products. Add more URLs as you validate the workflow. The free tier gives you 200 screenshots per month, which is enough to monitor five pages hourly. For more pages or higher frequency, upgrade to the Starter plan at nineteen dollars per month. Your monitoring setup will pay for itself the first time it catches a production incident before a customer reports it. Create your free account and set up your first monitor today.
Screenshot-based monitoring with SnapAPI integrates in under an hour and runs reliably in any environment that can make HTTP requests. The API handles browser rendering, JavaScript execution, and CDN hosting automatically. Whether you are monitoring five pages or five hundred, the implementation complexity stays the same. You write the comparison logic once and scale by adding URLs to your monitoring list. No browser infrastructure to provision, no Chromium processes to manage, no memory leaks to debug at two in the morning. Just clean HTTP calls and CDN image URLs, continuously capturing the visual state of your production site so you can catch problems before your users do. Sign up free and run your first visual monitor today.