SnapRender
Change monitoring

Know the moment
a page changes

Add a page and SnapRender checks it every hour, day or week, compares each capture with the last one, and alerts you when it changes, with both versions side by side. Prefer code? The recipes below diff the page text yourself, in Python or Node.js.

200 renders a month free, no card. Every feature on every plan.

Two ways to run it

Let SnapRender run the schedule, the comparison and the alerts, or call the API from your own code. Same captures, same price per render.

Without code: a schedule

  1. Add the page and choose every hour, day or week

  2. Pick what should alert you: any change, bigger edits, or big changes only

  3. Get a change.detected webhook (or an email on Business and Scale), and see before and after side by side in the dashboard

A page before and after a change in the SnapRender dashboard, with the changed areas outlined

Set it up free How schedules work

With code: the recipes below

Two approaches cover most monitoring. A text hash is cheap and ignores rendering noise, so it is the right first signal. A pixel diff catches layout and image changes the text misses. Start with text, add pixels where they matter.

  • monitor.py: text hash with a screenshot on change (Python)
  • pixel-diff.mjs: visual change percentage (Node.js)
  • .github/workflows/monitor.yml: run it every six hours (YAML)
  • No cron at all: a built-in schedule (curl)

See the code

Try it on your URL

Live capture, no signup. You get the screenshot and the exact API call that produced it.

Why this is harder than it looks

Change monitors that compare raw HTML fire on every rotating ad slot, CSRF token and timestamp in the markup. After a week of false alarms nobody reads the alerts. Comparing the rendered text of the page, after scripts have run and consent pop-ups are gone, removes most of that noise.

Self-hosting the browser that renders those pages is the part that breaks. A headless Chromium on a cron box leaks memory, fails silently on sites that need a real user agent, and captures the consent dialog instead of the content. The job keeps running and the archive fills with screenshots of cookie banners.

Hosted monitoring tools solve that, priced per monitored page and with the history locked in their app. That suits a team watching ten pages. A developer watching a few hundred URLs usually wants a price per capture and the changes routed into their own systems.

Who does what

With a schedule, SnapRender does the capture, the history and the alert. With your own code, the schedule and the files stay in your systems.

SnapRender does

  • Render the page in real Chromium with ads and cookie banners removed
  • Return the visible text from GET /v1/extract?type=text, ready to hash and diff
  • Capture a full-page PNG of the changed version, fresh every time (caching is off unless you turn it on)
  • Run batches of up to 50 URLs and call your webhook when the batch finishes
  • Or run the whole loop for you: hourly, daily or weekly captures with a history, a change percentage and a change.detected webhook, plus an email on Business and Scale (POST /v1/schedules)

You wire up

  • With a schedule: choose the pages and how big a change should alert you
  • With your own code: run it from cron, GitHub Actions, a cloud scheduler or n8n, and keep the previous hash or image
  • Decide where the alert goes: your inbox, a webhook, Slack

The code

Two approaches cover most monitoring. A text hash is cheap and ignores rendering noise, so it is the right first signal. A pixel diff catches layout and image changes the text misses. Start with text, add pixels where they matter.

monitor.py: text hash with a screenshot on change
Python
import hashlib, json, os, pathlib, datetime, requests

API = "https://app.snap-render.com"
HEADERS = {"X-API-Key": os.environ["SNAPRENDER_API_KEY"]}
URLS = ["https://example.com/pricing", "https://example.com/terms"]
STATE = pathlib.Path("state.json")
ARCHIVE = pathlib.Path("captures")

state = json.loads(STATE.read_text()) if STATE.exists() else {}
ARCHIVE.mkdir(exist_ok=True)

for url in URLS:
    r = requests.get(f"{API}/v1/extract", headers=HEADERS, timeout=60,
                     params={"url": url, "type": "text"})
    r.raise_for_status()
    text = r.json()["content"]
    digest = hashlib.sha256(text.encode()).hexdigest()

    if state.get(url) == digest:
        continue  # unchanged since the last run

    stamp = datetime.datetime.now(datetime.timezone.utc).strftime("%Y%m%dT%H%M%SZ")
    shot = requests.get(f"{API}/v1/screenshot", headers=HEADERS, timeout=90,
                        params={"url": url, "format": "png", "full_page": "true"})
    shot.raise_for_status()
    name = ARCHIVE / f"{url.split('//')[1].replace('/', '_')}-{stamp}.png"
    name.write_bytes(shot.content)

    if url in state:  # first run records a baseline, later runs alert
        print(f"CHANGED {url} -> {name}")
    state[url] = digest

STATE.write_text(json.dumps(state, indent=2))

Each URL costs one extract call per run, plus one screenshot only when the text changed. The first run records a baseline without alerting.

pixel-diff.mjs: visual change percentage
Node.js
// npm install pngjs pixelmatch
import fs from 'node:fs';
import { PNG } from 'pngjs';
import pixelmatch from 'pixelmatch';

