# Cron Schedule Shortcuts: @daily, @weekly, @hourly, and Where They Work

By Dan Ochoa · Published 2026-11-16 · Updated 2026-11-16
Canonical: https://cronradar.com/blog/cron-schedule-shortcuts

> What @yearly, @monthly, @weekly, @daily, @midnight, @hourly, and @reboot expand to, which cron daemons and schedulers accept them, and the mistakes they invite.

**Cron shortcuts are names for fixed five-field schedules: `@hourly` is `0 * * * *`, `@daily` and `@midnight` are `0 0 * * *`, `@weekly` is `0 0 * * 0`, `@monthly` is `0 0 1 * *`, and `@yearly` and `@annually` are `0 0 1 1 *`.** `@reboot` is different: it isn't a schedule at all, but "once when cron starts at boot." cronie, Debian's cron, BusyBox crond, and Kubernetes accept the scheduling shortcuts; many other schedulers accept none of them or use their own names with different meanings.

This reference covers cronie 1.7, Debian cron 3.0pl1, BusyBox 1.37, systemd's current calendar syntax, Kubernetes CronJobs, Hangfire 1.8, Quartz.NET, Laravel, and GitHub Actions, checked November 16, 2026. For the five fields themselves, see [cron expressions](https://cronradar.com/blog/cron-expression).

## What Each Shortcut Expands To

| Shortcut               | Five-field form | Runs                                 |
| ---------------------- | --------------- | ------------------------------------ |
| `@yearly`, `@annually` | `0 0 1 1 *`     | 00:00 on January 1                   |
| `@monthly`             | `0 0 1 * *`     | 00:00 on the 1st of every month      |
| `@weekly`              | `0 0 * * 0`     | 00:00 every Sunday                   |
| `@daily`, `@midnight`  | `0 0 * * *`     | 00:00 every day                      |
| `@hourly`              | `0 * * * *`     | Minute 0 of every hour               |
| `@reboot`              | none            | Once, when the daemon starts at boot |

Every shortcut fixes the minute at 0 and, except `@hourly`, the hour at 0. There's no shortcut for "every five minutes," "weekdays," or "02:30"; write the fields. A crontab line with a shortcut has no time fields at all:

```text
# crontab -e: shortcut, then the command
@daily /usr/local/bin/rotate-exports

# /etc/crontab and /etc/cron.d: shortcut, user, command
@daily root /usr/local/bin/rotate-exports
```

## Which Implementations Accept Them

| Implementation              | Shortcuts                                                                                                    | Notes                                        |
| --------------------------- | ------------------------------------------------------------------------------------------------------------ | -------------------------------------------- |
| cronie (Fedora, RHEL, Arch) | All of the above, including `@reboot`                                                                        | Standard on Red Hat family systems           |
| Debian and Ubuntu cron      | All of the above, including `@reboot`                                                                        | Vixie cron with Debian patches               |
| BusyBox crond (Alpine)      | All of the above, including `@reboot`                                                                        | Compile-time option, on by default           |
| Kubernetes CronJob          | `@yearly`, `@annually`, `@monthly`, `@weekly`, `@daily`, `@midnight`, `@hourly`                              | No `@reboot`                                 |
| Hangfire 1.8 (Cronos)       | The above plus `@every_minute` and `@every_second`                                                           | `Cron.Weekly()` means Monday                 |
| Quartz.NET                  | None                                                                                                         | Six- or seven-field expressions with seconds |
| Laravel scheduler           | Fluent methods: `->hourly()`, `->daily()`, `->weekly()`, `->monthly()`, `->yearly()`                         | `->weekly()` is Sunday 00:00                 |
| systemd `OnCalendar=`       | Own names, no `@`: `minutely`, `hourly`, `daily`, `weekly`, `monthly`, `yearly`, `quarterly`, `semiannually` | `weekly` means Monday                        |
| GitHub Actions              | None                                                                                                         | Docs say so explicitly                       |

A few of these deserve detail.

