Migrating From Cronhub: Replace Monitors and Scheduled URL Calls
Contents
Cronhub has shut down, so every job that still pings a Cronhub URL is unmonitored, and every URL a Cronhub scheduler used to call has stopped being called. The migration has two halves: point each job's heartbeat at a new monitor with the same schedule and grace period, and move any scheduled URL calls to a scheduler you control, since a monitor watches jobs but doesn't run them. This guide covers what to recover, how to map each Cronhub monitor, and how to confirm nothing was dropped. Written November 16, 2026.
What Happened, and What We Could Verify#
When checked on November 16, 2026, cronhub.io wasn't responding. A third-party write-up from Crontap, itself a scheduling product, reports that a shutdown banner on cronhub.io announced the closure on May 12, 2026, that billing stopped on May 31, and that the service shut down fully on June 30, 2026, with schedules, monitors, and ping history deleted. We found no official statement still online to confirm those dates, so treat them as reported.
The practical consequences don't depend on the exact dates:
- Pings to Cronhub fail. A job that calls a Cronhub ping URL either gets an error or a timeout. If the ping isn't guarded, that can slow or fail the job itself (see below).
- No alerts. Nothing is watching those jobs.
- Scheduled calls stopped. If you used Cronhub's scheduler to call your endpoints on a cron schedule, those calls stopped when the service did.
- No export. The same write-up says there was no documented bulk export, so your configuration has to be rebuilt from your own records.
Step 1: Find Every Job That Pinged Cronhub#
Your code and servers still hold the ping URLs, which is the best record left. The write-up describes them as https://cronhub.io/start/<uuid> and https://cronhub.io/finish/<uuid>, plus a plain ping. Search everywhere a job might be defined:
# Repositories
git grep -n "cronhub" -- . ':!node_modules'
# Every user's crontab and the system cron directories on a server
for user in $(cut -d: -f1 /etc/passwd); do crontab -l -u "$user" 2>/dev/null | grep -n cronhub | sed "s/^/$user: /"; done
grep -rn cronhub /etc/crontab /etc/cron.d /etc/cron.daily /etc/cron.hourly 2>/dev/null
# systemd units that ping in ExecStartPost or ExecStopPost
grep -rln cronhub /etc/systemd/system /usr/local/lib/systemd 2>/dev/nullAlso check CI schedules (GitHub Actions, GitLab), platform schedulers (Heroku Scheduler, Render, Kubernetes CronJob manifests), environment variables or secrets named like CRONHUB_*, and configuration management. Scheduled job inventory has a fuller list of places jobs hide.
For each hit, record:
| Field | Where to find it |
|---|---|
| Job | The command, script, or function that pings |
| Schedule | The crontab line, timer, or scheduler config that runs it |
| Time zone | The server's or scheduler's zone (often UTC) |
| Grace period | Your memory, runbook, or screenshots; otherwise estimate from typical duration |
| Ping style | Single ping, or start plus finish |
| Alert target | Who should hear about it, and where |
Step 2: Make the Pings Safe First#
Before swapping URLs, check how each job calls the monitor. With Cronhub gone, a ping written as curl https://cronhub.io/... with no timeout can hang until the TCP timeout, and a ping chained with && before the real work stops the job when it fails. Monitoring should never be able to break the job:
# Bad: no timeout, and a failed ping skips the backup entirely
curl https://cronhub.io/start/UUID && /opt/backup.sh
# Better: bounded, quiet, and the job's own exit code is kept
curl -fsS -m 5 -o /dev/null "$START_URL" || true
/opt/backup.sh
status=$?If you can't migrate a job today, remove its dead Cronhub call or make it bounded like this, so the job isn't slowed by a service that no longer answers.
Step 3: Map Each Monitor#
Cronhub monitors were heartbeats with an expected interval and a grace period. Most replacements work the same way, so the mapping is mostly mechanical. Decide two things per job:
- Interval or cron schedule. If the job runs from a cron expression, monitor it with the same cron expression in the same time zone rather than an interval. A job on
0 9 * * 1-5has a 72-hour gap over the weekend; an interval check either alerts every Saturday or is too loose on weekdays. - Single ping or start and finish. Start plus finish gives duration and catches runs that start but never finish. Single pings catch only missed and, with a fail call, failed runs.
Then choose where to move. Fair options, depending on what you want:
- Healthchecks.io is open source and self-hostable, with cron and systemd schedules,
/startand/failpings, and a free tier of 20 jobs. See Healthchecks.io compared. - Cronitor has schedules, start/complete/fail telemetry, and crontab auto-import; its free plan has 5 monitors. See the Cronitor comparison.
- Better Stack heartbeats fit if you also want uptime monitoring and on-call in one bill. See Better Stack compared.
- Dead Man's Snitch is the simplest check-in model, interval-based. See Dead Man's Snitch compared.
- CronRadar is cron-only: cron schedules with an application time zone, start/complete/fail, and automatic discovery for Hangfire, Quartz.NET, Celery beat, and Laravel. See the Cronhub comparison and pricing.
Step 4: Swap the URLs Job by Job#
With CronRadar, a ping that carries a schedule creates the monitor on its first request, so you don't create monitors in a dashboard first. Store the application key as CRONRADAR_API_KEY in the job's environment. For a crontab job that pinged Cronhub at start and finish, a small wrapper keeps the key out of the crontab line and returns the job's own exit code, following the ingestion API:
#!/usr/bin/env bash
# /usr/local/bin/monitored: monitored <key> <schedule> <command...>
key="$1"; schedule="$2"; shift 2
base="https://cron.life/api/v1/ping/$key"
run_id="$key-$(date +%s)-$$"
ping() {
curl --silent --show-error --max-time 5 --output /dev/null \
--user "$CRONRADAR_API_KEY:" --get "$base/$1" \
--data-urlencode "schedule=$schedule" \
--data-urlencode "run_id=$run_id" "${@:2}" || true
}
ping start
if "$@"; then
ping complete
else
status=$?
ping fail --data-urlencode "message=Exited with code $status"
exit "$status"
fi# crontab: /etc/cronradar.env (mode 600) exports CRONRADAR_API_KEY, so the key stays out of the crontab
0 2 * * * . /etc/cronradar.env && /usr/local/bin/monitored daily-backup "0 2 * * *" /opt/backup.shFor a monitor that used a single ping, a heartbeat after the job succeeds is enough:
/opt/report.sh && curl -fsS -m 5 -o /dev/null --user "$CRONRADAR_API_KEY:" \
--get "https://cron.life/api/v1/ping/weekly-report" --data-urlencode "schedule=0 7 * * 1"In application code, use the SDK for your language instead of shelling out: CronRadar.CronRadar.WrapAsync in .NET, cronradar.wrap in Node.js, with cronradar.job(...) in Python, and CronRadar::wrap in PHP. For Hangfire, Quartz.NET, Celery beat, and Laravel's scheduler, the framework packages discover every job, so you delete the Cronhub calls instead of replacing them one by one.
Set the CronRadar application's time zone to the zone the jobs run in, an IANA name such as America/New_York, or leave it as UTC if the servers run in UTC. Grace periods can be passed as gracePeriod (seconds, minimum 60) on the ping or set per monitor in the dashboard.
Step 5: Replace Cronhub Schedulers#
If Cronhub called your URLs on a schedule, a monitor won't replace that: CronRadar, like most cron monitors, watches jobs and doesn't run them. Move each scheduled call to something that runs on a schedule you control, then monitor it:
- A cron job or systemd timer on a server you already run:
curl -fsS -m 30 https://example.com/tasks/nightlyin the wrapper above. - Your framework's scheduler, if the endpoint belongs to an app that has one; call the code directly instead of over HTTP.
- A platform scheduler: GitHub Actions schedules, Cloudflare Cron Triggers, Google Cloud Scheduler, or EventBridge Scheduler. Check each one's timing guarantees: GitHub Actions schedules, for example, can run late or be dropped under load.
- A hosted HTTP scheduler, if you want the same model Cronhub had.
Whichever you pick, report each run to the monitor from the scheduled side, so you hear about it when the scheduler, not just the endpoint, stops.
Step 6: Confirm Nothing Was Dropped#
- Every job from Step 1 has a monitor, and every monitor shows a successful run after its next scheduled time.
- Alerts reach the right people: send a test alert to each destination (email, Slack, webhook, Discord, PagerDuty) and have someone confirm it.
git grep cronhuband the server searches return nothing.- Jobs that run rarely (monthly, quarterly) are marked so someone checks them after their first run under the new monitor; monitors created ahead of time in CronRadar alert if that first run never arrives.
Frequently Asked Questions#
Is Cronhub still running?#
No. When checked on November 16, 2026, cronhub.io wasn't responding. A third-party report says the shutdown was announced on May 12, 2026, billing ended on May 31, and the service closed fully on June 30, 2026, with data deleted. We couldn't find an official statement still online.
Can I export my Cronhub monitors?#
The service is offline, and the third-party report says there was no documented bulk export even before. Rebuild the list from your own systems: the ping URLs in your code, crontabs, and scheduler configs show which jobs reported to Cronhub, and their schedules are in the same places.
Does CronRadar run scheduled jobs like Cronhub's scheduler?#
No. CronRadar monitors scheduled jobs that run elsewhere and alerts when one is missed, fails, or never finishes. To replace a Cronhub scheduler, run the call from cron, a systemd timer, your framework's scheduler, or a platform scheduler, and report each run to the monitor.
What's the fastest way to move many Cronhub monitors?#
Put the monitor call in one wrapper script or SDK helper and change each job to use it, passing the job's key and schedule. With CronRadar, the first ping that carries a schedule creates the monitor, so no dashboard setup is needed. For Hangfire, Quartz.NET, Celery beat, and Laravel, the framework integrations discover jobs on their own.
Put this guide to work
Know when the next run is missing
Connect one scheduled job, confirm a real completion, then verify the alert destination. Keep your existing scheduler in charge of running the work.