How to Monitor StatusCake with Vigilmon

StatusCake is a mature website uptime monitoring and performance testing platform that provides multi-location HTTP, TCP, DNS, and SMTP checks; SSL certificate expiry alerts; domain expiry monitoring; page speed testing; and public status pages with configurable alert thresholds and on-call scheduling. It's the tool that watches your production infrastructure — which means if StatusCake is degraded or unavailable, your monitoring coverage has gaps you don't know about.

This guide covers how to use Vigilmon to monitor StatusCake itself, so you're never in the position of discovering StatusCake was down by noticing that none of your alerts fired during an outage.

Why Monitor StatusCake?

StatusCake is a third-party monitoring dependency. Like all SaaS tools, it can have incidents:

• Alert delivery delays — StatusCake detects an outage but email or webhook alerts are stuck in a queue; you find out 30 minutes after the fact
• Check runner degradation — probe nodes in specific regions stop running checks; monitors show healthy when the underlying service is down
• API unavailability — automated integrations that use the StatusCake API to manage monitors stop working
• Dashboard unavailability — engineers can't review check history or manage incidents during an outage
• Status page delivery failure — your public StatusCake status page becomes unreachable for customers

Using Vigilmon as a secondary monitoring layer catches all of these, independent of StatusCake's own infrastructure.

Key Metrics to Monitor

| Metric | Why it matters | |--------|---------------| | StatusCake API availability | Automated monitor management depends on the API | | Dashboard HTTP response | Engineers must access check history during incidents | | StatusCake status page | Official StatusCake incident communications | | Your public status page | Customer-facing uptime page must stay up | | Alert delivery pipeline | Alerts must fire; silent failures are the worst outcome | | Check result freshness | Stale check results mean probes have stopped running |

Setting Up Vigilmon Monitors for StatusCake

1. StatusCake's Own Status Page

The fastest way to detect StatusCake platform issues is to watch their official status page:

1. Log in to Vigilmon → Monitors → New Monitor
2. Type: HTTP
3. Method: GET
4. URL: https://www.statuscakestat.com
5. Keyword check: All Systems Operational
6. Interval: 5 minutes
7. Response timeout: 10 seconds
8. Save

When StatusCake has a platform incident, their status page will show an active incident and the keyword check will fail — alerting you before StatusCake has a chance to page you through its own (possibly broken) alert pipeline.

2. StatusCake REST API

Monitor the API your integrations depend on:

1. Type: HTTP
2. Method: GET
3. URL: https://api.statuscake.com/v1/uptime
4. Custom headers:
   • Authorization: Bearer your-statuscake-api-key
5. Keyword check: "data" (confirms a valid JSON response)
6. Interval: 5 minutes
7. Save

This confirms the API is reachable and your credentials are valid. A 401 response means your API key needs rotation; a 5xx means the API is degraded.

3. StatusCake Dashboard

1. Type: HTTP
2. Method: GET
3. URL: https://app.statuscake.com
4. Keyword check: StatusCake
5. Interval: 5 minutes
6. Save

4. Your Public Status Page (Powered by StatusCake)

If you host a public status page through StatusCake, monitor it directly:

1. Type: HTTP
2. Method: GET
3. URL: https://status.yourdomain.com (your StatusCake status page)
4. Keyword check: your company name or All Systems Operational
5. Interval: 1 minute
6. Save

Detecting Alert Delivery Failures with a Heartbeat

Alert delivery failure is the most dangerous StatusCake failure mode — checks run, detects are made, but notifications never arrive. A heartbeat monitor is the best defense:

Concept: Set up a StatusCake check that monitors a Vigilmon heartbeat endpoint. StatusCake will ping Vigilmon when it runs the check. If Vigilmon stops receiving those pings, you know StatusCake's probe runners have stopped.

1. In Vigilmon, create a Heartbeat monitor — copy the heartbeat URL
2. In StatusCake, create a new uptime check:
   • URL: your Vigilmon heartbeat URL
   • Check interval: 5 minutes
   • Check type: HTTP
3. In Vigilmon, set the heartbeat timeout to 10 minutes

Now if StatusCake's check runners stop firing — for any reason — you'll see the heartbeat go silent in Vigilmon within 10 minutes.

Monitoring Check Result Freshness via the StatusCake API

StatusCake's API lets you query the last check time for any monitor. You can build a freshness probe that alerts if checks are running behind schedule:

