Compare

Drumbeats vs Healthchecks.io

We build Drumbeats, so weigh this accordingly. Every Healthchecks.io number below links to the page we read it on. Facts checked .

Verdict

Healthchecks.io is an open-source dead man's switch for cron jobs that you can use hosted or run on your own server: 20 jobs free, then $20 a month for 100 and $80 for 1,000, with 27 alert integrations. Drumbeats is hosted only and watches more of your background work from the first day: 50 monitors free, queue workers and other jobs that have no fixed timing, HTTP uptime checks, a public status page per monitor, and every alert channel and every seat on the Free plan.

  • Pick Healthchecks.io if you want to self-host or need code you can read, if your alerts must arrive by SMS, WhatsApp, phone call, Signal or Matrix, or if you run hundreds of jobs every few minutes and want a bill fixed by job count.
  • Pick Drumbeats if you have more than 20 jobs and do not want to pay yet, if part of your work is queue jobs or webhooks and not cron, or if you want uptime checks, status pages and PagerDuty alerts without a paid plan.

Price at five real sizes

Each size assumes 3 people who receive alerts and one run an hour per monitor, billed monthly in USD. Where a vendor only lists a yearly price, the table shows that price divided by 12 and says so.

MonitorsDrumbeatsHealthchecks.io
10 monitors3 people, hourly jobs$0Free7,200 Beats a month$0Hobbyist
50 monitors3 people, hourly jobs$0Free36,000 Beats a month$20Business
100 monitors3 people, hourly jobs$20Pro72,000 Beats a month$20Business
200 monitors3 people, hourly jobs$20Pro144,000 Beats a month$80Business Plus
500 monitors3 people, a run every 5 minutes, start and success pings$99Scale8,640,000 Beats a month$80Business Plus

Drumbeats plans are read from the same source as our pricing page. Healthchecks.io prices are from healthchecks.io/pricing/, read 13 Nov 2026.

The two tools count different things. Healthchecks.io counts jobs, so a job costs the same whether it runs once a week or every minute. Drumbeats counts pings (one Beat each) and does not count monitors on paid plans. That is why the columns cross: Drumbeats is cheaper at 50 and at 200 hourly jobs, both cost $20 at 100, and Healthchecks.io is cheaper when hundreds of jobs run every few minutes.

Healthchecks.io plans as listed

PlanPriceJobsHistory keptShortest interval
HobbyistFree20Last 100 log entries per job1 min
Supporter$5 a month20Last 100 log entries per job1 min
Business$20 a month, or $192 a year100Last 1,000 log entries per job1 min
Business Plus$80 a month, or $768 a year1,000Last 1,000 log entries per job1 min

Supporter has the same limits as Hobbyist; it exists for people who want to pay for the project. Yearly billing takes 20% off the two paid plans. SMS, WhatsApp and phone call credits start on Business: 50 SMS & WhatsApp credits, 20 phone call credits a month. Open-source projects and nonprofits can get Business free of charge.

Side by side

FeatureDrumbeatsHealthchecks.io
Free plan50 monitors, 200K beats a month, every alert channel20 jobs (Hobbyist), the last 100 log entries per job
Paid pricing$20 a month flat (Pro): unlimited monitors, 1M beats$20 a month for 100 jobs (Business), $80 for 1,000 (Business Plus)
What you pay forPings. One ping is one Beat; an idle monitor costs nothingThe number of checks in the account
Monitor typesCron, heartbeat, queue workers and HTTP uptimeChecks that expect a ping on time: simple (period and grace time), cron expressions and systemd OnCalendar. No website uptime checks
Ping signalsStart, success, failure and log pings, plus the exit code in the URLSuccess, start, failure and log pings, plus the script's exit status in the URL
Run IDsAny string up to 255 charactersA UUID
Output kept per ping100 KB on Free, 1 MB on Pro, 2 MB on Business and ScaleThe first 100 kB of each ping
History keptLast 250 pings per monitor on Free, 1,000 on Pro, 5,000 on Business, 10,000 on ScaleLast 100 log entries per job on Hobbyist, 1,000 on the paid plans
Alert channels8 on every plan: email, Slack, Telegram, Discord, webhook, browser push, Microsoft Teams & PagerDuty27 integrations, among them Signal, Matrix, Mattermost, Zulip and ntfy. Opsgenie, PagerDuty, Splunk On-Call, phone calls, SMS and WhatsApp are on paid plans only
SMS and phone callsNoYes, as monthly credits on paid plans: 50 SMS & WhatsApp credits, 20 phone call credits a month on Business
Team seatsUnlimited on every plan, including FreePer project, with Owner, Manager, Team Member and Read-only roles; no seat price or seat limit stated
Status pagesA public page per monitor on every plan; branded multi-monitor pages from ProStatus badges (SVG, JSON, Shields.io); no hosted status page
API and agentsREST API and an MCP server on every planREST Management API: list, create, update, pause and delete checks. No MCP server in its docs
Open sourceNo, hosted onlyYes: BSD-3-Clause, self-hostable

