Sending emails is a common requirement in modern web applications. Whether you need to send welcome emails, password reset links, order confirmations, invoices, notifications, or contact form messages, Laravel provides a clean and flexible email system.

Laravel’s built-in Mail features make it possible to send emails using popular providers such as SMTP services, Amazon SES, Mailgun, Postmark, and other supported email delivery platforms.

In this guide, you’ll learn how to send emails in Laravel from the basics to more advanced approaches, including Mailables, Blade email templates, SMTP configuration, attachments, queues, Markdown emails, and common troubleshooting techniques.

---

What Is Laravel Mail?

Laravel provides a dedicated mail system for sending application emails.

Instead of putting email logic directly inside controllers, Laravel allows you to create reusable Mailable classes.

A typical Laravel email flow looks like this:

User Action
    │
    ▼
Controller / Service
    │
    ▼
Mailable Class
    │
    ▼
Email View
    │
    ▼
Mail Driver
    │
    ▼
SMTP / Email Provider
    │
    ▼
Recipient Inbox

This structure keeps email-related code organized and easier to maintain.

---

Why Use Laravel for Sending Emails?

Laravel’s email system provides several useful features:

• SMTP support
• Mailable classes
• Blade email templates
• Markdown emails
• Email attachments
• HTML emails
• Plain-text emails
• Queued emails
• Multiple mail configurations
• Mail testing
• Integration with external email providers

Laravel also makes it easy to separate email content from application logic.

---

How Laravel Email Configuration Works

Laravel’s mail configuration is generally managed through environment variables in the .env file.

A typical configuration may look like:

MAIL_MAILER=smtp
MAIL_HOST=smtp.example.com
MAIL_PORT=587
MAIL_USERNAME=your-email@example.com
MAIL_PASSWORD=your-password
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS="your-email@example.com"
MAIL_FROM_NAME="${APP_NAME}"

The exact values depend on the email provider you’re using.

Important: Never commit real email passwords, API keys, or other credentials to Git.

---

Step 1: Configure Your Mail Driver

Laravel supports different mail transport options depending on your Laravel version and installed packages.

For SMTP, your .env configuration can look like:

MAIL_MAILER=smtp
MAIL_HOST=smtp.example.com
MAIL_PORT=587
MAIL_USERNAME=your-email@example.com
MAIL_PASSWORD=your-password
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS="your-email@example.com"
MAIL_FROM_NAME="My Laravel App"

Replace the placeholder values with credentials provided by your email service.

---

Step 2: Clear Configuration Cache

If you change .env values and Laravel doesn’t appear to recognize them, clear the configuration cache:

php artisan config:clear

In development, you can also use:

php artisan optimize:clear

This is a common troubleshooting step when changing mail configuration.

---

Step 3: Create a Mailable Class

Laravel provides Artisan commands for generating mailables.

Run:

php artisan make:mail WelcomeEmail

Laravel will create a Mailable class inside:

app/Mail/WelcomeEmail.php

Depending on your Laravel version and generated structure, the class may contain methods such as:

public function envelope(): Envelope
{
    return new Envelope(
        subject: 'Welcome to Our Application',
    );
}

and:

public function content(): Content
{
    return new Content(
        view: 'emails.welcome',
    );
}

---

Creating a Simple Laravel Email

Let’s create a basic welcome email.

Generate the Mailable:

php artisan make:mail WelcomeEmail

Then configure the subject and view.

For example:

use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;

public function envelope(): Envelope
{
    return new Envelope(
        subject: 'Welcome to Our Application',
    );
}

public function content(): Content
{
    return new Content(
        view: 'emails.welcome',
    );
}

This tells Laravel to use:

resources/views/emails/welcome.blade.php

as the email template.

---

Create the Blade Email Template

Create:

resources/views/emails/welcome.blade.php

Then add:

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Welcome</title>
</head>
<body>
    <h1>Welcome to Our Application!</h1>

    <p>
        Thank you for creating an account with us.
    </p>

    <p>
        We are happy to have you here.
    </p>
</body>
</html>

Laravel will render this Blade template when the email is sent.

---

Sending an Email From a Controller

Once the Mailable is ready, import Laravel’s Mail facade:

use Illuminate\Support\Facades\Mail;
use App\Mail\WelcomeEmail;

Then send the email:

Mail::to('user@example.com')
    ->send(new WelcomeEmail());

A controller example:

public function sendWelcomeEmail()
{
    Mail::to('user@example.com')
        ->send(new WelcomeEmail());

    return response()->json([
        'message' => 'Email sent successfully.',
    ]);
}

The basic process is:

Controller
    │
    ▼
Mail::to()
    │
    ▼
WelcomeEmail
    │
    ▼
Blade Template
    │
    ▼
