# Get an alert when a web page changes, set up from ChatGPT or Claude

Source: https://clickruntime.com/use-cases/website-change-alerts

> Ask your assistant to watch a page. ClickRuntime checks it on a schedule, compares it with the last version it saw and sends you a short summary of what changed, by email or in Slack.

## Can ChatGPT or Claude watch a website for changes?

Not on their own: an assistant only acts while you are chatting, and it doesn't remember what the page looked like last time. With ClickRuntime connected, you ask once and it sets up an automation that checks the page on a schedule (every 5 minutes or slower), keeps the last version, and emails you or posts to Slack only when something changed.

### Why the assistant can't do this on its own

- No schedule. ChatGPT and Claude answer when you send a message. Nothing checks the page at 3 a.m. unless something outside the chat runs it.
- No memory of the page. To know something changed you need the previous version. A chat starts fresh, so there is nothing to compare against.
- Built-in scheduled tasks re-run a prompt and answer in the chat. They can browse, but they don't keep a stored copy to compare against, can't use your Slack workspace, and have limits on how many run.
- ClickRuntime runs a small Python script on its servers. It fetches the page, keeps a fingerprint and a copy of the part you care about in the automation's state, and only notifies you on a real change.

## Set it up from your AI assistant

Prompt to copy:

> Create a ClickRuntime automation: every hour, check https://acme.com/pricing. Only look at the pricing table, not the whole page. When it changes, email me a short summary of what changed. Don't email me when nothing changed.

1. **Connect ClickRuntime to your assistant.** Add ClickRuntime as a connector (MCP server) in ChatGPT, Claude, Cursor or another MCP client, using https://clickruntime.com/api/mcp. You sign in with Google or email; there is no API key to copy. This is done once per assistant.
2. **Paste the prompt.** Start a new chat and paste: “Create a ClickRuntime automation: every hour, check https://acme.com/pricing. Only look at the pricing table, not the whole page. When it changes, email me a short summary of what changed. Don't email me when nothing changed.” Change the details (times, channels, addresses) to yours.
3. **Read the draft.** The assistant restates what will happen, asks for anything missing, such as your timezone or which channel to post to, and saves a draft automation. A draft never runs on its own, so nothing happens until you agree.
4. **Connect accounts and save keys.** Watching a public page needs no accounts. Email alerts go to the address you signed in with. If you'd rather get the alert in Slack, the assistant gives you a button to connect a Slack workspace for notifications in the ClickRuntime dashboard, and asks which channel to use.
5. **Test it.** The assistant runs it once. The first run stores the current version and reports “baseline saved”. To see an alert, it can run a test against a page you know will differ, or you can ask it to show what the summary would look like from the stored copy.
6. **Turn it on.** The assistant tells you what will run, when, and which services it will contact, then asks your permission to turn it on. From then on it runs on ClickRuntime's servers, and you can close the chat.
7. **Check it in the ClickRuntime dashboard.** The automation's page shows its schedule, the next three run times and every run with its result, such as “no change” or “changed: Pro plan price $49 → $59”. Under State you can see the stored fingerprint and when it last changed. Pause, run now and the script itself are on the same page.

Connector setup for each assistant: https://clickruntime.com/assistants

## What the assistant writes

`watch_pricing_page.py`

```python
import hashlib
from bs4 import BeautifulSoup
from clickruntime import on_trigger, report_fetched, state, notify, ai, http, log

URL = "https://acme.com/pricing"
SELECTOR = "table.pricing"        # the part of the page to watch

@on_trigger
def run(event):
    html = http.get(URL, headers={"User-Agent": "ClickRuntime page watch"}).text
    node = BeautifulSoup(html, "lxml").select_one(SELECTOR)
    if node is None:
        raise RuntimeError(f"{SELECTOR} not found on {URL}; the page layout may have changed")
    text = " ".join(node.get_text(" ").split())
    digest = hashlib.sha256(text.encode()).hexdigest()

    previous = state.get("digest")
    changed = previous is not None and previous != digest
    report_fetched(1 if changed else 0)
    if previous is None:
        state.set("digest", digest)
        state.set("text", text[:8000])
        return {"summary": "Baseline saved"}
    if not changed:
        return {"summary": "No change"}

    old_text = state.get("text") or ""
    try:
        summary = ai.generate(
            f"Before:\n{old_text[:4000]}\n\nAfter:\n{text[:4000]}",
            system="Say in at most three short lines what changed between the two versions of a pricing table.",
            max_output_tokens=150,
        ).text.strip()
    except ai.AIError as e:
        log.warning("AI summary unavailable", {"code": getattr(e, "code", None)})
        summary = "The pricing table changed. Open the page to see the new version."

    notify.email_me(f"Change on {URL}", f"{summary}\n\n{URL}")
    state.set("digest", digest)
    state.set("text", text[:8000])
    return {"summary": "Changed", "what": summary}
```