Who wins where

Where Healthchecks.io wins

  • Self-hosting. The code is open source (BSD-3-Clause) and runs on your own server with Python 3.12+, Django 6.0, PostgreSQL or MySQL. The number of jobs is then limited by your hardware, not by a plan. Drumbeats has no self-hosted edition.
  • SMS, WhatsApp and phone calls. Business includes 50 SMS & WhatsApp credits, 20 phone call credits a month. Drumbeats sends no SMS and makes no calls; to wake someone up it has PagerDuty and browser push.
  • More integrations. 27 against 8, among them Signal, Matrix, Mattermost, Zulip, ntfy, Pushover and Opsgenie. Drumbeats reaches those only through a webhook.
  • Many jobs that run often. 500 jobs that each run every five minutes cost $80 a month on Business Plus. On Drumbeats the same load is 8.64 million Beats a month, which is $99 on Scale.
  • Open-source projects and nonprofits get the Business plan free of charge.
  • Track record. Healthchecks.io has run since July 2015, and both the company and its servers are in the EU.

Where Drumbeats wins

  • More jobs covered before you pay. Free has 50 monitors against 20 jobs. At 50 hourly jobs Drumbeats is still $0 and Healthchecks.io is $20 a month on Business.
  • Work that has no clock. Every Healthchecks.io check expects a ping on time, by a period, a cron expression or an OnCalendar expression. A queue worker or a webhook handler is never late, so there is nothing to wait for. Drumbeats has an event-driven monitor for this: it opens an incident when a run reports failure, or starts and never finishes.
  • Run IDs you already have. Both tools pair the start and the end of a run by a run ID. Healthchecks.io takes a UUID. Drumbeats takes any string up to 255 characters, so an order number or a message ID is the run ID and the alert names it.
  • Uptime checks and status pages in the same tool. Healthchecks.io says it is not the right tool for probing a website, and it offers status badges, not status pages. Drumbeats has HTTP uptime monitors and a public status page per monitor on every plan, with branded multi-monitor pages from Pro.
  • Every channel and every seat on Free. All 8 channels are on the Free plan: email, Slack, Telegram, Discord, webhook, browser push, Microsoft Teams & PagerDuty. On Healthchecks.io, Opsgenie, PagerDuty, Splunk On-Call, phone calls, SMS and WhatsApp need a paid plan.
  • Room for the full output. Drumbeats keeps up to 1 MB per ping on Pro and 2 MB on Business and Scale. Healthchecks.io keeps the first 100 kB of each ping.
  • Set up by an agent. The Drumbeats MCP server lets Claude, Cursor or VS Code create, pause and resolve monitors from the editor, and the REST API is on every plan.

If you are thinking of self-hosting

Self-hosting changes the price comparison completely. The Healthchecks.io code is free, so the cost is one small server and your time, and no hosted plan on this page matters.

The time is the real cost. You run a Django app with a database, the process that sends alerts, mail delivery, backups and upgrades. And the monitor needs a monitor: if that server stops, nothing tells you that your jobs are no longer watched.

If your team already runs services like this, self-hosted Healthchecks.io is a good choice and we will not talk you out of it. A middle path also works: keep it for your jobs and point one hosted heartbeat at the server itself, so its silence is noticed. If nobody wants one more service to keep alive, a hosted plan from either tool costs $0 to $20 a month up to 100 jobs.

