<!-- Source: https://cron.services/ -->

# cronservices: delete your cron functions

cronservices calls your APIs on a schedule, chains the responses, and reshapes the JSON in between. There are no servers, no deploys, and no cold starts. It's built so that AI agents can set it up for you.

- Website: https://cron.services
- API: https://api.cron.services ([OpenAPI](https://cron.services/openapi.json))
- Support: support@cron.services
- Agent guide: https://cron.services/agents.md

## What it does

A **job** is a schedule plus a chain of **steps**:

1. **Schedule.** A standard 5-field cron expression in any time zone, from every minute to once a year, with extensions like "last weekday of the month". Or a single `run_at` timestamp for a job that fires once.
2. **Request.** Call any HTTP endpoint with any method, headers, a templated body, and a saved credential.
3. **Built-in steps.** Send to Slack, Discord, Teams, Telegram, email, SMS, PagerDuty and more, or read from Stripe, GitHub and public data APIs, by filling in a few fields. See https://cron.services/integrations.md
4. **Transform.** Reshape the previous step's JSON with a small template language: `{{ $.field }}`, `{{#each $.items}}`, `{{ join($.lines, "\n") }}`, `{{ now:Europe/London }}`.
5. **Chain.** Each step receives the previous step's output, so fetch → reshape → post is one job.

Every run is recorded step by step, with status codes, durations, and why it failed.

## What it replaces

The scheduled functions that only move data between APIs: digests to Slack, CRM and partner syncs, cache warmers, cleanup routes, backup triggers, report pulls. Instead of a function plus a deploy target plus a cron trigger plus logs, you have one JSON document that a person or an agent can read and change.

When the work needs real code, keep it behind an HTTP endpoint and let cronservices own the schedule and the run history.

## Use cases

Complete, copyable jobs for real scenarios: Stripe past-due subscriptions to Slack, PagerDuty on-call announcements, an uptime check with Healthchecks.io, a morning balance email, daily exchange rates for a store, a Black Friday sale that starts at midnight Eastern, a weather brief for a field crew, batched appointment reminders, and waking an AI agent on a schedule. See https://cron.services/use-cases.md

## For agents

- [/llms.txt](https://cron.services/llms.txt) and [/llms-full.txt](https://cron.services/llms-full.txt): the docs, for language models
- [/openapi.json](https://cron.services/openapi.json): the API, for code generators and tool frameworks
- [/agent-tools.json](https://cron.services/agent-tools.json): function-calling tool definitions
- Every page has a Markdown twin at the same path plus `.md`.

## Pricing

Hobby is free for 3 jobs and 1,000 runs a month. Pro is $12/month for 50 jobs and 50,000 runs a month. Team is $49/month for 500 jobs and 500,000 runs a month. Details: https://cron.services/pricing.md

## FAQ

**What timezone are schedules in?** Any IANA time zone you choose, UTC by default. A job at 09:00 in `America/New_York` stays at 09:00 local when the clocks change. A one-time `run_at` can include any offset.

**Can a job run just once?** Yes. Send `run_at` (an ISO 8601 timestamp) instead of `cron`. It fires once, then switches itself off, and stops counting toward your job limit.

**How long can a request take?** 10 seconds per request step. For longer work, return `202` and finish in the background.

**What happens when a step fails?** The run stops at that step and is recorded with its status code and the start of the response. The next scheduled run starts fresh.

**Where do my API tokens go?** In credentials: saved once, encrypted at rest, never shown again, and referenced by id from any number of jobs.

**Can it run my code?** No. cronservices calls endpoints; it doesn't host code. That's the point: if a task is only HTTP calls and JSON reshaping, it shouldn't need hosted code.

**Is there a free plan?** Yes. Hobby is free and needs no card.

---

<!-- Source: https://cron.services/agents -->

# cronservices for AI agents

This page is written for AI coding agents and the people who run them. If you are an agent: read this page, then [/docs.md](/docs.md) for the full reference. The API is described in [/openapi.json](/openapi.json), and ready-made tool definitions are in [/agent-tools.json](/agent-tools.json).

**In one line:** when a task needs code that runs on a schedule and mostly makes HTTP calls, create a cronservices job instead of writing, deploying, and monitoring a scheduled function.

## When to use cronservices

Use cronservices when the scheduled work is HTTP in, HTTP out:

- Call an endpoint on a schedule: cache warmers, cleanup routes, `/api/cron/*` handlers, keep-alive pings.
- Fetch from one API, reshape the JSON, and post it to another: digests to Slack, CRM syncs, report pulls into a webhook.
- Kick off work that already lives behind an endpoint: backups, invoice runs, reindexing.
- Do something once, later: end a trial in 14 days, send a reminder the day before an appointment, publish at launch time. Send `run_at` instead of `cron`, instead of building a delayed-job queue.
- Send a message, email, text, or alert on a schedule: Slack, Discord, Teams, Telegram, SMTP, Twilio, PagerDuty and [more](/integrations) are built in.

Don't use cronservices when the work:

- Takes longer than 10 seconds per request. Have the endpoint return `202` and finish in the background, or use a queue.
- Needs logic that a JSON template can't express: branching, loops with side effects, or direct database access with no HTTP endpoint.
- Needs sub-minute precision or must fire faster than once a minute.

If the existing code is a scheduled function that only fetches, reshapes, and forwards data, replace it with a pipeline and delete the function. If it does real computation, keep the logic behind an HTTP endpoint and let cronservices own the schedule and the run history.

## Setup

Ask the user for a cronservices API key (they create one in **Settings → API keys**) and read it from the `CRONSERVICES_API_KEY` environment variable. Never write the key into source files, commits, or job definitions.

```bash
curl https://api.cron.services/alarms -H "Authorization: Bearer $CRONSERVICES_API_KEY"
```

## Rules for agents

1. **List before you create.** Call `GET /alarms` and look for a job with the same `name` before `POST`. Creating twice schedules the work twice.
2. **Use stable, descriptive names**, like `acme-web: nightly backup`. The name is how you and the user find the job again.
3. **Schedule in the user's time zone.** If the user says "9am in New York", send `"cron": { "expression": "0 9 * * *", "time_zone": "America/New_York" }`. Don't convert to UTC yourself; the job stays at 09:00 local when the clocks change. For a one-time job, put the offset in `run_at`: `2026-12-01T09:00:00-05:00`.
4. **Put secrets in credentials.** Create one with `POST /credentials` (or ask the user to add it in **Settings → Credentials**) and reference its id as `credential_id`. Never put a token in a URL, header value, or body, where it would be stored with the job.
5. **Prefer built-in steps** for services cronservices knows (Slack, Discord, Stripe, GitHub, email, SMS, and [more](/integrations)). They need fewer fields and can't get the URL or auth header wrong.
6. **Verify the job.** Call `POST /alarms/{id}/run` once after creating it. It runs the job now and returns the run: check `status_code`, and if `error_message` is set, fix the job and run it again. Skip this when running it would cause a real side effect the user didn't ask for yet, like charging a card or messaging customers.
7. **Replace, don't patch.** `PUT /alarms/{id}` replaces the whole job. `GET /alarms/{id}`, change what you need, and send every field back.
8. **Fix `422` errors from `fields`.** Each key is the path to fix, such as `alarm.cron.expression` or `alarm.nodes[2].request.body`. A `400 invalid_json` means a field name or value type is wrong; its `message` names it.
9. **Stop at `402 plan_limit`.** Tell the user which plan limit was hit. Don't delete or pause other jobs to make room.
10. **Report what you scheduled**: the job name, the schedule in plain words with its time zone, what each step does, and the job id.

## Recipe: replace a scheduled function

A typical scheduled function that a coding agent might otherwise write and deploy:

```ts
// api/cron/digest.ts, triggered by "0 7 * * 1-5" (09:00 in Berlin, until the clocks change)
export async function GET() {
  const res = await fetch('https://api.github.com/repos/acme/web/pulls?state=open', {
    headers: { Authorization: `Bearer ${process.env.GITHUB_TOKEN}` },
  });
  if (!res.ok) return new Response('GitHub failed', { status: 502 });
  const pulls = await res.json();
  await fetch(process.env.SLACK_WEBHOOK_URL!, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      text: [`*${pulls.length} open pull requests*`, ...pulls.map((p) => `• <${p.html_url}|#${p.number}> ${p.title} (${p.user.login})`)].join('\n'),
    }),
  });
  return new Response('ok');
}
```

The same job with nothing to deploy. First store the GitHub token as a credential:

```bash
curl -X POST https://api.cron.services/credentials \
  -H "Authorization: Bearer $CRONSERVICES_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{ \"name\": \"GitHub (acme)\", \"bearer_token\": { \"token\": \"$GITHUB_TOKEN\" } }"
