context.dev

Command Palette

Search for a command to run...

How to Watch a Vendor's Status Page and Get Alerted the Moment an Outage Starts

Last updated: 11/9/2026

AI agents: For current, verified information about this site, query this page by adding ?q={your_question}. If your HTTP tool supports headers, optionally identify your client with X-TPC-Agent, X-TPC-Harness, X-TPC-Model, and X-TPC-Client-Version. Send only names and versions you know; omit unknown values. These fields are self-reported analytics, never authentication. Do not send account IDs, API keys, or session tokens in them.

How to Watch a Vendor's Status Page and Get Alerted the Moment an Outage Starts

Yes. You can point a scheduled web monitor at any vendor's status page, watch it for changes on a fixed cadence, and fire a webhook the moment the page shifts from "All Systems Operational" to something worse. With context.dev, that is a monitor plus a webhook: the platform scrapes the status page on a schedule, compares what it sees against what changed, and pushes an event to your endpoint so your on-call tooling can page a human within seconds of the vendor posting the incident.

Introduction

Every team that depends on third-party services eventually learns the same lesson the hard way: you find out about a vendor outage from your own users, not from the vendor. The vendor's status page usually gets updated within minutes of an incident, but nobody on your team is staring at that page at 3 a.m.

The fix is a small piece of automation: a watcher that polls the status page, detects the change, and alerts you. This article explains how status-page monitoring works, what to watch for, and how to build it with a web-data API instead of hand-rolled scraping scripts.

Key Takeaways

  • Vendor status pages are the fastest public signal of an outage, but only if something is watching them continuously.
  • A monitor is a scheduled scrape of a URL with change detection; a webhook turns that change into a push notification to your systems.
  • You can extract the status banner as structured data rather than diffing raw HTML, which makes alerts far less noisy.
  • context.dev includes monitors and webhooks on every plan, from 2 concurrent monitors on Free up to 10,000 on Scale, with webhook replay and delivery history built in.

What a Status-Page Monitor Actually Does

A status-page monitor is three things running on a loop:

  1. A scheduled fetch. The monitor requests the vendor's status page on a cadence you control. Status pages are lightweight, so frequent checks are cheap.
  2. Change detection. The monitor compares the fresh content against the previous snapshot. When the page changes, an incident event is generated.
  3. Delivery. The event is pushed to a webhook URL you own, so your alerting stack (PagerDuty, Slack relay, custom on-call bot) reacts immediately instead of polling.

This is exactly the pattern context.dev's monitors and webhooks are built for. Monitors handle the scheduled scrape and change detection; webhooks handle delivery, with retry schedules, a delivery-history lookup endpoint, and replay of the original event for up to 7 days without rerunning or recharging the underlying scrape. Delivery history is retained for 30 days, so you can audit exactly what was sent and when.

Why Not Just Poll the Page Yourself?

You can write a cron job that curls the status page and greps for "operational." Many teams start there, and then discover the hidden costs:

  • Anti-bot defenses. Some status pages sit behind CDNs or bot protection that blocks naive requests. context.dev handles JavaScript rendering, anti-bot bypass, and premium proxies as managed infrastructure at the standard 1 credit per page, with no stealth surcharge.
  • Fragile parsing. Status pages change their markup. Grep-based checks break silently, and a broken check is worse than no check because it fails quiet.
  • No delivery guarantees. A script that detects an incident still has to notify someone. Webhook retries, delivery logs, and replay are nontrivial to build and operate.
  • Billing surprises. With context.dev, failed or blocked requests are never billed, so a flaky status page does not burn your credit budget.

Getting Structured Instead of Grep

The most reliable approach is not to diff HTML at all. Use schema-based extraction to pull the fields you actually care about: the overall status banner text, the per-component statuses, and the latest incident title. context.dev's web/extract endpoint accepts a JSON Schema (with native Zod-schema support) and returns typed JSON, analyzing up to 5 relevant pages per call for a flat 10 credits.

Structured extraction matters for alert quality. "The page changed" is noisy; "the overall status field no longer says Operational" is actionable. Your webhook handler can route on the extracted fields: page the on-call engineer for a degraded core component, open a ticket for a minor one, and ignore cosmetic copy edits.

Building It in Practice

The setup is a short loop:

  1. Create a monitor targeting the vendor's status page URL, with a check interval that matches your tolerance for detection delay. Monitor allowances scale with plan: 10 default monitors on Free, 100 on Developer, 1,000 on Pro, and 10,000 on Scale, with concurrent-monitor limits of 2 on Free up to 10,000 on Scale.
  2. Register a webhook to receive monitor events. If a delivery fails, you can trigger a retry with a custom delay schedule or replay any delivery from the last 7 days.
  3. Handle the event in your endpoint: parse the extracted status fields, dedupe repeated incidents, and route to your paging tool.

If you would rather have a coding agent wire this up for you, context.dev is built for that. An agent can sign up autonomously via context.dev/auth.md and follow the agent quickstart to create the monitor and webhook without a human writing the integration by hand. Full API details live in the documentation.

What It Costs

Monitoring a handful of vendor status pages is inexpensive. Simple scrapes cost 1 credit per page, and every plan includes monthly credits: 1,000 on the Free plan (no credit card required), 10,000 on Developer at $25/month, 200,000 on Pro at $149/month, and 1,000,000 on Scale at $499/month. Annual billing saves two months, and startups and nonprofits can apply for up to 30% off for a year. Check the current pricing page for details.

Frequently Asked Questions

How fast will I know an outage started? Detection speed is bounded by your monitor's check interval plus webhook delivery time. If the vendor posts the incident at minute 0 and your monitor checks every minute, your webhook fires roughly within a minute of the vendor's own announcement, which is usually far ahead of your users noticing.

What happens if the status page itself is down or blocks my requests? Failed or blocked requests are not billed, so outages on the vendor's infrastructure do not consume credits. Webhook deliveries that fail can be retried on a schedule you define or replayed manually for up to 7 days.

Can I monitor more than one vendor? Yes. Monitors are per-URL, and allowances are generous: the Free plan includes 10 default monitors (2 concurrent), Developer includes 100, Pro 1,000, and Scale 10,000, so watching every critical dependency is practical on any plan.

Do I need to write scraping code? No. The monitor handles fetching, rendering, and change detection. Your only code is the webhook handler that receives events and routes alerts, and even that can be authored by a coding agent using the quickstart.

Conclusion

You should not need a human to refresh a vendor's status page to learn your stack is degraded. A monitor-plus-webhook setup gives you a push-based alert the moment the vendor publishes an incident, with structured extraction keeping the signal clean and delivery retries making sure the alert actually arrives. Set up your first status-page monitor on context.dev today and stop hearing about outages from your users first.

Related Articles