Modern web applications often need to perform tasks automatically in the background.

You may need to send daily emails, clean up old records, generate reports, process subscriptions, send reminders, remove expired sessions, or run database maintenance jobs at specific times.

Instead of manually running these operations, Laravel provides a powerful Task Scheduling feature that allows developers to define scheduled commands directly inside the application.

In this guide, you’ll learn how to schedule tasks in Laravel, how Laravel’s scheduler works, how to create scheduled Artisan commands, how to configure cron jobs, how to run tasks every minute or at specific intervals, and how to avoid common scheduling problems.

---

What Is Laravel Task Scheduling?

Laravel Task Scheduling provides a convenient way to define and manage recurring tasks within a Laravel application.

Instead of creating multiple server-level cron entries, you can define your application’s scheduled tasks using Laravel’s expressive PHP syntax.

For example:

Schedule::command('emails:send')
    ->daily();

This tells Laravel that the emails:send Artisan command should run once every day.

The general architecture looks like this:

┌──────────────────────┐
│     Server Cron      │
│    Runs Scheduler    │
└──────────┬───────────┘
           │
           ▼
┌──────────────────────┐
│ Laravel Scheduler    │
│                      │
│ Checks Due Tasks     │
└──────────┬───────────┘
           │
           ▼
┌─────────────────────────────┐
│      Scheduled Tasks        │
├─────────────────────────────┤
│ Send Emails                 │
│ Clean Database              │
│ Generate Reports            │
│ Send Notifications          │
│ Process Subscriptions       │
└─────────────────────────────┘

Laravel handles the application-level scheduling logic, while the server’s cron system triggers Laravel’s scheduler.

---

Why Use Laravel Task Scheduling?

Without Laravel’s scheduler, you might have to create separate cron entries for every task.

For example:

Cron Job 1 → Send emails
Cron Job 2 → Clean records
Cron Job 3 → Generate reports
Cron Job 4 → Send reminders
Cron Job 5 → Process subscriptions

This can become difficult to manage.

With Laravel task scheduling, the server can trigger Laravel regularly:

Server Cron
     │
     ▼
Laravel Scheduler
     │
     ├── Emails
     ├── Reports
     ├── Cleanup
     ├── Notifications
     └── Subscriptions

This keeps scheduling logic inside your Laravel application.

---

Laravel Scheduler vs Cron

It’s important to understand the difference.

Feature	Cron	Laravel Scheduler
Runs system commands	Yes	Through Laravel
Defines application logic	Limited	Excellent
Laravel-friendly syntax	No	Yes
Multiple scheduled tasks	Can become complex	Easy to manage
Conditional scheduling	Limited	Supported
Task chaining	Limited	Supported
Prevent overlapping	Not directly	Supported
Application timezone	Manual configuration	Laravel-aware
Maintenance	Server-focused	Application-focused

Cron is responsible for triggering the scheduler.

Laravel determines which tasks should run and when.

---

How Laravel Task Scheduling Works

The basic workflow is:

                    Every Minute
                         │
                         ▼
                 ┌───────────────┐
                 │ Server Cron   │
                 └───────┬───────┘
                         │
                         ▼
                 ┌───────────────┐
                 │ Laravel       │
                 │ Scheduler     │
                 └───────┬───────┘
                         │
                  Is Task Due?
                    /        \
                  No          Yes
                  │            │
                  ▼            ▼
                Stop      Run Task
                               │
                               ▼
                         Log / Output

The scheduler checks your defined tasks and determines whether each task is due.

---

Step 1: Create an Artisan Command

A common approach is to create a custom Artisan command.

Run:

php artisan make:command SendDailyReports

Laravel will create a command file similar to:

app/
└── Console/
    └── Commands/
        └── SendDailyReports.php

Depending on your Laravel version and application structure, the command location may vary.

---

Step 2: Define the Artisan Command

A command can look like this:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;

class SendDailyReports extends Command
{
    protected $signature = 'reports:send';

    protected $description = 'Send daily reports to administrators';

    public function handle()
    {
        // Your report logic here

        $this->info('Daily reports sent successfully.');

        return self::SUCCESS;
    }
}

The important part is the signature:

protected $signature = 'reports:send';

You can manually execute the command with:

php artisan reports:send

If everything works correctly, you should see:

Daily reports sent successfully.

---

Step 3: Schedule the Command