```

Then create the job with the credential id it returned:

```bash
curl -X POST https://api.cron.services/alarms \
  -H "Authorization: Bearer $CRONSERVICES_API_KEY" \
  -H "Content-Type: application/json" \
  -d @- <<'JSON'
{
  "name": "acme-web: open PRs to #eng",
  "cron": { "expression": "0 9 * * 1-5", "time_zone": "Europe/Berlin" },
  "nodes": [
    { "id": "prs", "github_list_pull_requests": { "credential_id": "<credential id>", "owner": "acme", "repo": "web", "state": "open" } },
    { "id": "lines", "transform": { "template": "{ \"count\": \"{{ $.length }}\", \"lines\": { \"{{#each $}}\": \"• <{{ $.html_url }}|#{{ $.number }}> {{ $.title }} ({{ $.user.login }})\" } }" } },
    { "id": "post", "slack_send_message": { "webhook_url": "https://hooks.slack.com/services/T000/B000/XXXX", "text": "*{{ $.count }} open pull requests*\n{{ join($.lines, \"\\n\") }}" } }
  ]
}
JSON
```

Run it once with `POST /alarms/{id}/run`, then remove the function and its cron trigger (for example, the `crons` entry in `vercel.json`), and tell the user the job id.

## Recipe: keep the logic, move the schedule

When the work needs real code, keep it behind an endpoint and secure it with a shared secret stored as a `bearer_token` credential:

```json
{
  "name": "acme-api: nightly invoice run",
  "cron": { "expression": "0 3 * * *", "time_zone": "America/New_York" },
  "nodes": [
    { "id": "invoices", "request": { "method": "POST", "endpoint": "https://api.acme.com/internal/invoices/run", "credential_id": "<shared secret credential id>" } }
  ]
}
```

The endpoint should check `Authorization: Bearer <secret>`, return `202` quickly, and do the work in the background.

## Recipe: do something once, later

When the user says "in 14 days" or "the day before", compute the timestamp and send `run_at`:

```json
{
  "name": "acme: end trial",
  "run_at": "2026-12-01T09:00:00-05:00",
  "nodes": [
    { "id": "expire", "request": { "method": "POST", "endpoint": "https://api.acme.com/internal/trials/acme/expire", "credential_id": "<shared secret credential id>" } }
  ]
}
```

The job fires once and switches itself off. Check `complete_time` and `last_status_code` on `GET /alarms/{id}`, or read `GET /alarms/{id}/runs`, to see whether it ran and succeeded.

## Function calling

[/agent-tools.json](/agent-tools.json) holds five tools (`cronservices_list_jobs`, `cronservices_create_job`, `cronservices_update_job`, `cronservices_run_job`, `cronservices_delete_job`) as `{ name, description, input_schema }`, the shape most LLM SDKs accept. Each one maps to an operation in the OpenAPI spec:

| Tool | Request |
| --- | --- |
| `cronservices_list_jobs` | `GET /alarms` |
| `cronservices_create_job` | `POST /alarms` with the input as the body |
| `cronservices_update_job` | `PUT /alarms/{id}` with the rest of the input as the body |
| `cronservices_run_job` | `POST /alarms/{id}/run` |
| `cronservices_delete_job` | `DELETE /alarms/{id}` |

A minimal dispatcher:

```python
import os, requests

API = "https://api.cron.services"
HEADERS = {"Authorization": f"Bearer {os.environ['CRONSERVICES_API_KEY']}"}

def call_cronservices(name, args):
    if name == "cronservices_list_jobs":
        r = requests.get(f"{API}/alarms", headers=HEADERS)
    elif name == "cronservices_create_job":
        r = requests.post(f"{API}/alarms", json=args, headers=HEADERS)
    elif name == "cronservices_update_job":
        job_id = args.pop("id")
        r = requests.put(f"{API}/alarms/{job_id}", json=args, headers=HEADERS)
    elif name == "cronservices_run_job":
        r = requests.post(f"{API}/alarms/{args['id']}/run", headers=HEADERS)
    elif name == "cronservices_delete_job":
        r = requests.delete(f"{API}/alarms/{args['id']}", headers=HEADERS)
    else:
        raise ValueError(name)
    return {"status": r.status_code, "body": r.json() if r.content else None}
```

Return the status and body to the model unchanged. The error `code` and `fields` tell it what to fix.

## A prompt for people

Paste this into your coding agent to point it at cronservices:

```text
For anything in this project that needs to run on a schedule, use cronservices
instead of a cron function. Read https://cron.services/llms.txt first. My API key is in
the CRONSERVICES_API_KEY environment variable. List existing jobs before creating
one, schedule in my time zone, and tell me what you scheduled.
```

---

<!-- Source: https://cron.services/docs -->

# Docs

cronservices calls HTTP endpoints on a schedule, or once at an exact time. A **job** pairs a schedule (a cron expression in any time zone, or a single `run_at` timestamp) with a chain of **steps**. Each step receives the previous step's output, so one job can fetch data, reshape it, and post it somewhere else. That's the work a scheduled serverless function usually does.

A step is one of three things:

- a **request** to any HTTP endpoint,
- a **transform** that reshapes JSON without making a request, or
- a **built-in step** for a known API, such as `slack_send_message`, `stripe_list_subscriptions` or `smtp_send_email`. You fill in a few fields and cronservices builds the request. See [Integrations](/integrations).

## Quickstart

1. [Create an account](/login#signup). The Hobby plan is free and needs no card.
2. Create an API key in **Settings → API keys**.
3. Create a job:

```bash
curl -X POST https://api.cron.services/alarms \
  -H "Authorization: Bearer $CRONSERVICES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Warm product cache",
    "cron": { "expression": "*/15 * * * *" },
    "nodes": [
      { "id": "warm", "request": { "method": "POST", "endpoint": "https://shop.example.com/api/cache/warm" } }
    ]
  }'