Email Provider
    │
    ▼
User

---

Sending Dynamic Data in Laravel Emails

Most real applications need to send personalized emails.

For example, you may want to send:

• User name
• Order number
• Product information
• Invoice amount
• Appointment date
• Verification link

You can pass data to the Mailable.

For example:

Mail::to($user->email)
    ->send(new WelcomeEmail($user));

Inside the Mailable:

public function __construct(
    public $user
) {
}

You can then access $user inside the Blade template.

---

Laravel Email Example With User Data

The Mailable can look like:

class WelcomeEmail extends Mailable
{
    public function __construct(
        public $user
    ) {
    }

    public function envelope(): Envelope
    {
        return new Envelope(
            subject: 'Welcome to Our Application',
        );
    }

    public function content(): Content
    {
        return new Content(
            view: 'emails.welcome',
        );
    }
}

The Blade template:

<!DOCTYPE html>
<html>
<body>

    <h1>Hello {{ $user->name }},</h1>

    <p>
        Welcome to our application.
    </p>

    <p>
        Your account has been created successfully.
    </p>

</body>
</html>

Now each user receives a personalized email.

---

Sending Emails With Markdown

Laravel also supports Markdown-based email templates.

Create a Markdown Mailable:

php artisan make:mail OrderConfirmation --markdown=emails.orders.confirmation

This creates a Markdown email view.

For example:

<x-mail::message>
# Order Confirmed

Hello {{ $order->user->name }},

Your order **#{{ $order->id }}** has been successfully confirmed.

<x-mail::button :url="$orderUrl">
View Order
</x-mail::button>

Thank you for shopping with us.

Thanks,<br>
{{ config('app.name') }}
</x-mail::message>

Laravel’s Markdown mail system provides reusable components for buttons, panels, tables, and other email elements.

---

Laravel Email Buttons

Markdown mailables can use Laravel’s mail button component:

<x-mail::button :url="$url">
View Order
</x-mail::button>

This is useful for emails containing actions such as:

• Verify Email
• Reset Password
• View Order
• Download Invoice
• Confirm Appointment
• Open Dashboard

---

Sending Email Attachments

Laravel allows you to attach files to emails.

For example:

public function attachments(): array
{
    return [
        Attachment::fromPath(
            storage_path('app/invoices/invoice.pdf')
        ),
    ];
}

You’ll need:

use Illuminate\Mail\Mailables\Attachment;

A typical email flow might be:

Order Completed
      │
      ▼
Generate Invoice
      │
      ▼
Create PDF
      │
      ▼
Attach PDF
      │
      ▼
Send Email

---

Attaching a File From Storage

You can also attach files using Laravel’s storage system.

For example:

Attachment::fromStorage(
    'invoices/invoice.pdf'
);

This can be useful when documents are stored using Laravel’s filesystem abstraction.

---

Setting the Email Sender

You can define the sender in your mail configuration.

For example:

MAIL_FROM_ADDRESS="no-reply@example.com"
MAIL_FROM_NAME="My Application"

You can also customize the sender for a specific Mailable:

public function envelope(): Envelope
{
    return new Envelope(
        from: new Address(
            'support@example.com',
            'Support Team'
        ),
        subject: 'Welcome to Our Application',
    );
}

This is useful when different types of emails need different sender identities.

---

Adding CC and BCC

Laravel allows you to send emails with CC and BCC recipients.

For example:

Mail::to($user->email)
    ->cc('manager@example.com')
    ->bcc('admin@example.com')
    ->send(new WelcomeEmail($user));

Use BCC carefully, especially when handling personal or confidential information.

---

Sending Emails to Multiple Recipients

You can send an email to multiple recipients:

Mail::to([
    'user1@example.com',
    'user2@example.com',
])->send(new WelcomeEmail());

For large recipient lists, however, you should consider queues and appropriate bulk-email infrastructure instead of sending thousands of emails in a single web request.

---

Laravel Queued Emails

Sending email synchronously can slow down an HTTP request.

For example:

User submits form
       │
       ▼
Application sends email
       │
       ▼
Wait for email provider
       │
       ▼
Response returned

This isn’t ideal for emails that take time to process.

Queues change the workflow:

User submits form
       │
       ▼
Create email job
       │
       ▼
Return response quickly
       │
       ▼
Queue Worker
       │
       ▼
Send Email

This improves the user experience.

---

Queue a Laravel Mailable

A Mailable can implement ShouldQueue:

use Illuminate\Contracts\Queue\ShouldQueue;

class WelcomeEmail extends Mailable implements ShouldQueue
{
    // ...
}

Then:

Mail::to($user->email)
    ->queue(new WelcomeEmail($user));

