Home›Generators›Developer Tools›Cron Expression Generator

Cron Expression Generator

Developer Tools

Build cron expressions visually and get a plain-English description of the schedule. Free, browser-based, no sign-up — instant cron job syntax.

Reviewed by the thecalcu.com team · Last updated July 13, 2026

What is a Cron?

A Cron Expression Generator builds the five-field schedule string used by Unix cron, cloud schedulers, and most job scheduling systems, and translates it into plain English so you can verify the schedule is exactly what you intended before deploying.

Cron syntax has been the standard for scheduled tasks on Unix-like systems since 1975. The same five-field format is used today by Linux crontab, macOS launchd, GitHub Actions scheduled workflows, AWS EventBridge, Google Cloud Scheduler, Kubernetes CronJobs, and virtually every modern job scheduling system. Understanding how to write and read cron expressions is an essential skill for any developer or systems administrator working on the backend.

The five fields are read left to right: minute (0–59), hour (0–23), day of month (1–31), month (1–12), day of week (0–7, where 0 and 7 both mean Sunday). Each field accepts a specific value, a wildcard * for 'every', a range 1-5, a step */15, or a comma-separated list 1,15,20.

The trickiest part of cron is not writing the expression, it is verifying that the expression matches your intent. An expression like 0 9 * * 1 looks correct ('9 AM on Monday'), but if you meant '9 AM every weekday', you need 0 9 * * 1-5. The plain-English output from this generator makes that kind of mistake immediately visible.

Use the UUID Generator to generate correlation IDs for tracking individual cron job runs in logs. For developer testing workflows, the Fake Email Generator produces test addresses for scheduled email pipelines and notification systems.

Why Use a Cron Expression Generator?

Cron syntax is compact but not intuitive. A developer who writes */15 8-18 * * 1-5 knows it means 'every 15 minutes during working hours on weekdays', but reviewing that expression in a codebase six months later requires parsing each field from scratch. A plain-English description, 'every 15 minutes, hour 8 through 18, Monday through Friday', is immediately understandable.

The generator also catches two common mistakes: writing 0 9 * * 1,2,3,4,5 when 0 9 * * 1-5 is simpler, and accidentally leaving both day-of-month and day-of-week as non-asterisk values (which creates an OR condition in most cron implementations, not AND).

For developers working across time zones or deploying to UTC servers, building the expression field by field in a visual tool makes it easier to reason about the schedule before committing to a deployment.

Who Should Use This Generator?

Backend developers who need to schedule database backups, report generation, cache warming, or API polling jobs. Cron expressions appear in every backend tech stack, shell scripts, Node.js (node-cron), Python (APScheduler), Ruby (whenever gem), and more.

DevOps and infrastructure engineers configuring Kubernetes CronJobs, AWS EventBridge rules, GitHub Actions scheduled workflows, and server-level crontab files. A generated expression with a verified description reduces deployment errors.

Data engineers scheduling ETL pipelines, data warehouse refreshes, and reporting jobs. A misscheduled pipeline that runs at the wrong frequency or wrong time can compound data quality issues silently.

Developers new to cron syntax who want to understand what an existing expression does. Paste the five fields into the generator and read the plain-English output, it is the fastest way to decode an unfamiliar schedule.

For splitting workloads across time windows, the Team Generator is useful for randomly assigning on-call rotations or assigning cron job ownership across a team.

What Insights Does the Cron Expression Generator Give You?

The generator produces two outputs: the cron expression itself (formatted as MIN HOUR DOM MON DOW in monospaced text, ready to copy into any scheduler) and the plain-English schedule description, which translates the five fields into a sentence describing when the job runs.

The expression output is copy-ready, paste it directly into a crontab, a GitHub Actions schedule: block, a Kubernetes CronJob spec.schedule, or an AWS EventBridge expression (note: EventBridge uses a six-field format with year appended; most platforms use the standard five-field format).

The description output verifies your intent before deployment. If you enter 0 9 * * 1 and the description says 'At 9:00 AM, on Monday' rather than 'on weekdays', you know to change 1 to 1-5.

How to use this Cron calculator

  1. Enter the minute field, type a specific minute (e.g. 0 for on the hour), a step like */15 for every 15 minutes, or * for every minute.
  2. Enter the hour field, type a specific hour in 24-hour format (e.g. 9 for 9 AM, 14 for 2 PM), a range (8-18), a step (*/6), or * for every hour.
  3. Enter the day-of-month field, type a calendar day (e.g. 1 for the 1st of each month), a list (1,15), or * for every day.
  4. Enter the month field, type a month number (1–12), a name abbreviation (JAN, FEB), a range (6-8), or * for every month.
  5. Enter the day-of-week field, type a weekday number (0=Sun through 6=Sat), a range (1-5 for weekdays), a name abbreviation (MON, TUE), or * for every day of the week.
  6. Click Generate, the tool outputs the formatted cron expression and its plain-English description.
  7. Verify the description, read the plain-English output to confirm the schedule matches your intention, then copy the expression for use in your scheduler.

Formula & Methodology

A cron expression is a string of exactly five space-separated fields. The generator joins the five inputs with a single space:

EXPRESSION = minute + " " + hour + " " + dom + " " + month + " " + dow

Field reference:

| Field | Position | Range | Allowed special characters |
|---|---|---|---|
| Minute | 1 | 0–59 | * , - / |
| Hour | 2 | 0–23 | * , - / |
| Day of month | 3 | 1–31 | * , - / |
| Month | 4 | 1–12 or JAN–DEC | * , - / |
| Day of week | 5 | 0–7 (0 and 7 = Sunday) or SUN–SAT | * , - / |