# health/statuscake_freshness.py
import requests
import os
import time

STATUSCAKE_API_KEY = os.environ["STATUSCAKE_API_KEY"]

def check_statuscake_freshness(test_id: str, max_age_seconds: int = 900) -> dict:
    """Verify that a StatusCake check ran within the expected window."""
    resp = requests.get(
        f"https://api.statuscake.com/v1/uptime/{test_id}",
        headers={"Authorization": f"Bearer {STATUSCAKE_API_KEY}"},
        timeout=10,
    )
    resp.raise_for_status()

    data = resp.json().get("data", {})
    last_tested = data.get("last_tested_at")

    if not last_tested:
        return {"ok": False, "reason": "no last_tested_at"}

    # Parse ISO8601 last_tested and compare to now
    from datetime import datetime, timezone
    last_dt = datetime.fromisoformat(last_tested.replace("Z", "+00:00"))
    age_seconds = (datetime.now(timezone.utc) - last_dt).total_seconds()

    return {
        "ok": age_seconds <= max_age_seconds,
        "age_seconds": int(age_seconds),
        "test_id": test_id,
    }

Expose this as a health endpoint and point Vigilmon at it — keyword check "ok":true. If a critical StatusCake check hasn't run in 15 minutes, you'll know immediately.

Verifying SSL Certificate Monitoring

StatusCake is widely used for SSL certificate expiry alerts. Verify that StatusCake's SSL monitoring is working by cross-checking your own certificate expiry independently in Vigilmon:

1. In Vigilmon → SSL Monitors → New SSL Monitor
2. Domain: your production domain
3. Alert before expiry: 30 days, 14 days, 7 days
4. Save

Now both StatusCake and Vigilmon are watching your SSL certificates independently. If StatusCake's SSL monitoring fails, Vigilmon's will still alert you before your certificate expires.

Alerting Configuration

| Monitor | Severity | Channel | |---------|----------|---------| | StatusCake status page | High | Slack #ops + email on-call | | StatusCake API | High | Slack #ops | | Dashboard availability | Medium | Slack #ops | | Your public status page | Critical | PagerDuty + Slack #incidents | | Heartbeat (probe freshness) | Critical | PagerDuty + Slack #ops | | Check freshness probe | High | Slack #ops + email |

Response time thresholds:

• Warning: 3000ms
• Critical: 10000ms

Building a Redundant Monitoring Architecture

The best practice is layered monitoring: no single monitoring tool should be your only safety net.

Production infrastructure
       │
       ├──► StatusCake (primary uptime monitoring)
       │         │
       │         └──► Alerts to Slack, PagerDuty, email
       │
       └──► Vigilmon (secondary / monitor-the-monitor)
                 │
                 ├──► Watches StatusCake API, status page, heartbeat
                 └──► Watches critical endpoints independently

Vigilmon monitors serve two roles in this architecture:

1. Watch StatusCake itself so you know when it's degraded
2. Provide independent coverage of your most critical endpoints in case StatusCake check runners miss them

Summary

| Monitor | URL/endpoint | Check type | |---------|-------------|------------| | StatusCake status page | https://www.statuscakestat.com | HTTP GET, keyword | | StatusCake API | https://api.statuscake.com/v1/uptime | HTTP GET, keyword | | Dashboard | https://app.statuscake.com | HTTP GET, keyword | | Your public status page | https://status.yourdomain.com | HTTP GET, keyword | | Heartbeat (probe freshness) | Vigilmon heartbeat URL | Heartbeat timeout | | Check freshness probe | Your health endpoint | HTTP GET, keyword |

Key principles:

• Watch StatusCake's own status page — it's the fastest signal of a platform incident
• Use a heartbeat monitor to detect silent check runner failures
• Run independent SSL certificate monitoring in Vigilmon as a backup to StatusCake's SSL alerts
• Layer monitoring tools: StatusCake for primary coverage, Vigilmon to watch StatusCake and cover critical endpoints independently

With Vigilmon watching StatusCake, you maintain monitoring coverage even when your primary monitoring tool has an incident — so you never experience an outage that went undetected because your monitoring was broken.

Further Reading

• Monitoring Instatus with Vigilmon
• Best Uptime Monitoring Tools for Developers 2026
• Monitoring Your REST API with Vigilmon