What does each cron field mean?

The 5 fields are: minute, hour, day of month, month, day of week.

How to schedule a task every 5 minutes?

Use the expression */5 * * * * to run every 5 minutes.

Cron Expression Builder: Online Cron Expression Generator

Cron expressions are strings that define when to execute automated tasks on Linux/Unix servers. Used by system administrators, DevOps engineers, and backend developers, cron expressions enable scheduling recurring jobs with minute-level precision.

Our Cron Expression Builder is completely free, intuitive, and generates valid cron expressions in real-time. Includes natural language explanation, common examples, and support for 5 and 6-field syntax.

What is Cron and How It Works

Cron is a daemon (background service) present in all Unix/Linux systems that executes scheduled commands at specific intervals. The name derives from the Greek "chronos" (time).

Anatomy of a Cron Expression

A cron expression consists of 5 or 6 fields separated by spaces:

┌───────────── minute (0 - 59)
│ ┌───────────── hour (0 - 23)
│ │ ┌───────────── day of month (1 - 31)
│ │ │ ┌───────────── month (1 - 12)
│ │ │ │ ┌───────────── day of week (0 - 6) (Sunday=0)
│ │ │ │ │
│ │ │ │ │
* * * * * command to execute

Example with 6 fields (includes seconds):
│ │ │ │ │ │
│ │ │ │ │ └─── day of week (0 - 6)
│ │ │ │ └───── month (1 - 12)
│ │ │ └─────── day of month (1 - 31)
│ │ └───────── hour (0 - 23)
│ └─────────── minute (0 - 59)
└───────────── second (0 - 59) [optional]

Special Characters

* (asterisk): Any value (e.g., `* * * * *` = every minute)
, (comma): List of values (e.g., `1,15,30` = minutes 1, 15, and 30)
- (hyphen): Range (e.g., `1-5` = from 1 to 5)
/ (slash): Step/increment (e.g., `*/5` = every 5 units)
? (question mark): No specific value (only in day of month/week)
L: Last (e.g., `L` in day = last day of month)
W: Nearest weekday (e.g., `15W` = weekday nearest to the 15th)
#: Nth occurrence (e.g., `2#3` = third Tuesday of month)

Common Cron Expression Examples

Expression	Description	Execution Time
`* * * * *`	Every minute	Every minute of every hour
`0 * * * *`	Every hour	At the start of every hour (00:00, 01:00, 02:00...)
`0 0 * * *`	Daily at midnight	00:00 every day
`0 2 * * *`	Daily at 2:00 AM	02:00 every day
`0 0 * * 0`	Every Sunday at midnight	00:00 every Sunday
`0 0 1 * *`	First day of every month	00:00 on the 1st of each month
`/5 * * *`	Every 5 minutes	00:00, 00:05, 00:10, 00:15...
`0 /2 * *`	Every 2 hours	00:00, 02:00, 04:00, 06:00...
`0 9-17 * * 1-5`	Every hour 9 AM-5 PM, Mon-Fri	Business hours 9-5 on weekdays
`0 0 * * 1`	Every Monday at midnight	00:00 every Monday
`0 3 1,15 * *`	1st and 15th at 3:00 AM	03:00 on the 1st and 15th
`30 4 1 1 *`	New Year's at 4:30 AM	04:30 on January 1st

Cron Expression Use Cases

1. Automated Backups

Schedule database, file, and configuration backups:

# Database backup daily at 2:00 AM
0 2 * * * /usr/local/bin/backup-db.sh

# Full backup every Sunday at 3:00 AM
0 3 * * 0 /usr/local/bin/full-backup.sh

# Incremental backup every 6 hours
0 */6 * * * /usr/local/bin/incremental-backup.sh

Practical case: Production server performing PostgreSQL database backup nightly with upload to S3.

2. Cleanup and Maintenance

Remove temporary files, old logs, cache:

# Clean logs older than 7 days, every Sunday at 4:00 AM
0 4 * * 0 find /var/log -name "*.log" -mtime +7 -delete

# Clear cache daily at midnight
0 0 * * * rm -rf /tmp/cache/*

# Vacuum PostgreSQL database every Monday at 3:00 AM
0 3 * * 1 psql -U postgres -d mydb -c "VACUUM ANALYZE;"

Practical case: System accumulating logs requiring weekly cleanup to prevent disk space exhaustion.

3. Reports and Analytics

Generate periodic reports, statistics, summary emails:

# Daily sales report at 8:00 AM
0 8 * * * /usr/local/bin/generate-daily-sales-report.sh

# Weekly report every Friday at 5:00 PM
0 17 * * 5 /usr/local/bin/weekly-summary.sh

# Monthly report on first day at 9:00 AM
0 9 1 * * /usr/local/bin/monthly-report.sh

Practical case: E-commerce sending daily sales reports to management via email.

4. Data Synchronization

Sync databases, files, cache between systems:

# Sync files from remote server every 15 minutes
*/15 * * * * rsync -avz user@remote:/data /local/data

