CronAlert vs Healthchecks.io: Heartbeat Monitoring and the Full Uptime Picture

Q: What does Healthchecks.io actually do?

Healthchecks.io is a passive heartbeat monitor. You create a check, get a unique URL, and ping that URL at the end of every successful cron run. If a ping doesn't arrive within the expected window (plus grace period), Healthchecks.io alerts you. It also supports start signals, exit-code reporting, log capture, and run-time tracking. It's deliberately narrow — it does cron heartbeats and not much else. There's no URL uptime monitoring, no content checks, no SSL monitoring, and no public status pages aside from a per-check badge.

Q: How is CronAlert different from Healthchecks.io?

CronAlert is a full uptime monitoring product that also does heartbeat monitoring. Heartbeats are one mode alongside HTTP/HTTPS uptime checks, content monitoring, keyword monitoring, SSL certificate monitoring, multi-region checks with quorum logic, and full public status pages. Healthchecks.io focuses on heartbeats and does them well. CronAlert covers the same heartbeat use case and adds the rest of the uptime surface, so teams using both tools today can consolidate to one.

Q: Is CronAlert cheaper than Healthchecks.io?

Roughly comparable on free tiers, cheaper at paid tiers when you account for what each tool covers. Healthchecks.io's free tier is 20 checks; its paid plans start at $5/month for 20 checks with more features, scaling up. CronAlert's free tier is 25 monitors (heartbeat or URL), and the $5/month Pro plan covers 100 monitors with 1-minute intervals. If you only need 20 heartbeats and don't need any other monitoring, both are similarly priced. If you need URL uptime, SSL monitoring, and status pages alongside heartbeats, CronAlert delivers them under one bill instead of stacking two vendors.

Q: Can I self-host Healthchecks.io?

Yes — Healthchecks.io is open source under the BSD license and the self-hosted edition is a supported deployment target. This is a real advantage if your compliance requirements rule out hosted monitoring or if you want to run heartbeat monitoring on your own infrastructure. CronAlert is hosted-only. The trade-off is the usual one: self-hosting moves cost from a subscription into engineering time, including the monitoring of the monitoring service itself. For most teams, hosted wins on total cost of ownership; for some, self-hosting is non-negotiable.

Q: Should I migrate from Healthchecks.io to CronAlert?

If you're already using a separate uptime monitor alongside Healthchecks.io, yes — consolidating to CronAlert removes a vendor and unifies the alerting surface. If Healthchecks.io is your only monitoring tool and you're happy with the self-host or hosted experience, the migration is optional. Migration takes about 10 minutes for a dozen checks: create heartbeat monitors in CronAlert, swap the ping URL in your crontabs or job runners, and disable on the Healthchecks.io side once you've seen a few successful pings on the new endpoints.

Healthchecks.io is one of the cleanest products in the monitoring space. It does cron job heartbeat monitoring, it does it well, and it doesn't pretend to do anything else. It's open source, the hosted version is reasonably priced, and the documentation reads like it was written by an engineer who actually uses the product. If all you need is "alert me when this cron job stops running," it's hard to recommend anything more focused.

Where the comparison with CronAlert gets interesting is when you need more than that. Most teams already monitor URLs, SSL certificates, and API endpoints somewhere else — UptimeRobot, Pingdom, Better Stack, a homegrown script. They use Healthchecks.io alongside that other tool because it covers a gap nothing else covers cleanly. This post compares the two on heartbeat features specifically, on pricing, and on the broader question of whether a single tool wins over a stack of two specialized ones.

What each tool covers

Healthchecks.io

Passive cron heartbeats — your job pings a URL on success; missing pings fire alerts.
Start signals — your job pings a /start URL at launch so the tool can measure run time and surface long-running jobs.
Exit codes and logs — append exit codes and stdout snippets to pings; visible in the run history.
Cron expression and simple interval scheduling — Healthchecks.io accepts cron expressions or a "ping every N seconds" interval.
Alert channels — email, Slack, Discord, Telegram, Microsoft Teams, PagerDuty, Opsgenie, webhooks, SMS (paid).
Read-only status badges — embedded badges showing check state. No full status page.
Self-hostable — BSD-licensed source; supported self-host path.

CronAlert

