How to Run a Cron Job Every 30 Seconds

The Problem: Cron's 1-Minute Minimum

A cron expression has five fields: minute, hour, day of month, month, and day of week. The smallest unit is one minute. There is no "seconds" field. Writing * * * * * gives you every minute — that's as fast as cron goes.

If you need to run a task every 30 seconds, you need one of the workarounds below.

Method 1: The Sleep Trick (Most Popular)

The most common approach: create two crontab entries. The first runs your script at the top of each minute. The second waits 30 seconds, then runs the same script:

# Run every 30 seconds
* * * * * /path/to/script.sh
* * * * * sleep 30 && /path/to/script.sh

How it works: Cron fires both entries every minute. The first runs immediately (at second 0). The second sleeps for 30 seconds, then runs (at second 30). Result: your script executes twice per minute, 30 seconds apart.

Method 2: Bash Loop with Sleep

Instead of two crontab entries, use a single entry that runs a wrapper script. The wrapper executes your task, sleeps 30 seconds, and runs it again:

#!/bin/bash
# run-every-30s.sh
for i in 0 30; do
  /path/to/script.sh &
  sleep 30
done

Then add a single crontab entry:

* * * * * /path/to/run-every-30s.sh

The & runs the script in the background so the sleep doesn't block execution. The loop runs twice per minute (at second 0 and second 30), matching cron's one-minute interval.

Method 3: systemd Timer

On modern Linux systems, systemd timers can schedule tasks with second-level precision. Create two unit files:

Service unit

/etc/systemd/system/my-task.service

[Unit]
Description=My 30-second task

[Service]
Type=oneshot
ExecStart=/path/to/script.sh

Timer unit

/etc/systemd/system/my-task.timer

[Unit]
Description=Run my task every 30 seconds

[Timer]
OnBootSec=30s
OnUnitActiveSec=30s
AccuracySec=1s

[Install]
WantedBy=timers.target

Enable and start:

sudo systemctl daemon-reload
sudo systemctl enable --now my-task.timer

OnUnitActiveSec=30s triggers the service 30 seconds after each completion. AccuracySec=1s reduces the default timer coalescing window from 1 minute to 1 second for better precision.

Method 4: watch Command

The watch utility repeats a command at a set interval:

watch -n 30 /path/to/script.sh

This runs your script every 30 seconds and shows the output in the terminal. To run it in the background without a terminal:

nohup watch -n 30 /path/to/script.sh > /dev/null 2>&1 &

Method 5: CronJobPro

CronJobPro supports sub-minute intervals natively. Set the interval to 30 seconds in the dashboard — no sleep tricks, no wrapper scripts, no systemd units. Your task URL or script gets called every 30 seconds with:

• Built-in monitoring and alerting on failure
• Automatic overlap protection — skip or queue if the previous run is still going
• Jitter support to spread load
• Full execution logs with status codes and response times
• No server-side setup required

Comparison Table

When You Actually Need Sub-Minute Scheduling

Before setting up a 30-second schedule, consider whether you truly need it. Common legitimate use cases:

• Health checks — monitoring uptime of critical services
• Queue processing — polling a job queue for new work
• Live data feeds — pulling stock prices, sensor data, or metrics
• Cache warming — refreshing frequently-accessed data
• Log shipping — forwarding logs to a central system

For many tasks, running every minute is sufficient. If your script takes 2 seconds to run and the data doesn't change faster than once per minute, a 30-second schedule just doubles your server load for no benefit.

Preventing Overlapping Runs

When running tasks every 30 seconds, overlapping runs become a real risk. If your script takes 35 seconds, the next invocation starts before the previous one finishes. This can corrupt data, double-send emails, or overload your database.

Option A: flock (file locking)

* * * * * flock -n /tmp/my-task.lock /path/to/script.sh
* * * * * sleep 30 && flock -n /tmp/my-task.lock /path/to/script.sh

The -n flag makes flock exit immediately (non-blocking) if the lock is already held. The second run simply skips if the first is still going.

Option B: PID file

Add this to the top of your script:

#!/bin/bash
PIDFILE="/tmp/my-task.pid"

if [ -f "$PIDFILE" ] && kill -0 $(cat "$PIDFILE") 2>/dev/null; then
  echo "Already running (PID $(cat "$PIDFILE"))"
  exit 0
fi

echo $$ > "$PIDFILE"
trap "rm -f $PIDFILE" EXIT

# Your actual task here
/path/to/actual-work.sh

FAQ