Modern Laravel applications allow scheduled tasks to be defined using the application’s scheduling configuration.

A typical example is:

use Illuminate\Support\Facades\Schedule;

Schedule::command('reports:send')
    ->daily();

This tells Laravel to execute:

reports:send

once per day.

The exact scheduler location can vary between Laravel versions, so check your application’s current structure when implementing this in an existing project.

---

Common Laravel Scheduling Frequencies

Laravel provides expressive scheduling methods.

For example:

Schedule::command('reports:send')->everyMinute();

Run every minute.

Schedule::command('reports:send')->hourly();

Run every hour.

Schedule::command('reports:send')->daily();

Run once per day.

Schedule::command('reports:send')->weekly();

Run once per week.

You can also use more specific scheduling expressions.

---

Laravel Task Scheduling Examples

Run a Task Every Minute

Schedule::command('reports:send')
    ->everyMinute();

Useful for:

• Frequent status checks
• Short-lived processing
• Queue-related maintenance
• Monitoring tasks

Avoid using every-minute scheduling for expensive operations unless necessary.

---

Run Every Five Minutes

Schedule::command('reports:send')
    ->everyFiveMinutes();

This is useful for periodic processing without running a task every minute.

---

Run Every Ten Minutes

Schedule::command('reports:send')
    ->everyTenMinutes();

---

Run Every Fifteen Minutes

Schedule::command('reports:send')
    ->everyFifteenMinutes();

---

Run Every Thirty Minutes

Schedule::command('reports:send')
    ->everyThirtyMinutes();

---

Run Every Hour

Schedule::command('reports:send')
    ->hourly();

---

Run Every Two Hours

Schedule::command('reports:send')
    ->everyTwoHours();

---

Run Daily

Schedule::command('reports:send')
    ->daily();

---

Run Daily at a Specific Time

For example:

Schedule::command('reports:send')
    ->dailyAt('09:00');

This schedules the task for 9:00 AM according to the application’s configured timezone.

---

Scheduling Tasks at Specific Times

Laravel provides several useful scheduling methods.

For example:

Schedule::command('reports:send')
    ->dailyAt('18:30');

You can use this for tasks such as:

• Daily sales reports
• End-of-day summaries
• Customer reminders
• Automated backups
• Daily notifications

---

Scheduling Weekly Tasks

You can schedule a task weekly.

For example:

Schedule::command('reports:send')
    ->weekly();

You can also specify a particular day and time:

Schedule::command('reports:send')
    ->weeklyOn(1, '09:00');

Here:

1 = Monday

So the task runs every Monday at 9:00 AM.

---

Scheduling Monthly Tasks

For monthly operations:

Schedule::command('reports:send')
    ->monthly();

This can be useful for:

• Monthly reports
• Subscription processing
• Billing summaries
• Monthly cleanup
• Account statements

---

Scheduling a Closure

You don’t always need to create a custom Artisan command.

Laravel can schedule a closure for simple operations.

For example:

Schedule::call(function () {
    // Perform task
})->daily();

This can be useful for small pieces of application logic.

However, for larger operations, a dedicated command or job is usually easier to maintain.

---

Scheduling Artisan Commands

Laravel’s scheduler can execute Artisan commands.

For example:

Schedule::command('cache:clear')
    ->daily();

Another example:

Schedule::command('reports:generate')
    ->dailyAt('23:00');

This is especially useful when you already have reusable Artisan commands.

---

Scheduling Queued Jobs

For heavier operations, you can schedule a Laravel job rather than performing everything directly inside the scheduler.

For example:

Schedule::job(new GenerateDailyReport)
    ->daily();

The architecture becomes:

Scheduler
    │
    ▼
Dispatch Job
    │
    ▼
Queue
    │
    ▼
Queue Worker
    │
    ▼
Generate Report

This is often better for resource-intensive tasks.

---

Task Scheduling With Queues

One important distinction is:

The scheduler and queue worker solve different problems.

The scheduler determines when something should happen.

The queue determines when and where the background job is processed.

For example:

Scheduler
   │
   │ 9:00 AM
   ▼
Dispatch Email Job
   │
   ▼
Queue
   │
   ▼
Worker
   │
   ▼
Send Email

This approach prevents expensive operations from blocking the scheduler.

---

Preventing Overlapping Tasks

Imagine you have a task that runs every minute:

