EventBridge Scheduler

Introduction

EventBridge Scheduler is a serverless scheduler that lets you invoke AWS services on a schedule. You can create one-time schedules that run at a specific time, and recurring schedules that run at a fixed rate or on a cron expression. Each schedule delivers a payload to a target, such as an SQS queue, a Lambda function, or a Step Functions state machine.

LocalStack allows you to use the Scheduler APIs in your local environment to create and manage schedules and schedule groups. LocalStack runs your schedules and delivers them to their targets, and provides an endpoint to fire a schedule immediately for testing. The supported APIs are available on our API Coverage section, which provides information on the extent of EventBridge Scheduler’s integration with LocalStack.

Getting started

This guide is designed for users new to EventBridge Scheduler and assumes basic knowledge of the AWS CLI and our lstk aws command.

Start your LocalStack container using your preferred method. The following steps show you how to create a schedule that sends a message to an SQS queue, fire it immediately, and receive the message.

Create an SQS queue

You can create a new SQS queue using the CreateQueue API. Run the following command to create a queue that receives the scheduled messages:

lstk aws sqs create-queue --queue-name local-notifications

Output

{
    "QueueUrl": "http://sqs.us-east-1.localhost.localstack.cloud:4566/000000000000/local-notifications"
}

You can fetch the Queue ARN using the GetQueueAttributes API. Run the following command to fetch the Queue ARN by specifying the Queue URL:

lstk aws sqs get-queue-attributes \
    --queue-url http://sqs.us-east-1.localhost.localstack.cloud:4566/000000000000/local-notifications \
    --attribute-names QueueArn

Output

{
    "Attributes": {
        "QueueArn": "arn:aws:sqs:us-east-1:000000000000:local-notifications"
    }
}

Save the Queue ARN for later use.

Create an execution role

EventBridge Scheduler assumes an execution role to deliver to the target. Create a file named trust-policy.json that allows the scheduler.amazonaws.com service principal to assume the role:

trust-policy.json

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "scheduler.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

Run the following command to create the role using the CreateRole API:

lstk aws iam create-role \
    --role-name scheduler-role \
    --assume-role-policy-document file://trust-policy.json

Output

{
    "Role": {
        "Path": "/",
        "RoleName": "scheduler-role",
        "RoleId": "AROAQAAAAAAAGNRMDKSAO",
        "Arn": "arn:aws:iam::000000000000:role/scheduler-role",
        "CreateDate": "2026-10-07T10:00:00.000000+00:00",
        "AssumeRolePolicyDocument": {
            "Version": "2012-10-17",
            "Statement": [
                {
                    "Effect": "Allow",
                    "Principal": {
                        "Service": "scheduler.amazonaws.com"
                    },
                    "Action": "sts:AssumeRole"
                }
            ]
        }
    }
}

Note

This role has a trust policy but no permissions, which is enough while IAM policy enforcement is disabled (the default). With ENFORCE_IAM=1, CreateSchedule rejects a role that EventBridge Scheduler cannot assume, and the role needs permission to call the target, such as sqs:SendMessage, as on AWS.

Create a schedule

You can create a new schedule using the CreateSchedule API. Run the following command to create a one-time schedule that sends a message to the queue on January 1, 2030:

lstk aws scheduler create-schedule \
    --name sqs-schedule \
    --schedule-expression 'at(2030-01-01T00:00:00)' \
    --target '{"RoleArn": "arn:aws:iam::000000000000:role/scheduler-role", "Arn": "arn:aws:sqs:us-east-1:000000000000:local-notifications", "Input": "Hello from EventBridge Scheduler"}' \
    --flexible-time-window '{"Mode": "OFF"}'

Output

{
    "ScheduleArn": "arn:aws:scheduler:us-east-1:000000000000:schedule/default/sqs-schedule"
}

Trigger the schedule

Instead of waiting for the scheduled time, you can fire the schedule immediately using the LocalStack trigger endpoint. Run the following command to trigger the schedule:

curl -X POST \
    http://localhost.localstack.cloud:4566/_aws/scheduler/schedules/arn:aws:scheduler:us-east-1:000000000000:schedule/default/sqs-schedule/trigger

Output

{"ScheduleArn": "arn:aws:scheduler:us-east-1:000000000000:schedule/default/sqs-schedule", "ExecutionId": "1f7c0d5e-6f2b-4a5e-9d63-2b1c4e8f0a7d"}

Receive the message

You can receive the message that the schedule delivered using the ReceiveMessage API:

lstk aws sqs receive-message \
    --queue-url http://sqs.us-east-1.localhost.localstack.cloud:4566/000000000000/local-notifications

Output

{
    "Messages": [
        {
            "MessageId": "6c1f5b0e-3a4d-4b8e-9f0a-2d7e1c9b8a63",
            "ReceiptHandle": "...",
            "MD5OfBody": "908bf5b73d416d19188915bdd7f4eb26",
            "Body": "Hello from EventBridge Scheduler"
        }
    ]
}

List all schedules

You can list all schedules using the ListSchedules API. Run the following command to list all schedules:

lstk aws scheduler list-schedules

Output

