How to Monitor Websites from Claude Code (and Codex)

TL;DR: To monitor a website from Claude Code or OpenAI Codex, connect the Visualping MCP server at https://visualping.io/mcp, sign in with your Visualping account, and ask the agent to watch a URL. Visualping checks the page from its own servers on a schedule (as often as every 2 minutes on Personal 10k and Business plans) and keeps watching after the agent session ends. The MCP works on every plan, including Free.

You ask Claude Code, OpenAI Codex, or Google Antigravity to "page me when the build status changes on this dashboard," or "alert me when the pricing on this competitor's docs page moves," or "trigger this workflow when the regulator updates the docket." The agent may be able to reason and write code, but without a persistent monitoring tool it may not have a durable place to put the watch. Without an external monitoring service, it may fall back to a polling loop, a one-off script, or an external scheduler that has to be maintained. For one worked end-to-end example, see this Claude Code workflow for keeping battlecards current.

The Visualping MCP inside Claude Code, in 86 seconds.

Many common MCP toolsets are not purpose-built for scheduled page monitoring; Visualping's MCP is. For recipes that pair it with GitHub, Slack, Filesystem, Linear, and Postgres MCPs, see Visualping in your MCP stack.

Visualping is a page monitoring agent: a system that watches a specific URL on a schedule, detects changes, can classify them with AI, and routes alerts based on configuration. In an agent stack, it is the page-watching service that information agents rely on, and the one coding agents call when they need to know that a specific URL changed. The Visualping MCP is live and works in any agent client that supports remote MCP servers with OAuth sign-in: you log in to Visualping and approve the connection, with no API key to copy. The REST API is available on every plan, including Free.

This is the practical guide to using it.

The connector setup

The simplest way to give an AI coding agent a working monitoring tool is the Model Context Protocol route. No custom polling loop or user-maintained cron job.

In Claude Code (see the Claude Code MCP documentation):

claude mcp add --transport http visualping https://visualping.io/mcp

By default this saves the server to your local scope, so it loads only in the current project and only for you. Add --scope user to load it in every project, or --scope project to write it to a .mcp.json file your team can commit. Then start Claude Code, run /mcp, select visualping, and follow the browser sign-in (or run claude mcp login visualping from your shell). Log in to visualping.io and click Allow to approve the connection.

In OpenAI Codex (the CLI, IDE extension and ChatGPT desktop app share one config; see the Codex MCP documentation):

codex mcp add visualping --url https://visualping.io/mcp
codex mcp login visualping

The same server as an entry in ~/.codex/config.toml (or .codex/config.toml in a trusted project):

[mcp_servers.visualping]
url = "https://visualping.io/mcp"

codex mcp login visualping opens visualping.io in your browser. Log in and click Allow. In the Codex TUI, /mcp lists the servers that are connected.

In Claude on the web or desktop (see the custom connectors documentation):

1. Open Customize > Connectors. On Team and Enterprise plans, an Owner first adds the connector under Organization settings > Connectors.
2. Click + Add, then Add custom connector. Free Claude accounts can add one custom connector.
3. Name it Visualping, paste https://visualping.io/mcp, click Continue, keep the sign-in settings Claude detects, and click Add.
4. Connect it, log in to visualping.io, and click Allow.

In ChatGPT, install the official Visualping plugin:

1. Open the Visualping plugin page in ChatGPT's Plugins directory.
2. Click Install plugin.
3. Log in to visualping.io when prompted and click Allow.
4. Ask ChatGPT to watch a page, for example "Check this product page daily and alert me if the price changes."

Once the connector is wired, the agent can call the Visualping tools by name. The server exposes 18 of them: get_monitors and get_monitor_settings read your setup; create_monitor, update_monitor, delete_monitor, activate_monitor and deactivate_monitor manage monitors; run_monitor and wait_for_monitor_check check a page on demand; get_timeline reads detected changes; set_monitor_schedule, set_monitor_actions and set_monitor_notifications handle schedules, login steps and alerts. The rest are describe_user and tools to flag or hide changes. Your client's MCP tool list shows the current parameters.

That is the MCP surface this guide relies on. Anything more elaborate is reachable via the REST API (next section).

Try it: five prompts for a configured Visualping MCP connection

Once the MCP connector is live, the test is whether you can drive it with natural language. These prompts are written for Claude Code but translate with small adjustments to Codex or Antigravity. Cadence requests have to fit your plan: Free checks at most hourly, Personal 1k every 15 minutes, Personal 5k every 5 minutes, and Personal 10k and Business as often as every 2 minutes.