# Sync database replica every hour
0 * * * * /usr/local/bin/sync-db-replica.sh

# Update cache from API every 5 minutes
*/5 * * * * curl -X POST https://api.example.com/refresh-cache

Practical case: CDN syncing static content from origin server every 10 minutes.

5. Monitoring and Health Checks

Check service status, send alerts, monitor metrics:

# Health check services every 5 minutes
*/5 * * * * /usr/local/bin/health-check.sh

# Monitor disk space every hour
0 * * * * df -h | mail -s "Disk Space Report" admin@example.com

# Check expired SSL certificates daily at 6:00 AM
0 6 * * * /usr/local/bin/check-ssl-certs.sh

Practical case: Monitoring system checking uptime of 50 microservices every 2 minutes.

6. System Tasks and DevOps

Restarts, updates, automated deployments:

# Restart service daily at 4:00 AM (memory leak fix)
0 4 * * * systemctl restart myapp.service

# System update every Sunday at 5:00 AM
0 5 * * 0 apt update && apt upgrade -y

# Automated deploy from Git every 30 minutes (CI/CD)
*/30 * * * * cd /var/www/app && git pull && npm install && pm2 restart app

7. Notifications and Reminders

Send scheduled emails, SMS, push notifications:

# Email reminder every Monday at 9:00 AM
0 9 * * 1 echo "Weekly standup at 10:00" | mail -s "Reminder" team@example.com

# Contract expiry notifications 7 days prior
0 10 * * * /usr/local/bin/contract-expiry-check.sh

# Send newsletter every Thursday at 2:00 PM
0 14 * * 4 /usr/local/bin/send-newsletter.sh

How to Use THEJORD Cron Builder

Visual Interface

Open the Cron Expression Builder
Select frequency using visual controls:
- Minutes: Choose specific minute or interval (*/5, */10, */15)
- Hours: Select hour or range (9-17 for business hours)
- Days of month: Pick specific days (1, 15) or all (*)
- Months: Select months or all (*)
- Days of week: Choose days (1=Mon, 5=Fri, 0=Sun)
See generated expression in real-time
Read description in plain English (e.g., "Every day at 2:00 AM")
Copy expression with one click

Advanced Mode

6-field syntax: Enable to include seconds (Quartz, Spring)
Common presets: Load predefined templates (hourly, daily, weekly)
Test next runs: View next 10 executions with dates/times
Validation: Check if expression is valid
Timezone conversion: Show times in UTC/Local

Practical Example: Nightly Database Backup

// Goal: Backup database every night at 3:00 AM

1. Minutes: 0
2. Hours: 3
3. Days of month: * (every day)
4. Months: * (all months)
5. Days of week: * (all days)

Result: 0 3 * * *
Description: "At 3:00 AM every day"

Next executions:
- 2024-12-03 03:00:00
- 2024-12-04 03:00:00
- 2024-12-05 03:00:00

Code Examples and Implementations

Linux Crontab

# Edit crontab for current user
crontab -e

# Add cron job
0 2 * * * /home/user/backup.sh

# View current crontab
crontab -l

# Remove all cron jobs
crontab -r

# System crontab (requires sudo)
sudo nano /etc/crontab

# Cron logs (for debugging)
tail -f /var/log/syslog | grep CRON

Node.js with node-cron

const cron = require('node-cron');

// Database backup daily at 2:00 AM
cron.schedule('0 2 * * *', () => {
  console.log('Running database backup...');
  require('./backup-db')();
});

// Clear cache every 5 minutes
cron.schedule('*/5 * * * *', () => {
  console.log('Clearing cache...');
  cache.clear();
});

// Weekly report every Friday at 5:00 PM
cron.schedule('0 17 * * 5', () => {
  console.log('Generating weekly report...');
  generateReport();
}, {
  timezone: "America/New_York"
});

Python with schedule

import schedule
import time

def backup_database():
    print("Running backup...")
    # backup logic

def send_report():
    print("Sending report...")
    # report logic

# Backup daily at 2:00 AM
schedule.every().day.at("02:00").do(backup_database)

# Report every Monday at 9:00 AM
schedule.every().monday.at("09:00").do(send_report)

# Cleanup every 5 minutes
schedule.every(5).minutes.do(lambda: print("Cleaning..."))

while True:
    schedule.run_pending()
    time.sleep(60)

