The PHP Framework
for Web Artisans

Authenticating users is as simple as adding an authentication middleware to your Laravel route definition:

Route::get('/profile', ProfileController::class)
    ->middleware('auth');

Once the user is authenticated, you can access the authenticated user via the Auth facade:

use Illuminate\Support\Facades\Auth;
 
// Get the currently authenticated user...
$user = Auth::user();

Of course, you may define your own authentication middleware, allowing you to customize the authentication process.

For more information on Laravel's authentication features, check out the authentication documentation.

You'll often need to check whether an authenticated user is authorized to perform a specific action. Laravel's model policies make it a breeze:

php artisan make:policy UserPolicy

Once you've defined your authorization rules in the generated policy class, you can authorize the user's request in your controller methods:

public function update(Request $request, Invoice $invoice)
{
    Gate::authorize('update', $invoice);
 
    $invoice->update(/* ... */);
}

Learn more

Scared of databases? Don't be. Laravel’s Eloquent ORM makes it painless to interact with your application's data, and models, migrations, and relationships can be quickly scaffolded:

php artisan make:model Invoice --migration

Once you've defined your model structure and relationships, you can interact with your database using Eloquent's powerful, expressive syntax:

// Create a related model...
$user->invoices()->create(['amount' => 100]);
 
// Update a model...
$invoice->update(['amount' => 200]);
 
// Retrieve models...
$invoices = Invoice::unpaid()->where('amount', '>=', 100)->get();
 
// Rich API for model interactions...
$invoices->each->pay();

Learn more

Migrations are like version control for your database, allowing your team to define and share your application's database schema definition:

public function up(): void
{
    Schema::create('flights', function (Blueprint $table) {
        $table->uuid()->primary();
        $table->foreignUuid('airline_id')->constrained();
        $table->string('name');
        $table->timestamps();
    });
}

Learn more

Laravel has over 90 powerful, built-in validation rules and, using Laravel Precognition, can provide live validation on your frontend:

public function update(Request $request)
{
    $validated = $request->validate([
        'email' => 'required|email|unique:users',
        'password' => Password::required()->min(8)->uncompromised(),
    ]);
 
    $request->user()->update($validated);
}

Learn more

Use Laravel to quickly send beautifully styled notifications to your users via email, Slack, SMS, in-app, and more:

php artisan make:notification InvoicePaid

Once you have generated a notification, you can easily send the message to one of your application's users:

$user->notify(new InvoicePaid($invoice));

Learn more

Laravel provides a robust filesystem abstraction layer, providing a single, unified API for interacting with local filesystems and cloud based filesystems like Amazon S3:

$path = $request->file('avatar')->store('s3');

Regardless of where your files are stored, interact with them using Laravel's simple, elegant syntax:

$content = Storage::get('photo.jpg');
 
Storage::put('photo.jpg', $content);

Learn more

Laravel lets you to offload slow jobs to a background queue, keeping your web requests snappy:

$podcast = Podcast::create(/* ... */);
 
ProcessPodcast::dispatch($podcast)->onQueue('podcasts');

You can run as many queue workers as you need to handle your workload:

php artisan queue:work redis --queue=podcasts

For more visibility and control over your queues, Laravel Horizon provides a beautiful dashboard and code-driven configuration for your Laravel-powered Redis queues.

Learn more

• Job Queues
• Laravel Horizon

Schedule recurring jobs and commands with an expressive syntax and say goodbye to complicated configuration files:

$schedule->job(NotifySubscribers::class)->hourly();

Laravel's scheduler can even handle multiple servers and offers built-in overlap prevention:

$schedule->job(NotifySubscribers::class)
    ->dailyAt('9:00')
    ->onOneServer()
    ->withoutOverlapping();

Learn more

Laravel is built for testing. From unit tests to browser tests, you’ll feel more confident in deploying your application:

$user = User::factory()->create();
 
$this->browse(fn (Browser $browser) => $browser
    ->visit('/login')
    ->type('email', $user->email)
    ->type('password', 'password')
    ->press('Login')
    ->assertPathIs('/home')
    ->assertSee("Welcome {$user->name}")
);

Learn more

Laravel's events allow you to send and listen for events across your application, and listeners can easily be dispatched to a background queue:

OrderShipped::dispatch($order);

class SendShipmentNotification implements ShouldQueue
{
    public function handle(OrderShipped $event): void
    {
        // ...
    }
}

Your frontend application can even subscribe to your Laravel events using Laravel Echo and WebSockets, allowing you to build real-time, dynamic applications:

Echo.private(`orders.${orderId}`)
    .listen('OrderShipped', (e) => {
        console.log(e.order);
    });

Learn more