Laravel is known for its elegant syntax and developer-friendly tools, and one of the most useful tools in the framework is Laravel Artisan.

Artisan is Laravel’s command-line interface (CLI). It allows developers to generate files, manage database migrations, clear application caches, inspect routes, run scheduled tasks, create queues, and perform many other development and maintenance tasks directly from the terminal.

Whether you’re a beginner learning Laravel or an experienced developer working on production applications, knowing the right Laravel Artisan commands can significantly improve your development workflow.

In this guide, we’ll cover the most useful Laravel Artisan commands, explain what they do, provide practical examples, and highlight commands that every Laravel developer should know.

---

What Is Laravel Artisan?

Artisan is the command-line interface included with Laravel.

You can access it using:

php artisan

Running this command displays the available Artisan commands for your Laravel application.

For example:

php artisan

You will see commands grouped into different categories, including:

make
migrate
db
route
cache
config
queue
schedule
storage
view

Artisan helps developers automate repetitive tasks instead of manually creating files or executing complicated commands.

---

Why Is Laravel Artisan Important?

Artisan can help you:

• Generate controllers
• Create models
• Generate migrations
• Create seeders and factories
• Run database migrations
• Roll back migrations
• Clear caches
• Inspect routes
• Run queues
• Create middleware
• Create validation requests
• Manage scheduled tasks
• Generate application keys
• Create symbolic storage links
• Run Laravel’s development server
• Build custom CLI commands

A simple way to think about Artisan is:

Developer
    │
    ▼
php artisan command
    │
    ▼
Laravel CLI
    │
    ├── Generate files
    ├── Manage database
    ├── Clear caches
    ├── Run queues
    ├── Inspect application
    └── Perform maintenance

---

How to See All Laravel Artisan Commands

The simplest command is:

php artisan

This displays the available commands.

You can also use:

php artisan list

Both commands provide an overview of Artisan’s available functionality.

---

Get Help for an Artisan Command

If you’re unsure how a command works, use:

php artisan help migrate

For example:

php artisan help make:controller

You can also use:

php artisan make:controller --help

This is one of the easiest ways to discover command options without searching through documentation.

---

Check Your Laravel Version

To check the Laravel version used by your application:

php artisan --version

Example:

Laravel Framework 12.x

This is useful when debugging version-specific behavior or working on a team where different Laravel versions may be installed.

---

Run the Laravel Development Server

One of the first Artisan commands beginners learn is:

php artisan serve

This starts Laravel’s local development server.

Typically, the application becomes available at:

http://127.0.0.1:8000

You can specify a different host and port:

php artisan serve --host=0.0.0.0 --port=8080

This can be useful when testing an application from another device on your local network.

---

Laravel Make Commands

One of Artisan’s most useful command groups is make.

The make commands generate common Laravel application files.

The general syntax is:

php artisan make:<type> <Name>

For example:

php artisan make:controller ProductController

---

Create a Controller

To create a controller:

php artisan make:controller ProductController

Laravel creates:

app/Http/Controllers/ProductController.php

For a resource controller:

php artisan make:controller ProductController --resource

This generates common CRUD methods such as:

index()
create()
store()
show()
edit()
update()
destroy()

---

Create a Model

Create an Eloquent model with:

php artisan make:model Product

Laravel creates:

app/Models/Product.php

You can create a model along with a migration:

php artisan make:model Product -m

This is particularly useful when creating a new database entity.

---

Create a Model With Multiple Related Files

Artisan supports several shortcuts for generating related files.

For example:

php artisan make:model Product -mcr

This can generate:

• Model
• Migration
• Controller
• Resource controller structure

Another common approach is to be explicit:

php artisan make:model Product --migration --controller --resource

Using explicit options can make the command easier to understand for teams and beginners.

---

Create a Migration

To create a migration:

php artisan make:migration create_products_table

For a new table:

php artisan make:migration create_products_table --create=products

For modifying an existing table:

php artisan make:migration add_status_to_products_table