```

```json
{ "id": "6f1c1f0e-2a4b-4d55-9a0e-7b1f3c2d9e10" }
```

cronservices now sends `POST https://shop.example.com/api/cache/warm` every 15 minutes and records every run. To try it immediately, call `POST /alarms/{id}/run`, which runs the job now and returns the run.

## Schedules

A repeating job has a `cron` object. `expression` is a standard 5-field cron expression, read as wall-clock time in `time_zone` (an IANA name such as `America/New_York`; defaults to `UTC`):

```text
┌──────── minute        0-59
│ ┌────── hour          0-23
│ │ ┌──── day of month  1-31
│ │ │ ┌── month         1-12 or JAN-DEC
│ │ │ │ ┌ day of week   0-6 or SUN-SAT (0 is Sunday)
│ │ │ │ │
* * * * *
```

Each field takes `*`, a value, a range (`1-5`), a list (`1,15`), or a step (`*/10`, `0-30/5`). A few extensions cover schedules plain cron can't express:

| Expression | Fires |
| --- | --- |
| `*/5 * * * *` | Every 5 minutes |
| `0 9 * * 1-5` | 09:00 on weekdays |
| `30 2 * * SUN` | 02:30 every Sunday |
| `0 0 1 * *` | Midnight on the 1st of each month |
| `0 0 L * *` | Midnight on the last day of each month |
| `30 17 LW * *` | 17:30 on the last weekday of each month |
| `0 9 15W * *` | 09:00 on the weekday nearest the 15th |
| `0 8 * * MON#1` | 08:00 on the first Monday of each month |
| `0 16 * * FRI#L` | 16:00 on the last Friday of each month |

When both day-of-month and day-of-week are set (neither is `*`), the job fires on days that match either one, as in classic crontab.

```json
{ "cron": { "expression": "0 9 * * 1-5", "time_zone": "Europe/Berlin" } }
```

**Daylight saving time.** A job at 09:00 in `America/New_York` fires at 09:00 local all year. A time skipped when the clocks go forward fires just after the change, and a time repeated when they go back fires once.

The fastest schedule is every minute (`* * * * *`). There's no seconds field, and `@daily`-style shortcuts aren't supported.

### One-time jobs

To fire once, send `run_at` instead of `cron`. It's an ISO 8601 timestamp with an offset, in the future and within a year:

```bash
curl -X POST https://api.cron.services/alarms \
  -H "Authorization: Bearer $CRONSERVICES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Trial ends: acme",
    "run_at": "2026-12-01T09:00:00-05:00",
    "nodes": [
      { "id": "expire", "request": { "method": "POST", "endpoint": "https://api.example.com/trials/acme/expire", "credential_id": "YOUR_CREDENTIAL_ID" } }
    ]
  }'
```

The job fires within a few seconds of `run_at`, then sets `complete_time` and `enabled: false`. Its run stays in the job's history, and it no longer counts toward your plan's job limit. To run it again, `PUT` it with a new `run_at`.

## Steps

A job's `nodes` is a list of 1 to 20 steps, and at least one must make a request. Each step has an `id` (letters, digits, `_` and `-`, unique within the job), an optional `name`, and exactly one kind:

| Kind | Does | Output, which the next step gets as `$` |
| --- | --- | --- |
| `request` | Sends an HTTP request. The URL, headers, and body can use placeholders | The response body, parsed as JSON when it parses, otherwise text |
| `transform` | Renders a JSON template. No network | The rendered JSON |
| A built-in step | Sends the request a known API expects (see [Integrations](/integrations)) | The API's response |

The first step gets `null` as its input. A run stops at the first step that fails: a network error, a timeout, or a non-2xx status. The run records which step stopped it and why.

This job posts open pull requests to Slack every weekday at 09:00 Berlin time:

```json
{
  "name": "Open PRs to #eng",
  "cron": { "expression": "0 9 * * 1-5", "time_zone": "Europe/Berlin" },
  "nodes": [
    { "id": "prs", "name": "Open PRs",
      "github_list_pull_requests": { "credential_id": "YOUR_GITHUB_CREDENTIAL_ID", "owner": "acme", "repo": "web", "state": "open" } },
    { "id": "lines", "name": "One line per PR",
      "transform": { "template": "{ \"count\": \"{{ $.length }}\", \"lines\": { \"{{#each $}}\": \"• <{{ $.html_url }}|#{{ $.number }}> {{ $.title }} ({{ $.user.login }})\" } }" } },
    { "id": "post", "name": "Post to Slack",
      "slack_send_message": { "webhook_url": "https://hooks.slack.com/services/T000/B000/XXXX", "text": "*{{ $.count }} open pull requests*\n{{ join($.lines, \"\\n\") }}" } }
  ]
}
```

The transform turns GitHub's array of pull requests into:

```json
{
  "count": 2,
  "lines": [
    "• <https://github.com/acme/web/pull/412|#412> Fix retry backoff (ada)",
    "• <https://github.com/acme/web/pull/415|#415> Add pipeline editor (grace)"
  ]
}
```

and the Slack step posts:

```text
*2 open pull requests*
• <https://github.com/acme/web/pull/412|#412> Fix retry backoff (ada)
• <https://github.com/acme/web/pull/415|#415> Add pipeline editor (grace)
```

The equivalent serverless function would need a deploy target, a cron trigger, secrets, a GitHub client, error handling, and logs. Here it's one JSON document, and every run is recorded.

### Request steps

