Scheduling an automated job usually means owning a machine — a crontab entry, a worker process, a retry story, and no visibility when the job silently stops firing. Recurrence Cloud replaces all of that with one API call: describe when (cron or plain English), describe where (a webhook URL), and it fires on schedule, signed and logged, forever.
The project: Recurrence Cloud is at recurrence.cloud. This walkthrough uses the same endpoints documented in the API reference.
The usual options (and their hidden cost)
| Option | Setup | Reliability | Visibility |
|---|---|---|---|
crontab on a server |
One line — easy | If the box dies or the job fails, it fails silently | Grep mail spool or logs |
| In-app scheduler (sidekiq-cron, node-cron…) | Bundled with your app | Dies when your app dies | Custom dashboards |
| Platform cron (Cloudflare, Vercel…) | Per-platform config | Tied to that platform | Per-platform logs |
| Message queue + worker | Significant infra | Good, but you build retries | Build it yourself |
| Recurrence Cloud | One API call | Managed worker, run receipts for every fire | Run history + activity trail, out of the box |
The pattern across every row: scheduling itself is easy; proving it ran and recovering when it didn’t is the expensive part. That’s what a hosted scheduler buys you.
Scheduling a job in one call
Create a schedule, target webhook, and event payload in a single request — auth is just an API key header:
curl -X POST https://api.recurrence.cloud/api/v1/schedules/with-webhook \
-H "X-API-Key: rc_live_abcdef1234567890..." \
-H "Content-Type: application/json" \
-d '{
"appId": "clxyz_app_id",
"schedule": {
"name": "Weekly DB cleanup",
"frequency": "week",
"interval": 1,
"byDay": "sunday",
"startTime": "02:30",
"timezone": "America/New_York"
},
"webhook": {
"url": "https://example.com/jobs/cleanup",
"method": "POST",
"secret": "my-webhook-secret"
},
"event": { "subject": "cleanup", "payload": { "olderThanDays": 30 } }
}'Three things stand out about how easy this makes recurring jobs:
- Plain-English recurrence.
"every 1 week on sunday at 02:30"— no30 2 * * 0gymnastics, and atimezonefield so “2:30” means what your users think it means. Cron expressions still work (cronExpr: "30 2 * * 0") when you want them. - One call creates everything. No separate create-schedule, then create-webhook, then link dance. Point it at an existing webhook with
webhookIdinstead ofurlif you already have one. - The payload travels with the schedule. The
eventdata is delivered on every run, so the target endpoint needs zero scheduling knowledge — it’s just an HTTP handler.
What “done” looks like: verify and observe
Every delivery with a webhook secret set is HMAC-SHA256 signed:
const expected = crypto
.createHmac('sha256', 'my-webhook-secret')
.update(JSON.stringify(req.body))
.digest('hex');
if (req.headers['x-webhook-signature'] !== expected) {
return res.status(401).json({ error: 'Invalid signature' });
}
// req.body: { scheduleName, firedAt, events: { cleanup: {...} }, ... }
And every run leaves a receipt. Query run history and delivery attempts from your monitoring, or just open the dashboard:
curl -H "X-API-Key: rc_live_abcdef1234567890..." \
https://api.recurrence.cloud/api/v1/schedules/<id>/runsFailures stop being silent: a job that returns 500, times out, or never fires shows up in the run history instead of quietly rotting in a crontab.
A realistic first week with Recurrence Cloud
- Day 1: create an app + API key in the dashboard; ship one real job (daily report, nightly cleanup) with the composite endpoint.
- Day 2: dry-run it with
POST /api/v1/schedules/test-dueto confirm the cron/timezone math before the first real fire. - Day 3: add a second and third schedule — different endpoints, different cadences, one app.
- Day 4: point your alerting at run histories so a missed run pages someone.
- Day 5: delete a crontab entry somewhere and don’t miss it.
When it’s the right tool
Reach for Recurrence Cloud when the job is HTTP-shaped: ping a URL, call an internal endpoint, hit a third-party API on a cadence. If the job needs to stream a database table in-process, keep it in your app — but let Recurrence Cloud decide when.
Where to next
- Integrating scheduling with Recurrence Cloud — full setup walkthrough, signing verification, and monitoring
- Webhooks & deliveries — payload shape
- Monitoring & retries — the activity trail
- Cron expression cheat sheet — copy-paste patterns for the times cron is unavoidable