const url = 'https://example.com';
const params = new URLSearchParams({ url, format: 'png', width: '1280', height: '800' });
const res = await fetch(`https://app.snap-render.com/v1/screenshot?${params}`, {
  headers: { 'X-API-Key': process.env.SNAPRENDER_API_KEY },
});
if (!res.ok) throw new Error(`capture failed: ${res.status}`);
const current = PNG.sync.read(Buffer.from(await res.arrayBuffer()));

if (fs.existsSync('previous.png')) {
  const previous = PNG.sync.read(fs.readFileSync('previous.png'));
  const { width, height } = current;
  const diff = new PNG({ width, height });
  const changed = pixelmatch(previous.data, current.data, diff.data, width, height, { threshold: 0.1 });
  const percent = (changed / (width * height)) * 100;
  console.log(`${percent.toFixed(2)}% of pixels changed`);
  if (percent > 1) fs.writeFileSync('diff.png', PNG.sync.write(diff));
}
fs.writeFileSync('previous.png', PNG.sync.write(current));

Viewport captures at a fixed 1280 x 800 keep both images the same size, which pixel diffing needs; full-page heights change from run to run.

.github/workflows/monitor.yml: run it every six hours
YAML
name: page-monitor
on:
  schedule:
    - cron: "0 */6 * * *"
  workflow_dispatch:

jobs:
  check:
    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:
          SNAPRENDER_API_KEY: ${{ secrets.SNAPRENDER_API_KEY }}
      - name: Keep state and captures in the repo
        run: |
          git config user.name "page-monitor"
          git config user.email "[email protected]"
          git add state.json captures
          git commit -m "monitor run" || echo "no changes"
          git push

GitHub Actions is a free scheduler for this. Committing state.json between runs gives the next run its baseline and keeps a dated history of every change.

No cron at all: a built-in schedule
curl
curl -X POST "https://app.snap-render.com/v1/schedules" \
  -H "X-API-Key: $SNAPRENDER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/pricing", "interval": "daily", "full_page": true, "change_threshold": 1}'

# History, newest first, with download links and the change percentage
curl "https://app.snap-render.com/v1/schedules/SCHEDULE_ID/captures" \
  -H "X-API-Key: $SNAPRENDER_API_KEY"

SnapRender keeps every capture with its SHA-256 and sends change.detected to your webhook when more than 1% of the page changes. The free plan holds one daily or weekly schedule; paid plans hold more and keep history longer.

Every parameter is in the API reference and the OpenAPI spec. Errors come back as { "error": { "code", "message", "status" } }; a 429 with QUOTA_EXCEEDED means the monthly allowance is used.

What it costs at your volume

A text check is one call per page per run, and screenshots only happen on change. Fifty pages checked daily is about 1,500 calls a month, which fits Starter at $9. Hourly checks on the same 50 pages are about 36,000 a month, which is Business territory.

About 0 renders a month

Free

Start free

A month counts as 30 days. Failed captures are refunded. Yearly billing on paid plans is ten months for twelve. All plans.

Get a key and run the first recipe today

Every script on this page works with a free key: 200 renders a month, every feature included, no card. Your first capture takes about two minutes.

Paid plans from $9 for 2,000 renders. Yearly billing is ten months for twelve. Failed captures are refunded.

Get a free API key

Frequently asked questions

Do I have to write code?+

No. Add the page as a schedule in the dashboard: SnapRender captures it every hour, day or week, compares each capture with the one before, and alerts you when it changes, with a before and after view. The code on this page is for teams who want to run the checks themselves.

Should I compare text or screenshots to detect changes?+

Start with text. GET /v1/extract?type=text returns what a reader sees after scripts run, so hashing it ignores markup noise such as tokens and ad slots. Add a pixel diff for pages where layout, images or colors are what you care about.

Does SnapRender run the schedule for me?+

It can. POST /v1/schedules, or the dashboard, captures a URL every hour, day or week, keeps each PNG with its SHA-256, compares it with the previous capture and sends capture.completed and change.detected webhooks. Every plan includes schedules; the free plan holds one daily or weekly schedule. If you would rather own the timing and the storage, call the API from cron, GitHub Actions or n8n instead.

Will I get stale results from a cache?+

No. Caching is off by default, so every request renders the page fresh. Batch jobs always render fresh too. Turn caching on with cache=true only for repeat requests where an older copy is acceptable.

How do I avoid false alarms from cookie banners and ads?+

Both are removed before capture by default (block_cookie_banners and block_ads are on). For other dynamic areas, such as a rotating testimonial, pass hide_selectors with a CSS selector and that element is hidden before the text or image is taken.

How many pages can I monitor on the free plan?+

The free plan includes 200 renders a month and one schedule; a daily schedule uses about 30 renders a month. With your own code, the same 200 renders cover six pages checked daily, or about forty checked weekly. Starter at $9 adds 5 schedules and 2,000 renders.

Your first capture takes two minutes

200 renders a month free, no card. The API key is on the next screen.