Everything included

Built to catch every kind
of scheduled job failure

Crontify covers the three failure modes that nothing else catches — missed runs, hung jobs, and jobs that complete successfully but do nothing useful.

Detection

Missed run detection

Crontify knows when each job is supposed to run based on its cron expression. If a ping doesn't arrive within the grace period, an alert fires immediately.

  • ·Cron-aware scheduling — understands 0 2 * * *, not just intervals
  • ·Configurable grace period per monitor (seconds to hours)
  • ·No false positives from DST shifts or scheduling jitter

Hung job detection

A job that starts but never calls success() or fail() is silently hanging. Crontify detects this and alerts before the damage compounds.

  • ·Configurable max duration per monitor
  • ·Checked every minute via distributed scheduler
  • ·Alert fires once — no repeat floods while job is still running

Output-aware alerting

A job that exits clean but processes zero rows is still a failure. Set rules on numeric output values — Crontify alerts on the result, not just the exit code.

  • ·Operators: eq ne lt gt
  • ·Stack multiple rules per monitor
  • ·Run stays success — a separate silent_failure alert fires
Sending output metadata with a success ping
await monitor.success({
  metadata: {
    rows_processed: 0,       // ← rule: rows_processed eq 0 → fire alert
    duration_ms:    4821,
  }
});

Instrumentation

Node.js / TypeScript SDK

npm i @crontify/sdk

Zero dependencies. ESM. Tree-shakeable. Handles start, success, and failure pings with full TypeScript types. SDK errors never crash your job.

  • ·wrap(fn) — one line, handles start/success/fail automatically
  • ·start() / success() / fail() for manual control
  • ·Ping failures are silent by default — your job always runs

Raw HTTP pings — any language

No SDK required. Any language that can make an HTTP POST request works. Python, Ruby, Go, Bash, PHP — it doesn't matter.

  • ·Three endpoints: /start /success /fail
  • ·Authenticated with a per-account API key via X-API-Key header
  • ·Pass metadata and log output in the request body
SDK — wrap() one-liner
import { CrontifyMonitor } from '@crontify/sdk';
const monitor = new CrontifyMonitor({
  apiKey: 'ck_live_...',
  monitorId: 'mon_...',
});

await monitor.wrap(async () => {
  await processEmails();
});
HTTP ping — any language
# Bash example
curl -s -X POST \
  https://api.crontify.com/api/v1/ping/mon_.../start \
  -H "X-API-Key: ck_live_..."

# run your job here

curl -s -X POST \
  https://api.crontify.com/api/v1/ping/mon_.../success \
  -H "X-API-Key: ck_live_..."

Alerting

Slack

Rich alert messages with job name, failure type, and the first 500 chars of your log output inline.

Email

Formatted alert emails with a direct link to the failed run in your dashboard. Available on all plans.

Discord

Post alerts directly to any Discord channel via webhook. Same rich content as Slack alerts.

Webhooks

POST a structured JSON payload to any URL. Build your own integrations — PagerDuty, Opsgenie, custom tooling.

Recovery alerts

When a previously failing job runs successfully, a recovery alert fires automatically. You know when things break — and when they're fixed.

Deduplication

Already-firing alerts don't repeat. If a job is continuously failing, you get one alert — not a flood every minute until it recovers.

Multiple channels per monitor

Attach as many alert channels as you like to each monitor. Page the on-call engineer on Slack and send an email summary at the same time.

Observability

Run history

Paginated history of every run — start time, duration, status, and metadata. Filter by status or date range. Plan-based retention from 14 days to unlimited.

Duration anomaly detection

Crontify tracks baseline run duration per monitor. Runs that take significantly longer than normal are automatically flagged — before they become hung jobs.

Log attachment

Attach up to 10,000 chars of stdout or stderr output to any failed run via the SDK. The first 500 chars appear inline in Slack alerts. Full log is one click away.

Real-time live updates

Your dashboard updates instantly the moment a job starts, completes, or fails. No manual refreshing. See what's running right now.

Run metadata

Attach arbitrary key-value metadata to any ping — rows processed, queue depth, record counts. Stored with the run and visible in the dashboard.

API keys

Create and revoke API keys from your dashboard. Keys are hashed at rest and never exposed after creation. One key can serve all your monitors.

Ready to stop flying blind?

Free plan includes 5 monitors. No credit card required. Up and running in under 5 minutes.

Start for free Read the docs →