HTTP/HTTPS URL uptime checks — multi-region, with quorum logic to suppress false positives.
Cron heartbeat monitoring — same passive-ping model as Healthchecks.io, with cron-expression or interval scheduling.
Keyword and content monitoring — assert that a response body contains (or doesn't contain) specific text, plus SHA-256 content-hash change detection.
SSL certificate monitoring — automatic during HTTPS checks; alerts on expiry and TLS errors.
Multi-region checks — five Cloudflare edge regions, quorum-required before alerting.
Public status pages — 90-day uptime history, incident tracking, Atom feed; included on every plan.
REST API and MCP integrations — full API plus MCP servers for Claude Code, Cursor, Windsurf, and Claude Desktop.
Alert channels — email, Slack, Discord, Microsoft Teams, Telegram, PagerDuty, Opsgenie, webhooks, push notifications via PWA.
Hosted on Cloudflare's edge — no self-host option.

The overlap is the heartbeat layer. The difference is that CronAlert treats heartbeats as one mode alongside URL monitoring; Healthchecks.io treats heartbeats as the entire product.

Heartbeat monitoring: feature by feature

Since this is the area of direct overlap, it's worth doing the comparison concretely. The heartbeat features are very close.

Ping endpoint

Both tools generate a unique URL per check and expect a GET (or POST) on success. Both accept /start for start signals and /fail for explicit failure pings. CronAlert and Healthchecks.io are roughly drop-in compatible at the cron-line level — see the heartbeat monitoring guide for the CronAlert version.

Schedule expressions

Both accept full cron expressions (with timezone) for jobs that run on a fixed schedule, and "expect a ping every N minutes" interval expressions for jobs that run continuously or on a non-cron schedule. CronAlert's grace period is configurable per monitor; Healthchecks.io's is configurable per check. No meaningful difference.

Run-time tracking

Both record the time between /start and the success ping, so you can see how long jobs take to run and alert on long-running jobs. Healthchecks.io surfaces this in a per-check dashboard with histograms; CronAlert surfaces it inline with the check history. Healthchecks.io's UI is slightly more polished for this specific view; CronAlert's UI is faster on jobs with many runs because of HTMX-driven pagination.

Exit codes and logs

Healthchecks.io has first-class support for appending exit codes and a few KB of stdout to each ping; the data shows up in the run history. CronAlert supports the same via POST body — the body is recorded and surfaced in the run timeline. The user-facing UI for browsing run logs is slightly more developed on Healthchecks.io; the underlying capability is similar.

Alert channels

Both cover the standard channels — email, Slack, Discord, Teams, Telegram, PagerDuty, Opsgenie, webhooks. Healthchecks.io includes SMS at higher tiers; CronAlert covers SMS through PagerDuty/Opsgenie or webhook-to-Twilio. CronAlert adds PWA-based push notifications on iOS, Android, Mac, and Windows — no App Store install needed, see the iOS setup guide.

What Healthchecks.io has that CronAlert doesn't

Self-hosting. Healthchecks.io is open source under BSD-3. You can deploy it on your own infrastructure and run it inside a compliance perimeter. CronAlert is hosted-only on Cloudflare.
Single-purpose UI. Healthchecks.io's dashboard is built around heartbeat checks specifically. The mental model is simpler if heartbeats are the only thing you care about. CronAlert's dashboard treats heartbeats as one of several monitor types, which is more capable but slightly more to navigate.
Project-level isolation. Healthchecks.io has explicit "projects" as a first-class organizing concept, which maps neatly onto teams or environments. CronAlert organizes by tags and teams; functionally similar but the metaphor is different.

What CronAlert has that Healthchecks.io doesn't

HTTP/HTTPS URL uptime monitoring. The whole reason teams add Healthchecks.io to an existing UptimeRobot or Pingdom setup. CronAlert covers both in one tool.
SSL certificate monitoring. Automatic during HTTPS checks. Healthchecks.io has no certificate-monitoring product.
Multi-region checks with quorum. Cuts false positives by requiring multiple regions to agree before alerting — see the false-positive playbook.
Content and keyword monitoring. Beyond "did the URL respond," CronAlert can assert that a response body contains expected text or doesn't contain unwanted text. Useful for detecting silent regressions.
Public status pages. 90-day uptime history, incident tracking, Atom feed. Included on every plan. Healthchecks.io has badges but no full status page.
MCP integrations. Manage monitors through Claude Code, Cursor, Windsurf, or Claude Desktop without leaving your editor. See the Claude Code setup.
Push notifications via PWA. Native push on iOS, Android, Mac, and Windows with no App Store install.

Pricing comparison

Healthchecks.io prices by check count and feature tier; CronAlert prices by monitor count and feature tier. The free tiers are close; the paid tiers diverge once you include URL uptime monitoring under the same vendor.

Healthchecks.io pricing

Hobbyist — free for 20 checks, basic features.
Supporter — around $5/month for 20 checks with SMS support and longer history.
Business — around $20/month for 100 checks with team features.
Self-hosted — free if you operate it yourself, but you're paying in engineering time.

CronAlert pricing

Free — $0/month for 25 monitors (URL or heartbeat) at 3-minute intervals, email/Slack/Discord/webhook alerts, one status page, SSL monitoring, basic API.
Pro — $5/month ($4 annual) for 100 monitors at 1-minute intervals, three status pages, all alert channels including PagerDuty/Opsgenie/Teams/Telegram, full API, keyword and content monitoring, maintenance windows.
Team — $20/month ($16 annual) for 500 monitors, unlimited status pages, 10 team members, multi-region checks, 90-day log retention.
Business — $50/month ($40 annual) for unlimited monitors, unlimited team members, SSO/SAML, audit logs, 1-year retention.

For a team running 20 cron heartbeats and nothing else, the free tiers are equivalent. For a team running 20 cron heartbeats and 30 URL uptime checks, Healthchecks.io covers only the heartbeats and you still need a separate uptime tool; CronAlert's $5 Pro plan covers all 50 monitors with 1-minute intervals. The consolidation savings show up at the paid tier, not the free one.

When Healthchecks.io is the right choice

You only need heartbeat monitoring. No URLs, no certificates, no status page. Healthchecks.io's focus is a feature, not a limitation.
You need self-hosting. Compliance, air-gapped environments, or sovereignty requirements that rule out hosted monitoring. CronAlert isn't an option here.
You're already on Healthchecks.io and happy with it. Switching tools for the sake of switching tools is not a great use of an engineer's afternoon. The migration is straightforward when there's a reason to do it, but "we already have the right tool" is a valid answer.

When CronAlert is the right choice

You're running Healthchecks.io alongside another uptime tool. Consolidate to one. Same heartbeat coverage, plus URL uptime, plus status pages, plus SSL, in a single dashboard under one bill.
You need a public status page. Customers expect a /status URL. Healthchecks.io's per-check badges aren't a substitute. See setting up a free status page.
You want multi-region quorum. A single-region check that flickers green-red-green pages on-call for nothing. Quorum requires multiple regions to agree before paging.
You want MCP integrations or PWA push notifications. CronAlert's product roadmap includes these; Healthchecks.io's doesn't.

Migrating from Healthchecks.io to CronAlert

The migration is low-friction because the heartbeat-ping pattern is identical at the cron-line level. Three steps:

Create heartbeat monitors in CronAlert for each Healthchecks.io check, copying the schedule expression and grace period. Use the REST API for bulk creation if you have more than a dozen.
Swap the ping URL in your crontabs or job runners. Where you previously had curl -fsS https://hc-ping.com/<uuid>, replace with the equivalent CronAlert ping URL. The contract is the same — GET on success, optional /start and /fail endpoints, optional POST body for logs.
Wait for a few successful pings on the CronAlert side, then disable on the Healthchecks.io side. Don't delete the Healthchecks.io account immediately — keep it pingable for a week so a partially-rolled-out cron doesn't go silent.

For URL uptime monitors (if you're also moving away from a separate uptime tool), the UptimeRobot migration guide covers the general pattern; it maps cleanly to most other vendors.

The bigger picture: one tool or two?

A reasonable argument for keeping two tools is that focused tools tend to do their one job better. Healthchecks.io has historically been more polished than the heartbeat features bolted onto larger uptime products. That gap has narrowed; CronAlert's heartbeat implementation is feature-equivalent for the common cases, and the consolidation upside (one bill, one dashboard, one alert routing config) is real.

The argument against consolidation is the usual one: vendor risk concentration. If your single monitoring vendor has an outage, you're flying blind on both URLs and heartbeats. The mitigation is to keep alerts routed to a channel you'll see during a CronAlert outage (PagerDuty rather than just email) and to run a tiny dead-man's-switch heartbeat on a second vendor for the monitoring tool itself.

Frequently asked questions

What does Healthchecks.io actually do?

Passive cron heartbeat monitoring — your job pings a URL on success, missing pings fire alerts. It's deliberately narrow and focused; no URL uptime, no SSL, no full status pages.

How is CronAlert different from Healthchecks.io?

CronAlert is a full uptime monitoring product that includes heartbeats as one mode alongside URL checks, content monitoring, SSL monitoring, multi-region quorum, and status pages. Healthchecks.io focuses on heartbeats only.

Is CronAlert cheaper than Healthchecks.io?

Comparable on free tiers (25 vs 20 checks), cheaper at paid tiers when you include URL uptime monitoring in the same vendor. If you only need heartbeats, the prices are similar; if you'd otherwise stack Healthchecks.io with a separate uptime tool, CronAlert consolidates to one bill.

Can I self-host Healthchecks.io?

Yes — Healthchecks.io is BSD-licensed and self-hosting is supported. CronAlert is hosted-only on Cloudflare.

Should I migrate from Healthchecks.io to CronAlert?

Yes if you're stacking it with another uptime monitor. Optional if Healthchecks.io is your only monitoring tool and it's working for you.

Consolidate your monitoring

The case for CronAlert over Healthchecks.io comes down to whether you want one tool covering both heartbeats and URLs, or two tools each covering one. For most teams, one tool is enough — and the migration takes minutes rather than hours. Create a free CronAlert account, add a heartbeat monitor that matches your existing Healthchecks.io check, swap the ping URL in your crontab, and you've started the migration.