How to schedule automated jobs without running cron infrastructure

Schedule automated jobs with Recurrence Cloud — skip crontab and worker upkeep, create recurring webhooks in one API call, and watch every run in an activity trail.

, updated

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:

  1. Plain-English recurrence. "every 1 week on sunday at 02:30" — no 30 2 * * 0 gymnastics, and a timezone field so “2:30” means what your users think it means. Cron expressions still work (cronExpr: "30 2 * * 0") when you want them.
  2. One call creates everything. No separate create-schedule, then create-webhook, then link dance. Point it at an existing webhook with webhookId instead of url if you already have one.
  3. The payload travels with the schedule. The event data 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>/runs

Failures 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-due to 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