Migrations are stored in:

database/migrations

---

Run Database Migrations

To run pending migrations:

php artisan migrate

Laravel checks the migration history and executes migrations that haven’t been run yet.

---

Check Migration Status

Use:

php artisan migrate:status

This helps you determine which migrations have already run.

Example:

Migration                                      Ran?
2026_01_01_000001_create_users_table          Yes
2026_01_01_000002_create_products_table       Yes
2026_01_01_000003_create_orders_table         No

---

Roll Back Migrations

To roll back the latest migration batch:

php artisan migrate:rollback

To roll back a specific number of migration batches:

php artisan migrate:rollback --step=2

This is useful during local development when testing schema changes.

---

Reset Migrations

To roll back all migrations:

php artisan migrate:reset

This reverses all executed migrations.

---

Refresh Migrations

To roll back migrations and run them again:

php artisan migrate:refresh

You can also specify a number of steps:

php artisan migrate:refresh --step=2

---

Fresh Database Migration

The following command drops all database tables and runs all migrations again:

php artisan migrate:fresh

You can also run seeders:

php artisan migrate:fresh --seed

This is extremely useful during local development.

Important: migrate:fresh can destroy existing data. Never run destructive database commands against production without fully understanding their impact.

---

Create a Seeder

Create a seeder with:

php artisan make:seeder ProductSeeder

The seeder is created inside:

database/seeders

You can then insert predefined data.

---

Run Database Seeders

Run the default database seeder:

php artisan db:seed

Run a specific seeder:

php artisan db:seed --class=ProductSeeder

You can also run migrations and seeders together:

php artisan migrate --seed

---

Create a Factory

Factories are useful for generating test and development data.

Create a factory:

php artisan make:factory ProductFactory

You can then generate records:

Product::factory()->count(50)->create();

Factories are especially useful when you need large amounts of realistic sample data.

---

Create a Form Request

Laravel Form Requests are useful for organizing validation and authorization logic.

Create one with:

php artisan make:request StoreProductRequest

Laravel generates:

app/Http/Requests/StoreProductRequest.php

This can keep controllers cleaner by moving complex validation rules into dedicated request classes.

---

Create Middleware

Middleware can inspect or filter incoming HTTP requests.

Create middleware with:

php artisan make:middleware CheckUserRole

Example use cases include:

• Authentication
• Authorization
• Role checking
• Request filtering
• Logging
• API security

---

Create a Policy

Policies organize authorization logic around models.

Create one with:

php artisan make:policy ProductPolicy

You can also generate a policy associated with a model:

php artisan make:policy ProductPolicy --model=Product

Policies are useful for actions such as:

Can the user update this product?
Can the user delete this order?
Can the user view this record?

---

Create an Event

Laravel events allow different parts of an application to communicate without tightly coupling the code.

Create an event:

php artisan make:event OrderCreated

Events are useful for actions such as:

• Sending notifications
• Recording activity
• Triggering background jobs
• Sending emails
• Updating external systems

---

Create a Listener

Create an event listener with:

php artisan make:listener SendOrderNotification

A listener can respond when a specific event occurs.

For example:

Order Created
     │
     ▼
OrderCreated Event
     │
     ▼
SendOrderNotification Listener
     │
     ▼
Notification

---

Create a Job

Jobs are useful for background processing.

Create one with:

php artisan make:job ProcessOrder

A job might perform:

• Email delivery
• Image processing
• Report generation
• API synchronization
• Payment processing
• Data imports

Jobs can be dispatched to a queue instead of blocking the current request.

---

Work With Laravel Queues

To process queued jobs:

php artisan queue:work

A worker continuously processes jobs from the configured queue.

For development, you may also use:

php artisan queue:listen

The appropriate queue strategy depends on your application’s Laravel version and deployment architecture.

---

Retry Failed Queue Jobs

If a queued job fails, Laravel can store information about it.

To retry failed jobs:

php artisan queue:retry all

You can inspect failed jobs using:

