How to Monitor Website Changes from Claude Code and Codex

Yes, Claude Code can check a website for changes, but the right setup depends on where the check runs and whether it needs a real browser. A recurring prompt in a local session, a cloud automation, and a browser-driven inspection are different workflows. For Codex, do not assume that ChatGPT’s Scheduled Tasks monitoring feature is automatically available: OpenAI documents Codex automations separately, and the exact Codex recipe for monitoring arbitrary websites is not established by the sources cited here.

A useful monitor needs five things: the page to inspect, the specific change that matters, a trigger or cadence, a rule for ignoring noise, and somewhere to send a report or alert. For pages where a screenshot is part of the check, ScreenshotNeo provides a screenshot API and MCP server; its response headers distinguish page outcomes and whether a capture was billed.

Choose the monitoring workflow

Approach	Execution	Best fit	Important limit
Claude Code `/loop`	Local, within the current session	Repeated checks while you are working in that session	The documented loop runs for up to three days at a time; it is not an independent durable monitor.
Claude Code `/schedule` or Routines	Cloud automation	Checks that should continue when your laptop is closed	Availability and configuration matter. Routines were announced as a research preview on April 14, 2026.
Claude in Chrome	Browser-based	Rendered pages or checks that need navigation and browser actions	Browser access and account availability apply; it cannot be assumed to work on every site.
ChatGPT Scheduled Tasks	ChatGPT task	A documented monitoring task that checks for changes and notifies about relevant updates	This is a ChatGPT feature. OpenAI says Codex automations are separate.
Custom Codex workflow	Depends on the automation you configure	A workflow you build for your environment and reporting path	The cited sources do not establish a universal built-in Codex monitor for arbitrary public websites.

Anthropic documents /loop as scheduling recurring work locally for up to three days. Its Routines announcement describes automations configured with a prompt, repository, and connectors that can run on a schedule, through an API call, or in response to an event. Claude in Chrome can read and navigate websites and supports scheduled browser tasks in documented contexts. OpenAI’s Scheduled Tasks documentation describes monitoring tasks that check for changes and notify when an update is relevant, while distinguishing Codex automations from those tasks.

Define what counts as a change

Before configuring an agent, write a compact specification. “Tell me if the page changes” is too broad: timestamps, rotating recommendations, advertisements, and layout shifts can produce noise without changing anything you care about.

Target: provide the exact URL, including the relevant route or query parameters.
Signal: name the text, element, image, price, status, or visual region to monitor. Prefer a precise condition such as “alert if the availability label changes from ‘In stock’” over “summarize the page.”
Method: choose a plain HTTP fetch for server-delivered text, or a rendered browser check if JavaScript, scrolling, consent, or interaction is required.
Cadence or trigger: set the interval or supported event. Avoid checking more often than the decision requires.
Baseline and noise: save an initial value, ignore known volatile regions, and require a meaningful difference before alerting.
Destination: state where the result should go, such as the automation’s supported notification or reporting destination. Verify the connector and permissions rather than assuming one is configured.
Failure behavior: distinguish “no change” from “could not check.” A timeout, access denial, or CAPTCHA is not evidence that the page stayed the same.

Recipe 1: recurring check in Claude Code

Use /loop when you want repeated checks during a current Claude Code session. It is useful for short-lived observation, such as watching a release page while you work. Since the loop is session-local and limited to up to three days, use a cloud automation or another scheduled system if the check must continue independently.

Open Claude Code in the context where you want the task to run.
Give it a precise monitoring prompt. For example:

/loop 30m Check https://example.com/status for a change to the service status text. Compare the status text with the previous successful check. Report only when it changes. Include the old value, new value, check time, and page URL. If the page cannot be loaded or the status cannot be read, report a check failure separately; do not call that “no change.”

Adjust the interval to the consequence and expected update frequency. Tell the agent what previous state to retain and how to report it. Do not interpret a repeated summary as proof that the page was successfully checked; the report should make check failures visible.

Recipe 2: cloud or event-triggered Claude automation

Use Claude Code /schedule or Routines when the automation should run without an open local session, subject to current account access and configuration. Routines also support API-call and GitHub-event triggers as described in Anthropic’s announcement. An event trigger is appropriate only when that event is genuinely related to the page change; a GitHub event does not itself guarantee that an external site has updated.

Configure the automation with the same monitoring specification: target, exact signal, comparison rule, cadence or event, failure reporting, and destination. For a scheduled workflow, tell it to retain the last successful value so it can compare runs. For event-driven workflows, decide whether the event should trigger an immediate page check or merely request a report. Confirm repository and connector access before relying on delivery.

Recipe 3: inspect a rendered page in a browser

Use a browser-driven check when the information is populated by JavaScript or requires navigation, scrolling, or another browser action. Claude in Chrome documents website navigation and reading, as well as scheduled browser tasks in supported contexts. Access depends on the account and browser setup; authentication, anti-automation controls, and site behavior can prevent a check from succeeding.

Identify the visible element or text that represents the condition.
Ask the browser task to navigate to the page and wait until that element is present or a stated timeout is reached.
Read only the target region where possible. If a screenshot comparison is needed, capture a consistent viewport and state.
Compare against the last successful observation and report the observed values plus the check time.
On login prompts, bot checks, blank content, or timeouts, report “check failed” and preserve the previous baseline.

A browser check is not a promise of access to every arbitrary page. Do not try to bypass a site’s access controls; use an authorized integration or a supported public endpoint when available.

