---
title: How to create schedules
sidebarTitle: Create Deployment Schedules
description: Learn how to create schedules for your deployments.
---

There are several ways to create a schedule for a deployment:

- Through the Prefect UI
- With the `cron`, `interval`, or `rrule` parameters if building your deployment with the
[`serve` method](/v3/how-to-guides/deployment_infra/run-flows-in-local-processes#serve-a-flow) of the `Flow` object or
[the `serve` utility](/v3/how-to-guides/deployment_infra/run-flows-in-local-processes#serve-multiple-flows-at-once) for managing multiple flows simultaneously
- If using [worker-based deployments](/v3/deploy/infrastructure-concepts/workers/)
  - When you define a deployment with `flow.serve` or `flow.deploy`
  - Through the interactive `prefect deploy` command
  - With the `deployments` -> `schedules` section of the `prefect.yaml` file

### Create schedules in the UI

You can add schedules in the **Schedules** section of a **Deployment** page in the UI.
To add a schedule select the **+ Schedule** button.
Choose **Interval** or **Cron** to create a schedule.

<Note>
**What about RRule?**
The UI does not support creating RRule schedules.
However, the UI will display RRule schedules that you've created through the command line.
</Note>

The new schedule appears on the **Deployment** page where you created it.
New scheduled flow runs are visible in the **Upcoming** tab of the **Deployment** page.

To edit an existing schedule, select **Edit** from the three-dot menu next to a schedule on a **Deployment** page.

### Create schedules in Python

Specify the schedule when you create a deployment in a Python file with `flow.serve()`, `serve`, `flow.deploy()`, or `deploy`.
Just add the keyword argument `cron`, `interval`, or `rrule`.

| Argument    | Description                                                                                                                                                                                                                                           |
| ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `interval`  | An interval on which to execute the deployment. Accepts a number or a timedelta object to create a single schedule. If a number is given, it is interpreted as seconds. Also accepts an iterable of numbers or timedelta to create multiple schedules.|
| `cron`      | A cron schedule string of when to execute runs of this deployment. Also accepts an iterable of cron schedule strings to create multiple schedules.                                                                                                    |
| `rrule`     | An rrule schedule string of when to execute runs of this deployment. Also accepts an iterable of rrule schedule strings to create multiple schedules.                                                                                                 |
| `schedules` | A list of schedule objects defining when to execute runs of this deployment. Used to define multiple schedules or additional scheduling options such as `timezone`.                                                                                   |
| `schedule`  | A schedule object defining when to execute runs of this deployment. Used to define additional scheduling options such as `timezone`.                                                                                                                  |
| `slug`      | An optional unique identifier for the schedule containing only lowercase letters, numbers, and hyphens. If not provided for a given schedule, the schedule will be unnamed.                                                                           |

The `serve` method below will create a deployment of `my_flow` with a cron schedule that creates runs every minute of every day:

```python
from prefect import flow

from myproject.flows import my_flow

my_flow.serve(name="flowing", cron="* * * * *")
```

If using deployments with [dynamic infrastructure](/v3/deploy/infrastructure-concepts/work-pools), the `deploy` method has the same schedule-based parameters.

When `my_flow` is served with this interval schedule, it will run every 10 minutes beginning at midnight on January, 1, 2026 in the `America/Chicago` timezone:

<CodeGroup>
```python prefect >= 3.1.16
from datetime import timedelta, datetime
from prefect.schedules import Interval

from myproject.flows import my_flow

my_flow.serve(
  name="flowing",
  schedule=Interval(
    timedelta(minutes=10),
    anchor_date=datetime(2026, 1, 1, 0, 0),
    timezone="America/Chicago"
  )
)
```

```python prefect < 3.1.16
from datetime import timedelta, datetime
from prefect.client.schemas.schedules import IntervalSchedule

from myproject.flows import my_flow

my_flow.serve(
  name="flowing",
  schedules=[
    IntervalSchedule(
      interval=timedelta(minutes=10),
      anchor_date=datetime(2026, 1, 1, 0, 0),
      timezone="America/Chicago"
    )
  ]
)
```

</CodeGroup>


<Tip>
Keyword arguments for schedules are also accepted by the `to_deployment` method that converts a flow to a deployment.
</Tip>

### Create schedules with the CLI

You can create a schedule through the interactive `prefect deploy` command. You will be prompted to choose which type of schedule to create.

You can also create schedules for existing deployments using the `prefect deployment schedule create` command. This command allows you to specify schedule details directly without going through the interactive flow.

<Note>
By default `prefect deployment schedule create` adds _additional_ schedules to your deployment.
Use the `--replace` flag to remove old schedules and update with the new one.
</Note>

**Examples:**

Create a cron schedule that runs every day at 9 AM:
```bash
prefect deployment schedule create my-deployment --cron "0 9 * * *"
```

Create an interval schedule that runs every 30 minutes:
```bash
prefect deployment schedule create my-deployment --interval 1800
```

Create a schedule with a specific timezone:
```bash
prefect deployment schedule create my-deployment --cron "0 9 * * *" --timezone "America/New_York"
```

Replace all existing schedules with a new one:
```bash
prefect deployment schedule create my-deployment --cron "0 9 * * *" --replace
```

### Create schedules in YAML

If you save the `prefect.yaml` file from the `prefect deploy` command, you will see it has a `schedules` section for your deployment.
Alternatively, you can create a `prefect.yaml` file from a recipe or from scratch and add a `schedules` section to it.

```yaml
deployments:
  ...
  schedules:
    - cron: "0 0 * * *"
      slug: "chicago-schedule"
      timezone: "America/Chicago"
      active: false
    - cron: "0 12 * * *"
      slug: "new-york-schedule"
      timezone: "America/New_York"
      active: true
    - cron: "0 18 * * *"
      slug: "london-schedule"
      timezone: "Europe/London"
      active: true
```

### Create schedules with Terraform

import { TF } from "/snippets/resource-management/terraform.mdx"
import { deployments } from "/snippets/resource-management/vars.mdx"

<TF name="schedules" href={deployments.tf} />


## Associate parameters with schedules
Using any of the above methods to create a schedule, you can bind parameters to your schedules.

For example, say you have a flow that sends an email.
Every day at 8:00 AM you want to send a message to one recipient, and at 8:05 AM you want to send a different message to another recipient.

Instead of creating independent deployments with different default parameters and schedules, you can bind parameters to the schedules themselves:

### Schedule parameters in Python

Whether using `.serve` or `.deploy`, you can pass `parameters` to your deployment `schedules`:

{/* pmd-metadata: notest */}
```python send_email_flow.py {13,17-20}
from prefect import flow
from prefect.schedules import Cron

@flow
def send_email(to: str, message: str = "Stop goofing off!"):
    print(f"Sending email to {to} with message: {message}")

send_email.serve(
  name="my-flow",
  schedules=[
    Cron(
      "0 8 * * *",
      slug="jim-email",
      parameters={"to": "jim.halpert@dundermifflin.com"}
    ),
    Cron(
      "5 8 * * *",
      slug="dwight-email",
      parameters={
        "to": "dwight.schrute@dundermifflin.com",
        "message": "Stop goofing off! You're assistant _to_ the regional manager!"
      }
    )
  ]
)
```
Note that our flow has a default `message` parameter, but we've overridden it for the second schedule.

This deployment will schedule runs that:

- Send "Stop goofing off!" to Jim at 8:00 AM every day
- Send "Stop goofing off! You're assistant _to_ the regional manager!" to Dwight at 8:05 AM every day

<Tip>
Use the same pattern to bind parameters to any schedule type in `prefect.schedules`.
You can provide one schedule via the `schedule` kwarg or multiple schedules via `schedules`.
</Tip>

### Schedule parameters in `prefect.yaml`

You can also provide parameters to schedules in your `prefect.yaml` file.

```yaml prefect.yaml {4-11}
deployments:
  name: send-email
  entrypoint: send_email_flow.py:send_email
  schedules:
    - cron: "0 8 * * *"
      slug: "jim-email"
      parameters:
        to: "jim.halpert@dundermifflin.com"
    - cron: "5 8 * * *"
      slug: "dwight-email"
      parameters:
        to: "dwight.schrute@dundermifflin.com"
        message: "Stop goofing off! You're assistant _to_ the regional manager!"
```

## See also

- [Manage deployment schedules](/v3/how-to-guides/deployments/manage-schedules) - Learn how to pause and resume deployment schedules
- [Schedules concept](/v3/concepts/schedules) - Deep dive into schedule types and options
- [Deployments](/v3/concepts/deployments) - Learn more about deployments