Prompt 1: A competitive pricing watch

Use Visualping to start monitoring https://competitor.example/pricing every five minutes. Name the monitor "Competitor pricing watch." When it changes, give me a short summary of what moved.

Prompt 2: A regulatory docket monitor

Set up a Visualping monitor on https://www.sec.gov/edgar/browse/?CIK=0000320193 checking once an hour. Name it "Apple SEC filings watch."

Prompt 3: A health check on your own deploy

Add a Visualping monitor for our staging environment at https://staging.acme.io/health checking every five minutes if my plan supports that cadence, or the tightest cadence available on my plan. Alert me by email when the page changes.

Prompt 4: A list-all-and-prune

Show me every Visualping monitor I currently have running, then identify any monitors that appear inactive based on the recent-change data available.

Prompt 5: A change-driven downstream task

Read the three most recent changes on my "Competitor pricing watch" monitor. Summarize what changed each time, and draft an update for our internal battlecard if any of the changes affected the Enterprise tier.

The fifth prompt is where the architecture earns its keep. The agent fetches timestamped change events from Visualping, reasons over them, and produces a downstream artifact (the battlecard update). The discovery happened in advance (you knew which page to watch); the precision happens in the background (Visualping watches it); the action happens on demand (the agent drafts the update). The two-architectures explainer covers the architectural framing in more depth.

Connect Visualping once, and your coding agent can create monitors and read page changes from any session.

The REST API for code-first patterns

The MCP is the fastest path. For developers who want their monitors managed by code (CI/CD, infrastructure-as-code, custom dashboards), the REST API is the durable surface.

Create an API key at visualping.io/account/developer. Keys are available on every plan, including the free tier.

A minimum-viable create-monitor call:

curl -X POST https://job.api.visualping.io/v2/jobs \
  -H "Authorization: Bearer $VP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/the-page-that-matters",
    "interval": "5",
    "description": "Competitor pricing watch",
    "summalyzer": {
      "importantDefinitionType": "default"
    }
  }'

For a Business workspace, include workspaceId in the body. The interval value is minutes as a string: "5" for every five minutes, "60" for hourly, and "1440" for daily. Visualping rejects an interval faster than your plan allows: hourly on Free, 15 minutes on Personal 1k, 5 minutes on Personal 5k, and 2 minutes on Personal 10k and Business.

In Python, the same call as a function you can drop into a project:

import os, requests

def create_monitor(url, interval_minutes="5", description=None, workspace_id=None):
    payload = {
        "url": url,
        "interval": str(interval_minutes),
        "description": description or url,
        "summalyzer": {"importantDefinitionType": "default"},
    }
    if workspace_id is not None:
        payload["workspaceId"] = workspace_id

    return requests.post(
        "https://job.api.visualping.io/v2/jobs",
        headers={
            "Authorization": f"Bearer {os.environ['VP_API_KEY']}",
            "Content-Type": "application/json",
        },
        json=payload,
        timeout=30,
    ).json()

create_monitor("https://competitor.example/pricing", interval_minutes="5", description="Competitor pricing watch")

API documentation for common operations such as listing monitors, fetching changes, configuring webhooks, and setting AI importance prompts is available in the Visualping API documentation. What matters for an agent stack is that core operations are exposed over HTTP, without requiring an SDK.

Webhooks: the integration with your stack

The most useful pattern, once monitoring is wired in, is to skip polling entirely and have Visualping push changes into your workflow.

Set a webhook URL on any monitor:

curl -X PUT https://job.api.visualping.io/v2/jobs/$JOB_ID \
  -H "Authorization: Bearer $VP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "notification": {
      "enableEmailAlert": false,
      "onlyImportantAlerts": true,
      "config": {
        "webhook": {
          "url": "https://your-app.example.com/visualping",
          "active": true
        }
      }
    }
  }'

When the monitor detects a change, Visualping POSTs one flat JSON object (event: "change") to your URL. Its datetime field is a JavaScript date string, not ISO-8601, so parse it leniently. Your inbound handler should normalize the event into fields like:

{
  "job_id": 1234567,
  "description": "Competitor pricing watch",
  "url": "https://competitor.example/pricing",
  "detected_at": "2026-05-26T14:32:17Z",
  "screenshot_url": "https://...timestamped-png...",
  "diff_summary": "Pricing for the Enterprise tier changed from $X to $Y.",
  "analyzer_alert_triggered": true
}