Schedule::command('reports:generate')
    ->everyMinute();

Suppose the first execution takes three minutes.

Without protection, another execution could start before the previous one finishes.

That can produce:

12:00 → Task A starts
12:01 → Task B starts
12:02 → Task C starts
12:03 → Task D starts

This can overload your application.

Use:

Schedule::command('reports:generate')
    ->everyMinute()
    ->withoutOverlapping();

Now Laravel can prevent another instance from starting while the previous task is still running.

---

Running Tasks on One Server

In a multi-server environment, the same scheduled task could potentially run on multiple servers.

For distributed deployments, Laravel provides mechanisms such as:

Schedule::command('reports:generate')
    ->daily()
    ->onOneServer();

This is useful when multiple application servers share the same scheduling responsibility.

Your application’s cache configuration must support the coordination mechanism required by your deployment.

---

Running Tasks in the Background

You can use:

Schedule::command('reports:generate')
    ->daily()
    ->runInBackground();

This can be useful when multiple scheduled commands need to execute without one long-running task blocking another.

Use this thoughtfully, especially on servers with limited CPU and memory.

---

Scheduling Tasks With Conditions

Sometimes you only want a task to execute when a specific condition is true.

For example:

Schedule::command('reports:send')
    ->daily()
    ->when(function () {
        return config('reports.enabled');
    });

You can also use application-specific conditions.

This allows your scheduling system to become more dynamic.

---

Running a Task Only in Production

Some tasks should never run in local development.

For example:

Schedule::command('reports:send')
    ->daily()
    ->environments(['production']);

This is useful for:

• Sending real emails
• Processing real payments
• Running production cleanup
• Generating customer notifications

It helps prevent accidental execution during development.

---

Task Maintenance Mode

You may have a task that should not execute while the application is under maintenance.

Laravel scheduling provides options for controlling this behavior.

For example:

Schedule::command('reports:send')
    ->daily()
    ->evenInMaintenanceMode();

Use this only when a task genuinely needs to continue running during maintenance.

---

Timezones and Laravel Task Scheduling

Timezone configuration is extremely important for scheduled tasks.

Imagine your application is hosted on a server using UTC:

Server Time: UTC
Application Users: India

If you expect a report at:

09:00 AM India

but schedule it without understanding the application’s timezone, the task may run at an unexpected local time.

Configure the application timezone appropriately in your Laravel configuration.

Then scheduling expressions such as:

Schedule::command('reports:send')
    ->dailyAt('09:00');

can behave according to the configured application timezone.

For applications serving multiple geographic regions, consider whether the task should use a single application timezone or region-specific scheduling logic.

---

Configuring the Server Cron Job

Defining a Laravel scheduled task isn’t enough.

Your server must actually invoke Laravel’s scheduler.

A common production configuration uses a cron entry that runs:

php artisan schedule:run

every minute.

For example:

* * * * * cd /path/to/your/project && php artisan schedule:run >> /dev/null 2>&1

Replace:

/path/to/your/project

with the actual path to your Laravel application.

The important concept is:

Cron runs every minute
        │
        ▼
schedule:run
        │
        ▼
Laravel checks scheduled tasks
        │
        ▼
Due tasks execute

You generally need one scheduler cron entry, rather than creating a separate cron entry for every Laravel task.

---

Laravel Scheduler in Production

A typical production setup looks like:

                    Linux Server
                         │
                         ▼
                 ┌──────────────┐
                 │ Cron Service │
                 └──────┬───────┘
                        │
                  Every Minute
                        │
                        ▼
              ┌──────────────────┐
              │ Laravel Scheduler│
              └────────┬─────────┘
                       │
          ┌────────────┼────────────┐
          ▼            ▼            ▼
       Emails       Reports       Cleanup
          │            │            │
          ▼            ▼            ▼
        Queue        Queue        Command

This is a clean and scalable pattern for many Laravel applications.

---

Testing Laravel Scheduled Tasks

You don’t need to wait until the scheduled time to test your task.

You can manually run:

php artisan schedule:run

Laravel will determine which scheduled tasks are currently due.

You can also inspect your scheduled tasks using:

php artisan schedule:list

This command is extremely useful when troubleshooting scheduling issues.

It can help you verify:

• Task names
• Frequency
• Next run time
• Scheduling configuration

---

Running the Scheduler Locally

During local development, you may want to continuously run Laravel’s scheduler.