php artisan queue:failed

You can remove failed jobs with:

php artisan queue:forget <id>

Be careful when retrying jobs that perform non-idempotent operations such as payments or external API requests.

---

Clear Failed Jobs

To remove all failed jobs:

php artisan queue:flush

Only use this when you are certain the failed-job records are no longer needed.

---

Laravel Route Commands

Artisan provides useful route inspection commands.

To display all routes:

php artisan route:list

This is one of the most useful debugging commands in Laravel.

You can filter routes:

php artisan route:list --path=api

You can also search for specific route names or methods using the available filtering options.

A route list helps you identify:

• HTTP method
• URL
• Route name
• Controller
• Middleware

---

Clear Route Cache

Laravel can cache routes for performance.

To clear the route cache:

php artisan route:clear

To cache routes:

php artisan route:cache

Route caching is commonly used in production deployments, while route clearing can help during development when debugging route changes.

---

Laravel Configuration Commands

Laravel configuration can be cached for better production performance.

To cache configuration:

php artisan config:cache

To clear the configuration cache:

php artisan config:clear

To view configuration-related information, you can use:

php artisan about

Configuration caching is especially important when deploying Laravel applications.

---

Clear Laravel Application Cache

To clear the application’s cache:

php artisan cache:clear

This can be useful when cached data is causing unexpected behavior.

Remember that application cache and configuration cache are different concepts.

---

Clear All Optimized Files

A commonly used maintenance command is:

php artisan optimize:clear

This clears various Laravel caches, including:

• Application cache
• Configuration cache
• Route cache
• View cache
• Event cache

It can be useful when troubleshooting stale application state.

---

Clear Compiled Views

Blade templates are compiled by Laravel.

To clear compiled views:

php artisan view:clear

This can help when debugging unexpected Blade rendering behavior.

---

Cache Blade Views

Laravel can compile Blade views for better performance.

You can cache views using:

php artisan view:cache

This is generally more relevant to production deployment workflows.

---

Laravel Storage Link

Laravel’s public storage files are commonly exposed through a symbolic link.

Create the link with:

php artisan storage:link

This typically creates:

public/storage

pointing to:

storage/app/public

This is commonly used for user-uploaded files and images.

---

Generate an Application Key

Laravel applications use an application key for encryption and related security functionality.

Generate the key with:

php artisan key:generate

This normally updates the .env file with:

APP_KEY=...

Never expose your application key publicly.

---

Laravel Maintenance Mode

Laravel provides maintenance mode commands.

To enable maintenance mode:

php artisan down

To disable it:

php artisan up

You can also customize the maintenance response depending on your Laravel version and deployment requirements.

Maintenance mode can be useful during deployments or major maintenance operations.

---

Laravel Schedule Commands

Laravel’s scheduler allows applications to execute recurring tasks.

To inspect scheduled tasks:

php artisan schedule:list

To run the scheduler manually:

php artisan schedule:run

This is useful for testing scheduled tasks locally.

For example:

Every minute
     │
     ▼
Laravel Scheduler
     │
     ├── Send reports
     ├── Clean old records
     ├── Process subscriptions
     └── Sync external data

---

Run the Scheduler Continuously

In many production environments, Laravel’s scheduler is triggered by a system-level cron entry.

A typical setup invokes:

php artisan schedule:run

at regular intervals.

The server’s scheduler then allows Laravel to determine which tasks are due.

---

Laravel Tinker

Tinker is one of the most useful Artisan tools for developers.

Start Tinker:

php artisan tinker

You can then interact with Laravel directly from the command line.

For example:

$user = User::first();

You can query models:

Product::where('is_active', true)->get();

Create records:

Product::create([
    'name' => 'Laptop',
    'price' => 999.99,
]);

Tinker is extremely useful for:

• Debugging
• Testing queries
• Checking database records
• Testing model relationships
• Running small experiments
• Inspecting application behavior

---

Laravel Database Commands

Artisan also provides database-related commands.

For example:

php artisan db

Depending on your Laravel version and configured database driver, this can open an interactive database shell.

You can also inspect database information using:

php artisan db:show

and table information with:

php artisan db:table users

These commands can be useful when diagnosing database-related issues.

---

Laravel About Command

The about command provides an overview of the Laravel application:

php artisan about

It can display useful information about:

• Laravel version
• PHP version
• Environment
• Cache status
• Database
• Drivers
• Application configuration

This can be a convenient first step when diagnosing an unfamiliar Laravel project.

---

Create a Custom Artisan Command

Laravel allows developers to create their own Artisan commands.

For example:

php artisan make:command GenerateReport

Laravel creates a command class inside:

app/Console/Commands

You can define a signature:

protected $signature = 'report:generate';

Then add logic:

public function handle()
{
    $this->info('Generating report...');

    // Report generation logic

    $this->info('Report generated successfully.');
}

Run it with:

php artisan report:generate

Custom Artisan commands are useful for repetitive business and maintenance tasks.

---

Useful Laravel Artisan Commands Cheat Sheet

Command	Purpose
php artisan	List Artisan commands
php artisan --version	Show Laravel version
php artisan serve	Start local development server
php artisan about	Show application information
php artisan route:list	List routes
php artisan migrate	Run migrations
php artisan migrate:status	Check migration status
php artisan migrate:rollback	Roll back migrations
php artisan migrate:fresh	Drop tables and migrate again
php artisan db:seed	Run seeders
php artisan tinker	Open Laravel REPL
php artisan cache:clear	Clear application cache
php artisan config:clear	Clear config cache
php artisan config:cache	Cache configuration
php artisan route:clear	Clear route cache
php artisan route:cache	Cache routes
php artisan view:clear	Clear compiled views
php artisan view:cache	Cache views
php artisan optimize:clear	Clear Laravel optimization caches
php artisan storage:link	Create storage symlink
php artisan key:generate	Generate application key
php artisan queue:work	Process queued jobs
php artisan schedule:list	List scheduled tasks
php artisan make:model	Create model
php artisan make:controller	Create controller
php artisan make:migration	Create migration
php artisan make:seeder	Create seeder
php artisan make:factory	Create factory
php artisan make:request	Create Form Request
php artisan make:middleware	Create middleware
php artisan make:policy	Create policy
php artisan make:job	Create job
php artisan make:event	Create event
php artisan make:listener	Create listener
php artisan make:command	Create custom command

---

Most Useful Artisan Commands for Daily Development

You don’t need to memorize every Artisan command.

For everyday Laravel development, start with these:

php artisan serve
php artisan make:model Product -m
php artisan make:controller ProductController --resource
php artisan make:request StoreProductRequest
php artisan migrate
php artisan migrate:rollback
php artisan db:seed
php artisan tinker
php artisan route:list
php artisan optimize:clear
php artisan storage:link

These commands cover many common development tasks.

---

Common Artisan Mistakes

1. Running Destructive Commands on Production

Be careful with:

php artisan migrate:fresh

and:

php artisan migrate:reset

These commands can remove database structures and potentially destroy data.

Always verify the environment before executing destructive operations.

---

2. Clearing the Wrong Cache

If your application isn’t reflecting changes, don’t blindly clear every cache.

Understand the difference between:

php artisan cache:clear
php artisan config:clear
php artisan route:clear
php artisan view:clear

For a broader reset during troubleshooting, you can use:

php artisan optimize:clear

---

3. Forgetting Production Configuration Caching

For production deployments, configuration and route caching can improve performance.

However, after changing environment or configuration values, make sure the relevant caches are rebuilt.

---

4. Running Queue Commands Without a Worker Strategy

If your application depends on queues, simply dispatching jobs isn’t enough.

A worker must process them:

php artisan queue:work

Production environments typically require a process manager or equivalent service to keep queue workers running reliably.

---

Laravel Artisan Best Practices

Use Artisan Instead of Manually Creating Framework Files