**BusyBox.** Shortcut support is the `FEATURE_CROND_SPECIAL_TIMES` build option, described as "Support special times (@reboot, @daily, etc) in crontabs" and on by default ([crond.c](https://github.com/vda-linux/busybox_mirror/blob/1_37_0/miscutils/crond.c#L38-L52)). Its table sets the minute to "0" for every special and gives `@weekly` as `0 0 * * 0`, matching cronie. A custom BusyBox build without the option treats `@daily` as an unparseable line.

**Kubernetes.** The [CronJob documentation](https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/#schedule-syntax) lists the same expansions, with `@weekly` as "midnight on Sunday morning." `@reboot` isn't in the list; a cluster has no boot for a CronJob to follow. The shortcut is read in `.spec.timeZone`, or in the controller's local zone without it.

**Hangfire.** Hangfire 1.8 parses cron with Cronos, and Cronos macros pass straight through `AddOrUpdate`. The trap is the `Cron` helper class: `Cron.Weekly()` returns `0 0 * * 1`, Monday, while `@weekly` means Sunday ([Hangfire cron expressions and time zones](https://cronradar.com/blog/hangfire-cron-time-zones) has the full helper table). `Cron.Daily()`, `Cron.Hourly()`, `Cron.Monthly()`, and `Cron.Yearly()` match the shortcuts.

**Quartz.NET.** Quartz cron expressions start with a seconds field and have no macros, so `@daily` throws a parse error. The equivalent is `0 0 0 * * ?`. [Quartz.NET cron expressions](https://cronradar.com/blog/quartz-net-cron-expressions) covers the format.

**systemd.** The [systemd.time(7)](https://www.freedesktop.org/software/systemd/man/latest/systemd.time.html) shorthands are written without `@` and normalize to calendar events: `daily` to `*-*-* 00:00:00`, `weekly` to `Mon *-*-* 00:00:00`, `monthly` to `*-*-01 00:00:00`. Moving `@weekly` from a crontab to `OnCalendar=weekly` moves the run from Sunday to Monday. `systemd-analyze calendar weekly` prints the normalized form and the next run.

**GitHub Actions.** The workflow docs state that "GitHub Actions does not support the non-standard syntax `@yearly`, `@monthly`, `@weekly`, `@daily`, `@hourly`, and `@reboot`." Write the fields in `on.schedule.cron`.

When you aren't sure what a library accepts, write the five fields. `0 0 * * *` is accepted everywhere five-field cron is, and nobody has to remember which day `@weekly` means.

## Translating a Shortcut to Another Scheduler

When a job moves from a crontab to another scheduler, translate what the shortcut means, not its name. These keep the crontab meaning, including Sunday for `@weekly`:

| Crontab    | systemd `OnCalendar=` | Quartz.NET      | Hangfire                           | Laravel       |
| ---------- | --------------------- | --------------- | ---------------------------------- | ------------- |
| `@hourly`  | `hourly`              | `0 0 * * * ?`   | `Cron.Hourly()`                    | `->hourly()`  |
| `@daily`   | `daily`               | `0 0 0 * * ?`   | `Cron.Daily()`                     | `->daily()`   |
| `@weekly`  | `Sun *-*-* 00:00:00`  | `0 0 0 ? * SUN` | `"0 0 * * 0"`, not `Cron.Weekly()` | `->weekly()`  |
| `@monthly` | `monthly`             | `0 0 0 1 * ?`   | `Cron.Monthly()`                   | `->monthly()` |
| `@yearly`  | `yearly`              | `0 0 0 1 1 ?`   | `Cron.Yearly()`                    | `->yearly()`  |

Quartz.NET needs `?` in one of the two day fields, which is why the weekly row puts it in day-of-month. Each of these still runs in its own scheduler's zone, so a translation can be correct and still move the run by hours; check the zone along with the expression.

## Pitfalls

### Every @daily Job Runs at Midnight

A shortcut picks 00:00 for you, so every `@daily` job on a host, and often every host in a fleet, starts at the same second. That's when backups, log rotation, certificate renewals, and report builds all compete for the same database, disk, and API quotas, and when a shared upstream sees its traffic spike. Pick a deliberate minute instead, such as `17 2 * * *`; [spreading cron jobs away from midnight](https://cronradar.com/blog/cron-midnight-load-spreading) covers fixed offsets and random delays.

### Midnight in Which Zone?

A shortcut says nothing about the zone. `@daily` on a server set to UTC runs at 00:00 UTC, which is 19:00 or 20:00 the previous evening in New York. That matters when a "daily" job is supposed to process "yesterday": run at local midnight, the job and the business agree on the date; run at UTC midnight, they may not. [Cron time zones](https://cronradar.com/blog/cron-timezone) covers how each daemon picks its zone.

Midnight is also a daylight saving boundary in a few zones that change the clock at 00:00 rather than 02:00, where `@daily` can be skipped or repeated on transition nights. [Cron and daylight saving time](https://cronradar.com/blog/cron-daylight-saving-time) explains what each scheduler does.

### @weekly and Day Numbering

`@weekly` is Sunday in crontab, Kubernetes, BusyBox, and Cronos, but Hangfire's `Cron.Weekly()` and systemd's `weekly` are Monday. Laravel's `->weekly()` is Sunday at 00:00. A job ported between them can move a day without any expression changing visibly, so check the next run times after a migration.

### @reboot Isn't a Schedule

`@reboot` runs once per boot, when the daemon first starts, and never again until the next boot; restarting the cron service doesn't trigger it. It has no recurring time, so nothing can say when it's "due," and the job usually starts before the network or mounts are ready. [@reboot in cron](https://cronradar.com/blog/cron-reboot) covers how each daemon implements it and the systemd units that replace it.

### A Shortcut Doesn't Take Arguments

`@daily 30` doesn't mean "daily at :30"; cron reads `30` as the command. And a shortcut doesn't combine with fields: there's no `@daily` on weekdays. Anything beyond the six fixed schedules needs the full expression.

## Monitoring a Job Scheduled With a Shortcut

A heartbeat monitor needs the same schedule the job uses. CronRadar accepts `@yearly`, `@annually`, `@monthly`, `@weekly`, `@daily`, `@midnight`, and `@hourly` wherever it takes a schedule and stores each in its five-field form, so `@weekly` shows as `0 0 * * 0`, Sunday. `@reboot` is rejected, because there's no recurring time to expect a run at. [Schedule syntax](https://docs.cronradar.com/schedules) lists every accepted form.

For a crontab job, send the schedule with the first report so it creates the monitor. A wrapper script avoids cron's `%` handling on the command line:

```sh
#!/bin/sh
# /usr/local/bin/rotate-exports-monitored: run the rotation and report it to CronRadar.
# The key lives in a file only this account can read, not in the crontab.
CRONRADAR_API_KEY=$(cat /etc/cronradar/api-key 2>/dev/null)
run_id="rotate-exports-$(date +%s)-$$"

report() {
  event=$1
  shift
  curl --fail --silent --show-error --max-time 5 --output /dev/null \
    --request POST --get --user "$CRONRADAR_API_KEY:" \
    --data-urlencode "schedule=@daily" \
    --data-urlencode "run_id=$run_id" \
    "$@" "https://cron.life/api/v1/ping/rotate-exports/$event" || true
}

report start
/usr/local/bin/rotate-exports
rc=$?
if [ "$rc" -eq 0 ]; then
  report complete
else
  report fail --data-urlencode "message=rotate-exports exited with code $rc"
fi
exit "$rc"
```

The crontab line becomes `@daily /usr/local/bin/rotate-exports-monitored`. CronRadar reads the schedule in the application's time zone, an IANA name set in the application's settings (UTC when unset), so set it to the server's zone or the `@daily` means a different midnight. After midnight plus the grace period with no report, the monitor goes from `warning` to `critical` and alerts; a `fail` report alerts immediately.

Framework integrations read the schedule from the scheduler itself: [Hangfire](https://cronradar.com/hangfire), [Laravel](https://cronradar.com/laravel), [Celery](https://cronradar.com/celery), and [Quartz.NET](https://cronradar.com/quartz) jobs are discovered with their schedules, so a `Cron.Daily()` or `->daily()` job needs no schedule written twice.

## Frequently Asked Questions

### What does @daily mean in cron?

`@daily` is `0 0 * * *`: once a day at 00:00 in the cron daemon's time zone. `@midnight` is a synonym. If you want another hour, write the fields, such as `30 2 * * *` for 02:30.

### What day does @weekly run?

In crontab, BusyBox, Kubernetes, and Hangfire's Cronos parser, `@weekly` is `0 0 * * 0`, Sunday at 00:00. systemd's `weekly` and Hangfire's `Cron.Weekly()` helper mean Monday, so check which one a scheduler uses.

### Is @hourly the same as 0 \* \* \* \*?

Yes. `@hourly` runs at minute 0 of every hour. For another minute, such as quarter past, write `15 * * * *`.

### Do Kubernetes CronJobs support @daily?

Yes. Kubernetes accepts `@yearly`, `@annually`, `@monthly`, `@weekly`, `@daily`, `@midnight`, and `@hourly`, read in `.spec.timeZone` or the controller's local zone. It doesn't accept `@reboot`.

### Can I monitor an @reboot job?

Not with a schedule-based check, because `@reboot` has no recurring time to expect. CronRadar rejects `@reboot` as a schedule. Monitor the recurring work the boot job starts, or replace it with a systemd unit, as [@reboot in cron](https://cronradar.com/blog/cron-reboot) describes.