{
    "Schedules": [
        {
            "Arn": "arn:aws:scheduler:us-east-1:000000000000:schedule/default/sqs-schedule",
            "CreationDate": "2026-10-07T10:00:05.123000+00:00",
            "GroupName": "default",
            "LastModificationDate": "2026-10-07T10:00:05.123000+00:00",
            "Name": "sqs-schedule",
            "State": "ENABLED",
            "Target": {
                "Arn": "arn:aws:sqs:us-east-1:000000000000:local-notifications"
            }
        }
    ]
}

Tag a schedule group

EventBridge Scheduler supports tags on schedule groups, not on individual schedules. Run the following command to create a schedule group using the CreateScheduleGroup API:

lstk aws scheduler create-schedule-group --name my-group

Output

{
    "ScheduleGroupArn": "arn:aws:scheduler:us-east-1:000000000000:schedule-group/my-group"
}

You can tag the schedule group using the TagResource API:

lstk aws scheduler tag-resource \
    --resource-arn arn:aws:scheduler:us-east-1:000000000000:schedule-group/my-group \
    --tags Key=Name,Value=Test

You can view the tags associated with the schedule group using the ListTagsForResource API:

lstk aws scheduler list-tags-for-resource \
    --resource-arn arn:aws:scheduler:us-east-1:000000000000:schedule-group/my-group

Output

{
    "Tags": [
        {
            "Key": "Name",
            "Value": "Test"
        }
    ]
}

Supported targets

LocalStack delivers to the following templated targets:

• Amazon SQS
• Amazon SNS
• AWS Lambda
• Amazon EventBridge
• Amazon Kinesis
• AWS Step Functions
• Amazon Data Firehose
• Amazon ECS
• AWS CodePipeline

LocalStack also delivers to universal targets.

Note

LocalStack does not yet deliver to CodeBuild, SageMaker, or Amazon Inspector templated targets. LocalStack accepts schedules with these targets, but logs a warning and delivers nothing when they fire.

ECS and CodePipeline targets require a plan that includes ECS and CodePipeline. Without it, LocalStack logs a warning and delivers nothing when these schedules fire.

Triggering a schedule

LocalStack provides the /_aws/scheduler/schedules/<schedule-arn>/trigger endpoint to fire a schedule immediately, without waiting for its scheduled time. This is useful in tests, where the minimum rate of one minute would otherwise slow down your test suite.

Send a POST request with the full ARN of the schedule:

curl -X POST \
    http://localhost.localstack.cloud:4566/_aws/scheduler/schedules/arn:aws:scheduler:us-east-1:000000000000:schedule/default/sqs-schedule/trigger

The endpoint delivers to the target before it responds, and returns the ARN of the schedule and the ID of the execution:

Output

{"ScheduleArn": "arn:aws:scheduler:us-east-1:000000000000:schedule/default/sqs-schedule", "ExecutionId": "1f7c0d5e-6f2b-4a5e-9d63-2b1c4e8f0a7d"}

The trigger endpoint behaves as follows:

• It fires the schedule even if the schedule is disabled.
• Triggering a one-time schedule consumes its single firing, so the schedule does not fire again at its scheduled time.
• Triggering a recurring schedule does not change when it fires next.
• If the delivery fails, the endpoint still returns 200 and includes an Error object with the Code and Message of the failure. If the target has a dead-letter queue, LocalStack also sends the failed request there.
• For a target that LocalStack does not deliver to, the endpoint returns 200 without an Error object and delivers nothing. Check the LocalStack logs for the warning.
• It returns 400 for an invalid ARN, and 404 if the schedule does not exist.

Current Limitations

• LocalStack ignores the FlexibleTimeWindow and fires every schedule at its exact scheduled time.
• LocalStack makes a single delivery attempt and does not retry a failed delivery. A failed delivery goes to the dead-letter queue right away, with the RETRY_ATTEMPTS attribute set to 0.
• LocalStack accepts cron expressions that use # in the day-of-week field or W in the day-of-month field, but such schedules never fire.
• LocalStack does not replay recurring firings missed while it was stopped or while the host was asleep. The schedule resumes at its next occurrence.
• A one-time schedule whose time passed while LocalStack was stopped fires once when LocalStack starts or loads the saved state. A one-time schedule that already fired does not fire again.

API Coverage

12 of 12 operations implemented

Available from the Hobby plan. Licensing details

Formats for tools and AIPage MarkdownCoverage MarkdownCoverage JSONCoverage catalog

Find an API

Search the full operation list, then sort the table to compare current support.

Loading operations…

Search by operation name

Operation ▲	Implemented ▼	Verified on Kubernetes
Loading operations…

PreviousNext

Complete static API list All 12 operations and their current support status

Operation	Status
CreateSchedule	Implemented
CreateScheduleGroup	Implemented
DeleteSchedule	Implemented
DeleteScheduleGroup	Implemented
GetSchedule	Implemented
GetScheduleGroup	Implemented
ListScheduleGroups	Implemented
ListSchedules	Implemented
ListTagsForResource	Implemented
TagResource	Implemented
UntagResource	Implemented
UpdateSchedule	Implemented