cronuru
Pattern

Every 10 Seconds

*/10 * * * * *
0/10 * * * * ?

Runs every 10 seconds. Requires a seconds-aware dialect — Spring or Quartz — because standard Unix cron is minute-precision only.

Use in your stack

{
  "schedule": {
    "cron": "0/10 * * * * ?",
    "timezone": "UTC"
  }
}
// 6-field: second minute hour day-of-month month day-of-week
@Scheduled(cron = "*/10 * * * * *")
public void everyTenSeconds() {
    // ...
}

// Simpler for pure intervals:
@Scheduled(fixedRate = 10000) // milliseconds
public void everyTenSecondsFixedRate() {
    // ...
}

Next runs

Pick a timezone to see when this expression fires next.

Next 10 runs
  1. 012026-07-03T16:50:40.000Z
  2. 022026-07-03T16:50:50.000Z
  3. 032026-07-03T16:51:00.000Z
  4. 042026-07-03T16:51:10.000Z
  5. 052026-07-03T16:51:20.000Z
  6. 062026-07-03T16:51:30.000Z
  7. 072026-07-03T16:51:40.000Z
  8. 082026-07-03T16:51:50.000Z
  9. 092026-07-03T16:52:00.000Z
  10. 102026-07-03T16:52:10.000Z

Variations

*/5 * * * * *

Every 5 seconds

*/30 * * * * *

Every 30 seconds

0 * * * * *

Every minute (Spring)

Common use cases

  • Polling a job queue or webhook backlog on a tight loop.
  • Refreshing a near-real-time cache or leaderboard.
  • Sampling a sensor or metric at 6× per minute.
  • Retrying a flaky downstream call at a short, fixed cadence.

Gotchas

  • **Unix crontab cannot do this.** The 5-field format has no seconds field; its minimum interval is one minute. Kubernetes CronJob and GitHub Actions share that limit.
  • In Spring, `*/10 * * * * *` is the 6-field form (seconds first) — not to be confused with Unix's `*/10 * * * *`, which means every 10 *minutes*.
  • In Quartz, use `0/10 * * * * ?` — `0/10` in the seconds field means "from second 0, every 10 seconds," and `?` fills the unused day-of-week field.
  • For a fixed interval like this, `@Scheduled(fixedRate = 10000)` (Spring) or `tokio::time::interval` (Rust) is usually simpler than a cron expression.
  • Watch for overlap: if a run can exceed 10 seconds, use `fixedDelay` or an in-flight guard so invocations don't stack.

Unix cron starts at minutes — five fields, no seconds — so “every 10 seconds” can’t be written as a classic crontab line. The tightest standard cron gets is once per minute.

For sub-minute schedules, reach for a 6-field, seconds-first dialect:

For a plain fixed interval, a timer beats a cron parser: Spring’s @Scheduled(fixedRate = 10000) or Rust’s tokio::time::interval(Duration::from_secs(10)) both say “every 10 seconds” more directly.

Frequently asked questions

What is the cron expression for every 10 seconds?
In a seconds-aware dialect, every 10 seconds is `*/10 * * * * *` (Spring) or `0/10 * * * * ?` (Quartz). Standard Unix/crontab cannot do it — it has no seconds field, so its finest granularity is one minute.
Why doesn't `*/10 * * * *` run every 10 seconds?
`*/10 * * * *` is a 5-field Unix expression whose first field is minutes, so it runs every 10 *minutes*. Unix cron has no seconds field. Every 10 seconds requires a 6-field dialect where the first field is seconds — Spring (`*/10 * * * * *`) or Quartz (`0/10 * * * * ?`).
How do I run something every 10 seconds in Spring Boot?
Use `@Scheduled(cron = "*/10 * * * * *")`, or more simply `@Scheduled(fixedRate = 10000)` (milliseconds). Use `fixedDelay = 10000` if each run should wait for the previous one to complete before the timer restarts.
Can Kubernetes CronJob run a job every 10 seconds?
No — Kubernetes CronJob uses standard 5-field cron with a one-minute minimum. For sub-minute intervals, run a long-lived Deployment with an internal loop or a language-level timer instead of a CronJob.

Browse all cron patterns

Every schedule Cronuru documents, with its expression and code snippets for six dialects.