Laravel places the email on the configured queue instead of waiting for it to be sent during the request.

---

Running the Queue Worker

For a basic queue worker:

php artisan queue:work

The worker processes queued jobs.

In production, queue workers should generally be managed by a process supervisor or an equivalent infrastructure service so they restart automatically when needed.

---

Email Notifications vs Mailables

Laravel provides multiple ways to send application notifications.

Use Mailables when you’re building a dedicated email with specific content and structure.

Use Notifications when an event needs to notify a user through one or more channels.

For example:

Order Completed
      │
      ▼
Notification
      │
      ├── Email
      ├── Database
      └── Other Channels

Notifications are particularly useful for application-wide notification systems.

---

Sending Emails With Laravel Notifications

You can create a notification using:

php artisan make:notification OrderShipped

Then define the mail channel:

public function via(object $notifiable): array
{
    return ['mail'];
}

You can then define the email content using Laravel’s notification mail functionality.

This approach is useful when your application already has a notification system.

---

Testing Laravel Emails

Testing emails is important before deploying your application.

Laravel provides tools for asserting that mail was sent.

For example:

use Illuminate\Support\Facades\Mail;

Mail::fake();

Mail::to('user@example.com')
    ->send(new WelcomeEmail());

Mail::assertSent(WelcomeEmail::class);

You can also inspect the Mailable’s contents and recipients in tests.

The key idea is:

Test
 │
 ▼
Mail::fake()
 │
 ▼
Application sends email
 │
 ▼
Laravel captures email
 │
 ▼
Assertions

No real email needs to be delivered during the test.

---

Previewing Email Templates

During development, it is often useful to preview your email templates before sending real messages.

You can return a Mailable from a route or controller in a development environment.

For example:

Route::get('/preview-welcome-email', function () {
    $user = User::first();

    return new WelcomeEmail($user);
});

This allows you to inspect the rendered email in your browser.

Do not expose email preview routes publicly in production.

---

Common Laravel Email Providers

Laravel applications can connect to different email delivery services.

Common options include:

Provider Type	Typical Use
SMTP	General email delivery
Amazon SES	High-volume transactional email
Mailgun	Developer-focused transactional email
Postmark	Transactional application email
Resend	Modern developer-focused email API
Other SMTP providers	Smaller applications and custom mail servers

The best choice depends on your application’s email volume, deliverability requirements, pricing, and infrastructure.

---

SMTP vs Email API

There are two common approaches to email delivery.

SMTP

SMTP is a traditional email delivery protocol.

Laravel
   │
   ▼
SMTP Server
   │
   ▼
Recipient Mail Server
   │
   ▼
Inbox

It is widely supported and relatively simple to configure.

Email API

An email API allows Laravel to communicate with a provider using an HTTP-based service.

Laravel
   │
   ▼
Email API
   │
   ▼
Provider Infrastructure
   │
   ▼
Recipient

Email APIs can provide additional features such as analytics, templates, delivery tracking, and detailed logs.

---

Laravel Email Troubleshooting

If emails aren’t being delivered, check the following.

Check .env Configuration

Verify:

MAIL_MAILER=
MAIL_HOST=
MAIL_PORT=
MAIL_USERNAME=
MAIL_PASSWORD=
MAIL_ENCRYPTION=
MAIL_FROM_ADDRESS=
MAIL_FROM_NAME=

Make sure the values match your provider’s documentation.

---

Clear Configuration Cache

After changing .env:

php artisan config:clear

If necessary:

php artisan optimize:clear

---

Check Queue Workers

If your Mailable implements ShouldQueue, make sure a worker is running:

php artisan queue:work

Otherwise, queued emails may remain pending.

---

Check Application Logs

Laravel logs can provide useful information about mail connection errors.

Check:

storage/logs/laravel.log

Look for:

• Authentication failures
• Connection errors
• Invalid SMTP settings
• TLS problems
• DNS errors
• Provider errors
• Queue failures

---

Common Laravel Email Mistakes

1. Hardcoding Email Credentials

Avoid putting credentials directly into PHP files.

Bad:

$password = 'my-secret-password';

Use .env and Laravel configuration instead.

---

2. Sending Large Emails Synchronously

Sending large emails or attachments during a web request can make the application feel slow.

Use queues for appropriate workloads.

---

3. Forgetting Queue Workers

If you use:

->queue(...)

or a queued Mailable, you need a functioning queue worker.

---

4. Not Configuring SPF and DKIM

Email delivery isn’t only about Laravel configuration.

For production email, configure the authentication records recommended by your email provider, commonly including:

• SPF
• DKIM
• DMARC

These help improve sender authentication and email deliverability.

---

5. Using a Personal Email Account for High-Volume Email

Personal mailboxes are generally not designed for application-scale transactional email.

