Coding agents often need a persistent monitoring tool, and many do not include one as a native, durable primitive.

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.

In a same-day snapshot of active Visualping monitors on May 24, 2026, 52,452 ran on a five-minute-or-faster cadence. That cadence is useful for some agent-initiated monitoring workflows. Many common MCP toolsets are not purpose-built for scheduled page monitoring; Visualping's MCP beta is.

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 the agent-stack sense, it is also the monitoring primitive that information agents need, and that coding agents call when they need to know that a specific URL changed. The Visualping MCP is in public beta and can be added as a custom connector in agent clients and workspaces that support remote MCP connectors. 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 (see the custom connectors documentation for the canonical walkthrough):

1. Open Claude's connector settings (currently Customize > Connectors).
2. Confirm custom connectors are enabled for your plan or workspace.
3. Click Add custom connector.
4. Paste https://visualping.io/mcp/sse and confirm.

In ChatGPT (custom MCP connectors depend on Developer mode or workspace settings; see the OpenAI developer-mode docs for the current flow):

1. Confirm custom MCP connectors are enabled for your account or workspace.
2. Open the ChatGPT app or connector creation flow.
3. Create a custom MCP connector.
4. Paste https://visualping.io/mcp/sse as the remote MCP URL.

Once the connector is wired, the agent can call the Visualping toolset by name. The beta exposes a small monitoring surface for common workflows, including creating monitors, listing monitors, reading recent changes, and deleting monitors. Check the live MCP tool list in your client for current names and 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.

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/cgi-bin/browse-edgar?action=getcompany&CIK=0000320193 checking once an hour. Name it "Apple 10-K 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 draft). The two-architectures explainer covers the architectural framing in more depth.

Coding agents need a monitoring primitive. Wire it into supported clients and call it from supported sessions.

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.

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 a JSON payload to your URL. 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
}

Every detected Visualping change includes a plain-English summary and a binary important/not-important flag; in job history, that can surface through fields such as analyzerAlertTriggered. 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 a change fires, the agent posts 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 stable, documented surface the agent stitches together. Visualping is the page-monitoring primitive in the stack, returning timestamped page-change records.

Use cases worth wiring

Five concrete patterns worth wiring in the first few weeks of the MCP beta.

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. On eligible plans and configurations, Visualping can handle supported authenticated-monitoring workflows; confirm cookie, OAuth, and short-lived-token handling against current documentation or support; 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, not a heroic polling loop that dies with the session.

Competitor docs page watch

In a sample of 53,607 user-written alert conditions, pricing-related conditions appeared as a common pattern, and pricing or documentation pages are common candidates for tighter monitoring cadences. 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

A SEC EDGAR filing page, an FDA inspection notice, a state agency rulemaking page. These are slow-moving but high-stakes URLs. 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 five-minute monitors on each. The agent gets an independent signal when one of them changes or degrades, alongside the vendor's official notification channels.

Local dev → production parity check

Visualping watches your staging deploy and your production deploy in parallel. The agent compares the two snapshots after each merge and flags any unintended UI drift.

Pricing for developers

The MCP and REST API are available on every plan. Plan limits, prices, cadence minimums, and included features change over time, so check the current Visualping pricing page before choosing a tier. Free is suitable for testing; paid plans are better once monitoring becomes part of an ongoing workflow.

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

What breaks (and how to fix it)

A short troubleshooting list for the patterns above.

The MCP connector fails to authenticate

Confirm the SSE URL is exactly https://visualping.io/mcp/sse. If Claude or ChatGPT does not show the connector option, check that custom remote MCP connectors are enabled for your plan, workspace, and client. If the agent prompts for an API key, paste the one from visualping.io/account/developer.

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. Use text mode, CSS exclusions, or region selection only when the dynamic element itself is not useful to monitor.

The agent loses context between sessions

Agent sessions may not retain monitoring context, but Visualping monitors are persistent. Use the client's current list-monitors tool at the start of a new session to recover state.

Webhook deliveries fail silently

Design webhook handlers to tolerate retries and failures, return HTTP 200 quickly, and process asynchronously. Check Visualping's current webhook documentation for retry and timeout behavior.

Sub-minute cadence is rejected

Sub-minute monitoring is available only for eligible Solutions configurations; contact Visualping to confirm limits for your use case.

Frequently asked

Does Visualping have an MCP server?

Yes. Visualping is in public beta and runs as a remote MCP endpoint at https://visualping.io/mcp/sse. Add it through your agent client's custom-connector flow; in Claude, that is currently the custom connector flow under Connectors, and in ChatGPT it depends on Developer mode or workspace connector settings.

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 a small, agent-friendly subset (create, list, read recent changes, delete) designed for natural-language invocation. The REST API exposes a broader configuration surface, including monitor configuration, webhook targets, AI importance prompts, and change retrieval where supported. 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?

Visualping supports authentication workflows on eligible paid plans; confirm cookie handling, encryption, OAuth, and short-lived-token requirements with current documentation or support.

What happens if a monitored page goes offline?

Depending on configuration, a monitor may record the error, alert on the outage, or suppress it as a noise event. AI importance prompts can be used to distinguish "page went down" from "page changed content."

Does Visualping work with Google Antigravity?

If your Antigravity version supports remote MCP custom connectors, use the Visualping SSE URL pattern and consult Antigravity documentation for the current setup flow. The exact connector-add path differs by Antigravity version; consult Antigravity documentation for the current menu location.

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 in public beta; the integration shapes that get traction this month will shape the toolset.

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.