You can use:

php artisan schedule:work

This keeps the scheduler running during development.

Conceptually:

schedule:work
      │
      ├── Check tasks
      ├── Wait
      ├── Check tasks
      ├── Wait
      └── Continue

This is convenient for testing scheduled tasks without configuring a system cron service on your local machine.

---

Example: Delete Old Records Automatically

Suppose you want to delete expired temporary records every night.

Create a command:

php artisan make:command CleanupExpiredRecords

Then:

class CleanupExpiredRecords extends Command
{
    protected $signature = 'records:cleanup';

    protected $description = 'Delete expired records';

    public function handle()
    {
        TemporaryRecord::where(
            'expires_at',
            '<',
            now()
        )->delete();

        $this->info('Expired records deleted.');

        return self::SUCCESS;
    }
}

Schedule it:

Schedule::command('records:cleanup')
    ->dailyAt('02:00')
    ->withoutOverlapping();

Now the cleanup task can run automatically every night.

---

Example: Send Daily Email Reports

A common business requirement is sending an automated report every morning.

Schedule::command('reports:send')
    ->dailyAt('09:00')
    ->withoutOverlapping();

The command can retrieve data:

$orders = Order::whereDate(
    'created_at',
    today()
)->get();

Then generate a report and send it to administrators.

The complete flow becomes:

09:00 AM
   │
   ▼
Laravel Scheduler
   │
   ▼
reports:send
   │
   ▼
Fetch Today's Orders
   │
   ▼
Generate Report
   │
   ▼
Send Email

---

Example: Automatically Process Expired Subscriptions

Subscription-based applications often need automated expiration handling.

For example:

Schedule::call(function () {

    Subscription::where('ends_at', '<', now())
        ->where('status', 'active')
        ->update([
            'status' => 'expired'
        ]);

})->hourly();

For larger business logic, move this into a dedicated command or service instead of keeping it inside a closure.

---

Scheduling Database Cleanup

Database maintenance is another common use case.

For example:

Schedule::command('logs:cleanup')
    ->weekly();

You could use the command to remove outdated application logs or temporary data.

However, be careful when deleting records automatically.

Always:

• Define retention rules
• Test the query
• Back up important data
• Avoid deleting production data accidentally
• Log cleanup operations

---

Laravel Scheduler and Email Notifications

You can combine scheduling with Laravel notifications.

For example:

Scheduler
    │
    ▼
Find users with pending reminders
    │
    ▼
Dispatch notification jobs
    │
    ▼
Queue
    │
    ▼
Email / SMS / Notification

This pattern is useful for:

• Appointment reminders
• Subscription renewals
• Payment reminders
• Abandoned carts
• Expiring documents
• Daily summaries

---

Common Laravel Scheduling Mistakes

1. Forgetting the Server Cron

You can define:

Schedule::command('reports:send')
    ->daily();

but if the server isn’t running Laravel’s scheduler, nothing will happen.

Make sure the server triggers:

php artisan schedule:run

regularly.

---

2. Using the Wrong PHP Binary

On some servers, the php command used by cron may point to a different PHP version than the one used by your application.

Check:

which php

and:

php -v

If necessary, use the full PHP binary path in cron.

---

3. Incorrect Project Path

This cron configuration:

* * * * * cd /wrong/path && php artisan schedule:run

will obviously fail.

Make sure the path points to your Laravel application’s root directory.

---

4. Timezone Confusion

A task scheduled for:

->dailyAt('09:00')

may not execute at the expected local time if timezone configuration isn’t understood.

Always verify your application’s timezone and server timezone.

---

5. Long-Running Tasks

A scheduled command that takes a long time can create overlapping processes.

Use:

->withoutOverlapping()

when appropriate.

For heavier workloads, consider queueing the actual work.

---

6. Putting Too Much Logic in the Scheduler

Avoid turning your scheduling configuration into a large business-logic file.

Instead of:

Schedule::call(function () {
    // hundreds of lines of business logic
})->daily();

prefer:

Schedule::command('reports:generate')
    ->daily();

and keep the business logic inside the command or service.

---

Best Practices for Laravel Task Scheduling

1. Use Artisan Commands for Complex Tasks

Keep complex logic out of the scheduler.

Scheduler
    ↓
Artisan Command
    ↓
Service
    ↓
Business Logic

This makes your code easier to test and maintain.

---