Whenever Laravel provides a generator, use it.

For example:

php artisan make:controller OrderController

is preferable to manually creating a controller file because Laravel establishes the expected structure automatically.

Check Command Help

When you’re unsure about an option:

php artisan help <command>

or:

php artisan <command> --help

Be Careful With Production Commands

Always check:

Environment
Database
Command
Expected Impact

before running destructive or deployment-related commands.

Keep Custom Commands Focused

Custom Artisan commands should have a clear purpose and should avoid becoming giant application scripts.

Move reusable business logic into services when appropriate.

Use Artisan in Deployment Automation

Common deployment workflows can include commands such as:

php artisan migrate --force
php artisan config:cache
php artisan route:cache
php artisan view:cache

The exact deployment sequence should match your application’s architecture and Laravel version.

---

Laravel Artisan Workflow

A typical Laravel development workflow might look like:

Create Feature
     │
     ▼
make:model / make:controller
     │
     ▼
make:migration
     │
     ▼
migrate
     │
     ▼
db:seed / Factory
     │
     ▼
tinker
     │
     ▼
route:list
     │
     ▼
Test Application
     │
     ▼
Deploy
     │
     ▼
Production Artisan Commands

Artisan becomes the central command-line toolkit throughout this workflow.

---

Key Takeaways

The most important things to remember about Laravel Artisan commands are:

• Artisan is Laravel’s built-in command-line interface.
• Use php artisan to explore available commands.
• Use make:* commands to generate Laravel files.
• Use migration commands to manage database structure.
• Use seeders and factories to populate development data.
• Use route:list to inspect application routes.
• Use tinker to interact with Laravel from the terminal.
• Use cache commands when troubleshooting stale application state.
• Use queue commands to process background jobs.
• Use scheduler commands to inspect and test scheduled tasks.
• Use storage:link for public storage access.
• Use custom Artisan commands to automate repetitive tasks.
• Be extremely careful with destructive database commands in production.

---

Frequently Asked Questions

What is Laravel Artisan?

Laravel Artisan is Laravel’s built-in command-line interface. It provides commands for generating application files, managing migrations, clearing caches, running queues, inspecting routes, interacting with the database, and performing other development and maintenance tasks.

What is the most useful Laravel Artisan command?

There isn’t one command that is best for every situation. For daily development, commands such as make:model, make:controller, migrate, route:list, tinker, and optimize:clear are particularly useful.

How do I see all Artisan commands?

Run:

php artisan

or:

php artisan list

This displays the available commands for your Laravel application.

How do I create a controller using Artisan?

Run:

php artisan make:controller ProductController

For a CRUD resource controller:

php artisan make:controller ProductController --resource

How do I run Laravel migrations?

Use:

php artisan migrate

Laravel will execute migrations that haven’t already been run.

What does php artisan migrate:fresh do?

It drops all database tables and then runs all migrations again.

php artisan migrate:fresh

It is useful for rebuilding local development databases but can destroy existing data, so it should be used with extreme caution.

What does php artisan tinker do?

Tinker provides an interactive command-line environment where you can interact with Laravel models, services, configuration, and application code.

For example:

php artisan tinker

Then:

User::count();

How do I clear Laravel caches?

For a broad cache cleanup during development or troubleshooting, you can use:

php artisan optimize:clear

You can also clear specific caches such as configuration, routes, views, or application cache individually.

---

Conclusion

Laravel Artisan commands are an essential part of a Laravel developer’s daily workflow. From generating controllers and models to managing migrations, inspecting routes, running queues, clearing caches, and interacting with the database, Artisan provides a consistent command-line interface for many common development tasks.

You don’t need to memorize every command. Start with the commands you use frequently, understand what each command does, and use php artisan help whenever you need additional information.

As your Laravel experience grows, learning more Artisan commands can help you automate repetitive work, troubleshoot applications faster, and manage production deployments more effectively.

The more comfortable you become with Artisan, the more productive your Laravel development workflow becomes.

---