Compare
Drumbeats vs Sentry Crons
We build Drumbeats, so weigh this accordingly. Every Sentry Crons number below links to the page we read it on. Facts checked .
Verdict
Sentry Crons is cron monitoring inside Sentry: a missed or failed run becomes an issue next to the errors and traces of the same code, with 1 cron monitor in every plan and each extra one at $0.78 a month on top of a paid plan from $29. Drumbeats is a job monitor on its own: 50 monitors, every alert channel and unlimited seats are free, Pro is $20 a month flat for unlimited monitors, and it also watches queue workers and HTTP uptime, with no SDK and no project to set up first.
- Pick Sentry Crons if your team already works in Sentry: you want a failed job to open an issue beside its stack trace, monitors that are created from code, and one place for errors, traces and jobs.
- Pick Drumbeats if you want job monitoring that does not hang off an error tracker: more than one monitor without a paid plan, a bill that does not grow with each job, Slack or Teams alerts on the free plan, and a status page per monitor.
Price at six 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.
| Monitors | Drumbeats | Sentry Crons |
|---|---|---|
| 1 monitor1 person, an hourly job | $0Free720 Beats a month | $0Developer |
| 10 monitors3 people, hourly jobs | $0Free7,200 Beats a month | $36.02Team |
| 50 monitors3 people, hourly jobs | $0Free36,000 Beats a month | $67.22Team |
| 100 monitors3 people, hourly jobs | $20Pro72,000 Beats a month | $106.22Team |
| 200 monitors3 people, hourly jobs | $20Pro144,000 Beats a month | $184.22Team |
| 1,550 monitors3 people, a job every minute | $1,238.20Scale66,960,000 Beats a month, $1,139.20 of that is pay-as-you-go overage | $1,237.22Team |
Drumbeats plans are read from the same source as our pricing page. Sentry Crons prices are from sentry.io/pricing/, read 13 Nov 2026.
Sentry prices here are for monthly billing; billed annually, Team is $26 a month. Every plan includes 1 cron monitor and each extra one is $0.78 a month, so the Sentry column is the Team plan plus the extra monitors. If you already pay for Sentry, only the extra monitors are new cost. The free Developer plan has one user and cannot add monitors, which is why it appears only in the one-job row.
Sentry plans as listed
| Plan | Price | Cron monitors | Seats | Shortest interval |
|---|---|---|---|---|
| Developer | Free | 1 | 1 | 1 min |
| Team | $29 base + $0.78 per monitor after the first a month | Unlimited | Unlimited | 1 min |
| Business | $89 base + $0.78 per monitor after the first a month | Unlimited | Unlimited | 1 min |
Every plan includes 1 cron monitor and 1 uptime monitor. More cron monitors are $0.78 each a month and uptime monitors $1.00 each, from the pay-as-you-go budget of a paid plan. At the start of a billing period, monitors may be deactivated if the pay-as-you-go budget does not cover them.
Side by side
| Feature | Drumbeats | Sentry Crons |
|---|---|---|
| Free plan | 50 monitors, unlimited seats, 200K beats a month, every alert channel | One user, 1 cron monitor, alerts by email |
| Paid pricing | $20 a month flat (Pro): unlimited monitors, 1M beats | $29 a month (Team) with 1 cron monitor, then $0.78 a month for each extra monitor |
| What you need first | An account. Each monitor has one ping URL | A Sentry account and project; the check-in URL carries the ingest domain, project ID and public key |
| Ping signals | Start, success, failure and log pings, plus the exit code in the URL | Two check-ins a run (in progress, then ok or error), or a single heartbeat check-in |
| Expected timing | A cron expression with a timezone, or an interval, plus a grace period | A five-field crontab expression or an interval, with a timezone and a check-in margin; shortest is one minute |
| Runs that hang | A run that starts and does not finish within its maximum duration opens an incident | A run that stays in progress past its maximum runtime is marked failed |
| Queue workers and webhooks | An event-driven monitor with no expected timing, tracked by run ID | A cron monitor with a crontab expression or an interval. A check-in ID ties the two check-ins of one run together |
| What a failure becomes | An incident with the run timeline and the output the job sent | A Sentry issue, shown with errors the SDK captured during the run |
| Uptime checks | HTTP uptime monitors on every plan, counted in Beats | 1 uptime monitor in every plan; more are billed per monitor |
| Alert channels | 8 on every plan: email, Slack, Telegram, Discord, webhook, browser push, Microsoft Teams & PagerDuty | Developer: email. API and third-party integrations start on Team |
| Team seats | Unlimited on every plan, including Free | 1 user on Developer, unlimited users on Team and up |
| API and agents | REST API and an MCP server on every plan | MCP access on every plan; the API and third-party integrations start on Team |
Who wins where
Where Sentry Crons wins
- The error next to the job. A missed or failed run becomes a Sentry issue, shown with errors the SDK captured during the run. You go from "the job failed" to the stack trace without leaving the tool. Drumbeats shows the run and the output the job sent, not your application's errors.
- Monitors from code. A check-in can create or update its monitor, so a new job brings its monitor with it. On Drumbeats you create the monitor first, in the dashboard, with the API or through the MCP server.
- Environments. One monitor can track the same job in several environments, each with its own status.
- One platform. Error monitoring, tracing, logs, session replay, profiling and uptime monitoring in the same product. If your team already pays for Sentry, cron monitoring adds $0.78 a month per job and nothing else to learn.
- Company controls. SAML and SCIM are on the Business plan; Drumbeats has neither.
- Hundreds of jobs every minute. 1,550 jobs that each run every minute cost $1,237.22 a month on Sentry and $1,238.20 on Drumbeats (66.96 million Beats). Above that, a price per monitor wins over a price per ping.
Where Drumbeats wins
- Every job gets a monitor. 50 hourly jobs are $0 on Drumbeats and $67.22 a month on Sentry Team; 100 are $20 against $106.22, and 200 are $20 against $184.22. A price per monitor is a reason to leave the small jobs out.
- A free plan that covers real work. 50 monitors, unlimited seats and all 8 alert channels. The free Sentry Developer plan has one user, 1 cron monitor and email alerts.
- No budget that can switch a monitor off. Extra Sentry monitors are paid from a pay-as-you-go budget, and its docs say monitors may be deactivated at the start of a billing period when the budget does not cover them. Drumbeats does not bill per monitor.
- Nothing to set up first. A Drumbeats monitor is one URL that any script can call. A Sentry check-in URL is built from an ingest domain, a project ID, a monitor slug and a public key, and needs a Sentry project.
- Work that has no clock. A Sentry cron monitor always has a crontab expression or an interval. A Drumbeats event-driven monitor expects nothing and opens an incident when a queue job or a webhook run fails or hangs.
- Alerts where the team is, on Free. Slack, Microsoft Teams, Telegram, Discord, webhooks and PagerDuty are on the Drumbeats Free plan. On Sentry, third-party integrations start on Team.
- A status page per monitor, and uptime checks that are not billed one by one.
The same job in both tools
A nightly cron job
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
Sentry Crons
# SENTRY_CRONS=https://<ingest-domain>/api/<project-id>/cron/<monitor-slug>/<public-key>/ # crontab: tell Sentry when the job starts, succeeds or fails 0 2 * * * curl -sf "$SENTRY_CRONS?status=in_progress" \ && /usr/local/bin/nightly-backup.sh \ && curl -sf "$SENTRY_CRONS?status=ok" \ || curl -sf "$SENTRY_CRONS?status=error"
The two are close: start, success and failure on both sides. The Sentry URL is longer because it names the project and carries a key.
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 }),
});
}
}Sentry Crons
// https://<ingest-domain>/api/<project-id>/cron/<monitor-slug>/<public-key>/
const CRONS = process.env.SENTRY_CRONS;
async function handleJob(job) {
const id = crypto.randomUUID(); // ties the two check-ins of one run
await fetch(`${CRONS}?check_in_id=${id}&status=in_progress`);
try {
await processJob(job);
await fetch(`${CRONS}?check_in_id=${id}&status=ok`);
} catch (err) {
await fetch(`${CRONS}?check_in_id=${id}&status=error`);
}
}Both tie the start and the end of a run together. The Drumbeats monitor has no expected timing, so a quiet queue is not a missed run.
Switching from Sentry Crons in three steps
- 1
Recreate your cron monitors
For each Sentry cron monitor, create a Drumbeats cron monitor with the same crontab expression and timezone, the check-in margin as the grace period and the maximum runtime as the maximum duration. Interval monitors become heartbeat monitors. The REST API or an agent on the MCP server can create them in one go.
- 2
Swap the check-in calls
Replace each Sentry check-in with the Drumbeats ping URL: status=in_progress becomes /start, status=ok becomes /success and status=error becomes /failure. If the SDK sent the check-ins for you, add the three calls around the job.
# 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
Run both for a week, then remove the extra monitors
A job can check in with both tools until you have seen a real alert from each. Keep Sentry for errors and traces. A monitor that was active in the current billing period still counts for that period after it is deactivated or deleted, so the saving shows on the next bill.
Questions people ask
- How much does Sentry Crons cost?
- Every Sentry plan includes 1 cron monitor. Each extra monitor is $0.78 a month, paid from the pay-as-you-go budget of a paid plan; Team is $29 a month, or $26 billed annually. So 100 cron monitors on Team come to $106.22 a month, and the same 100 on Drumbeats Pro are $20.
- Is Sentry Crons free?
- One cron monitor is, on the free Developer plan, which has one user and email alerts. More monitors need a paid plan with a pay-as-you-go budget. The Drumbeats Free plan has 50 monitors, unlimited seats and all 8 alert channels.
- Is Drumbeats a Sentry Crons alternative?
- Yes, when you want job monitoring on its own: the same start, success and failure signals, cron expressions and timezones, with more free monitors and a flat price. It is not when the point is to see a failed job next to its stack trace in Sentry; that link is what Sentry Crons is for.
- Can I use Drumbeats for jobs and keep Sentry for errors?
- Yes. The job calls the Drumbeats ping URL, and the Sentry SDK keeps reporting errors as before. You lose the automatic link between a failed check-in and an issue, and you stop paying per cron monitor.
- Does Drumbeats need an SDK?
- No. A monitor is a URL. A cron job calls it with curl, and any language that can make an HTTP request can send the start, success and failure pings.
- Does Drumbeats track errors or traces?
- No. Drumbeats records each run: when it started, how long it took, whether it failed and the output the job sent. For exceptions and traces inside your code, Sentry is the right tool.
- How current are these prices?
- Every Sentry 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
- sentry.io/pricing/read
- docs.sentry.io/product/monitors-and-alerts/monitors/crons/getting-started/http/read
- docs.sentry.io/pricing/read
- docs.sentry.io/pricing/quotas/manage-cron-monitors/read
- docs.sentry.io/product/monitors-and-alerts/monitors/crons/job-monitoring/read
- docs.sentry.io/product/monitors-and-alerts/monitors/crons/read
Sentry Crons is named here as a product name only; it is a trademark of its owner, and Sentry Crons 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