Self-hosted Visualping alternative: watch any webpage for changes with changedetection.io
The web changes underneath you all the time, and almost none of it gets announced. A price quietly drops. A product comes back in stock for six hours. A vendor edits their terms of service and hopes nobody rereads them. Tools like Visualping and Distill exist to catch exactly these moments -- and then they meter you: so many pages, so many checks a day, more only if you upgrade. What you actually want is simple. Point it at a URL, tell it what matters, get told when it moves. changedetection.io does that, and you own the whole thing.
What changedetection.io is
changedetection.io is an open-source web page change monitor. You give it a URL, it fetches that page on a schedule, and when the part you care about changes, it tells you -- with a diff showing exactly what was added or removed. That's the whole premise, and it's executed properly. This isn't a stripped-down clone that handles static pages and gives up on anything modern. It renders JavaScript-heavy sites through a real browser, reads structured product data to track prices and stock, filters out the noise you don't care about, and pushes alerts to dozens of channels.
The contrast with the hosted services is mostly the meter. Visualping and Distill gate the number of watches and the check frequency behind tiers; the free plans are demos and the useful plans are subscriptions that scale with how much you watch. Self-hosted, there's no per-watch cap. You watch as many pages, as often, as your server can handle -- and that's a line you control, not a billing row.
The features that actually matter
None of these are premium add-ons here. The self-hosted build is the whole thing, and this is the part of it you'll live in.
- Visual selector. Instead of hand-writing selectors, you click the exact element you want to track -- the price, the "in stock" line, one paragraph of a policy -- and it watches only that. It's the point-and-click experience the paid services charge for.
- Real diffs, kept as history. Every check keeps a snapshot, and changes show up as an added/removed text diff. You see *what* changed, not just *that* something did, and you can scroll back through past versions.
- Restock and price monitoring. A dedicated mode reads the structured product data most e-commerce pages publish, so it tracks price and availability directly -- alert me when this drops below a number, moves more than a set percentage, or comes back in stock.
- Notifications through Apprise. Apprise is built in, fanning out to 85-plus channels: email, Telegram, Discord, Slack, Pushover, webhooks, and more. Alert bodies are Jinja2 templates, so you can drop in tokens like the diff and the current snapshot.
- Filters, ignore rules, and trigger text. CSS, XPath, JSONPath, and jq selectors narrow what's watched; ignore-text rules drop the parts that always churn; trigger-text only fires when a specific phrase appears. This is how you kill false alarms.
- A real browser when the page needs one. For sites that render with JavaScript or hide content behind a login, it drives a headless Chrome and supports Browser Steps -- click, scroll, fill a field, then capture.
- Conditions, scheduling, and an API. Set numeric conditions so it only notifies when a rule is met, tune the recheck interval per watch down to day-of-week and time-of-day windows, subscribe to changes as an RSS feed, and drive the whole thing from a REST API.
Why self-host it instead of the hosted version
Your watch list is data. The URLs you monitor say a lot -- what you're buying, which competitors you track, whose terms you're waiting on. On a hosted service that list, and every snapshot it captures, lives on someone else's account. Self-hosted, it never leaves your box.
The cost doesn't scale per-watch. The hosted tools price on volume: more pages and more frequent checks cost more, every month, forever. Your own instance costs the same whether it's watching five pages or five hundred. The economics invert right at the point the tool gets genuinely useful and you want to watch a lot.
You control the checks and the alerts. Set five-minute intervals on the watches that matter without hitting a plan ceiling. Route notifications wherever your team already lives. Run it on your own domain, behind your own auth. It answers to your rules, not a tier chart.
Who it's for
Deal hunters and resellers who want to catch a price drop or a restock the minute it happens, across as many product pages as they like, without paying per watch.
Ops and compliance teams tracking competitor pricing, supplier pages, status pages, or the terms and privacy policies of vendors they depend on -- with a diff and a timestamp for the record.
Anyone waiting on a specific page -- a job board, a course opening, a government form, a concert page, a landlord's listings -- who'd rather get a ping than refresh a tab twelve times a day.
The honest setup notes
Self-hosting this well means owning a few chores. Everything -- your watches, their filters, and all the snapshot history -- lives in a single datastore volume. That's tidy, but it also means one lost host takes the whole thing with it, so you need real backups. Monitoring JavaScript-rendered sites requires a second browser container alongside the app; the base image alone does a plain HTTP fetch, and the browser adds meaningful memory. Notifications go nowhere until you wire up an SMTP account or an Apprise channel yourself. And the project ships on a fast-moving `latest` tag, so staying current means pulling and recreating on your own cadence.
None of that is hard. It's just yours to remember, on top of running the server underneath it. Or let us run it.
Deploy it in one click
Rolling your own means provisioning a host, wiring the datastore volume, deciding whether to run the browser container, configuring SMTP, and keeping the image patched -- then doing that same maintenance every month. On Caliber Node you deploy changedetection.io in one click and skip straight to the part that matters: adding watches. We handle the container, the persistent storage, TLS on your own subdomain, and the backups. You still get real logs, SFTP into the files, and a datastore you can export whenever you want. It's the full, unrestricted app -- no watch caps, no metered checks -- without the afternoon of setup or the standing maintenance tab.
First run
- Open your changedetection.io URL and set a password under Settings so the instance isn't world-readable.
- Paste a URL into "Add a new watch" and save it.
- Open the watch, launch the visual selector, and click the exact element you care about -- the price, the stock line, the paragraph.
- Under Notifications, add your email or a channel through Apprise and send a test alert.
- Set the recheck interval, save, and wait for the first diff to land in your inbox.
That's a live watch in five steps -- and you can duplicate it across as many pages as you want without asking anyone's permission.
The bigger picture
Watching the web for changes is a small, quiet form of leverage. It's how you catch the price before it climbs back up, the restock before it sells out, the policy edit before it's the new normal. Hand that to a service that meters it, and your own vigilance becomes a subscription line. Own the tool and it turns back into infrastructure -- something that just runs, watching what you tell it, for as long as you keep the lights on.
Deploy changedetection.io in a few minutes →
One-click self-hosted apps, managed for you -- real logs, SFTP, and your data always exportable. Never a black box.