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
- 012026-07-03T16:50:40.000Z
- 022026-07-03T16:50:50.000Z
- 032026-07-03T16:51:00.000Z
- 042026-07-03T16:51:10.000Z
- 052026-07-03T16:51:20.000Z
- 062026-07-03T16:51:30.000Z
- 072026-07-03T16:51:40.000Z
- 082026-07-03T16:51:50.000Z
- 092026-07-03T16:52:00.000Z
- 102026-07-03T16:52:10.000Z
Variations
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:
- Spring
@Scheduled(cron = "*/10 * * * * *")— details in the Spring cron reference and the Spring @Scheduled guide. - Quartz
0/10 * * * * ?— details in the Quartz cron reference.
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.