The same job in both tools

A nightly cron job that reports start, success and failure

Drumbeats

# crontab: tell Drumbeats when the job starts, succeeds or fails
0 2 * * * curl -sf https://api.drumbeats.io/v1/ping/<monitor-id>/start \
  && /usr/local/bin/nightly-backup.sh \
  && curl -sf https://api.drumbeats.io/v1/ping/<monitor-id>/success \
  || curl -sf https://api.drumbeats.io/v1/ping/<monitor-id>/failure
# crontab: tell Drumbeats when the job starts, succeeds or fails
0 2 * * * curl -sf https://api.drumbeats.io/v1/ping/<monitor-id>/start \
  && /usr/local/bin/nightly-backup.sh \
  && curl -sf https://api.drumbeats.io/v1/ping/<monitor-id>/success \
  || curl -sf https://api.drumbeats.io/v1/ping/<monitor-id>/failure

Healthchecks.io

# crontab: tell Healthchecks.io when the job starts, succeeds or fails
0 2 * * * curl -sf https://hc-ping.com/<uuid>/start \
  && /usr/local/bin/nightly-backup.sh \
  && curl -sf https://hc-ping.com/<uuid> \
  || curl -sf https://hc-ping.com/<uuid>/fail
# crontab: tell Healthchecks.io when the job starts, succeeds or fails
0 2 * * * curl -sf https://hc-ping.com/<uuid>/start \
  && /usr/local/bin/nightly-backup.sh \
  && curl -sf https://hc-ping.com/<uuid> \
  || curl -sf https://hc-ping.com/<uuid>/fail

The calls map one to one. /start stays /start, the bare Healthchecks.io ping becomes /success, and /fail becomes /failure. Both tools also accept the exit code in the URL.

A queue job that can run many times at once

Drumbeats

const PING = "https://api.drumbeats.io/v1/ping/<monitor-id>";

async function handleJob(job) {
  const runId = `order-${job.id}`; // any string up to 255 characters
  await fetch(`${PING}/start?run_id=${runId}`);
  try {
    await processJob(job);
    await fetch(`${PING}/success?run_id=${runId}`);
  } catch (err) {
    await fetch(`${PING}/failure?run_id=${runId}`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ payload: err.message }),
    });
  }
}
const PING = "https://api.drumbeats.io/v1/ping/<monitor-id>";

async function handleJob(job) {
  const runId = `order-${job.id}`; // any string up to 255 characters
  await fetch(`${PING}/start?run_id=${runId}`);
  try {
    await processJob(job);
    await fetch(`${PING}/success?run_id=${runId}`);
  } catch (err) {
    await fetch(`${PING}/failure?run_id=${runId}`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ payload: err.message }),
    });
  }
}

Healthchecks.io

const PING = "https://hc-ping.com/<uuid>";

async function handleJob(job) {
  const rid = crypto.randomUUID(); // must be a UUID
  await fetch(`${PING}/start?rid=${rid}`);
  try {
    await processJob(job);
    await fetch(`${PING}?rid=${rid}`);
  } catch (err) {
    await fetch(`${PING}/fail?rid=${rid}`, {
      method: "POST",
      body: err.message,
    });
  }
}
const PING = "https://hc-ping.com/<uuid>";

async function handleJob(job) {
  const rid = crypto.randomUUID(); // must be a UUID
  await fetch(`${PING}/start?rid=${rid}`);
  try {
    await processJob(job);
    await fetch(`${PING}?rid=${rid}`);
  } catch (err) {
    await fetch(`${PING}/fail?rid=${rid}`, {
      method: "POST",
      body: err.message,
    });
  }
}

With a UUID you need your own lookup to get from an alert back to the order. With the order number as the run ID, the alert already says which order failed.