- Only the selected part of the page is compared, so a rotating banner or a timestamp in the footer doesn't cause false alerts.
- The first run stores a baseline. Every later run compares against the last stored version, which lives in the automation's state.
- A check that finds no change returns straight away. Quick checks that find nothing and send nothing aren't counted toward your monthly runs.
- The AI summary uses ClickRuntime's built-in model, with no API key, including on the free plan. If AI isn't available the alert still goes out with a plain message.

## A schedule, not a trigger link

Use a schedule. A web page doesn't tell anyone when it changes, so the automation has to look. Hourly suits most pages; every 5 minutes is the shortest interval, for things like a stock or ticket page.

If the site does send webhooks (for example a CMS that posts on publish), use the automation's trigger link instead and the check runs only when something was published.

## Limits

- The shortest interval is every 5 minutes.
- Pages are fetched over HTTPS without a browser, so content drawn by JavaScript after load may not be in the HTML. Ask the assistant to use the site's JSON endpoint or API if there is one.
- Pages behind a login work only when the site offers an API or token you can save as a secret in the ClickRuntime dashboard.
- Respect the site's terms and robots rules, and don't check more often than you need.

## Troubleshooting

### The run fails with “selector not found”.

The page's layout changed or the part you watch is drawn by JavaScript. Ask your assistant: “my page watch can't find the table, fix it”. It reads the run's error and updates the selector.

### I get alerts for changes that don't matter.

Narrow what is compared, for example only the price cells, or ask the assistant to ignore dates and counters before comparing.

### The site returns 403.

Some sites block automated requests. Check whether the site has an API or feed, and use that instead.

## Related

- [Slack automations](https://clickruntime.com/apps/slack)
- [Gmail automations](https://clickruntime.com/apps/gmail)
- [Notion automations](https://clickruntime.com/apps/notion)
- [watch-pricing-page](https://clickruntime.com/templates/watch-pricing-page)
- [Monitoring and alerts](https://clickruntime.com/use-cases/monitoring-and-alerts)
- [Price drop alerts](https://clickruntime.com/use-cases/price-drop-alerts)
- [Stateful automations](https://clickruntime.com/use-cases/stateful-automations)
- [Assistant scheduled tasks alternative](https://clickruntime.com/alternatives/chatgpt-claude-scheduled-tasks)
- [GitHub Actions cron alternative](https://clickruntime.com/alternatives/github-actions-cron)
- [Docs: state](https://clickruntime.com/docs/state)
- [Docs: troubleshooting](https://clickruntime.com/docs/troubleshooting)

## Extend it: what you can add next

The first version is rarely the last. Because the automation is a Python script with memory, AI and any API available, you grow it by asking your assistant for the change. Each change is a new version, and a failed deploy never replaces the working one.

- **Only alert when the change matters, judged by AI against what you care about** (Built-in AI)
  Prompt: "Change my pricing page watch so it only emails me when a price or plan limit changes, and ignores wording and layout changes."
- **Keep a history of every version and when it changed** (Memory between runs)
  Prompt: "Change my pricing page watch so it keeps the last 20 versions with their dates, and include the date of the previous change in each alert."
- **Watch several competitor pages in one automation** (Multi-step logic)
  Prompt: "Change my pricing page watch so it also checks the pricing pages of beta.com and gamma.io, and says which site changed in each alert."
- **Post changes to a Slack channel instead of email** (Any app or API)
  Prompt: "Change my pricing page watch so it posts each change to #competitors in Slack instead of emailing me."
- **Log every change as a row in a Google Sheet** (Any app or API)
  Prompt: "Add to my pricing page watch: when it finds a change, add a row to my Competitor changes sheet with the date, the site and the summary."
- **Check faster during business hours only** (Schedules)
  Prompt: "Change my pricing page watch to check every 15 minutes on weekdays from 8:00 to 18:00 London time, and hourly otherwise."
- **A weekly AI digest of everything that changed** (Built-in AI)
  Prompt: "Add to my pricing page watch: every Monday at 9, email me one summary of all the changes from the past week."

## Questions

### Can ChatGPT monitor a website for changes by itself?

Not reliably. ChatGPT only acts while you chat, and its scheduled tasks re-run a prompt without keeping a stored copy of the page to compare. Connect ClickRuntime and ChatGPT can set up an automation that checks the page on a schedule, keeps the last version and alerts you only on a change.

### Can Claude watch a website for me?

Yes, through ClickRuntime. Add ClickRuntime as a connector in Claude, ask it to watch the page, and it sets up an automation that runs on ClickRuntime's servers after the chat is closed.

### How often can it check?

As often as every 5 minutes. Hourly is enough for most pages and uses about 720 runs a month, but checks that find no change and send nothing aren't counted.

### Does it work on pages that need JavaScript?

Pages are fetched without a browser. If the content is loaded by JavaScript, the assistant can usually call the JSON endpoint the page itself uses, or the site's API.

### Is it free?

The free plan includes 250 runs a month, and checks that find nothing and send nothing aren't counted. The AI summary is included, including on the free plan.

### What else can I add to it later?

Anything in the Extend it list on this page, such as watching several sites, logging changes to a sheet, or a weekly AI digest. Ask your assistant for the change and it updates the same automation.