What Codex can and cannot be assumed to do

OpenAI’s documentation describes ChatGPT Scheduled Tasks as capable of monitoring changes and sending notifications for relevant updates. It also says Codex uses separate automations. Therefore, a ChatGPT monitoring task is not evidence that a Codex session has the same recurring monitoring behavior.

For Codex, first identify the product surface and automation mechanism available in your account. If you build a custom workflow around Codex, treat scheduling, browser access, state persistence, and alert delivery as components to configure and validate. The sources reviewed for this article do not establish a single step-by-step Codex setup that monitors arbitrary third-party websites, so avoid assuming a particular command or universal capability.

Plain fetch or browser rendering?

Question	Plain page fetch	Rendered browser
Where is content available?	In the initial HTML or a supported endpoint	After scripts run or browser interaction
What can it inspect?	Response content accessible to the fetching workflow	Visible rendered content and, where supported, browser state
What can break it?	Network errors, changed markup, access restrictions	All fetch issues plus browser access, timing, interaction, and session issues
When to choose it?	When the signal is simple and server-delivered	When the page’s meaningful state only exists after rendering or interaction

Neither method is universally more accurate. Choose based on how the target page exposes the specific signal and validate that the workflow reads the same thing a person would rely on.

Or skip the browser setup

If the change you care about is visual or appears only after rendering, ScreenshotNeo can return a screenshot with one GET request. See the ScreenshotNeo API documentation for request options. The example captures a page as WebP:

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://example.com -o shot.webp

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://example.com"},
    timeout=90,
)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://example.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
await Bun.write('shot.webp', res);

ScreenshotNeo accepts cookie or consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits cost nothing, and response headers identify the page verdict and billing status. Its MCP server provides take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, and other MCP clients. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. Use an actual before-and-after comparison and define what visual difference should trigger an alert; a screenshot API supplies the capture, not a monitoring schedule or notification by itself.

Reliability, noise, and cost

Keep a successful baseline: update stored state only after the target signal was read successfully. Otherwise a transient failure can erase the comparison point.
Separate failures from unchanged results: report timeouts, access errors, missing selectors, and bot checks distinctly.
Reduce false alerts: compare a named field or region, normalize whitespace and irrelevant timestamps, and optionally require the condition to persist on another successful check.
Control cadence: match the interval to how quickly you need to react and avoid unnecessary repeated requests. Respect the target site’s access rules.
Make reports auditable: include the URL, check time, old and new values, and whether the page was actually inspected.
Budget for the whole workflow: the cited agent documentation does not establish a universal price for these checks. Consider the agent or automation plan, browser access, storage, notification path, and request volume. ScreenshotNeo’s stated plan prices are Free: 1,000 monthly shots; Starter: $5 for 3,000; Growth: $15 for 15,000; Pro: $39 for 60,000; Scale: $99 for 250,000; Business: $249 for 1,000,000. Yearly billing gives two months free, and every feature is on every plan.

Troubleshooting

Symptom	Likely cause	What to do
No recurring check occurs	A local session ended, the loop reached its documented limit, or the cloud automation is not enabled/configured.	Check whether the chosen mechanism is session-local or cloud-based, and verify its current account availability and schedule.
The agent reports no change but the page looks different	It may be reading stale or incomplete content, or comparing a broad summary instead of the relevant signal.	Specify the exact field or region, require a successful read, and report the observed value with the result.
Browser task cannot find content	Content loads later, requires scrolling or interaction, or is unavailable to the current browser session.	Wait for a specific element with a bounded timeout; verify navigation and authorized access; report missing content as a failed check.
Checks fail intermittently	Network variability, page changes, rate limits, authentication expiry, or anti-automation controls.	Use bounded retries with backoff where appropriate, preserve the last successful baseline, and do not treat failure as unchanged.
Too many alerts	Volatile content or layout changes are part of the comparison.	Narrow the watched region, normalize known volatile values, and alert only on a defined meaningful condition.
Notifications do not arrive	The configured destination or connector is missing, unauthorized, or not supported by that automation.	Verify the automation’s configured destination and permissions, then test delivery with a non-critical report.
Codex steps do not match ChatGPT instructions	ChatGPT Scheduled Tasks and Codex automations are separate product surfaces.	Follow the documentation for the actual surface available in your account; do not copy ChatGPT task assumptions into Codex.

FAQ

Can Claude Code check a website for changes?

Yes. The documented local /loop can repeat a prompt during a session; cloud scheduling and browser-based options have different availability and constraints.

Can Codex monitor a website?

OpenAI documents Codex automations separately from ChatGPT Scheduled Tasks. A general built-in recipe for arbitrary website monitoring is not established by the sources used here.

How do I get notified when a webpage changes?

Configure a workflow that compares a defined signal with its last successful value and connect a supported notification destination. ChatGPT Scheduled Tasks are documented as able to notify about relevant monitoring changes; other agent workflows need their own configured delivery path.

Will a browser agent work on any site?

No universal compatibility is established. Rendering, sign-in, browser access, anti-automation controls, and account eligibility can all affect a check.

Sources

Anthropic, Claude Code interactive mode and power-user features (including /loop and /schedule).
Anthropic, Claude Code Routines announcement.
Anthropic, Claude in Chrome help documentation.
OpenAI, Scheduled Tasks in ChatGPT.
OpenAI, Codex product documentation.