2. Use Queues for Heavy Processing

If a task performs expensive work, dispatch a job instead of blocking the scheduler.

---

3. Prevent Overlapping Tasks

For tasks that might take longer than their scheduling interval:

->withoutOverlapping()

is often useful.

---

4. Use Meaningful Command Names

Prefer:

reports:generate
subscriptions:expire
orders:cleanup
emails:send-reminders

instead of vague names such as:

task:run
process:data
do:stuff

Clear command names make production maintenance easier.

---

5. Log Important Operations

For critical scheduled processes, log important events:

Log::info('Daily report generation started.');

and:

Log::info('Daily report generation completed.');

This can make debugging significantly easier.

---

6. Monitor Failed Tasks

Scheduled tasks that silently fail can cause serious business problems.

Monitor:

• Application logs
• Queue failures
• Server cron
• Scheduler output
• Notifications
• Task execution times

---

Laravel Scheduler vs Queue

These features are often confused.

Feature	Scheduler	Queue
Determines when work starts	Yes	No
Background processing	Not primarily	Yes
Recurring tasks	Yes	No
Delayed jobs	Limited use case	Yes
Large workloads	Can trigger them	Designed for them
Email processing	Can schedule	Can process
Report generation	Can trigger	Can execute

The two systems work very well together.

Recommended architecture

Scheduler
    │
    ▼
Dispatch Job
    │
    ▼
Queue
    │
    ▼
Worker
    │
    ▼
Process Task

---

Laravel Task Scheduling Checklist

Before deploying scheduled tasks to production, verify:

☐ Task is defined correctly
☐ Artisan command works manually
☐ schedule:list shows the task
☐ schedule:run works
☐ Server cron is configured
☐ PHP version is correct
☐ Laravel application path is correct
☐ Timezone is correct
☐ Environment configuration is correct
☐ Long tasks use queues when appropriate
☐ Overlapping is prevented when necessary
☐ Errors are logged
☐ Sensitive operations are authorized
☐ Production scheduling has been tested

---

Frequently Asked Questions

1. How do I schedule a task in Laravel?

Define the task using Laravel’s scheduler and specify its frequency.

For example:

Schedule::command('reports:send')
    ->daily();

Then configure your server to run Laravel’s scheduler regularly using php artisan schedule:run.

---

2. What command runs the Laravel scheduler?

The standard scheduler command is:

php artisan schedule:run

Your server should invoke this command regularly, commonly once every minute.

---

3. How do I run Laravel scheduled tasks locally?

You can use:

php artisan schedule:work

This continuously runs the scheduler during local development.

---

4. How do I schedule a Laravel command every minute?

Use:

Schedule::command('reports:send')
    ->everyMinute();

Make sure your server is also invoking the Laravel scheduler.

---

5. How do I schedule a Laravel task at a specific time?

Use dailyAt():

Schedule::command('reports:send')
    ->dailyAt('09:00');

The configured application timezone should be considered when choosing the execution time.

---

6. How can I prevent scheduled Laravel tasks from overlapping?

Use:

Schedule::command('reports:generate')
    ->everyMinute()
    ->withoutOverlapping();

This helps prevent a new execution from starting while a previous execution is still running.

---

7. Can Laravel scheduler run queued jobs?

Yes. Laravel’s scheduler can dispatch jobs to the queue.

For example:

Schedule::job(new GenerateDailyReport)
    ->daily();

This is useful for resource-intensive operations that should run asynchronously.

---

8. How can I check Laravel scheduled tasks?

Use:

php artisan schedule:list

This provides a useful overview of configured scheduled tasks and their next execution times.

---

Key Takeaways

• Laravel Task Scheduling allows developers to automate recurring application tasks.
• Laravel’s scheduler works alongside the server’s cron system.
• Use Artisan commands for complex scheduled operations.
• Use daily(), hourly(), weekly(), everyMinute(), and other scheduling methods to define frequencies.
• Use dailyAt() and similar methods when execution must happen at a specific time.
• Configure the server to execute php artisan schedule:run.
• Use schedule:work for convenient local development.
• Use withoutOverlapping() for tasks that shouldn’t run concurrently.
• Use queues for expensive or long-running operations.
• Pay close attention to application and server timezones.
• Use schedule:list and logs when troubleshooting.
• Keep scheduling configuration clean and move complex business logic into commands, services, and jobs.