Page change monitoring
Upcheck's content check rereads a page you choose every five minutes and tells your team the moment its text — or a price on it — changes, by email, Slack, Discord, Teams, or webhook.
$10/month base · $1 per website · content check included
Most changes don't file a ticket
A competitor doesn't email you when they cut a price. A colleague doesn't open a ticket when they edit the terms page instead of asking anyone. A status page banner doesn't fire a webhook when someone types over it by hand. Uptime monitoring answers whether a page is there; it has nothing to say about whether the page still says what it said yesterday.
Website change detection means rereading the page and comparing what it says now with what it said last time — no deploy hook, no CMS webhook, nothing to wire up on the site itself. Upcheck's content check does exactly that: point it at a path and an optional element, and every 5 minutes it rereads that selection and reports the moment a real content change happens, or a price on the page moves. It's the most direct way to monitor a web page for changes you don't control, or don't want to rely on someone remembering to announce.
Failures use the same detection math as the uptime check: confirmed twice so a mid-deploy blip never pages anyone. A real change alerts on the first probe, because there is no false positive once the fingerprint has actually moved.
Page change monitoring in three steps
- 01
Name the page, the element, and the mode
A path on the website's hostname — the homepage by default, or /pricing, /terms, a competitor's product page. An optional CSS selector such as #price, .product-price, or main, to narrow the comparison to one element instead of the whole page. And a mode: text for any change, number for a change to a figure, decrease or increase to alert on only one direction. One content check per website, opt-in and created disabled until you set it up.
- 02
Every 5 minutes, the page is reduced to the words that matter
A real fetch of the page, redirects followed, a 10-second timeout, reading up to the first 2 MB of the response. Scripts, styles, noscript blocks, templates, comments, and tags are stripped out, whitespace is collapsed, and what's left is fingerprinted and compared with what the previous probe saw. In a number mode, the first number in the selection is parsed instead — thousands separators, decimal commas, and currency symbols included — and compared as a number.
- 03
A change alerts immediately; a failure waits for a second probe
The first probe that sees a different fingerprint alerts, with the text or number before and after in the message, and the new content becomes the baseline — there is no confirmation delay for a real change. A failure — the page unreachable, a 5xx, a selector matching nothing, no number found in a number mode — is confirmed by a second probe first, the same as an uptime check, and a recovery alert follows once it passes again.
One content change, read the way you need it
Every content check reads the same selection. What differs is which kind of change in it is worth an alert.
The default when you don't know what will change and just want to know that it did — a paragraph reworded, a clause added to a policy, a new entry at the top of a changelog. Point it at the whole page or narrow it to one element; either way, any difference in the visible text trips it.
Reads the first number out of the selection — a price, a count, a percentage — handling thousands separators, decimal commas, and currency symbols, and compares it as a number rather than as text.
Everything number mode does, with the alert filtered to one direction. Point it at a competitor's price and hear about it the day they cut it, without a notification for every cosmetic re-render of the same figure.
The mirror of decrease mode — for a price you expect to hold steady, a quota you don't want raised without notice, or a competitor whose price rise is itself the news.
A content change comes with its own evidence
“Changed” on its own sends someone to reload the page and compare it by eye. So every probe keeps what it saw: the text or number before and after, which selector produced it, the HTTP status and timing, and where redirects landed — the same detail an uptime probe keeps, plus the content itself.
The verdict and the HTTP status are recorded separately. A page can pass — content unchanged — while answering a 4xx, since a 4xx is read like any other page; and it can fail the content check while answering 200, when the selector stops matching anything on an otherwise healthy page.
Every state a content check can be in
- Unchanged
The selection matches the fingerprint from the last probe — same text, or in a number mode the same figure. Nothing to report, and no alert fires.
- Failing
The page couldn't be read — unreachable, a 5xx, a timeout — or, in a number mode, the selector matched nothing or held no number at all. One failing probe starts the clock; a second, five minutes later, confirms it and fires your rules.
- Checking
Just set up. The first probe runs the moment you save the check, so it has a real baseline in seconds rather than waiting for the next five-minute slot.
- Not set up
Every website has a content check waiting, created disabled. Until you set a path, selector, and mode, it costs nothing and watches nothing.
If the selection changes on three consecutive probes, the check stops alerting and shows a warning instead of paging you — narrowing the selector usually resolves it, and alerting resumes the moment the content holds still for a probe.
One alert for a change, one for a failure, and one when it recovers
A content rule fires the moment a change is confirmed — for a real change, that is the very first probe that sees it — and again, with the recovery trigger, once a failure clears. The alert names what happened: a change shows the text or number before and after; a failure names what went wrong, an unreachable page, a 5xx, a selector matching nothing, no number found; a recovery alert follows once the page passes again.
The first content check an organization sets up creates its own email alert rule automatically, so it alerts with no further setup. From there it behaves like every other rule — scope it to specific websites, and route it to email, Slack, Discord, Microsoft Teams, or a webhook, where it arrives as a structured content.alert event carrying content_changed, content_failed, or recovered, so your own tooling can route it apart from an outage or an expiring certificate.
What makes a good page change monitoring tool quiet
The check is only as good as the selector and mode you give it. These are the rules that keep it quiet when nothing meaningful moved, and loud when it did.
- 01
Narrow the selector when you can
#price, .product-price, a specific section's id — the narrower the selection, the fewer probes are tripped by something else on the page moving instead.
- 02
Leave it empty only when you mean the whole page
Whole-page text mode also catches a rotating testimonial, an ad slot, or a “updated 3 minutes ago” timestamp — anything that isn't the change you actually want to hear about.
- 03
Match the mode to what you're watching
A price or a count wants number, decrease, or increase; a paragraph or a banner wants text. Number mode on a price ignores everything around it that isn't the figure; text mode on the same element would alert on a currency symbol swap too.
- 04
Check View Source, not the rendered page
Only the HTML the server sends is read. Content a script inserts after the page loads isn't there to be compared — the same limitation the keyword check has.
- 05
If it keeps flapping, the selector is too broad
Three changes on three consecutive probes trips a warning and the check stops alerting until the content holds still for a probe. Narrowing the selector is usually the fix, not switching mode.
- 06
One content check per website, on the page that matters
Point it at the page whose change actually costs something — a pricing page, a terms page, a competitor's product page — not the blog.
What people point a content check at
A competitor's pricing page
Point it at their pricing page, narrow the selector to the price, and set mode to decrease for the moment they cut it — or increase to hear about a rise before a customer asks why yours looks expensive by comparison.
Your own terms, privacy, or pricing pages
A website update to a legal or pricing page rarely comes with a pull request. A content check on the same page logs what it said before and what it says now, in the alert.
Documentation or a changelog
A docs page that changes without a version bump, or a changelog that gets a new entry, shows up as a content change on the next probe — useful when the page is the only record of what shipped.
A status page banner
A vendor's incident banner is page content, not an API. Reading it every 5 minutes is a content check's job, run against a page you don't control.
A client's site, edited without telling the agency
An agency managing sites it doesn't touch day to day gets the alert a client should have sent: what changed on their page, and when.
Defacement
A wholesale, unexpected rewrite of a page's text trips the same comparison as a small edit — the alert carries the before and after, whatever the size of the change.
A regulatory notice page
A licence, a compliance disclosure, any page required to carry a specific notice — watched the same way, alerting the moment its text changes.
Waiting for a product to come back in stock is a different job: the keyword check in absent mode, watching for “Out of stock” to disappear, is the better tool for that.
What this page change monitoring is not
Not a screenshot or visual diff tool
It compares text, not pixels. A redesign that keeps the same words untouched won't register as a change; a single word edited inside an otherwise identical layout will.
Not a crawler
One page per website, not a site-wide scan. To watch more pages, add more websites, or point the one content check at the page that matters most.
Not a rendered browser
No headless browser runs on a probe. Text that JavaScript adds to the page after it loads is invisible to it, the same limitation the keyword check has.
Not the keyword check
The keyword check confirms one phrase you name is present or absent. The content check watches a page for any change to its text or a number, without you predicting what the change will say. A website gets one of each.
Included in the dollar
$10 per month for the workspace, plus $1 per website per month — and the dollar covers everything Upcheck watches on that website: uptime every 5 minutes, the content check every 5 minutes once you set one up, the keyword check every 5 minutes once you set one up, the SSL certificate every 12 hours, DNS every 6, and the domain registration daily. There is no separate content monitor to count, no tier that withholds it, and no cap on how many of your websites run one. A workspace can track up to 500 websites.
Comparing monitoring tools? The honest UptimeRobot alternative page lays out what is included on Upcheck's one plan, and what is not.
Frequently asked questions
Does page change monitoring render JavaScript?
No. Each probe is a single HTTP fetch of the page — the same document View Source shows — reduced to text after removing scripts, styles, and markup. Content a script adds after the page loads, a single-page app's rendered body, a price fetched client-side, is invisible to it. If the text or number you care about only appears in the browser's Elements inspector and not in View Source, this check cannot see it.
How does it avoid false positives?
The comparison strips scripts, styles, noscript blocks, templates, comments, and HTML tags before comparing, and collapses whitespace, so a rotated nonce or CSRF token doesn't register as a change — only the visible text does. A selector narrows the comparison to the one element that matters instead of the whole page. And if the selection changes on three consecutive probes, the check stops alerting and shows a warning to narrow the selector, rather than paging you every five minutes.
Can I use it as a price drop alert?
Yes — set mode to decrease, point the path at the page, and narrow the selector to the price element. Upcheck parses the first number in that selection, handling currency symbols, thousands separators, and decimal commas, and alerts only when it goes down. Set mode to increase instead to catch a price rise, or to number to hear about either direction.
How is it different from the keyword check?
The keyword check confirms one phrase you name is present or absent on a page. The content check watches a page, or one element of it, for any change to its text or a number, without you having to predict what the change will look like. They're separate checks with separate configuration, and a website gets one of each.
How often does it check the page?
Every 5 minutes, the same cadence as the uptime check and the keyword check, fetching the page fresh with a 10-second timeout and reading up to the first 2 MB of the response. A change alerts on the very first probe that sees it — unlike a failure, there's no second-probe wait before it fires.
Does it take screenshots?
No. It compares text, not pixels — there's no screenshot, no visual diff, and no rendering of the page at all. If a redesign changes a paragraph's wording, the check sees that; if it only changes the layout or colors around the same words, the check sees nothing, because the words didn't change.
How many pages per website can I monitor?
One. The content check takes a single path on the website's hostname, the homepage by default, and optionally a CSS selector to narrow it to one element on that page. It isn't a crawler — to watch more than one page, add another website for each hostname, or point the one content check at the page that matters most.
What happens when the page is down?
A page that's unreachable, times out, or returns a 5xx is treated as a failure, not a change, and it's confirmed the way an uptime failure is: a second probe five minutes later, before anyone is alerted. A 4xx page is read like any other page — if the selector still matches text there, the check evaluates it normally. Once the page passes a probe again, a recovery alert follows.
Know when the page itself changes, not just when it goes down.
Add the websites you own, point a content check at the page that matters, and let the probes read it for you.