Special character rules:
- *, matches every value in the field
- ,, separates a list of values: 1,15 means the 1st and 15th
- -, defines a range: 1-5 means 1, 2, 3, 4, 5
- /, defines a step: */15 in the minute field means every 15 minutes; 2/15 means every 15 minutes starting at minute 2

Common patterns:

| Expression | Meaning |
|---|---|
| * * * * * | Every minute |
| 0 * * * * | Every hour on the hour |
| 0 0 * * * | Daily at midnight |
| 0 9 * * 1-5 | Weekdays at 9:00 AM |
| */15 * * * * | Every 15 minutes |
| 0 0 1 * * | First day of every month at midnight |
| 0 9,17 * * 1-5 | Weekdays at 9 AM and 5 PM |
| 0 0 * * 0 | Every Sunday at midnight |

Frequently Asked Questions

A cron expression is a string of five fields, minute, hour, day-of-month, month, and day-of-week, that together define a recurring schedule for a task. Cron is the job scheduler built into Unix-like operating systems (Linux, macOS), and cron expressions are the syntax it uses to specify when a job should run. The expression `0 9 * * 1-5` means 'at 9:00 AM every weekday', and `*/15 * * * *` means 'every 15 minutes'. Most modern job schedulers, cloud platforms, and CI/CD tools use the same five-field cron syntax.
Reading left to right: the first field is the minute (0–59), the second is the hour (0–23 in 24-hour time), the third is the day of the month (1–31), the fourth is the month (1–12 or JAN–DEC), and the fifth is the day of the week (0–7, where both 0 and 7 represent Sunday, or SUN–SAT). Each field can be a specific value, an asterisk `*` (meaning 'every'), a range (`1-5`), a step (`*/15`), or a comma-separated list (`1,15`).
An asterisk in a cron field means 'every possible value for this field'. In the minute field, `*` means every minute (0 through 59). In the hour field, `*` means every hour (0 through 23). In the day-of-month field, `*` means every day of the month. So `* * * * *` runs every minute of every day, while `0 * * * *` runs at the start of every hour (minute 0, every hour).
Use the step syntax `*/15` in the minute field: `*/15 * * * *`. The `*/n` pattern means 'every n units starting from 0'. So `*/15` in the minute field produces runs at :00, :15, :30, and :45 of every hour. Similarly, `*/6 * * * *` runs every 6 minutes, and `0 */4 * * *` runs every 4 hours on the hour. The step syntax works in all five fields.
Use `1-5` in the day-of-week field (Monday through Friday). For example, `0 9 * * 1-5` runs at 9:00 AM every weekday. Many cron implementations also accept the named shorthand `MON-FRI`. To run on weekends only, use `0,6` or `SAT,SUN` in the day-of-week field. Note: when both the day-of-month and day-of-week fields are non-asterisk, most cron implementations run the job when *either* condition is met, not both, this is a common source of unintended schedules.
The day-of-month field (third position) specifies which calendar day to run, for example, `15` means the 15th of every month. The day-of-week field (fifth position) specifies which weekday to run, for example, `1` means every Monday. When you set both to non-asterisk values, most cron daemons treat it as an OR condition: the job runs if *either* the day-of-month matches or the day-of-week matches. To schedule 'the first Monday of each month', you need a workaround (typically a shell `if` check inside the job).
By default, cron on Linux uses the server's local timezone as set in `/etc/timezone` or `TZ` environment variable. Many hosted schedulers (AWS EventBridge, GitHub Actions, Kubernetes CronJobs) run cron in UTC by default. This is a frequent source of bugs: a cron job written to run at '9 AM' runs at the wrong wall-clock time after a timezone offset. When deploying cron jobs in production, always confirm the timezone and convert your intended local time to UTC explicitly.
The Cron Expression Generator shows a plain-English description of the schedule alongside the expression, this is the fastest way to verify that the expression matches your intent. For additional verification, tools like `crontab guru` online or the `cronitor` CLI can explain and simulate cron expressions. In production, always test with a more frequent schedule first (e.g. every minute) to confirm the job runs, then switch to the intended interval.
Frequently used patterns: `0 * * * *`, every hour on the hour; `0 0 * * *`, daily at midnight; `0 9 * * 1-5`, every weekday at 9 AM; `0 0 1 * *`, first day of every month at midnight; `*/5 * * * *`, every 5 minutes; `0 0 * * 0`, every Sunday at midnight; `0 9,17 * * 1-5`, weekdays at 9 AM and 5 PM; `0 0 1 1 *`, once a year on 1st January at midnight.
Standard Unix cron uses five fields with minute as the finest granularity, you cannot schedule a job to run every 30 seconds with standard cron. Some extended implementations (Quartz Scheduler in Java, AWS EventBridge, some cron libraries) add a sixth field for seconds at the start, giving a six-field expression. For sub-minute scheduling in production, use a purpose-built job queue (Sidekiq, Celery, BullMQ) rather than cron.
A crontab (cron table) is the file or system where cron jobs are defined, it contains one or more lines, each combining a cron expression with the command to run. A cron expression is just the five-field schedule portion of a crontab line. The full crontab line looks like: `0 9 * * 1-5 /home/user/backup.sh`. The Cron Expression Generator produces the expression part; the command you run is separate.
Also known as
cron job generatorcron syntax buildercron schedule generatorcron expression builderlinux cron generatorcrontab generator