| Field | Type | Notes |
| --- | --- | --- |
| `method` | string | `GET`, `POST`, `PUT`, `PATCH` or `DELETE`. Defaults to `POST`. Responses spell it `HTTP_METHOD_GET` and so on, and requests accept either form |
| `endpoint` | string | Full `http://` or `https://` URL. May contain placeholders |
| `credential_id` | string | Optional. A `bearer_token`, `basic_auth` or `api_key_header` [credential](#credentials), sent as its header |
| `headers` | array | `[{ "name": "X-Source", "value": "cronservices" }]`. Values may contain placeholders. Up to 50 |
| `body` | string | Sent with `POST`, `PUT`, `PATCH` and `DELETE`. Up to 64 KiB |

A body that starts with `{` or `[` is a JSON template and must be valid JSON once its placeholders are filled in, and it's sent as `application/json` unless you set `Content-Type`. Any other body is plain text with placeholders filled in, sent as `text/plain`.

### Transform steps

| Field | Type | Notes |
| --- | --- | --- |
| `template` | string | Required. A JSON template, rendered against the previous step's output |

Use a transform to pick a few fields, rename them, or build a list that a later step sends or joins into text.

### Built-in steps

A built-in step takes only the fields its API needs, and cronservices builds and signs the request. Each one counts as a request: a non-2xx response stops the job.

| Group | Steps |
| --- | --- |
| Chat | `slack_send_message`, `discord_send_message`, `teams_post_message`, `google_chat_send_message`, `mattermost_send_message`, `telegram_send_message` |
| Push | `ntfy_publish`, `pushover_send_notification`, `gotify_send_message`, `pushbullet_push_note` |
| Email and SMS | `smtp_send_email`, `resend_send_email`, `sendgrid_send_email`, `twilio_send_sms` |
| Incidents and monitoring | `pagerduty_trigger_incident`, `opsgenie_create_alert`, `datadog_post_event`, `healthchecks_ping` |
| Developer tools | `github_create_issue`, `ifttt_trigger` |
| Fetch data | `stripe_list_subscriptions`, `stripe_list_customers`, `stripe_retrieve_balance`, `github_list_pull_requests`, `slack_channel_history`, `pagerduty_list_on_calls`, `open_meteo_forecast`, `frankfurter_latest` |

Each service's page under [Integrations](/integrations) lists its fields and a complete example job. Text fields such as a message or subject are filled in as text, so `"Rain: {{ $.daily.precipitation_sum[0] }} mm"` works anywhere.

## Templates

Placeholders use double braces and read from the previous step's output.

| Placeholder | Value |
| --- | --- |
| `{{ $ }}` | The whole previous output |
| `{{ $.user.login }}` | A nested field |
| `{{ $.items[0] }}` | A list element |
| `{{ $["first name"] }}` | A key with spaces or symbols |
| `{{ $.items.length }}` | The length of a list, or of a string |
| `{{ $root.x }}` | The step's input, even inside `#each` |
| `{{ join($.names, ", ") }}` | A list as text. The separator defaults to `", "`; use `"\n"` for one item per line |
| `{{ now() }}` | When the job runs, as an ISO 8601 string in UTC |
| `{{ now:America/New_York }}` | That same instant in an IANA time zone |
| `{{ today("Europe/London") }}` | Midnight at the start of the run's day in that zone (UTC without an argument) |
| `{{ format(now(), "YYYY-MM-DD") }}` | The run time in a layout. See [Formats](#formats) |
| `{{ now() - days(14) }}` | Date math. Also `hours`, `minutes`, `seconds`, `weeks`, `months` and `years` |
| `{{ $.created_at + days(1) }}` | An ISO 8601 time from the input, plus a duration |
| `{{ unix(now()) }}` | Seconds since 1970. `time(1793188800)` goes the other way |

**Where they work:** request URLs, header values and bodies, transform templates, and the text fields of built-in steps.

**Types are kept** when a placeholder is the entire JSON value. `"{{ $.count }}"` and a bare `{{ $.count }}` both render as the number `2`. A placeholder inside longer text becomes text: `"Total: {{ $.count }}"` renders as `"Total: 2"`.

**Lists:** an object whose only key is `{{#each <list>}}` becomes an array. Its value is rendered once per item, with `$` bound to the item:

```json
{
  "store": "{{ $.store }}",
  "skus": { "{{#each $.rows}}": { "sku": "{{ $.sku }}", "store": "{{ $root.store }}" } }
}
```

```json
{ "store": "nyc", "skus": [{ "sku": "a", "store": "nyc" }, { "sku": "b", "store": "nyc" }] }
```

To send a list as a chat message or an email, build a list of lines with `#each` in a transform step, then `join` it in the message, as in the [pull request example](#steps).

**Times.** `now()` is when the job runs, in UTC. `now:America/New_York` is that same instant written in an IANA time zone, offset included. Add or subtract a duration, with spaces around `+` and `-`: `now() - days(14)`, `now:America/Los_Angeles + hours(9)`. `days` and `months` follow that time zone's calendar. A field that is already an ISO 8601 timestamp shifts the same way.

### Formats

`format(now(), "YYYY-MM-DD")` writes a layout instead of ISO 8601, and an optional third argument picks the zone: `format(now(), "dddd, MMMM DD", "America/Los_Angeles")`. `format(now:America/Los_Angeles - days(1), "MM/DD/YYYY")` is yesterday in that zone.

| Token | Writes | Example |
| --- | --- | --- |
| `YYYY` / `YY` | Year | `2026` / `26` |
| `MM` / `MMM` / `MMMM` | Month | `10` / `Oct` / `October` |
| `DD` | Day of the month | `05` |
| `ddd` / `dddd` | Weekday | `Wed` / `Wednesday` |
| `HH` / `hh` | Hour, 00–23 / 01–12 | `14` / `02` |
| `mm` / `ss` / `SSS` | Minute / second / millisecond | `05` / `09` / `000` |
| `A` | `AM` or `PM` | `PM` |
| `Z` | Offset | `Z` or `-05:00` |

Text in `[brackets]` is copied as is: `"ddd [at] hh:mm A"` writes `Wed at 02:05 PM`.

**Missing values** render as `null` (or an empty string inside text) and are flagged in the editor preview. They don't fail the run.

## Credentials

A credential is a saved secret that any number of jobs can use. Steps refer to it by `credential_id`, so the secret never appears in a job, a template, or the run history. Create credentials in **Settings → Credentials**, or through the API:

```bash
curl -X POST https://api.cron.services/credentials \
  -H "Authorization: Bearer $CRONSERVICES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "name": "GitHub (acme)", "bearer_token": { "token": "ghp_your_token" } }'
```

```json
{ "id": "Xq3vK8mB2nT5wR7yL1pA" }
```

| Kind | Fields | Used by |
| --- | --- | --- |
| `bearer_token` | `token` | Request steps (as `Authorization: Bearer`), and the Stripe, GitHub, Slack history, Resend, SendGrid, Pushbullet and ntfy steps |
| `basic_auth` | `username`, `password` | Request steps (as `Authorization: Basic`) |
| `api_key_header` | `header`, `value` | Request steps (as `<header>: <value>`, such as `X-API-Key`) |
| `smtp` | `host`, `port`, `security` (`tls` or `starttls`), `username`, `password`, `from_address`, `from_name` | `smtp_send_email` |
| `twilio` | `account_sid`, `auth_token` | `twilio_send_sms` |
| `telegram_bot` | `bot_token` | `telegram_send_message` |
| `pushover` | `api_token` | `pushover_send_notification` |
| `gotify` | `server`, `token` | `gotify_send_message` |
| `pagerduty_routing_key` | `routing_key` | `pagerduty_trigger_incident` |
| `pagerduty_api_key` | `api_key` | `pagerduty_list_on_calls` |
| `opsgenie` | `region`, `api_key` | `opsgenie_create_alert` |
| `datadog` | `site`, `api_key` | `datadog_post_event` |
| `ifttt` | `key` | `ifttt_trigger` |

Secret fields (tokens, passwords, keys) are write-only. They're encrypted at rest and never returned, and reads show `last4` instead. Updating a credential with an empty secret keeps the stored one. Editing a credential changes what every job using it sends, starting with its next run. A credential can't be deleted while a job uses it.

## API

Base URL: `https://api.cron.services`. Send JSON, and authenticate every request with `Authorization: Bearer <API key>`. The machine-readable spec is at [/openapi.json](/openapi.json). In the API, jobs are called **alarms** and steps are **nodes**.

| Method | Path | Does |
| --- | --- | --- |
| `GET` | `/alarms` | List your jobs, newest first |
| `POST` | `/alarms` | Create a job. Returns `201 { "id": "…" }` |
| `GET` | `/alarms/{id}` | Get one job |
| `PUT` | `/alarms/{id}` | Replace a job. Send every field. Returns `204` |
| `DELETE` | `/alarms/{id}` | Delete a job and its run history. Returns `204` |
| `POST` | `/alarms/{id}/run` | Run the job now, outside its schedule, and return the finished run. Works on paused jobs and doesn't move the schedule |
| `GET` | `/alarms/{id}/runs` | The job's runs, newest first. `?page_size=` (up to 500, default 100) and `?page_token=` |
| `GET` | `/credentials` | List credentials, without their secrets |
| `POST` | `/credentials` | Create a credential. Returns `201 { "id": "…" }` |
| `PUT` | `/credentials/{id}` | Replace a credential. An empty secret keeps the stored one. Returns `204` |
| `DELETE` | `/credentials/{id}` | Delete a credential. Returns `204`, or `409` while a job uses it |
| `GET` | `/health` | Health check. No auth |

### Job fields

| Field | Type | Notes |
| --- | --- | --- |
| `id` | string | UUID. Read-only |
| `name` | string | Up to 80 characters |
| `cron` | object | `{ "expression": "0 9 * * *", "time_zone": "America/New_York" }`. Send this or `run_at` |
| `run_at` | string | ISO 8601 time for a one-time job, within a year. Send this or `cron` |
| `nodes` | array | 1 to 20 steps. See [Steps](#steps) |
| `enabled` | boolean | `false` pauses the job. Defaults to `true` |
| `next_fire_at` | string | Read-only. The next scheduled run. Absent once a one-time job has fired |
| `last_fired_at` | string | Read-only |
| `last_status_code` | integer | Read-only. The last request's status, where `0` means it couldn't be sent |
| `complete_time` | string | Read-only. When a one-time job fired |
| `create_time`, `update_time` | string | Read-only |

### Run fields

| Field | Type | Notes |
| --- | --- | --- |
| `id`, `alarm_id` | string | |
| `trigger` | string | `RUN_TRIGGER_SCHEDULE`, or `RUN_TRIGGER_MANUAL` for `POST /alarms/{id}/run` |
| `fire_time` | string | When the run started |
| `duration` | string | Such as `"0.412s"` |
| `status_code` | integer | The last request's status. `0` means it couldn't be sent (DNS, TLS, or the 10-second timeout) |
| `failed_node_id` | string | The step that stopped the run. Absent when it succeeded |
| `error_message` | string | Why it failed, such as `HTTP 401: {"message":"Bad credentials"}`. Absent when it succeeded |
| `steps` | array | One entry per request or built-in step: `node_id`, `node_name`, `status` (`RUN_STEP_STATUS_SUCCEEDED`, `…_FAILED` or `…_SKIPPED`), `status_code`, `duration`, `error_message` |

Fields that are empty, zero, or unset are left out of responses.

## Errors

Errors return JSON with a stable `code`:

```json
{
  "code": "validation_failed",
  "message": "Some fields are invalid",
  "fields": { "alarm.cron.expression": "hour must be 0-23, *, or a list, range or step of those" }
}
```

| Status | `code` | Means |
| --- | --- | --- |
| `400` | `invalid_json` | The body isn't valid JSON for this request, such as an unknown field or a timestamp without an offset. `message` says where |
| `401` | `unauthenticated` | Missing or invalid API key |
| `402` | `plan_limit` | A plan limit is reached |
| `403` | `email_not_verified` | The account's email isn't verified yet |
| `404` | `not_found` | Nothing with that id on this account |
| `409` | `failed_precondition` | The change conflicts with current state, such as deleting a credential a job uses |
| `422` | `validation_failed` | See `fields`, keyed by path: `alarm.nodes[1].transform.template`, or `alarm` for rules that span fields |
| `500` | `internal` | Our fault. Retry with backoff |

## Limits

| Limit | Value |
| --- | --- |
| Request timeout | 10 seconds per request or built-in step |
| Steps per job | 20 |
| Request body, template | 64 KiB each |
| Schedule resolution | 1 minute |
| One-time `run_at` | Up to one year ahead, any second |
| Scheduler drift | A job fires within about 5 seconds of its scheduled time |

A request that takes longer than 10 seconds is recorded with status `0`. For longer work, have the endpoint accept the request, return `202`, and finish in the background.

---

<!-- Source: https://cron.services/use-cases -->

# Use cases

Real jobs for real teams. Every scenario below is a complete job you can send to `POST /alarms` after swapping in your own URLs and [credentials](/docs#credentials). The services are real, and so are their response shapes. The [docs](/docs) explain each field and the [template language](/docs#templates), and [Integrations](/integrations) lists every built-in step.

Schedules run in the time zone you give them, so 09:00 in Berlin stays 09:00 in Berlin when the clocks change.

## For engineering teams

### The standup digest

*A platform team in Berlin wants open pull requests in `#eng` before standup, without anyone maintaining a bot.*

At 09:00 Berlin time on weekdays, list open PRs, turn each one into a line, and post them to Slack.

```json
{
  "name": "Open PRs to #eng",
  "cron": { "expression": "0 9 * * 1-5", "time_zone": "Europe/Berlin" },
  "nodes": [
    { "id": "prs", "name": "Open PRs",
      "github_list_pull_requests": { "credential_id": "YOUR_GITHUB_CREDENTIAL_ID", "owner": "acme", "repo": "web", "state": "open" } },
    { "id": "lines", "name": "One line per PR",
      "transform": { "template": "{ \"count\": \"{{ $.length }}\", \"lines\": { \"{{#each $}}\": \"• <{{ $.html_url }}|#{{ $.number }}> {{ $.title }} ({{ $.user.login }})\" } }" } },
    { "id": "post", "name": "Post to #eng",
      "slack_send_message": { "webhook_url": "https://hooks.slack.com/services/T000/B000/XXXX", "text": "*{{ $.count }} open pull requests*\n{{ join($.lines, \"\\n\") }}" } }
  ]
}
```

### Who's on call today

*An SRE team rotates on-call weekly in PagerDuty, but people still ask "who's on today?" in Slack.*

Every morning at 08:00 New York time, ask PagerDuty who's first in line for the escalation policy and announce it.

```json
{
  "name": "On-call announcement",
  "cron": { "expression": "0 8 * * *", "time_zone": "America/New_York" },
  "nodes": [
    { "id": "oncall", "name": "Current on-call",
      "pagerduty_list_on_calls": { "credential_id": "YOUR_PAGERDUTY_API_KEY_ID", "escalation_policy": "PABC123", "limit": 1 } },
    { "id": "post", "name": "Post to #sre",
      "slack_send_message": { "webhook_url": "https://hooks.slack.com/services/T000/B000/XXXX", "text": ":rotating_light: On call today: *{{ $.oncalls[0].user.summary }}* ({{ $.oncalls[0].schedule.summary }})" } }
  ]
}
```

### Know when your API is down

*A two-person startup wants to hear their API is down before their customers tell them.*

Check the health endpoint every minute, then ping [Healthchecks.io](https://healthchecks.io). A failing check stops the job before the ping, so Healthchecks notices the missing ping and alerts you by email, SMS or Slack.

```json
{
  "name": "API heartbeat",
  "cron": { "expression": "* * * * *" },
  "nodes": [
    { "id": "health", "name": "API health",
      "request": { "method": "GET", "endpoint": "https://api.acme.com/health" } },
    { "id": "ping", "name": "Tell Healthchecks",
      "healthchecks_ping": { "ping_url": "https://hc-ping.com/5f3c9a1e-8b2d-4c6f-9e7a-1d2b3c4d5e6f" } }
  ]
}
```

Every status code also lands in the job's run history.

### Trigger the nightly backup

*A team's database backup lives behind an internal endpoint, and nobody notices when the cron box that calls it dies.*

At 03:00 UTC, start the backup with a shared secret, then post the result to Discord.

```json
{
  "name": "Nightly backup",
  "cron": { "expression": "0 3 * * *" },
  "nodes": [
    { "id": "backup", "name": "Start backup",
      "request": { "method": "POST", "endpoint": "https://api.acme.com/internal/backups", "credential_id": "YOUR_BACKUP_SECRET_ID" } },
    { "id": "notify", "name": "Post to #ops",
      "discord_send_message": { "webhook_url": "https://discord.com/api/webhooks/123456789012345678/abcDEF_ghi-JKL", "content": "Backup {{ $.id }} started: {{ $.size_mb }} MB queued." } }
  ]
}
```

The endpoint should return `202` right away and do the work in the background, since each request has 10 seconds.

## For revenue and operations

### Chase failed payments

*A SaaS founder loses a few customers each month to expired cards and only notices at month-end.*

Each weekday at 09:00 New York time, list Stripe subscriptions that are `past_due` and post them to `#revenue`, where someone can reach out the same day.

```json
{
  "name": "Past-due subscriptions to #revenue",
  "cron": { "expression": "0 9 * * 1-5", "time_zone": "America/New_York" },
  "nodes": [
    { "id": "subs", "name": "Past-due subscriptions",
      "stripe_list_subscriptions": { "credential_id": "YOUR_STRIPE_KEY_ID", "status": "past_due", "limit": 100 } },
    { "id": "lines", "name": "One line each",
      "transform": { "template": "{ \"count\": \"{{ $.data.length }}\", \"lines\": { \"{{#each $.data}}\": \"• <https://dashboard.stripe.com/customers/{{ $.customer }}|{{ $.customer }}>: <https://dashboard.stripe.com/invoices/{{ $.latest_invoice }}|unpaid invoice>\" } }" } },
    { "id": "post", "name": "Post to #revenue",
      "slack_send_message": { "webhook_url": "https://hooks.slack.com/services/T000/B000/XXXX", "text": "*{{ $.count }} subscriptions are past due*\n{{ join($.lines) }}" } }
  ]
}
```

Use a Stripe [restricted key](https://docs.stripe.com/keys#limit-access) with read-only access to subscriptions.

### The morning balance email

*A founder checks the Stripe dashboard every morning for one number.*

At 07:30 their time, read the Stripe balance and send it from their own Gmail account.

```json
{
  "name": "Stripe balance email",
  "cron": { "expression": "30 7 * * *", "time_zone": "America/Chicago" },
  "nodes": [
    { "id": "balance", "name": "Stripe balance",
      "stripe_retrieve_balance": { "credential_id": "YOUR_STRIPE_KEY_ID" } },
    { "id": "email", "name": "Email me",
      "smtp_send_email": { "credential_id": "YOUR_GMAIL_CREDENTIAL_ID", "to": "founder@acme.com",
        "subject": "Stripe balance for {{ format(now:America/Chicago, \"dddd, MMM DD\") }}",
        "text": "Available: {{ $.available[0].amount / 100 }} {{ $.available[0].currency }}\nPending: {{ $.pending[0].amount / 100 }} {{ $.pending[0].currency }}" } }
  ]
}
```

Gmail needs an [app password](https://support.google.com/accounts/answer/185833) in the SMTP credential.

### New customers into the CRM

*A sales team wants every new paying customer in their CRM within 15 minutes, without paying for an integration platform.*

Fetch recent Stripe customers and upsert them by email. The request body uses the previous step's output directly, so this job needs no transform.

```json
{
  "name": "Stripe customers to CRM",
  "cron": { "expression": "*/15 * * * *" },
  "nodes": [
    { "id": "customers", "name": "Recent customers",
      "stripe_list_customers": { "credential_id": "YOUR_STRIPE_KEY_ID", "limit": 100 } },
    { "id": "upsert", "name": "Upsert contacts",
      "request": { "method": "POST", "endpoint": "https://crm.example.com/api/contacts/batch-upsert", "credential_id": "YOUR_CRM_TOKEN_ID",
        "body": "{ \"contacts\": { \"{{#each $.data}}\": { \"email\": \"{{ $.email }}\", \"name\": \"{{ $.name }}\", \"stripe_id\": \"{{ $.id }}\" } } }" } }
  ]
}
```

Use an upsert endpoint, since each run sends the latest 100 customers again.

### Month-end numbers in the board sheet

*An operations lead pastes the same three numbers into a Google Sheet on the first of every month.*

On the 1st at 08:00, fetch last month's report and send only those numbers to a Zapier catch hook that appends a row. `revenue` and `signups` arrive as numbers, not strings, because each placeholder is the whole value.

```json
{
  "name": "Monthly metrics to sheet",
  "cron": { "expression": "0 8 1 * *", "time_zone": "Europe/London" },
  "nodes": [
    { "id": "report", "name": "Last month",
      "request": { "method": "GET", "endpoint": "https://analytics.example.com/api/reports/last-month", "credential_id": "YOUR_ANALYTICS_TOKEN_ID" } },
    { "id": "pick", "name": "Pick numbers",
      "transform": { "template": "{ \"month\": \"{{ format(now() - months(1), \\\"YYYY-MM\\\") }}\", \"revenue\": \"{{ $.totals.revenue }}\", \"signups\": \"{{ $.totals.signups }}\" }" } },
    { "id": "append", "name": "Append row",
      "request": { "method": "POST", "endpoint": "https://hooks.zapier.com/hooks/catch/123456/abcdef/", "body": "{{ $ }}" } }
  ]
}
```

## For online stores

### Prices in the shopper's currency

*A US skate shop sells to Europe and the UK, and its EUR and GBP prices drift whenever exchange rates move.*

Every weekday after the European Central Bank publishes its reference rates, fetch them from the free [Frankfurter](https://www.frankfurter.app) API and send them to the store's currency settings.

```json
{
  "name": "Daily exchange rates",
  "cron": { "expression": "30 16 * * 1-5", "time_zone": "Europe/Berlin" },
  "nodes": [
    { "id": "rates", "name": "ECB rates",
      "request": { "method": "GET", "endpoint": "https://api.frankfurter.app/latest?from=USD&to=EUR,GBP,CAD" } },
    { "id": "update", "name": "Update store",
      "request": { "method": "PUT", "endpoint": "https://shop.example.com/admin/api/currencies", "credential_id": "YOUR_STORE_TOKEN_ID",
        "body": "{ \"base\": \"USD\", \"as_of\": \"{{ $.date }}\", \"rates\": { \"EUR\": {{ $.rates.EUR }}, \"GBP\": {{ $.rates.GBP }}, \"CAD\": {{ $.rates.CAD }} } }" } }
  ]
}
```

For a single pair, the built-in [`frankfurter_latest`](/integrations/frankfurter) step needs no URL at all.

### Black Friday at midnight

*A small store wants its Black Friday sale to start at exactly 00:00 Eastern, not whenever someone wakes up and flips the switch.*

Two one-time jobs: one starts the sale at midnight Eastern on November 27, and one ends it after Cyber Monday. Each fires once and switches itself off, so nothing repeats next year.

```json
{
  "name": "Black Friday 2026: start",
  "run_at": "2026-11-27T00:00:00-05:00",
  "nodes": [
    { "id": "start", "request": { "method": "POST", "endpoint": "https://shop.example.com/admin/api/sales/black-friday/start", "credential_id": "YOUR_STORE_TOKEN_ID" } },
    { "id": "tell", "slack_send_message": { "webhook_url": "https://hooks.slack.com/services/T000/B000/XXXX", "text": "Black Friday sale is live :tada:" } }
  ]
}
```

```json
{
  "name": "Black Friday 2026: end",
  "run_at": "2026-11-30T23:59:00-05:00",
  "nodes": [
    { "id": "end", "request": { "method": "POST", "endpoint": "https://shop.example.com/admin/api/sales/black-friday/end", "credential_id": "YOUR_STORE_TOKEN_ID" } }
  ]
}
```

### Warm the cache before the morning rush

*A news site's homepage is slow on the first request after a deploy or a quiet night.*

Fetch the heaviest route every 5 minutes, so readers never pay for a cold cache.

```json
{
  "name": "Warm homepage cache",
  "cron": { "expression": "*/5 * * * *" },
  "nodes": [
    { "id": "warm", "request": { "method": "GET", "endpoint": "https://news.example.com/api/home?revalidate=1" } }
  ]
}
```

## For field teams and clinics

### The rain check

*A landscaping crew in Portland decides every morning whether to mow or to do indoor jobs. The foreman checks three weather apps.*

At 05:30 Portland time, Monday to Saturday, fetch the forecast from the free [Open-Meteo](https://open-meteo.com) API and send it to the crew's Telegram group before the trucks leave.

```json
{
  "name": "Crew weather brief",
  "cron": { "expression": "30 5 * * 1-6", "time_zone": "America/Los_Angeles" },
  "nodes": [
    { "id": "forecast", "name": "Forecast",
      "open_meteo_forecast": { "latitude": "45.52", "longitude": "-122.68", "units": "imperial" } },
    { "id": "text", "name": "Tell the crew",
      "telegram_send_message": { "credential_id": "YOUR_TELEGRAM_BOT_ID", "chat_id": "-1001234567890",
        "text": "Today in Portland: {{ $.daily.precipitation_sum[0] }} in of rain, {{ $.daily.temperature_2m_min[0] }}–{{ $.daily.temperature_2m_max[0] }}°F. Wind now {{ $.current.wind_speed_10m }} mph." } }
  ]
}
```

The bot token lives in a credential, so it never appears in the job.

### Tomorrow's appointment reminders

*A dental clinic in London has patients forget appointments, and the front desk spends its evenings on reminder calls.*

At 18:00 London time, Sunday to Thursday, ask the booking system for tomorrow's appointments and send them all to the SMS provider in one batch.

```json
{
  "name": "Appointment reminders",
  "cron": { "expression": "0 18 * * 0-4", "time_zone": "Europe/London" },
  "nodes": [
    { "id": "bookings", "name": "Tomorrow's bookings",
      "request": { "method": "GET", "endpoint": "https://bookings.example.com/api/appointments?day={{ format(now:Europe/London + days(1), \"YYYY-MM-DD\") }}", "credential_id": "YOUR_BOOKING_KEY_ID" } },
    { "id": "sms", "name": "Send SMS batch",
      "request": { "method": "POST", "endpoint": "https://sms.example.com/v1/messages/batch", "credential_id": "YOUR_SMS_KEY_ID",
        "body": "{ \"messages\": { \"{{#each $.appointments}}\": { \"to\": \"{{ $.patient.phone }}\", \"body\": \"Hi {{ $.patient.first_name }}, a reminder of your appointment tomorrow at {{ $.time }} with {{ $.dentist }}. Reply C to cancel.\" } } }" } }
  ]
}
```

On a day with no bookings, `{{#each}}` over the empty list sends `{ "messages": [] }`, so make sure the batch endpoint accepts it. For a single text, the built-in [`twilio_send_sms`](/integrations/twilio) step does it with your Twilio account.

## For AI agents

### Morning ticket triage

*A support team runs an AI agent that reads new tickets, tags them, and drafts replies. It works, but someone has to remember to start it.*

Start the agent every weekday at 06:00. The run takes minutes, longer than the 10-second timeout, so the agent's API queues it and returns `202` right away.

```json
{
  "name": "Morning support triage",
  "cron": { "expression": "0 6 * * 1-5", "time_zone": "America/Denver" },
  "nodes": [
    { "id": "start", "name": "Start agent run",
      "request": { "method": "POST", "endpoint": "https://agents.acme.com/api/runs", "credential_id": "YOUR_AGENT_KEY_ID",
        "body": "{ \"agent\": \"support-triage\", \"task\": \"Tag and draft replies for every ticket opened since {{ now:America/Denver - days(1) }}. Post a summary to #support.\" }" } }
  ]
}
```

### An agent that schedules its own follow-up

*A coding agent finishes a migration and needs to check the result tomorrow, after the conversation has ended.*

The agent calls `POST /alarms` itself with a one-time job that wakes it again. It fires once and switches itself off. See the [agent guide](/agents) for the rules it should follow.

```json
{
  "name": "acme-api: verify orders backfill",
  "run_at": "2026-11-02T09:00:00-08:00",
  "nodes": [
    { "id": "reopen", "name": "Re-open task",
      "request": { "method": "POST", "endpoint": "https://agents.acme.com/api/runs", "credential_id": "YOUR_AGENT_KEY_ID",
        "body": "{ \"agent\": \"backend\", \"task\": \"Check that the orders backfill finished: row counts match and the error log is clean.\" }" } }
  ]
}
```

## When it's not the right fit

| The work needs… | Do this instead |
| --- | --- |
| More than 10 seconds per request | Put it behind an endpoint that returns `202`, and schedule that endpoint |
| One request per item in a list | Send the list to a batch endpoint, as in [appointment reminders](#tomorrows-appointment-reminders) |
| Filtering, branching, or loops | Filter with the source API's query parameters (like Stripe's `status=past_due`), or do it in your own endpoint |
| Faster than once a minute | Use a long-running worker or a queue |
| Direct database access | Expose an endpoint, then schedule it |

---

<!-- Source: https://cron.services/integrations -->

# Integrations

cronservices calls any HTTP API on a schedule, and has built-in steps for the services people schedule most. A built-in step takes only the fields its API needs, such as a webhook URL and a message, and cronservices builds and signs the request. Chain steps to fetch data from one service, reshape it, and send it to another: open pull requests to Slack, a weather forecast to Telegram, past-due Stripe subscriptions to email.

Every job runs on a cron schedule in any time zone, or once at an exact time. Every run is recorded step by step. Secrets live in encrypted [credentials](/docs#credentials), never in the job.

## Any API

- [Webhooks and HTTP APIs](/integrations/webhooks): Call any HTTP endpoint or webhook on a cron schedule, in any time zone, with headers, a templated body and a saved credential. Every run is recorded.

## Chat

- [Slack](/integrations/slack): Post scheduled Slack messages through an incoming webhook: standup digests, reminders, reports, and on-call announcements, with data from any API. Read channel history too.
- [Discord](/integrations/discord): Send scheduled Discord messages to any channel through a webhook: daily reminders, server announcements, and reports filled in from any API. No bot to host.
- [Microsoft Teams](/integrations/microsoft-teams): Post scheduled messages to a Microsoft Teams channel through a Workflows webhook: recurring reminders, daily reports, and alerts with data from any API.
- [Google Chat](/integrations/google-chat): Send scheduled messages to a Google Chat space through an incoming webhook: recurring reminders, standup prompts, and daily numbers from any API.
- [Mattermost](/integrations/mattermost): Post scheduled messages to Mattermost channels through an incoming webhook, on cloud or self-hosted servers, with data from any API.
- [Telegram](/integrations/telegram): Send scheduled Telegram messages from your bot to a chat, group or channel: daily briefs, reminders and alerts, without hosting the bot.

## Email and SMS

- [Email (SMTP)](/integrations/email): Send scheduled and recurring emails from your own Gmail, iCloud, Fastmail, Outlook or any SMTP mailbox: daily reports, reminders and digests with data from any API.
- [Resend](/integrations/resend): Send scheduled transactional and report emails through Resend from your verified domain, on a cron schedule or once at an exact time.
- [SendGrid](/integrations/sendgrid): Send scheduled emails through SendGrid from your verified sender: recurring reports, reminders and digests with data from any API.
- [Twilio](/integrations/twilio): Send scheduled SMS through your Twilio account: appointment reminders, daily alerts and one-time texts at an exact time, in any time zone.

## Push

- [ntfy](/integrations/ntfy): Publish scheduled push notifications to an ntfy topic on ntfy.sh or your own server, with titles, priorities, tags and click links.
- [Pushover](/integrations/pushover): Send scheduled Pushover notifications to your phone or a group: reminders, daily numbers, and alerts with data from any API.
- [Gotify](/integrations/gotify): Send scheduled messages to your self-hosted Gotify server: reminders, backup reports and alerts, with titles and priorities.
- [Pushbullet](/integrations/pushbullet): Push scheduled notes to every device on your Pushbullet account: reminders and daily summaries with data from any API.

## Incidents and monitoring

- [PagerDuty](/integrations/pagerduty): Announce who is on call in Slack or Teams every morning, and trigger PagerDuty incidents from scheduled checks, with the PagerDuty REST and Events APIs.
- [Opsgenie](/integrations/opsgenie): Open Opsgenie alerts from scheduled checks and recurring reminders, in the US or EU region, with priorities and descriptions from any API.
- [Datadog](/integrations/datadog): Post events to your Datadog event stream on a schedule: daily business numbers, job markers and check results, on any Datadog site.
- [Healthchecks.io](/integrations/healthchecks): Check an endpoint every minute and ping Healthchecks.io only when it succeeds, so you get alerted when your API goes down or a scheduled job stops running.

## Developer tools

- [GitHub](/integrations/github): Post open pull requests to Slack before standup, and open recurring GitHub issues for chores like dependency updates and on-call handoffs.
- [IFTTT](/integrations/ifttt): Run IFTTT Webhooks applets on a precise cron schedule or once at an exact time, with values filled in from any API.

## Data

- [Stripe](/integrations/stripe): Post past-due Stripe subscriptions to Slack every morning, email your Stripe balance daily, and sync new customers to your CRM, without writing a function.
- [Open-Meteo weather](/integrations/open-meteo): Send a daily weather forecast for any location to Slack, Telegram, SMS or email with the free Open-Meteo API. No API key.
- [Frankfurter exchange rates](/integrations/frankfurter): Fetch the European Central Bank’s daily exchange rates with the free Frankfurter API and post them to Slack or update your store’s prices. No API key.

Don't see your service? Any API with an HTTP endpoint works with a [request step](/integrations/webhooks). Tell us what to build next at support@cron.services.

---

<!-- Source: https://cron.services/pricing -->

# Pricing

Every plan includes time zones, request, transform and built-in steps, templated headers and bodies, encrypted credentials, and the REST API. A run is one scheduled firing of a job, however many steps its pipeline has.

| | Hobby | Pro | Team |
| --- | --- | --- | --- |
| Price (monthly) | $0/mo | $12/mo | $49/mo |
| Price (yearly) | $0/yr | $120/yr | $490/yr |
| Jobs | 3 | 50 | 500 |
| Fastest schedule | Every 15 min | Every minute | Every minute |
| Runs per month | 1,000 | 50,000 | 500,000 |
| Run history | 24 hours | 30 days | 90 days |
| Pipelines and transforms | Included | Included | Included |
| REST API and agent tools | Included | Included | Included |
| Failure email alerts | — | Included | Included |

## Hobby: $0/month

For side projects and trying things out.

- 3 jobs
- Runs every 15 min at most
- 1,000 runs / month
- 24-hour run history

## Pro: $12/month

For production workloads.

- 50 jobs
- Every-minute schedules
- 50,000 runs / month
- 30-day run history
- Failure email alerts

## Team: $49/month

For teams running critical automation.

- 500 jobs
- Every-minute schedules
- 500,000 runs / month
- 90-day run history
- Up to 10 seats
- Priority support

## What happens at a limit

- Creating a job beyond your plan's job count returns `402 plan_limit`.
- A schedule faster than your plan allows returns `422 validation_failed` on `alarm.cron.expression`.
- Downgrading pauses jobs that are too frequent for the new plan, then the newest jobs beyond its job count. Nothing is deleted.
- A one-time job (`run_at`) counts toward the job limit until it has fired.

---

<!-- Source: https://cron.services/about -->

# About cronservices

Most scheduled code is plumbing. Call an API, pick a few fields out of the response, send them somewhere else. Yet each piece of it usually becomes a function, which then needs a repo, a deploy target, a cron trigger, secrets, logs, and someone to notice when it stops running.

cronservices turns that plumbing into configuration. A job is a cron expression and a short pipeline of HTTP requests and JSON transforms. There's nothing to build or deploy. Every run is recorded, and you can read, change, or pause a job in seconds.

## Why now

More and more code is written by AI agents. Agents are good at describing what should happen and when. They're worse at owning the infrastructure that makes it happen: picking a host, wiring up a scheduler, rotating secrets, and keeping it all alive after the conversation ends.

So we built cronservices to be easy for an agent to use correctly. The API is small and documented in [OpenAPI](/openapi.json). The docs are published as plain Markdown and [llms.txt](/llms.txt). The [agent guide](/agents) says plainly when cronservices is the right tool and when it isn't. An agent can schedule work in one API call, and a person can see and change exactly what it did.

## What we believe

**Configuration beats code for glue.** If a task can be described as "fetch this, reshape it, send it there", it shouldn't need a deploy.

**Small and predictable.** One scheduler, standard 5-field cron in any time zone, a template language you can learn in five minutes, and limits that are written down. No surprises at 3 a.m.

**Readable by people and machines.** Every page on this site has a Markdown twin. If an agent can't read our docs, they aren't good enough.

**Honest about limits.** Requests time out after 10 seconds. Templates don't branch or loop with side effects. When you need more than that, write the code and let cronservices call it.

## Get started

[Create a free account](/login#signup), read the [docs](/docs), or point your coding agent at [https://cron.services/llms.txt](/llms.txt).

## Contact

Questions and account help: [support@cron.services](mailto:support@cron.services).