Spring Boot with @Scheduled

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class ScheduledTasks {

    // Backup daily at 2:00 AM
    @Scheduled(cron = "0 0 2 * * *")
    public void backupDatabase() {
        System.out.println("Running backup...");
        // backup logic
    }

    // Report every Monday at 9:00 AM
    @Scheduled(cron = "0 0 9 * * MON")
    public void sendWeeklyReport() {
        System.out.println("Sending weekly report...");
        // report logic
    }

    // Cleanup every 5 minutes (6 fields with seconds)
    @Scheduled(cron = "0 */5 * * * *")
    public void cleanCache() {
        System.out.println("Cleaning cache...");
        // cleanup logic
    }
}

Kubernetes CronJob

apiVersion: batch/v1
kind: CronJob
metadata:
  name: database-backup
spec:
  schedule: "0 2 * * *"  # Daily at 2:00 AM
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: backup
            image: postgres:15
            command:
            - /bin/sh
            - -c
            - pg_dump -U postgres mydb > /backup/dump.sql
          restartPolicy: OnFailure

Comparison of Cron Alternatives

System	Syntax	Precision	Persistence	Logging
Cron (Unix)	5 fields	Minute	✅ Crontab	Syslog
Quartz (Java)	6-7 fields	Second	✅ Database	Log4j
systemd timers	Unit files	Microsecond	✅ Service files	Journalctl
node-cron	5-6 fields	Second	❌ In-memory	Console
Kubernetes CronJob	5 fields	Minute	✅ YAML	kubectl logs

When to Use What

Traditional cron: Linux/Unix servers, simple tasks, shell scripts
systemd timers: Modern Linux, preferred over cron for system integration
Quartz/Spring: Enterprise Java applications with complex scheduling
node-cron: Node.js applications, in-process tasks
Kubernetes CronJob: Containerized workloads, cloud-native microservices

Best Practices and Troubleshooting

✅ Best Practices

Absolute paths: Always use full paths in cron commands
Logging: Redirect output for debugging: command >> /var/log/cron.log 2>&1
Lock files: Prevent overlapping executions with flock
Timeouts: Use timeout to avoid stuck processes
Email notifications: Configure MAILTO to receive errors
Test first: Test scripts manually before scheduling

⚠️ Common Problems

Problem: Cron job doesn't execute

# Check if cron service is running
systemctl status cron

# Check syntax errors in crontab
crontab -l

# View cron logs for errors
tail -f /var/log/syslog | grep CRON

Problem: Script works manually but not from cron

Cause: Different environment variables (PATH, HOME, USER)
Solution: Set variables in crontab or script

# In crontab, define environment
PATH=/usr/local/bin:/usr/bin:/bin
HOME=/home/user

0 2 * * * /home/user/script.sh

Problem: Duplicate executions

Cause: Previous job still running when next one starts
Solution: Use flock for lock file

*/5 * * * * flock -n /tmp/myjob.lock /usr/local/bin/myjob.sh

Frequently Asked Questions (FAQ)

What's the difference between 5-field and 6-field cron?

Traditional Unix cron uses 5 fields (minute-hour-day-month-week) with minute-level precision. Quartz and Spring use 6 fields adding seconds at the beginning, enabling second-level precision.

Can I run a cron job every second?

No with traditional cron (minimum 1 minute). Yes with Quartz/Spring (6 fields with seconds) or systemd timers. For sub-minute tasks on Linux, use systemd timer or loop in script.

How to run a job only on weekdays?

0 9 * * 1-5  # Mon-Fri at 9:00 AM

# Or explicitly excluding Sat/Sun
0 9 * * 1,2,3,4,5

What does */5 mean in cron expressions?

"Every 5 units". Example: `*/5` in minutes = every 5 minutes (0, 5, 10, 15...). `*/2` in hours = every 2 hours (0, 2, 4, 6...).

How to run a job on the last day of the month?

# No standard syntax in Unix cron
# Workaround with script checking date
0 0 * * * [ $(date -d tomorrow +\%d) -eq 1 ] && /path/to/script.sh

# Or use Quartz which supports "L"
0 0 L * *  # Quartz syntax

Does cron respect daylight saving time?

Yes, cron uses local system time. During DST transitions, a job scheduled at 2:30 AM might execute 0, 1, or 2 times. To avoid issues, use times away from transition (1:00-2:00 AM).

How do I debug a failing cron job?

# 1. Redirect output to file
0 2 * * * /path/script.sh >> /var/log/myjob.log 2>&1

# 2. Add set -x to script for debugging
#!/bin/bash
set -x  # Debug mode
echo "Starting job..."

# 3. Check email (cron sends output via mail)
# Configure in crontab:
MAILTO=admin@example.com

Related Resources

Explore other useful THEJORD tools:

RegEx Tester: Test regex patterns to validate cron job output
JSON Formatter: Format JSON produced by scheduled scripts
Diff Checker: Compare cron job output between executions
Hash Generator: Verify integrity of files generated by automated backups

External Documentation

Try the Cron Builder Now →