Let's be direct: Checkly's free Hobby plan is arguably the most generous free tier in the whole monitoring category. Per their own pricing page (September 2026): 10 uptime monitors at up to 2-minute frequency across HTTPS, TCP, DNS, ICMP, SSL/TLS, gRPC, traceroute and heartbeat protocols, probed round-robin from 6 global locations with an automatic single retry; 10,000 API check runs and 1,000 Playwright browser check runs per month of real synthetic monitoring; email, Slack and webhook alerts all at $0 (webhooks free is rare — and theirs are HMAC-SHA256-signed via x-checkly-signature, properly); a free status page with 20 services and 250 subscribers; even 10 free AI root-cause-analysis invocations a month. And the machine surface — MCP server, Checkly CLI, Terraform and Pulumi providers — is included on every plan, free tier included. Used by Airbus- and CrowdStrike-sized teams, SOC 2 Type II. If signing up is fine, honestly: use Checkly. This page will not pretend otherwise.
So what's left? One narrow moment: everything in Checkly starts with an account. The CLI, the Terraform provider, the MCP server and the REST API all authenticate with an API key you create in the dashboard, tied to your user (the Hobby plan has exactly 1 seat; non-personal "service API keys" are Enterprise-only per the pricing table). That's a completely reasonable design for a monitoring platform — and still a wall when the moment is "watch this URL from this shell, right now, and POST my webhook when it dies," in a CI job with no secrets configured, from a throwaway script, or from an agent that has no keys. That's the gap this page fills: one curl, no account, no API key — HMAC-signed webhook alerts, a public status page, README badge and Atom feed included.
Facts from Checkly's own pricing page, September 2026 — verify current numbers yourself. Hobby ($0): 10 uptime monitors, 2-min max frequency, 8 protocols including heartbeat (dead-man's-switch cron monitoring — free, credit where due), 6 locations (max 3 per check), single retry, 10,000 API check runs + 1,000 browser/Playwright check runs per month, SSL-expiry alerts, email + Slack + webhook alerting, status page (20 services, 250 subscribers, Checkly-hosted domain), 1 dashboard, 10 AI RCA invocations, 1 user, 7-day raw data retention, and full MCP/CLI/Terraform/Pulumi access. Not on Hobby: buying more check runs (the caps are hard — no overages on free, so a chatty monitor simply stops), incident-management integrations (PagerDuty, OpsGenie, Incident.io, Rootly — Team plan), maintenance windows, SMS/phone alerts, custom status-page domain, the 22-location pool, 10-second frequency, private locations, Prometheus export. Starter ($24/month) adds 50 monitors at 1-min frequency, purchasable overages, SMS and a custom status-page domain; Team ($64) adds 75 monitors at 30-sec frequency, all 22 locations, private locations, incident integrations and maintenance windows.
Said plainly: their free 2-minute interval is 15× faster than our 30-minute checks, they probe from 6 named locations where we probe from Cloudflare's edge as a single logical vantage point, they retry before alerting, and Playwright-based synthetic monitoring — their actual core product — has no equivalent here at all. This page is about one thing Checkly structurally can't offer: a check that exists before any account does.
curl -X POST https://mockbird.mockbird.workers.dev/api/status/monitor \
-H 'content-type: application/json' \
-d '{"url":"https://api.example.com/health","notify":"https://your-endpoint.example.com/hook"}'We GET your URL every 30 minutes from Cloudflare's network (8s timeout, redirects followed, 2xx/3xx = up). Your URL is probed immediately, so the response doubles as a one-shot "is my site up from outside?" check — and it contains everything else you need:
No webhook handy? Omit notify and you get a pollable monitor instead: the create response includes a poll URL that returns the down/recovered transitions since your last poll plus the latest check — no endpoint to host. How poll mode works.
{
"id": "mon-XXXX",
"secret": "…",
"current": { "ok": true, "http_status": 200, "ms": 87 },
"checked_every_minutes": 30,
"status_page": "https://mockbird.mockbird.workers.dev/status/mon-XXXX",
"badge_svg": "https://mockbird.mockbird.workers.dev/status/mon-XXXX/badge.svg",
"feed_atom": "https://mockbird.mockbird.workers.dev/status/mon-XXXX/feed.xml"
}No dashboard, no project, no API key, no checkly.config.ts. The same endpoint self-documents on a bare GET, which makes it trivially scriptable in CI (curl … || exit 1) or from an agent.
notify takes a Slack incoming webhook, a Discord webhook, or any HTTPS endpoint — the format is sniffed from the host: hooks.slack.com gets {"text": …}, discord.com/api/webhooks gets {"content": …}, and anything else gets JSON signed with your monitor's secret (x-mockbird-signature: sha256=hex(hmac-sha256(secret, body)) — verify it like a Stripe webhook). A confirmation delivery hits your webhook at create time so you know the channel works before you rely on it.
Credit where due: Checkly's webhooks are also free and also HMAC-SHA256-signed (x-checkly-signature), with retries and templating ours doesn't have. The difference isn't the signature — it's that theirs requires an account and a configured alert channel, and ours is the create-call's second JSON field.
Alerting here is deliberately quiet: one POST when the URL goes down, one when it recovers, debounced — two consecutive checks must agree, so a single blip never pages you. No retries, best-effort delivery, and 5 consecutive failed deliveries auto-remove the monitor (a dead webhook can't rot forever). No email, no SMS, stated plainly — the webhook is the product.
Checkly ships a real MCP server, a CLI, Terraform and Pulumi providers, all included on the free plan — genuinely the strongest machine story of any monitoring vendor we've compared. But all of them authenticate with an API key plus account ID created in the dashboard, tied to the Hobby plan's single user seat (service keys for non-humans: Enterprise). Machine access, yes — keyless machine access, no.
Mockbird's monitors are exposed as MCP tools with zero keys: an agent can arm a watch (uptime_monitor), read the current state, and unsubscribe, without any credential existing beforehand. The per-monitor secret in the create response is the only auth there is, scoped to that one monitor. If you're wiring an agent that needs to know "is this dependency up?", it can also subscribe to our public tracker of 50+ developer APIs at /status without spending a monitor slot.
Checkly's heartbeat monitors are included in the Hobby plan's protocol list — free dead-man's-switch cron monitoring, which most rivals charge for. Same story as above: dashboard + account there, one curl here. POST /api/status/heartbeat returns a secret ping URL; append && curl -fsS -m 10 <ping_url> to the cron job, and if pings stop arriving within period + grace you get one service.down webhook, one service.up on resume. Full recipes: cron-job monitoring with one curl.
| Checkly concept | Here |
|---|---|
| Uptime monitor (10 free at 2-min checks, 8 protocols, account + dashboard or CLI/API-key first) | POST /api/status/monitor {"url": …, "notify": …} — HTTPS GET only, no account, response includes the current check |
| Email / Slack / webhook alert channels (all free — rare and excellent) | Slack + Discord auto-detected from the notify host; anything else gets signed JSON. No email here, stated plainly |
Signed webhooks (x-checkly-signature, free, with retries + templating) | Same idea: x-mockbird-signature, HMAC-SHA256, free — but no retries, and a create-time confirmation delivery |
| API / CLI / Terraform / Pulumi (free, authenticate with API key + account ID) | The API is the product — no key exists at all; self-documents on bare GET. No Terraform provider, stated plainly |
| MCP server (free, API-key auth) | MCP tools with zero keys |
| Heartbeat monitors (free on Hobby — credit where due) | POST /api/status/heartbeat — separate free pool, 30 min–7 day periods |
| Status page (free: 20 services, 250 subscribers, hosted domain) | One per monitor, unguessable URL, hostname-only — plus badge + Atom feed. Theirs is the fuller product |
| Playwright browser checks + multistep API checks (1k + 10k runs/month free) | No equivalent. Synthetics are their core product; we speak HTTP GET and webhooks only |
| AI root-cause analysis (10/month free) | No equivalent — and none planned; we're a no-LLM product by design |
Facts checked September 2026 against each vendor's own pricing page — verify current numbers yourself:
| Free tier | Pick it when | |
|---|---|---|
| Checkly | 10 uptime monitors, 2-min checks, 6 locations, retries, 10k API + 1k Playwright check runs/mo, email + Slack + signed-webhook alerts, status page, heartbeats, MCP/CLI/Terraform free; hard caps (no overages), 1 seat, 7-day retention | Almost always, honestly — if an account and an API key are fine. Best-in-class free tier, and the only one here with real Playwright synthetics. |
| Hyperping | 20 monitors, 5-min checks, 18 regions, free Slack + Teams alerts, cron healthchecks; API paid-plans-only (details) | You want a polished all-in-one dashboard with free chat alerts and don't need terminal/agent arming. |
| Better Stack | 10 monitors + 10 heartbeats, 3-min checks, Slack + e-mail alerts, 1 status page (details) | You want the fullest free package (logs, exceptions, replays too) and a signup is fine. |
| UptimeRobot | 50 monitors, 5-min checks, email alerts, API access; Slack paid, webhooks Team-plan (details) | You want a free dashboard watching many sites and email alerts are enough. |
| Uptime Kuma | Self-hosted, unlimited, ~90k GitHub stars (details) | You have a second server to run it on and want full control. |
| Mockbird | URL monitors: 3 live per IP (deleting frees the slot), 30 total, 30-min checks. Heartbeats: 5 live per IP. Webhook + Slack + Discord alerts, status page/badge/feed, MCP tools — free, no account | The check must exist before any account does — armed from a terminal, CI step, script or agent this minute, alerting a webhook you can verify. |
Where Checkly wins, plainly: 2-minute free checks with retries from 6 named locations (15× faster than ours, multi-location where we're single-vantage), eight protocols where we speak one, real Playwright synthetic monitoring and multistep API checks, a proper status-page product with subscribers, free MCP/CLI/Terraform/Pulumi, AI root-cause analysis, SOC 2, and paid tiers that scale to 30-second checks from 22 locations with on-call integrations. We do: one curl, no signup, no API key, HMAC-signed webhook down/up alerts, public status artifacts, free heartbeats, and keyless MCP tools — at $0 with no account, where Checkly's $0 starts with a signup form.
# info + 24h ok-rate + recent checks · then stop
curl "https://mockbird.mockbird.workers.dev/api/status/monitor/mon-XXXX?secret=YOUR_SECRET"
curl -X DELETE "https://mockbird.mockbird.workers.dev/api/status/monitor/mon-XXXX?secret=YOUR_SECRET"Both endpoints self-document on a bare GET. The complete walkthrough of the monitor feature is the uptime monitor API guide.