Each detected change carries an AI summary and an important/not-important verdict: important in the webhook payload ("true", "false", or "no analyzer call") and analyzerAlertTriggered in REST job history. Downstream, you can route only important changes to a noisy channel like Slack while sending every change to a quieter audit log.

Composability: Visualping alongside other MCP tools

The pattern that compounds is to wire Visualping into an agent stack that already has GitHub, Slack, and Filesystem MCPs. Each one exposes tools the agent can chain.

A realistic workflow:

1. GitHub MCP: the agent reads your competitor-monitoring repo to find which URLs to watch.
2. Visualping MCP: the agent calls create_monitor for each URL with a 15-minute cadence and an AI importance prompt that flags pricing changes specifically.
3. Slack MCP: when you ask for a digest, the agent reads new changes with get_timeline and posts them to #competitive-intelligence with the change summary and screenshot URL.
4. Filesystem MCP: the agent appends every change event to a local audit log for compliance review.

The agent never wrote a polling loop. Each tool is a documented surface the agent stitches together. Visualping is the part of the stack that watches the pages and returns timestamped change records.

Use cases worth wiring

Five concrete patterns worth wiring first.

CI status board outside your dashboard

A staging deploy monitor is the clean version of this pattern: watch the health page on the tightest cadence your plan supports, alert only when the status changes, and let the agent summarize the change in the shell. Monitoring a page behind a login works on every plan, including Free: add Actions that sign in before each check, or create the monitor from the Chrome extension, which captures your logged-in session once; the monitor can keep running after the agent session ends; the agent can surface the state change when you ask for it. The value is persistence: the watch outlives the session, and you never have to babysit a polling loop.

Competitor docs page watch

Of the 403,872 live Visualping monitors with a custom "Alert me when" condition, 17% mention price or pricing (October 22, 2026). Visualping watches the docs or pricing page on the cadence your plan supports. When the page changes, the agent compares the new content to a stored summary and tells you whether the change is a breaking-API event, a feature addition, or a typo fix.

Regulator docket monitor

An SEC EDGAR filing page, an FDA inspection notice, a state agency rulemaking page. These are slow-moving but high-stakes URLs. As of October 22, 2026, 859 live Visualping monitors watched sec.gov pages and 2,140 watched fda.gov. A daily cadence may be enough for some workflows. The change event becomes a structured row in your compliance ticketing system via webhook.

Status-page-of-record for your vendors

Pick the status pages for your five most critical SaaS dependencies. Set each one to check every 5 minutes (Personal 5k plans and up). The agent gets an independent signal when one of them changes or degrades, alongside the vendor's official notification channels.

Staging and production parity check

Visualping watches your staging deploy and your production deploy in parallel. After each merge, the agent calls run_monitor on both, reads the results with wait_for_monitor_check, and flags any unintended UI drift.

Pricing for developers

The MCP and REST API are available on every plan, including Free. Free covers 150 checks a month on 5 pages, checked at most hourly, which is enough to test the setup. Personal 1k ($14/mo, or $120 billed yearly) raises that to 1,000 checks, 10 pages and 15-minute checks. Personal 5k ($35/mo or $300/yr) adds 5-minute checks and SMS alerts, and Personal 10k ($70/mo or $600/yr) checks as often as every 2 minutes. Business starts at $140/mo ($1,200/yr) with 20,000 checks, 200 pages, 5 seats, 2-minute checks, and native Slack, Microsoft Teams, Discord, Google Sheets and Google Chat alerts. Limits change, so confirm on the pricing page before you pick a tier.

A common progression is to test on Free, move to a paid individual plan when monitoring becomes part of an ongoing workflow, and use Business when monitors and alert routing need to be shared across a team.

What breaks (and how to fix it)

A short troubleshooting list for the patterns above.

The MCP connector fails to authenticate

Confirm the URL is exactly https://visualping.io/mcp. The MCP does not use an API key: the client opens a visualping.io sign-in, then an Allow page, and nothing connects until you click Allow. If the popup says it couldn't read your visualping.io sign-in, your browser is blocking visualping.io cookies. If it says the request is invalid or expired, start connecting again; the Allow page times out after 10 minutes. If Claude or ChatGPT does not show the connector option, check that custom MCP connectors are enabled for your plan, workspace, and client.

Monitor sends too many alerts (false positives)

