Explain a cron expression
Turn a cron line into a plain sentence: 0 3 * * 1-5 reads as at 3:00 AM, Monday through Friday, so nobody has to count fields from memory or open a reference. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Nobody remembers whether the minute field comes before or after the hour, or what asterisks and dashes mean stacked five deep in a row.
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.
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.
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.
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
What cron formats does it understand?
It parses standard five and six-field cron syntax, including ranges, steps, lists and wildcards.
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.
What does */15 mean in a cron expression?
It means every 15 minutes. For example, */15 9 * * 1 is explained as every 15 minutes, at 9 o'clock, on weekday 1, so the step value is spelled out instead of guessed.
Where is a plain-language cron explanation useful?
Next to each raw schedule in an admin dashboard, as a readable comment above a cron line in a deployment file, or in a support reply that tells a client why a report arrives at 3am instead of 9am.
Does it also tell me when the job will run next?
No. It explains what the expression means in words. To see the exact upcoming run times, pair it with a next-run lookup: first the meaning, then the concrete dates.
Related tools
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
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, by email and from Telegram — and soon from our app too.
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 '{"cron":"0 9 * * 1"}'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({
"cron": "0 9 * * 1"
})
});
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['KIT_KEY']}"},
json={
"cron": "0 9 * * 1"
},
)
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" => '{"cron":"0 9 * * 1"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"cron":"0 9 * * 1"}`)
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
{
"cron": "0 9 * * 1"
}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
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. |
Technical notes
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.
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.
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.
Integration use cases
Legacy crontab audits
Feed every line of an inherited crontab through the endpoint to quickly document what each job actually does and when.
Technical questions
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.
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.