Switching from Healthchecks.io in three steps

  1. 1

    Recreate your checks as monitors

    List your checks with the Healthchecks.io Management API or read them off the dashboard. Create one Drumbeats monitor for each: a cron monitor for a check with a cron expression, a heartbeat monitor for a check with a period, with the same grace time. The REST API or an agent on the MCP server can create them in one go.

  2. 2

    Swap the ping URL

    Replace the hc-ping.com URL in each job with the Drumbeats ping URL. Keep /start, send /success where you sent the bare ping, and send /failure where you sent /fail. A job that reported its exit code in the URL keeps doing so.

    # crontab: tell Drumbeats when the job starts, succeeds or fails
    0 2 * * * curl -sf https://api.drumbeats.io/v1/ping/<monitor-id>/start \
      && /usr/local/bin/nightly-backup.sh \
      && curl -sf https://api.drumbeats.io/v1/ping/<monitor-id>/success \
      || curl -sf https://api.drumbeats.io/v1/ping/<monitor-id>/failure
    # crontab: tell Drumbeats when the job starts, succeeds or fails
    0 2 * * * curl -sf https://api.drumbeats.io/v1/ping/<monitor-id>/start \
      && /usr/local/bin/nightly-backup.sh \
      && curl -sf https://api.drumbeats.io/v1/ping/<monitor-id>/success \
      || curl -sf https://api.drumbeats.io/v1/ping/<monitor-id>/failure
  3. 3

    Run both for a week, then cancel

    Each tool has its own URL, so a job can ping both until you have seen a real alert from each. Healthchecks.io lets you cancel at any time and gives no refund for the rest of a paid period, so the overlap costs one month at most.

Questions people ask

What does the Healthchecks.io free plan include?
The free Hobbyist plan covers 20 jobs and keeps the last 100 log entries per job. SMS, WhatsApp and phone call credits are not on it; they start on the Business plan. The Drumbeats Free plan covers 50 monitors, 200K beats a month and all 8 alert channels.
How much does Healthchecks.io cost?
Healthchecks.io has four hosted plans: Hobbyist is free for 20 jobs, Supporter is $5 a month with the same limits, Business is $20 a month for 100 jobs and Business Plus is $80 a month for 1,000 jobs. Billed yearly, Business is $192 and Business Plus is $768. The price depends on the number of jobs, not on how often they run.
Can I self-host Healthchecks.io?
Yes. Healthchecks.io is open source under the BSD-3-Clause licence and runs on your own server with Python 3.12+, Django 6.0, PostgreSQL or MySQL. You then run the app, the database, alert delivery and backups yourself. Drumbeats is hosted only.
Is Drumbeats a good Healthchecks.io alternative?
It is when you have more than 20 jobs and want to stay on a free plan, when you also run queue workers or need uptime checks and status pages, or when you want PagerDuty and Microsoft Teams alerts without paying. It is not when you need to self-host, need SMS or phone calls, or run hundreds of jobs every few minutes: Healthchecks.io is the better fit there.
Does Healthchecks.io have an MCP server?
We found none in its documentation or in its list of third-party projects when we read them on 13 Nov 2026. It has a REST Management API. Drumbeats has an official MCP server on every plan, so an AI client such as Claude or Cursor can create monitors and look into incidents.
Does Healthchecks.io monitor website uptime?
No. Its documentation says it is not the right tool for probing a website with HTTP requests; it waits for pings from your jobs. Drumbeats does both: it waits for pings from jobs and it runs HTTP uptime checks against your URLs.
Does Drumbeats send SMS alerts?
No. Drumbeats alerts by email, Slack, Telegram, Discord, webhook, browser push, Microsoft Teams & PagerDuty. If you need a text message or a phone call, the Healthchecks.io Business plan includes monthly credits for both.
What does a Drumbeats monitor cost when a job runs often?
Each ping is one Beat. A job that runs every hour uses 720 Beats a month, and one that runs every minute uses 43,200. Pro includes 1M beats a month, and extra Beats are $20 per million if you turn overage on.
How current are these prices?
Every Healthchecks.io number on this page links to the page it was read from, with the date we read it. A monthly check re-reads each source and updates the file this page is built from. If you spot an error, email hello@drumbeats.io and we will fix it.

Sources

Healthchecks.io is named here as a product name only; it is a trademark of its owner, and Healthchecks.io has not reviewed this page. Spot an error? Email hello@drumbeats.io and we will correct it.

Try it on one job

Point one cron job at Drumbeats

Create a monitor, paste the ping URL into the job, and see the first check-in land. The Free plan covers 50 monitors with no card.

Free for up to 50 monitors · Setup in 60 seconds · No credit card required