Use a proper transactional email provider for production applications.

---

Laravel Email Best Practices

Use Mailables

Keep email content and configuration inside dedicated Mailable classes rather than putting large HTML templates inside controllers.

Use Blade or Markdown Templates

Separate email presentation from application logic.

Queue Important Emails

Use queues for emails that don’t need to block the user’s request.

Keep Credentials Secure

Store mail credentials in environment variables or your deployment secret manager.

Configure Email Authentication

For production domains, configure SPF, DKIM, and DMARC according to your email provider’s instructions.

Test Emails Automatically

Use Mail::fake() and assertions in automated tests.

Monitor Delivery

For production systems, monitor email provider logs, delivery events, bounces, and failures.

---

Real-World Example: Order Confirmation Email

A typical e-commerce workflow might look like:

Customer Places Order
        │
        ▼
Order Saved
        │
        ▼
Order Confirmation Event
        │
        ▼
Queue Email
        │
        ▼
Mail Worker
        │
        ▼
Email Provider
        │
        ▼
Customer Receives Email

The email could contain:

Order #10582

Hello John,

Your order has been confirmed.

Product:
Laptop

Total:
$799.99

[View Order]

Thank you for shopping with us.

Using a queued Mailable keeps the checkout request fast while the email is processed in the background.

---

Laravel Email Workflow Cheat Sheet

# Create a Mailable
php artisan make:mail WelcomeEmail

# Create a Markdown Mailable
php artisan make:mail OrderConfirmation --markdown=emails.orders.confirmation

# Create a notification
php artisan make:notification OrderShipped

# Clear configuration cache
php artisan config:clear

# Clear Laravel caches
php artisan optimize:clear

# Run queue worker
php artisan queue:work

Basic sending:

Mail::to($user->email)
    ->send(new WelcomeEmail($user));

Queued sending:

Mail::to($user->email)
    ->queue(new WelcomeEmail($user));

---

Frequently Asked Questions

How do I send an email in Laravel?

Create a Mailable using:

php artisan make:mail WelcomeEmail

Configure the Mailable and email view, then send it using:

Mail::to('user@example.com')
    ->send(new WelcomeEmail());

How do I configure SMTP in Laravel?

Configure the required mail environment variables in your .env file, including the mailer, SMTP host, port, username, password, encryption, and sender address.

What is a Mailable in Laravel?

A Mailable is a Laravel class that defines the content, subject, recipients, attachments, and other behavior of an email.

It keeps email logic organized and reusable.

How do I send an email asynchronously in Laravel?

Make the Mailable implement ShouldQueue and send it using:

Mail::to($user->email)
    ->queue(new WelcomeEmail($user));

Then run a queue worker:

php artisan queue:work

Can Laravel send HTML emails?

Yes. Laravel supports HTML emails through Blade templates and Markdown-based mailables.

How do I attach a PDF to a Laravel email?

Laravel Mailables support attachments. You can attach a file from a path or storage using Laravel’s Attachment class.

Why is my Laravel email not sending?

Check your .env mail configuration, clear configuration cache, inspect storage/logs/laravel.log, and verify your queue worker if the email is queued.

Also verify that your email provider allows the configured sender and authentication method.

Should I use SMTP or an email API with Laravel?

Both approaches can work. SMTP is simple and widely supported, while email APIs can provide additional features such as delivery tracking and provider-specific integrations.

For production applications, choose a provider based on deliverability, reliability, volume, features, and cost.

---

Key Takeaways

• Laravel provides a powerful built-in mail system.
• Mailables are the preferred way to organize reusable email content.
• Email templates can be created with Blade or Markdown.
• Configure your mail provider through environment variables.
• Use queues when email delivery shouldn’t block the user’s request.
• Attach files using Laravel’s Mailable attachment functionality.
• Use Notifications when email is part of a broader notification system.
• Test emails using Mail::fake().
• Clear configuration caches after changing mail settings when necessary.
• Configure SPF, DKIM, and DMARC for production email domains.
• Never expose email credentials or application secrets in source control.

---

Conclusion

Learning how to send emails in Laravel is an essential skill for Laravel developers because almost every production application eventually needs transactional email.

Laravel’s Mailable system provides a clean way to create reusable email classes, while Blade and Markdown templates make email content easy to maintain. For larger applications, queues allow emails to be processed in the background without slowing down user requests.

A production-ready Laravel email system should go beyond simply sending a message. It should use secure configuration, proper email authentication, reliable delivery infrastructure, automated testing, queue processing, and monitoring.

Once you understand Mailables, templates, SMTP or email APIs, attachments, queues, and notifications, you can build reliable email workflows for everything from welcome messages and password resets to invoices, order confirmations, and application notifications.

---