ForHosting KIT · Developer Utilities

Explain a cron expression

Nobody remembers whether the minute field comes before or after the hour, or what asterisks and dashes mean stacked five deep in a row. This cron expression parser API reads a cron string and returns a plain-language sentence describing exactly when it fires, turning a squint-and-guess moment into an instant answer.

● StableFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailApp soonTelegram soon

The five-field puzzle everyone re-learns from scratch

A cron expression like 0 3 * * 1-5 is dense by design, five or six fields packed with numbers, asterisks, commas, dashes and slashes, each with its own meaning depending on position. Developers inheriting an old deployment script, DevOps engineers auditing a crontab left behind by someone who left the company, and support staff trying to explain to a client why a report arrives at 3am instead of 9am all hit the same wall: the syntax is compact enough that even experienced engineers open a reference or a testing tool rather than trust their memory. That small friction, repeated across a team, adds up to real time lost to something that should be a one-line answer.

What you send and what comes back

POST /dev/cron-explain accepts a raw cron expression as a string and returns a clear, human-readable description of its schedule, something like 'At 3:00 AM, Monday through Friday.' The task is queued asynchronously, returning a task_id right away, and the explanation is delivered moments later via signed webhook or a signed link valid for 24 hours, ready to display in a UI, a log annotation or a code comment.

A scheduling format that predates most of today's tooling

The cron syntax traces back to the original cron utility built for Unix systems in the 1970s, designed to let administrators schedule recurring jobs without a graphical interface, just a compact text line in a table. That same terse format survived essentially unchanged for decades because it works, and it's now embedded everywhere from CI pipelines to serverless schedulers to database maintenance jobs, which is exactly why so many people who never touched Unix directly still have to read one today.

Where explanation fits into a bigger workflow

Scheduling dashboards, deployment tools and internal admin panels increasingly show cron expressions to non-engineers who need to understand a job's timing without learning the syntax, and this endpoint is the piece that makes that possible without hardcoding a parsing library into every product. It pairs naturally with a next-run-time lookup: explain what an expression means, then show exactly when it will fire next. At $0.002 per request, adding a plain-language explanation next to every cron field in an admin UI costs a negligible amount even at scale.

Access and current status

Using the endpoint requires prepaid balance; without one, the request returns HTTP 402 rather than a partial or guessed explanation, and a failed request is never billed after its retries. Pricing is a flat $0.002 per request. The endpoint is live now, and submitted expressions are discarded after the delivery window, never retained for training.

What you can do with it

Admin dashboard readability

Show a plain-English schedule description next to each raw cron string in a job scheduling UI, so non-engineers understand it at a glance.

Legacy crontab audits

Feed every line of an inherited crontab through the endpoint to quickly document what each job actually does and when.

Code review and documentation

Auto-generate a human-readable comment above a cron expression in a deployment config or CI pipeline definition.

Customer support explanations

Translate a customer's configured schedule into a sentence support staff can paste directly into a reply.

FAQ

How does this cron expression parser API work?

Send a raw cron string to POST /dev/cron-explain and it returns a plain-language description of the schedule, delivered by webhook or a signed link.

What cron formats does it understand?

It parses standard five and six-field cron syntax, including ranges, steps, lists and wildcards.

Is there a free tier for this API?

The tool above runs free in your browser. The API is paid — each call draws from your prepaid ForHosting KIT balance: top up from $10.00 (it never expires), pay each request's published price, and a call with no balance returns HTTP 402. No subscription, no tokens, and a failed task is never charged.

How much does the cron explainer API cost?

It costs a flat $0.002 per request regardless of the expression's complexity.

Can it handle non-standard cron syntax like @daily or @hourly?

It is built around standard field-based cron syntax; check the endpoint's schema for exactly which shorthand forms are accepted.

Is the cron explainer API live now?

Yes, it is live and accepting requests.

Does it also show the next run time, not just the meaning?

This endpoint focuses on describing what the expression means in plain language; next run times are available through a separate cron endpoint.

Can I explain many cron expressions in bulk?

Submit one request per expression; each is queued and priced independently, suitable for auditing an entire crontab file at once.

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/dev/cron-explain

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/dev/cron-explain \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"items":["valor-1","valor-2"]}'

const res = await fetch("https://api.kit.forhosting.com/dev/cron-explain", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "items": [
      "valor-1",
      "valor-2"
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/cron-explain",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "items": [
        "valor-1",
        "valor-2"
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/cron-explain", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"items":["valor-1","valor-2"]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"items":["valor-1","valor-2"]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/cron-explain", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "items": [
    "valor-1",
    "valor-2"
  ]
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.cron_explain",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Read the full KIT documentation →

Run — free