Dynamic pages often produce frequent detected changes: analytics widgets, relative-time stamps, randomized hero images, cookie banners, ads, and other page elements can move between checks. That does not mean every visual change needs to become an alert. The first fix is to define what counts as important for the job, then route Slack, email, and webhook notifications with onlyImportantAlerts: true so alerts key off the important/not-important classification (important in webhook payloads and analyzerAlertTriggered in REST job history).

Visualping can still preserve the full change history for audit or review, while noisy changes marked not important stay out of interruptive channels. If important alerts are still noisy, tighten the importance definition by naming the exact content, page region, or business event that matters and the page elements to ignore. If a dynamic element is never useful to watch, crop the monitor to an area of the page in its settings, or switch it to the legacy Text changes mode.

The agent loses context between sessions

Agent sessions may not retain monitoring context, but Visualping monitors are persistent. Have the agent call get_monitors at the start of a new session to recover state, and get_timeline to see what changed while it was away.

Webhook deliveries fail silently

Visualping sends each webhook once, with no retries, so a delivery your endpoint drops is gone. Return HTTP 200 quickly, process asynchronously, use an unguessable URL, and backfill recent gaps from the REST API, where GET /v2/jobs/{id} returns the monitor's most recent detected changes. It is not a full archive, so process deliveries as they arrive.

A fast cadence is rejected

Visualping refuses an interval faster than your plan allows. The fastest is every 2 minutes, on Personal 10k and Business plans, and there is no sub-minute option. Ask the agent to fall back to the tightest cadence your plan supports, as Prompt 3 does.

Frequently asked

Does Visualping have an MCP server?

Yes. The Visualping MCP server is live at https://visualping.io/mcp and works on every plan, including Free. In Claude Code, run claude mcp add --transport http visualping https://visualping.io/mcp; in Codex, run codex mcp add visualping --url https://visualping.io/mcp. In Claude on the web, add it under Customize > Connectors; in ChatGPT, add it as a custom MCP server under Plugins. You sign in with your Visualping account, with no API key.

Can Claude Code or Codex create a Visualping monitor without a prompt?

The agent must be prompted to use the Visualping tool, the same way any MCP tool is invoked. The model decides to call the relevant create-monitor tool when the user's request implies "watch this page" semantics. Adding the URL to the prompt is usually enough.

What is the difference between the MCP and the REST API?

The MCP exposes 18 tools designed for natural-language use: create, update, pause, run and delete monitors, read the change timeline, set schedules, login actions and notifications, and flag or hide changes. It signs in as you through OAuth. The REST API uses an API key and adds what scripts need, such as custom intervals in whole minutes, bulk import, and labels. Use the MCP for agent-driven monitoring; use the REST API for code-first or infrastructure-as-code patterns.

Is the Visualping API available on the Free plan?

Yes. Every plan, including Free, can generate an API key at visualping.io/account/developer. The Free plan caps usage at 150 checks per month across 5 pages.

How do I monitor a page that requires authentication?

Every plan, including Free, can monitor pages behind a login. Add Actions that type your credentials and click through the login before each check, or create the monitor from the Chrome extension, which captures your logged-in session once (it is not re-synced, so recreate the monitor when the site expires it). Actions cannot complete two-factor or CAPTCHA challenges; for those, run a local monitor in the extension, which checks the page in your own signed-in browser.

What happens if a monitored page goes offline?

A failed check (an HTTP error, a timeout, or a bot block) is logged as an error, not as a change. By default Visualping sends an error alert after several consecutive failed checks, then less often while the page stays down; you can set a monitor to alert on every error or never. Error alerts go to email, SMS, and webhooks, where they arrive with event: "error".

Does Visualping work with Google Antigravity?

Antigravity reads remote MCP servers from ~/.gemini/antigravity/mcp_config.json, where each one needs a serverUrl entry, so point it at https://visualping.io/mcp. Sign-in may not complete yet: Visualping accepts OAuth from clients that use a local callback and from a fixed list of hosted ones, and Antigravity's documented callback (https://antigravity.google/oauth-callback) is not on that list. Claude Code and Codex both use a local callback and connect without extra setup.

That is the connector setup, the REST API, and the patterns that compound. If you wire it in and find a use case I have not listed, tell me. The MCP is live, and the use cases people send in will shape what the tools do next.

Eric Do Couto is Head of Marketing at Visualping. He writes about the architecture of monitoring, AI agents, and the slow business of category formation.