Will Your Timer Ever Fire?
Paste an OnCalendar expression. The validator says whether it parses, shows the form systemd would print, and names the exact reason when it does not. It runs entirely in your browser: nothing you paste leaves the page.
The page says where its answers are approximations.
Check an expression
Paste an OnCalendar expression below. The validator reads it in your browser, says whether it parses, shows the normalized form, and names the specific fault when it does not parse. It never uploads the paste.
Or load a sample, each one checked against the real binary:
## Check a whole timer file Paste a .timer unit file and the validator checks every OnCalendar line in it, with line numbers, plus the notes systemd-analyze verify would add. It cannot check that the named service exists, and it says so rather than pretending.What systemd-analyze will not tell you
The built-in check already validates, normalizes, and computes the next elapse. Run systemd-analyze calendar on an expression and it prints the normalized form and the next time it fires. The gap is not validation. The gap is explanation.
Every invalid expression fails the same way. systemd-analyze calendar exits 1 and prints Failed to parse calendar specification ...: Invalid argument. It does not say which part broke. An hour of 25, a month of 13, a reversed weekday range, and a plain English word all produce that one line. This page exists to name the fault: hour 25 is out of range, month 13 is out of range, Fri..Mon is a reversed range, Fridays is not a weekday name.
The second gap is the silent pass. Some expressions parse cleanly and still never fire. The built-in prints Next elapse: never for those, but nothing in the output explains that never is a trap rather than a normal result. The two traps below are the cases that cost people the most time.
The two traps
The past one-shot trap is a fully-dated expression in the past. 2026-11-06 04:00:00 parses with exit code 0. Its next elapse is never, because that moment is gone and a fully-dated expression fires exactly once. A timer built on it will sit enabled forever and never run its service. The fix is to drop the date and keep the time, so the expression recurs: *-*-* 04:00:00 fires every day at 04:00.
The past-year trap is subtler. A two-digit field at the front of a date is read as a year, not a month. 12-*-* means the year 2012, so it normalized to 2012-*-* and never fires. The manual page example Mon,Sun 12-*-* 2,1:23 normalizes to Mon,Sun 2012-*-* 01,02:23:00, and that form also never fires. If you meant December, write the month in the middle: *-12-*. Two-digit years pivot at 69 and 70: 69 means 2069, 70 means 1970. Three-digit years are rejected outright.
A third case looks like a trap but is not an error. February 30 and April 31 parse fine and never fire, because those dates never occur. systemd accepts the expression and reports no next elapse. February 29 is different: it fires in leap years, next on 2028-02-29. The validator flags all three shapes as valid but never firing, with the reason named.
Shorthands and their real forms
systemd accepts nine shorthand words. Each one expands to an explicit form, and the explicit form is the one worth keeping in a unit file, because it says what the timer does without making the reader look the word up.
- minutely means every minute:
*-*-* *:*:00 - hourly means the top of every hour:
*-*-* *:00:00 - daily means midnight every day:
*-*-* 00:00:00 - monthly means midnight on the first of the month:
*-*-01 00:00:00 - weekly means midnight on Monday:
Mon *-*-* 00:00:00 - yearly and annually both mean midnight on January 1:
*-01-01 00:00:00 - quarterly means midnight on the first of January, April, July, and October:
*-01,04,07,10-01 00:00:00 - semiannually means midnight on the first of January and July:
*-01,07-01 00:00:00
A timezone can follow a shorthand or an explicit form: daily UTC and weekly Pacific/Auckland are both valid. The zone has to be a name the system knows. UTC, CET, Europe/Berlin, and America/Toronto all work. An offset such as +05:30 and a bare Z do not work after a calendar expression, and an invented zone such as Mars/Olympus fails too.
The rules the validator checks
Weekday names are the full English name or the three-letter abbreviation, and case does not matter: MONDAY, Monday, and Mon are the same day. Thurs and Tues are not accepted. Lists and ranges combine freely: Sat,Thu,Mon..Wed,Sat..Sun normalizes to Mon..Thu,Sat,Sun. A two-day run stays as two names, so Mon..Tue normalizes to Mon,Tue, while three or more days merge into a range. Weekday ranges run Monday to Sunday and cannot wrap past Sunday, so Fri..Mon and Sun..Sat both fail. A single dash between two weekday names is a range too: Mon-Fri means Mon..Fri.
Hours run 0 to 23. There is no 24:00, so midnight is 00:00, not the end of the day. Minutes and seconds run 0 to 59, so a second of 60 fails. Months run 1 to 12, days run 1 to 31, and a day of 0 or 32 fails. Seconds can carry a fraction down to microseconds: 00.5 becomes 00.500000. Parts you leave out get defaults: no seconds means :00, no time means midnight, no date means every day, and a bare time such as 08:00 means every day at 08:00.
The last-day marker ~ counts back from the end of the month and attaches to the month with no dash: *-02~03 is the third-last day of February, and Mon *-05~07/1 is the last Monday in May. A ~ standing alone as a day, as in *-*-~3, is rejected.
What this page cannot check
This page is a JavaScript approximation of systemd's rules, and it labels the places where approximation ends.
The next-elapse time is an approximation computed in your browser. It is right for the expressions this page covers in your local time zone and in UTC. For any other named zone, such as Europe/Berlin, the page shows the expression as valid with its normalized form but does not compute a next elapse, because that math needs the system timezone database and daylight-saving rules. Run systemd-analyze calendar for the exact time.
The timer-file check cannot confirm that the named service exists. systemd-analyze verify itself returns success for a timer whose Unit= names a missing service, so the page states that plainly instead of claiming a check it cannot do. Confirm the name with systemctl cat on the machine that owns the files. The page also cannot check that the ExecStart= binary in the paired service exists, because it has no filesystem to look at. Only the real systemd-analyze verify on that machine performs that check, and the page says so on every timer-file result.
A timer with no AccuracySec= fires somewhere inside a one-minute window starting at the scheduled time. That is the default, and it surprises people who expect second-exact firing. Set AccuracySec=1us in the unit for the tightest timing. A timer with no Persistent= does not catch up on missed runs: if the machine was off when the timer should have fired, that run is skipped.
How to check for real
The verdict that counts comes from the machine itself. For one expression:
systemd-analyze calendar 'Mon *-*-* 09:00:00'
Add --iterations=3 to see the next three elapses, or --base-time="2026-11-06 04:00:00" to anchor the calculation at a chosen moment instead of now. For a timer and service pair:
systemd-analyze verify my.timer my.service
That command reports a bad OnCalendar= with the file and line number, refuses the unit, and checks that the ExecStart= binary exists and is executable. It does not catch a Unit= that names a missing service, so check that name separately.
Frequently asked questions
Does this page send my expression anywhere? No. The validator is client-side JavaScript. Your paste stays in your browser tab and is never uploaded, logged, or sent to any server.
My expression is valid but the timer never fires. Why?
The usual cause is a date in the past. A fully-dated expression such as 2026-11-06 04:00:00 parses fine, but once that moment is gone there is no next elapse, so the timer never fires. A two-digit year-looking field is the same trap: 12-*-* means 2012, not December. Check the date first, then check AccuracySec and Persistent on the timer unit.
Why does systemd say Invalid argument with no reason?
That is all the detail systemd-analyze calendar gives for a bad expression. It exits 1 and prints the same generic message whether the hour is 25, the month is 13, or the weekday range is reversed. This page diagnoses the specific fault instead.
Can this page prove my timer works?
No. This page approximates systemd's rules in JavaScript and labels its next-elapse time as an approximation. The proof is systemd-analyze calendar for the expression and systemd-analyze verify for the timer and service files, run on the machine that owns them.
What does Next elapse: never mean? It means the expression parses but matches no future time. The common cases are a fully-dated moment in the past, a year in the past, and a date that never occurs, such as February 30. The expression is valid; it simply never fires.
Sources
- systemd.time(7) — Linux manual page — calendar-event syntax, the shorthand table, normalization examples, the last-day marker, and the pointer to
systemd-analyze calendar. Read fresh 2026-11-07, systemd 262~devel. - systemd.timer(5) — Linux manual page —
OnCalendar=, theAccuracySec=default of 1min,Persistent=,Unit=,WakeSystem=, andRemainAfterElapse=. Read fresh 2026-11-07, systemd 262~devel.DeferReactivation=(added in 257) andRandomizedOffsetSec=(added in 258) are newer than the probe machine and are not covered here. - systemd-analyze(1) — Linux manual page — the
calendarverb (parse, normalize, next elapse) and theverifyverb (the errors it detects, includingExecStart=binaries not found or not executable). Read fresh 2026-11-07, systemd 262~devel.
Keep Exploring
Seven tips and seven puzzles so far, each one a short runnable example with the fix explained.
Paste a [Service] section and get a plain-language verdict on every sandboxing setting it finds.
Paste sshd -G output and get a hardening verdict on the values your server actually runs.
Paste an AddressSanitizer, UBSan, or ThreadSanitizer report and get the bug, the file and line, and the fix — in plain language.
Paste a systemd timer expression and get the specific reason it fails, the normalized form, and the past-date traps the built-in check hides.