Mail

• Introduction
  • Configuration
  • Driver Prerequisites
  • Failover Configuration
  • Round Robin Configuration
• Generating Mailables
• Writing Mailables
  • Configuring the Sender
  • Configuring the View
  • View Data
  • Attachments
  • Inline Attachments
  • Attachable Objects
  • Headers
  • Tags and Metadata
  • Customizing the Symfony Message
• Markdown Mailables
  • Generating Markdown Mailables
  • Writing Markdown Messages
  • Customizing the Components
• Sending Mail
  • Queueing Mail
• Rendering Mailables
  • Previewing Mailables in the Browser
• Localizing Mailables
• Testing
  • Testing Mailable Content
  • Testing Mailable Sending
• Mail and Local Development
• Events
• Custom Transports
  • Additional Symfony Transports

Introduction

Sending email doesn't have to be complicated. Laravel provides a clean, simple email API powered by the popular Symfony Mailer component. Laravel and Symfony Mailer provide drivers for sending email via SMTP, Mailgun, Postmark, Resend, Amazon SES, and sendmail, allowing you to quickly get started sending mail through a local or cloud based service of your choice.

Configuration

Laravel's email services may be configured via your application's config/mail.php configuration file. Each mailer configured within this file may have its own unique configuration and even its own unique "transport", allowing your application to use different email services to send certain email messages. For example, your application might use Postmark to send transactional emails while using Amazon SES to send bulk emails.

Within your mail configuration file, you will find a mailers configuration array. This array contains a sample configuration entry for each of the major mail drivers / transports supported by Laravel, while the default configuration value determines which mailer will be used by default when your application needs to send an email message.

Driver / Transport Prerequisites

The API based drivers such as Mailgun, Postmark, Resend, and MailerSend are often simpler and faster than sending mail via SMTP servers. Whenever possible, we recommend that you use one of these drivers.

Mailgun Driver

To use the Mailgun driver, install Symfony's Mailgun Mailer transport via Composer:

1composer require symfony/mailgun-mailer symfony/http-client
1composer require symfony/mailgun-mailer symfony/http-client

Next, set the default option in your application's config/mail.php configuration file to mailgun and add the following configuration array to your array of mailers:

1'mailgun' => [
2    'transport' => 'mailgun',
3    // 'client' => [
4    //     'timeout' => 5,
5    // ],
6],
1'mailgun' => [
2    'transport' => 'mailgun',
3    // 'client' => [
4    //     'timeout' => 5,
5    // ],
6],

After configuring your application's default mailer, add the following options to your config/services.php configuration file:

1'mailgun' => [
2    'domain' => env('MAILGUN_DOMAIN'),
3    'secret' => env('MAILGUN_SECRET'),
4    'endpoint' => env('MAILGUN_ENDPOINT', 'api.mailgun.net'),
5    'scheme' => 'https',
6],
1'mailgun' => [
2    'domain' => env('MAILGUN_DOMAIN'),
3    'secret' => env('MAILGUN_SECRET'),
4    'endpoint' => env('MAILGUN_ENDPOINT', 'api.mailgun.net'),
5    'scheme' => 'https',
6],

If you are not using the United States Mailgun region, you may define your region's endpoint in the services configuration file:

1'mailgun' => [
2    'domain' => env('MAILGUN_DOMAIN'),
3    'secret' => env('MAILGUN_SECRET'),
4    'endpoint' => env('MAILGUN_ENDPOINT', 'api.eu.mailgun.net'),
5    'scheme' => 'https',
6],
1'mailgun' => [
2    'domain' => env('MAILGUN_DOMAIN'),
3    'secret' => env('MAILGUN_SECRET'),
4    'endpoint' => env('MAILGUN_ENDPOINT', 'api.eu.mailgun.net'),
5    'scheme' => 'https',
6],

Postmark Driver

To use the Postmark driver, install Symfony's Postmark Mailer transport via Composer:

1composer require symfony/postmark-mailer symfony/http-client
1composer require symfony/postmark-mailer symfony/http-client

Next, set the default option in your application's config/mail.php configuration file to postmark. After configuring your application's default mailer, ensure that your config/services.php configuration file contains the following options:

1'postmark' => [
2    'token' => env('POSTMARK_TOKEN'),
3],
1'postmark' => [
2    'token' => env('POSTMARK_TOKEN'),
3],

If you would like to specify the Postmark message stream that should be used by a given mailer, you may add the message_stream_id configuration option to the mailer's configuration array. This configuration array can be found in your application's config/mail.php configuration file:

1'postmark' => [
2    'transport' => 'postmark',
3    'message_stream_id' => env('POSTMARK_MESSAGE_STREAM_ID'),
4    // 'client' => [
5    //     'timeout' => 5,
6    // ],
7],
1'postmark' => [
2    'transport' => 'postmark',
3    'message_stream_id' => env('POSTMARK_MESSAGE_STREAM_ID'),
4    // 'client' => [
5    //     'timeout' => 5,
6    // ],
7],

This way you are also able to set up multiple Postmark mailers with different message streams.

Resend Driver

To use the Resend driver, install Resend's PHP SDK via Composer:

1composer require resend/resend-php
1composer require resend/resend-php

Next, set the default option in your application's config/mail.php configuration file to resend. After configuring your application's default mailer, ensure that your config/services.php configuration file contains the following options:

1'resend' => [
2    'key' => env('RESEND_KEY'),
3],
1'resend' => [
2    'key' => env('RESEND_KEY'),
3],

SES Driver

To use the Amazon SES driver you must first install the Amazon AWS SDK for PHP. You may install this library via the Composer package manager:

1composer require aws/aws-sdk-php
1composer require aws/aws-sdk-php

Next, set the default option in your config/mail.php configuration file to ses and verify that your config/services.php configuration file contains the following options:

1'ses' => [
2    'key' => env('AWS_ACCESS_KEY_ID'),
3    'secret' => env('AWS_SECRET_ACCESS_KEY'),
4    'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
5],
1'ses' => [
2    'key' => env('AWS_ACCESS_KEY_ID'),
3    'secret' => env('AWS_SECRET_ACCESS_KEY'),
4    'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
5],

To utilize AWS temporary credentials via a session token, you may add a token key to your application's SES configuration:

1'ses' => [
2    'key' => env('AWS_ACCESS_KEY_ID'),
3    'secret' => env('AWS_SECRET_ACCESS_KEY'),
4    'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
5    'token' => env('AWS_SESSION_TOKEN'),
6],
1'ses' => [
2    'key' => env('AWS_ACCESS_KEY_ID'),
3    'secret' => env('AWS_SECRET_ACCESS_KEY'),
4    'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
5    'token' => env('AWS_SESSION_TOKEN'),
6],

To interact with SES's subscription management features, you may return the X-Ses-List-Management-Options header in the array returned by the headers method of a mail message:

 1/**
 2 * Get the message headers.
 3 */
 4public function headers(): Headers
 5{
 6    return new Headers(
 7        text: [
 8            'X-Ses-List-Management-Options' => 'contactListName=MyContactList;topicName=MyTopic',
 9        ],
10    );
11}
 1/**
 2 * Get the message headers.
 3 */
 4public function headers(): Headers
 5{
 6    return new Headers(
 7        text: [
 8            'X-Ses-List-Management-Options' => 'contactListName=MyContactList;topicName=MyTopic',
 9        ],
10    );
11}

If you would like to define additional options that Laravel should pass to the AWS SDK's SendEmail method when sending an email, you may define an options array within your ses configuration:

 1'ses' => [
 2    'key' => env('AWS_ACCESS_KEY_ID'),
 3    'secret' => env('AWS_SECRET_ACCESS_KEY'),
 4    'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
 5    'options' => [
 6        'ConfigurationSetName' => 'MyConfigurationSet',
 7        'EmailTags' => [
 8            ['Name' => 'foo', 'Value' => 'bar'],
 9        ],
10    ],
11],
 1'ses' => [
 2    'key' => env('AWS_ACCESS_KEY_ID'),
 3    'secret' => env('AWS_SECRET_ACCESS_KEY'),
 4    'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
 5    'options' => [
 6        'ConfigurationSetName' => 'MyConfigurationSet',
 7        'EmailTags' => [
 8            ['Name' => 'foo', 'Value' => 'bar'],
 9        ],
10    ],
11],

MailerSend Driver

MailerSend, a transactional email and SMS service, maintains their own API based mail driver for Laravel. The package containing the driver may be installed via the Composer package manager:

1composer require mailersend/laravel-driver
1composer require mailersend/laravel-driver

Once the package is installed, add the MAILERSEND_API_KEY environment variable to your application's .env file. In addition, the MAIL_MAILER environment variable should be defined as mailersend:

1MAIL_MAILER=mailersend
2MAIL_FROM_ADDRESS[email protected]
3MAIL_FROM_NAME="App Name"
4 
5MAILERSEND_API_KEY=your-api-key
1MAIL_MAILER=mailersend
2MAIL_FROM_ADDRESS[email protected]
3MAIL_FROM_NAME="App Name"
4 
5MAILERSEND_API_KEY=your-api-key

Finally, add MailerSend to the mailers array in your application's config/mail.php configuration file:

1'mailersend' => [
2    'transport' => 'mailersend',
3],
1'mailersend' => [
2    'transport' => 'mailersend',
3],

To learn more about MailerSend, including how to use hosted templates, consult the MailerSend driver documentation.

Failover Configuration

Sometimes, an external service you have configured to send your application's mail may be down. In these cases, it can be useful to define one or more backup mail delivery configurations that will be used in case your primary delivery driver is down.

To accomplish this, you should define a mailer within your application's mail configuration file that uses the failover transport. The configuration array for your application's failover mailer should contain an array of mailers that reference the order in which configured mailers should be chosen for delivery:

 1'mailers' => [
 2    'failover' => [
 3        'transport' => 'failover',
 4        'mailers' => [
 5            'postmark',
 6            'mailgun',
 7            'sendmail',
 8        ],
 9    ],
10 
11    // ...
12],
 1'mailers' => [
 2    'failover' => [
 3        'transport' => 'failover',
 4        'mailers' => [
 5            'postmark',
 6            'mailgun',
 7            'sendmail',
 8        ],
 9    ],
10 
11    // ...
12],

Once your failover mailer has been defined, you should set this mailer as the default mailer used by your application by specifying its name as the value of the default configuration key within your application's mail configuration file:

1'default' => env('MAIL_MAILER', 'failover'),
1'default' => env('MAIL_MAILER', 'failover'),

Round Robin Configuration

The roundrobin transport allows you to distribute your mailing workload across multiple mailers. To get started, define a mailer within your application's mail configuration file that uses the roundrobin transport. The configuration array for your application's roundrobin mailer should contain an array of mailers that reference which configured mailers should be used for delivery:

 1'mailers' => [
 2    'roundrobin' => [
 3        'transport' => 'roundrobin',
 4        'mailers' => [
 5            'ses',
 6            'postmark',
 7        ],
 8    ],
 9 
10    // ...
11],
 1'mailers' => [
 2    'roundrobin' => [
 3        'transport' => 'roundrobin',
 4        'mailers' => [
 5            'ses',
 6            'postmark',
 7        ],
 8    ],
 9 
10    // ...
11],

Once your round robin mailer has been defined, you should set this mailer as the default mailer used by your application by specifying its name as the value of the default configuration key within your application's mail configuration file:

1'default' => env('MAIL_MAILER', 'roundrobin'),
1'default' => env('MAIL_MAILER', 'roundrobin'),

The round robin transport selects a random mailer from the list of configured mailers and then switches to the next available mailer for each subsequent email. In contrast to failover transport, which helps to achieve high availability, the roundrobin transport provides load balancing.

Generating Mailables

When building Laravel applications, each type of email sent by your application is represented as a "mailable" class. These classes are stored in the app/Mail directory. Don't worry if you don't see this directory in your application, since it will be generated for you when you create your first mailable class using the make:mail Artisan command:

1php artisan make:mail OrderShipped
1php artisan make:mail OrderShipped

Writing Mailables

Once you have generated a mailable class, open it up so we can explore its contents. Mailable class configuration is done in several methods, including the envelope, content, and attachments methods.

The envelope method returns an Illuminate\Mail\Mailables\Envelope object that defines the subject and, sometimes, the recipients of the message. The content method returns an Illuminate\Mail\Mailables\Content object that defines the Blade template that will be used to generate the message content.

Configuring the Sender

Using the Envelope

First, let's explore configuring the sender of the email. Or, in other words, who the email is going to be "from". There are two ways to configure the sender. First, you may specify the "from" address on your message's envelope:

 1use Illuminate\Mail\Mailables\Address;
 2use Illuminate\Mail\Mailables\Envelope;
 3 
 4/**
 5 * Get the message envelope.
 6 */
 7public function envelope(): Envelope
 8{
 9    return new Envelope(
10        from: new Address('[email protected]', 'Jeffrey Way'),
11        subject: 'Order Shipped',
12    );
13}
 1use Illuminate\Mail\Mailables\Address;
 2use Illuminate\Mail\Mailables\Envelope;
 3 
 4/**
 5 * Get the message envelope.
 6 */
 7public function envelope(): Envelope
 8{
 9    return new Envelope(
10        from: new Address('[email protected]', 'Jeffrey Way'),
11        subject: 'Order Shipped',
12    );
13}

If you would like, you may also specify a replyTo address:

1return new Envelope(
2    from: new Address('[email protected]', 'Jeffrey Way'),
3    replyTo: [
4        new Address('[email protected]', 'Taylor Otwell'),
5    ],
6    subject: 'Order Shipped',
7);
1return new Envelope(
2    from: new Address('[email protected]', 'Jeffrey Way'),
3    replyTo: [
4        new Address('[email protected]', 'Taylor Otwell'),
5    ],
6    subject: 'Order Shipped',
7);

Using a Global from Address

However, if your application uses the same "from" address for all of its emails, it can become cumbersome to add it to each mailable class you generate. Instead, you may specify a global "from" address in your config/mail.php configuration file. This address will be used if no other "from" address is specified within the mailable class:

1'from' => [
2    'address' => env('MAIL_FROM_ADDRESS', '[email protected]'),
3    'name' => env('MAIL_FROM_NAME', 'Example'),
4],
1'from' => [
2    'address' => env('MAIL_FROM_ADDRESS', '[email protected]'),
3    'name' => env('MAIL_FROM_NAME', 'Example'),
4],

In addition, you may define a global "reply_to" address within your config/mail.php configuration file:

1'reply_to' => ['address' => '[email protected]', 'name' => 'App Name'],
1'reply_to' => ['address' => '[email protected]', 'name' => 'App Name'],

Configuring the View

Within a mailable class's content method, you may define the view, or which template should be used when rendering the email's contents. Since each email typically uses a Blade template to render its contents, you have the full power and convenience of the Blade templating engine when building your email's HTML:

1/**
2 * Get the message content definition.
3 */
4public function content(): Content
5{
6    return new Content(
7        view: 'mail.orders.shipped',
8    );
9}
1/**
2 * Get the message content definition.
3 */
4public function content(): Content
5{
6    return new Content(
7        view: 'mail.orders.shipped',
8    );
9}

Plain Text Emails

If you would like to define a plain-text version of your email, you may specify the plain-text template when creating the message's Content definition. Like the view parameter, the text parameter should be a template name which will be used to render the contents of the email. You are free to define both an HTML and plain-text version of your message:

 1/**
 2 * Get the message content definition.
 3 */
 4public function content(): Content
 5{
 6    return new Content(
 7        view: 'mail.orders.shipped',
 8        text: 'mail.orders.shipped-text'
 9    );
10}
 1/**
 2 * Get the message content definition.
 3 */
 4public function content(): Content
 5{
 6    return new Content(
 7        view: 'mail.orders.shipped',
 8        text: 'mail.orders.shipped-text'
 9    );
10}

For clarity, the html parameter may be used as an alias of the view parameter:

1return new Content(
2    html: 'mail.orders.shipped',
3    text: 'mail.orders.shipped-text'
4);
1return new Content(
2    html: 'mail.orders.shipped',
3    text: 'mail.orders.shipped-text'
4);

View Data

Via Public Properties

Typically, you will want to pass some data to your view that you can utilize when rendering the email's HTML. There are two ways you may make data available to your view. First, any public property defined on your mailable class will automatically be made available to the view. So, for example, you may pass data into your mailable class's constructor and set that data to public properties defined on the class:

 1<?php
 2 
 3namespace App\Mail;
 4 
 5use App\Models\Order;
 6use Illuminate\Bus\Queueable;
 7use Illuminate\Mail\Mailable;
 8use Illuminate\Mail\Mailables\Content;
 9use Illuminate\Queue\SerializesModels;
10 
11class OrderShipped extends Mailable
12{
13    use Queueable, SerializesModels;
14 
15    /**
16     * Create a new message instance.
17     */
18    public function __construct(
19        public Order $order,
20    ) {}
21 
22    /**
23     * Get the message content definition.
24     */
25    public function content(): Content
26    {
27        return new Content(
28            view: 'mail.orders.shipped',
29        );
30    }
31}
 1<?php
 2 
 3namespace App\Mail;
 4 
 5use App\Models\Order;
 6use Illuminate\Bus\Queueable;
 7use Illuminate\Mail\Mailable;
 8use Illuminate\Mail\Mailables\Content;
 9use Illuminate\Queue\SerializesModels;
10 
11class OrderShipped extends Mailable
12{
13    use Queueable, SerializesModels;
14 
15    /**
16     * Create a new message instance.
17     */
18    public function __construct(
19        public Order $order,
20    ) {}
21 
22    /**
23     * Get the message content definition.
24     */
25    public function content(): Content
26    {
27        return new Content(
28            view: 'mail.orders.shipped',
29        );
30    }
31}

Once the data has been set to a public property, it will automatically be available in your view, so you may access it like you would access any other data in your Blade templates:

1<div>
2    Price: {{ $order->price }}
3</div>
1<div>
2    Price: {{ $order->price }}
3</div>

Via the with Parameter:

If you would like to customize the format of your email's data before it is sent to the template, you may manually pass your data to the view via the Content definition's with parameter. Typically, you will still pass data via the mailable class's constructor; however, you should set this data to protected or private properties so the data is not automatically made available to the template:

 1<?php
 2 
 3namespace App\Mail;
 4 
 5use App\Models\Order;
 6use Illuminate\Bus\Queueable;
 7use Illuminate\Mail\Mailable;
 8use Illuminate\Mail\Mailables\Content;
 9use Illuminate\Queue\SerializesModels;
10 
11class OrderShipped extends Mailable
12{
13    use Queueable, SerializesModels;
14 
15    /**
16     * Create a new message instance.
17     */
18    public function __construct(
19        protected Order $order,
20    ) {}
21 
22    /**
23     * Get the message content definition.
24     */
25    public function content(): Content
26    {
27        return new Content(
28            view: 'mail.orders.shipped',
29            with: [
30                'orderName' => $this->order->name,
31                'orderPrice' => $this->order->price,
32            ],
33        );
34    }
35}
 1<?php
 2 
 3namespace App\Mail;
 4 
 5use App\Models\Order;
 6use Illuminate\Bus\Queueable;
 7use Illuminate\Mail\Mailable;
 8use Illuminate\Mail\Mailables\Content;
 9use Illuminate\Queue\SerializesModels;
10 
11class OrderShipped extends Mailable
12{
13    use Queueable, SerializesModels;
14 
15    /**
16     * Create a new message instance.
17     */
18    public function __construct(
19        protected Order $order,
20    ) {}
21 
22    /**
23     * Get the message content definition.
24     */
25    public function content(): Content
26    {
27        return new Content(
28            view: 'mail.orders.shipped',
29            with: [
30                'orderName' => $this->order->name,
31                'orderPrice' => $this->order->price,
32            ],
33        );
34    }
35}

Once the data has been passed to the with method, it will automatically be available in your view, so you may access it like you would access any other data in your Blade templates:

1<div>
2    Price: {{ $orderPrice }}
3</div>
1<div>
2    Price: {{ $orderPrice }}
3</div>

Attachments

To add attachments to an email, you will add attachments to the array returned by the message's attachments method. First, you may add an attachment by providing a file path to the fromPath method provided by the Attachment class:

 1use Illuminate\Mail\Mailables\Attachment;
 2 
 3/**
 4 * Get the attachments for the message.
 5 *
 6 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 7 */
 8public function attachments(): array
 9{
10    return [
11        Attachment::fromPath('/path/to/file'),
12    ];
13}
 1use Illuminate\Mail\Mailables\Attachment;
 2 
 3/**
 4 * Get the attachments for the message.
 5 *
 6 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 7 */
 8public function attachments(): array
 9{
10    return [
11        Attachment::fromPath('/path/to/file'),
12    ];
13}

When attaching files to a message, you may also specify the display name and / or MIME type for the attachment using the as and withMime methods:

 1/**
 2 * Get the attachments for the message.
 3 *
 4 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 5 */
 6public function attachments(): array
 7{
 8    return [
 9        Attachment::fromPath('/path/to/file')
10                ->as('name.pdf')
11                ->withMime('application/pdf'),
12    ];
13}
 1/**
 2 * Get the attachments for the message.
 3 *
 4 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 5 */
 6public function attachments(): array
 7{
 8    return [
 9        Attachment::fromPath('/path/to/file')
10                ->as('name.pdf')
11                ->withMime('application/pdf'),
12    ];
13}

Attaching Files From Disk

If you have stored a file on one of your filesystem disks, you may attach it to the email using the fromStorage attachment method:

 1/**
 2 * Get the attachments for the message.
 3 *
 4 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 5 */
 6public function attachments(): array
 7{
 8    return [
 9        Attachment::fromStorage('/path/to/file'),
10    ];
11}
 1/**
 2 * Get the attachments for the message.
 3 *
 4 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 5 */
 6public function attachments(): array
 7{
 8    return [
 9        Attachment::fromStorage('/path/to/file'),
10    ];
11}

Of course, you may also specify the attachment's name and MIME type:

 1/**
 2 * Get the attachments for the message.
 3 *
 4 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 5 */
 6public function attachments(): array
 7{
 8    return [
 9        Attachment::fromStorage('/path/to/file')
10                ->as('name.pdf')
11                ->withMime('application/pdf'),
12    ];
13}
 1/**
 2 * Get the attachments for the message.
 3 *
 4 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 5 */
 6public function attachments(): array
 7{
 8    return [
 9        Attachment::fromStorage('/path/to/file')
10                ->as('name.pdf')
11                ->withMime('application/pdf'),
12    ];
13}

The fromStorageDisk method may be used if you need to specify a storage disk other than your default disk:

 1/**
 2 * Get the attachments for the message.
 3 *
 4 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 5 */
 6public function attachments(): array
 7{
 8    return [
 9        Attachment::fromStorageDisk('s3', '/path/to/file')
10                ->as('name.pdf')
11                ->withMime('application/pdf'),
12    ];
13}
 1/**
 2 * Get the attachments for the message.
 3 *
 4 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 5 */
 6public function attachments(): array
 7{
 8    return [
 9        Attachment::fromStorageDisk('s3', '/path/to/file')
10                ->as('name.pdf')
11                ->withMime('application/pdf'),
12    ];
13}

Raw Data Attachments

The fromData attachment method may be used to attach a raw string of bytes as an attachment. For example, you might use this method if you have generated a PDF in memory and want to attach it to the email without writing it to disk. The fromData method accepts a closure which resolves the raw data bytes as well as the name that the attachment should be assigned:

 1/**
 2 * Get the attachments for the message.
 3 *
 4 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 5 */
 6public function attachments(): array
 7{
 8    return [
 9        Attachment::fromData(fn () => $this->pdf, 'Report.pdf')
10                ->withMime('application/pdf'),
11    ];
12}
 1/**
 2 * Get the attachments for the message.
 3 *
 4 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
 5 */
 6public function attachments(): array
 7{
 8    return [
 9        Attachment::fromData(fn () => $this->pdf, 'Report.pdf')
10                ->withMime('application/pdf'),
11    ];
12}

Inline Attachments

Embedding inline images into your emails is typically cumbersome; however, Laravel provides a convenient way to attach images to your emails. To embed an inline image, use the embed method on the $message variable within your email template. Laravel automatically makes the $message variable available to all of your email templates, so you don't need to worry about passing it in manually:

1<body>
2    Here is an image:
3 
4    <img src="{{ $message->embed($pathToImage) }}">
5</body>
1<body>
2    Here is an image:
3 
4    <img src="{{ $message->embed($pathToImage) }}">
5</body>

Embedding Raw Data Attachments

If you already have a raw image data string you wish to embed into an email template, you may call the embedData method on the $message variable. When calling the embedData method, you will need to provide a filename that should be assigned to the embedded image:

1<body>
2    Here is an image from raw data:
3 
4    <img src="{{ $message->embedData($data, 'example-image.jpg') }}">
5</body>
1<body>
2    Here is an image from raw data:
3 
4    <img src="{{ $message->embedData($data, 'example-image.jpg') }}">
5</body>

Attachable Objects

While attaching files to messages via simple string paths is often sufficient, in many cases the attachable entities within your application are represented by classes. For example, if your application is attaching a photo to a message, your application may also have a Photo model that represents that photo. When that is the case, wouldn't it be convenient to simply pass the Photo model to the attach method? Attachable objects allow you to do just that.

To get started, implement the Illuminate\Contracts\Mail\Attachable interface on the object that will be attachable to messages. This interface dictates that your class defines a toMailAttachment method that returns an Illuminate\Mail\Attachment instance:

 1<?php
 2 
 3namespace App\Models;
 4 
 5use Illuminate\Contracts\Mail\Attachable;
 6use Illuminate\Database\Eloquent\Model;
 7use Illuminate\Mail\Attachment;
 8 
 9class Photo extends Model implements Attachable
10{
11    /**
12     * Get the attachable representation of the model.
13     */
14    public function toMailAttachment(): Attachment
15    {
16        return Attachment::fromPath('/path/to/file');
17    }
18}
 1<?php
 2 
 3namespace App\Models;
 4 
 5use Illuminate\Contracts\Mail\Attachable;
 6use Illuminate\Database\Eloquent\Model;
 7use Illuminate\Mail\Attachment;
 8 
 9class Photo extends Model implements Attachable
10{
11    /**
12     * Get the attachable representation of the model.
13     */
14    public function toMailAttachment(): Attachment
15    {
16        return Attachment::fromPath('/path/to/file');
17    }
18}

Once you have defined your attachable object, you may return an instance of that object from the attachments method when building an email message:

1/**
2 * Get the attachments for the message.
3 *
4 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
5 */
6public function attachments(): array
7{
8    return [$this->photo];
9}
1/**
2 * Get the attachments for the message.
3 *
4 * @return array<int, \Illuminate\Mail\Mailables\Attachment>
5 */
6public function attachments(): array
7{
8    return [$this->photo];
9}

Of course, attachment data may be stored on a remote file storage service such as Amazon S3. So, Laravel also allows you to generate attachment instances from data that is stored on one of your application's filesystem disks:

1// Create an attachment from a file on your default disk...
2return Attachment::fromStorage($this->path);
3 
4// Create an attachment from a file on a specific disk...
5return Attachment::fromStorageDisk('backblaze', $this->path);
1// Create an attachment from a file on your default disk...
2return Attachment::fromStorage($this->path);
3 
4// Create an attachment from a file on a specific disk...
5return Attachment::fromStorageDisk('backblaze', $this->path);

In addition, you may create attachment instances via data that you have in memory. To accomplish this, provide a closure to the fromData method. The closure should return the raw data that represents the attachment:

1return Attachment::fromData(fn () => $this->content, 'Photo Name');
1return Attachment::fromData(fn () => $this->content, 'Photo Name');

Laravel also provides additional methods that you may use to customize your attachments. For example, you may use the as and withMime methods to customize the file's name and MIME type:

1return Attachment::fromPath('/path/to/file')
2        ->as('Photo Name')
3        ->withMime('image/jpeg');
1return Attachment::fromPath('/path/to/file')
2        ->as('Photo Name')
3        ->withMime('image/jpeg');

Headers

Sometimes you may need to attach additional headers to the outgoing message. For instance, you may need to set a custom Message-Id or other arbitrary text headers.

To accomplish this, define a headers method on your mailable. The headers method should return an Illuminate\Mail\Mailables\Headers instance. This class accepts messageId, references, and text parameters. Of course, you may provide only the parameters you need for your particular message:

 1use Illuminate\Mail\Mailables\Headers;
 2 
 3/**
 4 * Get the message headers.
 5 */
 6public function headers(): Headers
 7{
 8    return new Headers(
 9        messageId: '[email protected]',
10        references: ['[email protected]'],
11        text: [
12            'X-Custom-Header' => 'Custom Value',
13        ],
14    );
15}
 1use Illuminate\Mail\Mailables\Headers;
 2 
 3/**
 4 * Get the message headers.
 5 */
 6public function headers(): Headers
 7{
 8    return new Headers(
 9        messageId: '[email protected]',
10        references: ['[email protected]'],
11        text: [
12            'X-Custom-Header' => 'Custom Value',
13        ],
14    );
15}

Tags and Metadata

Some third-party email providers such as Mailgun and Postmark support message "tags" and "metadata", which may be used to group and track emails sent by your application. You may add tags and metadata to an email message via your Envelope definition:

 1use Illuminate\Mail\Mailables\Envelope;
 2 
 3/**
 4 * Get the message envelope.
 5 *
 6 * @return \Illuminate\Mail\Mailables\Envelope
 7 */
 8public function envelope(): Envelope
 9{
10    return new Envelope(
11        subject: 'Order Shipped',
12        tags: ['shipment'],
13        metadata: [
14            'order_id' => $this->order->id,
15        ],
16    );
17}
 1use Illuminate\Mail\Mailables\Envelope;
 2 
 3/**
 4 * Get the message envelope.
 5 *
 6 * @return \Illuminate\Mail\Mailables\Envelope
 7 */
 8public function envelope(): Envelope
 9{
10    return new Envelope(
11        subject: 'Order Shipped',
12        tags: ['shipment'],
13        metadata: [
14            'order_id' => $this->order->id,
15        ],
16    );
17}

If your application is using the Mailgun driver, you may consult Mailgun's documentation for more information on tags and metadata. Likewise, the Postmark documentation may also be consulted for more information on their support for tags and metadata.

If your application is using Amazon SES to send emails, you should use the metadata method to attach SES "tags" to the message.

Customizing the Symfony Message

Laravel's mail capabilities are powered by Symfony Mailer. Laravel allows you to register custom callbacks that will be invoked with the Symfony Message instance before sending the message. This gives you an opportunity to deeply customize the message before it is sent. To accomplish this, define a using parameter on your Envelope definition:

 1use Illuminate\Mail\Mailables\Envelope;
 2use Symfony\Component\Mime\Email;
 3 
 4/**
 5 * Get the message envelope.
 6 */
 7public function envelope(): Envelope
 8{
 9    return new Envelope(
10        subject: 'Order Shipped',
11        using: [
12            function (Email $message) {
13                // ...
14            },
15        ]
16    );
17}
 1use Illuminate\Mail\Mailables\Envelope;
 2use Symfony\Component\Mime\Email;
 3 
 4/**
 5 * Get the message envelope.
 6 */
 7public function envelope(): Envelope
 8{
 9    return new Envelope(
10        subject: 'Order Shipped',
11        using: [
12            function (Email $message) {
13                // ...
14            },
15        ]
16    );
17}

Markdown Mailables

Markdown mailable messages allow you to take advantage of the pre-built templates and components of mail notifications in your mailables. Since the messages are written in Markdown, Laravel is able to render beautiful, responsive HTML templates for the messages while also automatically generating a plain-text counterpart.

Generating Markdown Mailables

To generate a mailable with a corresponding Markdown template, you may use the --markdown option of the make:mail Artisan command:

1php artisan make:mail OrderShipped --markdown=mail.orders.shipped
1php artisan make:mail OrderShipped --markdown=mail.orders.shipped

Then, when configuring the mailable Content definition within its content method, use the markdown parameter instead of the view parameter:

 1use Illuminate\Mail\Mailables\Content;
 2 
 3/**
 4 * Get the message content definition.
 5 */
 6public function content(): Content
 7{
 8    return new Content(
 9        markdown: 'mail.orders.shipped',
10        with: [
11            'url' => $this->orderUrl,
12        ],
13    );
14}
 1use Illuminate\Mail\Mailables\Content;
 2 
 3/**
 4 * Get the message content definition.
 5 */
 6public function content(): Content
 7{
 8    return new Content(
 9        markdown: 'mail.orders.shipped',
10        with: [
11            'url' => $this->orderUrl,
12        ],
13    );
14}

Writing Markdown Messages

Markdown mailables use a combination of Blade components and Markdown syntax which allow you to easily construct mail messages while leveraging Laravel's pre-built email UI components:

 1<x-mail::message>
 2# Order Shipped
 3 
 4Your order has been shipped!
 5 
 6<x-mail::button :url="$url">
 7View Order
 8</x-mail::button>
 9 
10Thanks,<br>
11{{ config('app.name') }}
12</x-mail::message>
 1<x-mail::message>
 2# Order Shipped
 3 
 4Your order has been shipped!
 5 
 6<x-mail::button :url="$url">
 7View Order
 8</x-mail::button>
 9 
10Thanks,<br>
11{{ config('app.name') }}
12</x-mail::message>

Button Component

The button component renders a centered button link. The component accepts two arguments, a url and an optional color. Supported colors are primary, success, and error. You may add as many button components to a message as you wish:

1<x-mail::button :url="$url" color="success">
2View Order
3</x-mail::button>
1<x-mail::button :url="$url" color="success">
2View Order
3</x-mail::button>

Panel Component

The panel component renders the given block of text in a panel that has a slightly different background color than the rest of the message. This allows you to draw attention to a given block of text:

1<x-mail::panel>
2This is the panel content.
3</x-mail::panel>
1<x-mail::panel>
2This is the panel content.
3</x-mail::panel>

Table Component

The table component allows you to transform a Markdown table into an HTML table. The component accepts the Markdown table as its content. Table column alignment is supported using the default Markdown table alignment syntax:

1<x-mail::table>
2| Laravel       | Table         | Example       |
3| ------------- | :-----------: | ------------: |
4| Col 2 is      | Centered      | $10           |
5| Col 3 is      | Right-Aligned | $20           |
6</x-mail::table>
1<x-mail::table>
2| Laravel       | Table         | Example       |
3| ------------- | :-----------: | ------------: |
4| Col 2 is      | Centered      | $10           |
5| Col 3 is      | Right-Aligned | $20           |
6</x-mail::table>

Customizing the Components

You may export all of the Markdown mail components to your own application for customization. To export the components, use the vendor:publish Artisan command to publish the laravel-mail asset tag:

1php artisan vendor:publish --tag=laravel-mail
1php artisan vendor:publish --tag=laravel-mail

This command will publish the Markdown mail components to the resources/views/vendor/mail directory. The mail directory will contain an html and a text directory, each containing their respective representations of every available component. You are free to customize these components however you like.

Customizing the CSS

After exporting the components, the resources/views/vendor/mail/html/themes directory will contain a default.css file. You may customize the CSS in this file and your styles will automatically be converted to inline CSS styles within the HTML representations of your Markdown mail messages.

If you would like to build an entirely new theme for Laravel's Markdown components, you may place a CSS file within the html/themes directory. After naming and saving your CSS file, update the theme option of your application's config/mail.php configuration file to match the name of your new theme.

To customize the theme for an individual mailable, you may set the $theme property of the mailable class to the name of the theme that should be used when sending that mailable.

Sending Mail

To send a message, use the to method on the Mail facade. The to method accepts an email address, a user instance, or a collection of users. If you pass an object or collection of objects, the mailer will automatically use their email and name properties when determining the email's recipients, so make sure these attributes are available on your objects. Once you have specified your recipients, you may pass an instance of your mailable class to the send method:

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use App\Http\Controllers\Controller;
 6use App\Mail\OrderShipped;
 7use App\Models\Order;
 8use Illuminate\Http\RedirectResponse;
 9use Illuminate\Http\Request;
10use Illuminate\Support\Facades\Mail;
11 
12class OrderShipmentController extends Controller
13{
14    /**
15     * Ship the given order.
16     */
17    public function store(Request $request): RedirectResponse
18    {
19        $order = Order::findOrFail($request->order_id);
20 
21        // Ship the order...
22 
23        Mail::to($request->user())->send(new OrderShipped($order));
24 
25        return redirect('/orders');
26    }
27}
 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use App\Http\Controllers\Controller;
 6use App\Mail\OrderShipped;
 7use App\Models\Order;
 8use Illuminate\Http\RedirectResponse;
 9use Illuminate\Http\Request;
10use Illuminate\Support\Facades\Mail;
11 
12class OrderShipmentController extends Controller
13{
14    /**
15     * Ship the given order.
16     */
17    public function store(Request $request): RedirectResponse
18    {
19        $order = Order::findOrFail($request->order_id);
20 
21        // Ship the order...
22 
23        Mail::to($request->user())->send(new OrderShipped($order));
24 
25        return redirect('/orders');
26    }
27}

You are not limited to just specifying the "to" recipients when sending a message. You are free to set "to", "cc", and "bcc" recipients by chaining their respective methods together:

1Mail::to($request->user())
2    ->cc($moreUsers)
3    ->bcc($evenMoreUsers)
4    ->send(new OrderShipped($order));
1Mail::to($request->user())
2    ->cc($moreUsers)
3    ->bcc($evenMoreUsers)
4    ->send(new OrderShipped($order));

Looping Over Recipients

Occasionally, you may need to send a mailable to a list of recipients by iterating over an array of recipients / email addresses. However, since the to method appends email addresses to the mailable's list of recipients, each iteration through the loop will send another email to every previous recipient. Therefore, you should always re-create the mailable instance for each recipient:

1foreach (['[email protected]', '[email protected]'] as $recipient) {
2    Mail::to($recipient)->send(new OrderShipped($order));
3}
1foreach (['[email protected]', '[email protected]'] as $recipient) {
2    Mail::to($recipient)->send(new OrderShipped($order));
3}

Sending Mail via a Specific Mailer

By default, Laravel will send email using the mailer configured as the default mailer in your application's mail configuration file. However, you may use the mailer method to send a message using a specific mailer configuration:

1Mail::mailer('postmark')
2        ->to($request->user())
3        ->send(new OrderShipped($order));
1Mail::mailer('postmark')
2        ->to($request->user())
3        ->send(new OrderShipped($order));

Queueing Mail

Queueing a Mail Message

Since sending email messages can negatively impact the response time of your application, many developers choose to queue email messages for background sending. Laravel makes this easy using its built-in unified queue API. To queue a mail message, use the queue method on the Mail facade after specifying the message's recipients:

1Mail::to($request->user())
2    ->cc($moreUsers)
3    ->bcc($evenMoreUsers)
4    ->queue(new OrderShipped($order));
1Mail::to($request->user())
2    ->cc($moreUsers)
3    ->bcc($evenMoreUsers)
4    ->queue(new OrderShipped($order));

This method will automatically take care of pushing a job onto the queue so the message is sent in the background. You will need to configure your queues before using this feature.

Delayed Message Queueing

If you wish to delay the delivery of a queued email message, you may use the later method. As its first argument, the later method accepts a DateTime instance indicating when the message should be sent:

1Mail::to($request->user())
2    ->cc($moreUsers)
3    ->bcc($evenMoreUsers)
4    ->later(now()->addMinutes(10), new OrderShipped($order));
1Mail::to($request->user())
2    ->cc($moreUsers)
3    ->bcc($evenMoreUsers)
4    ->later(now()->addMinutes(10), new OrderShipped($order));

Pushing to Specific Queues

Since all mailable classes generated using the make:mail command make use of the Illuminate\Bus\Queueable trait, you may call the onQueue and onConnection methods on any mailable class instance, allowing you to specify the connection and queue name for the message:

1$message = (new OrderShipped($order))
2                ->onConnection('sqs')
3                ->onQueue('emails');
4 
5Mail::to($request->user())
6    ->cc($moreUsers)
7    ->bcc($evenMoreUsers)
8    ->queue($message);
1$message = (new OrderShipped($order))
2                ->onConnection('sqs')
3                ->onQueue('emails');
4 
5Mail::to($request->user())
6    ->cc($moreUsers)
7    ->bcc($evenMoreUsers)
8    ->queue($message);

Queueing by Default

If you have mailable classes that you want to always be queued, you may implement the ShouldQueue contract on the class. Now, even if you call the send method when mailing, the mailable will still be queued since it implements the contract:

1use Illuminate\Contracts\Queue\ShouldQueue;
2 
3class OrderShipped extends Mailable implements ShouldQueue
4{
5    // ...
6}
1use Illuminate\Contracts\Queue\ShouldQueue;
2 
3class OrderShipped extends Mailable implements ShouldQueue
4{
5    // ...
6}

Queued Mailables and Database Transactions

When queued mailables are dispatched within database transactions, they may be processed by the queue before the database transaction has committed. When this happens, any updates you have made to models or database records during the database transaction may not yet be reflected in the database. In addition, any models or database records created within the transaction may not exist in the database. If your mailable depends on these models, unexpected errors can occur when the job that sends the queued mailable is processed.

If your queue connection's after_commit configuration option is set to false, you may still indicate that a particular queued mailable should be dispatched after all open database transactions have been committed by calling the afterCommit method when sending the mail message:

1Mail::to($request->user())->send(
2    (new OrderShipped($order))->afterCommit()
3);
1Mail::to($request->user())->send(
2    (new OrderShipped($order))->afterCommit()
3);

Alternatively, you may call the afterCommit method from your mailable's constructor:

 1<?php
 2 
 3namespace App\Mail;
 4 
 5use Illuminate\Bus\Queueable;
 6use Illuminate\Contracts\Queue\ShouldQueue;
 7use Illuminate\Mail\Mailable;
 8use Illuminate\Queue\SerializesModels;
 9 
10class OrderShipped extends Mailable implements ShouldQueue
11{
12    use Queueable, SerializesModels;
13 
14    /**
15     * Create a new message instance.
16     */
17    public function __construct()
18    {
19        $this->afterCommit();
20    }
21}
 1<?php
 2 
 3namespace App\Mail;
 4 
 5use Illuminate\Bus\Queueable;
 6use Illuminate\Contracts\Queue\ShouldQueue;
 7use Illuminate\Mail\Mailable;
 8use Illuminate\Queue\SerializesModels;
 9 
10class OrderShipped extends Mailable implements ShouldQueue
11{
12    use Queueable, SerializesModels;
13 
14    /**
15     * Create a new message instance.
16     */
17    public function __construct()
18    {
19        $this->afterCommit();
20    }
21}

Rendering Mailables

Sometimes you may wish to capture the HTML content of a mailable without sending it. To accomplish this, you may call the render method of the mailable. This method will return the evaluated HTML content of the mailable as a string:

1use App\Mail\InvoicePaid;
2use App\Models\Invoice;
3 
4$invoice = Invoice::find(1);
5 
6return (new InvoicePaid($invoice))->render();
1use App\Mail\InvoicePaid;
2use App\Models\Invoice;
3 
4$invoice = Invoice::find(1);
5 
6return (new InvoicePaid($invoice))->render();

Previewing Mailables in the Browser

When designing a mailable's template, it is convenient to quickly preview the rendered mailable in your browser like a typical Blade template. For this reason, Laravel allows you to return any mailable directly from a route closure or controller. When a mailable is returned, it will be rendered and displayed in the browser, allowing you to quickly preview its design without needing to send it to an actual email address:

1Route::get('/mailable', function () {
2    $invoice = App\Models\Invoice::find(1);
3 
4    return new App\Mail\InvoicePaid($invoice);
5});
1Route::get('/mailable', function () {
2    $invoice = App\Models\Invoice::find(1);
3 
4    return new App\Mail\InvoicePaid($invoice);
5});

Localizing Mailables

Laravel allows you to send mailables in a locale other than the request's current locale, and will even remember this locale if the mail is queued.

To accomplish this, the Mail facade offers a locale method to set the desired language. The application will change into this locale when the mailable's template is being evaluated and then revert back to the previous locale when evaluation is complete:

1Mail::to($request->user())->locale('es')->send(
2    new OrderShipped($order)
3);
1Mail::to($request->user())->locale('es')->send(
2    new OrderShipped($order)
3);

User Preferred Locales

Sometimes, applications store each user's preferred locale. By implementing the HasLocalePreference contract on one or more of your models, you may instruct Laravel to use this stored locale when sending mail:

 1use Illuminate\Contracts\Translation\HasLocalePreference;
 2 
 3class User extends Model implements HasLocalePreference
 4{
 5    /**
 6     * Get the user's preferred locale.
 7     */
 8    public function preferredLocale(): string
 9    {
10        return $this->locale;
11    }
12}
 1use Illuminate\Contracts\Translation\HasLocalePreference;
 2 
 3class User extends Model implements HasLocalePreference
 4{
 5    /**
 6     * Get the user's preferred locale.
 7     */
 8    public function preferredLocale(): string
 9    {
10        return $this->locale;
11    }
12}

Once you have implemented the interface, Laravel will automatically use the preferred locale when sending mailables and notifications to the model. Therefore, there is no need to call the locale method when using this interface:

1Mail::to($request->user())->send(new OrderShipped($order));
1Mail::to($request->user())->send(new OrderShipped($order));

Testing

Testing Mailable Content

Laravel provides a variety of methods for inspecting your mailable's structure. In addition, Laravel provides several convenient methods for testing that your mailable contains the content that you expect. These methods are: assertSeeInHtml, assertDontSeeInHtml, assertSeeInOrderInHtml, assertSeeInText, assertDontSeeInText, assertSeeInOrderInText, assertHasAttachment, assertHasAttachedData, assertHasAttachmentFromStorage, and assertHasAttachmentFromStorageDisk.

As you might expect, the "HTML" assertions assert that the HTML version of your mailable contains a given string, while the "text" assertions assert that the plain-text version of your mailable contains a given string:

 1use App\Mail\InvoicePaid;
 2use App\Models\User;
 3 
 4test('mailable content', function () {
 5    $user = User::factory()->create();
 6 
 7    $mailable = new InvoicePaid($user);
 8 
 9    $mailable->assertFrom('[email protected]');
10    $mailable->assertTo('[email protected]');
11    $mailable->assertHasCc('[email protected]');
12    $mailable->assertHasBcc('[email protected]');
13    $mailable->assertHasReplyTo('[email protected]');
14    $mailable->assertHasSubject('Invoice Paid');
15    $mailable->assertHasTag('example-tag');
16    $mailable->assertHasMetadata('key', 'value');
17 
18    $mailable->assertSeeInHtml($user->email);
19    $mailable->assertSeeInHtml('Invoice Paid');
20    $mailable->assertSeeInOrderInHtml(['Invoice Paid', 'Thanks']);
21 
22    $mailable->assertSeeInText($user->email);
23    $mailable->assertSeeInOrderInText(['Invoice Paid', 'Thanks']);
24 
25    $mailable->assertHasAttachment('/path/to/file');
26    $mailable->assertHasAttachment(Attachment::fromPath('/path/to/file'));
27    $mailable->assertHasAttachedData($pdfData, 'name.pdf', ['mime' => 'application/pdf']);
28    $mailable->assertHasAttachmentFromStorage('/path/to/file', 'name.pdf', ['mime' => 'application/pdf']);
29    $mailable->assertHasAttachmentFromStorageDisk('s3', '/path/to/file', 'name.pdf', ['mime' => 'application/pdf']);
30});
 1use App\Mail\InvoicePaid;
 2use App\Models\User;
 3 
 4test('mailable content', function () {
 5    $user = User::factory()->create();
 6 
 7    $mailable = new InvoicePaid($user);
 8 
 9    $mailable->assertFrom('[email protected]');
10    $mailable->assertTo('[email protected]');
11    $mailable->assertHasCc('[email protected]');
12    $mailable->assertHasBcc('[email protected]');
13    $mailable->assertHasReplyTo('[email protected]');
14    $mailable->assertHasSubject('Invoice Paid');
15    $mailable->assertHasTag('example-tag');
16    $mailable->assertHasMetadata('key', 'value');
17 
18    $mailable->assertSeeInHtml($user->email);
19    $mailable->assertSeeInHtml('Invoice Paid');
20    $mailable->assertSeeInOrderInHtml(['Invoice Paid', 'Thanks']);
21 
22    $mailable->assertSeeInText($user->email);
23    $mailable->assertSeeInOrderInText(['Invoice Paid', 'Thanks']);
24 
25    $mailable->assertHasAttachment('/path/to/file');
26    $mailable->assertHasAttachment(Attachment::fromPath('/path/to/file'));
27    $mailable->assertHasAttachedData($pdfData, 'name.pdf', ['mime' => 'application/pdf']);
28    $mailable->assertHasAttachmentFromStorage('/path/to/file', 'name.pdf', ['mime' => 'application/pdf']);
29    $mailable->assertHasAttachmentFromStorageDisk('s3', '/path/to/file', 'name.pdf', ['mime' => 'application/pdf']);
30});

 1use App\Mail\InvoicePaid;
 2use App\Models\User;
 3 
 4public function test_mailable_content(): void
 5{
 6    $user = User::factory()->create();
 7 
 8    $mailable = new InvoicePaid($user);
 9 
10    $mailable->assertFrom('[email protected]');
11    $mailable->assertTo('[email protected]');
12    $mailable->assertHasCc('[email protected]');
13    $mailable->assertHasBcc('[email protected]');
14    $mailable->assertHasReplyTo('[email protected]');
15    $mailable->assertHasSubject('Invoice Paid');
16    $mailable->assertHasTag('example-tag');
17    $mailable->assertHasMetadata('key', 'value');
18 
19    $mailable->assertSeeInHtml($user->email);
20    $mailable->assertSeeInHtml('Invoice Paid');
21    $mailable->assertSeeInOrderInHtml(['Invoice Paid', 'Thanks']);
22 
23    $mailable->assertSeeInText($user->email);
24    $mailable->assertSeeInOrderInText(['Invoice Paid', 'Thanks']);
25 
26    $mailable->assertHasAttachment('/path/to/file');
27    $mailable->assertHasAttachment(Attachment::fromPath('/path/to/file'));
28    $mailable->assertHasAttachedData($pdfData, 'name.pdf', ['mime' => 'application/pdf']);
29    $mailable->assertHasAttachmentFromStorage('/path/to/file', 'name.pdf', ['mime' => 'application/pdf']);
30    $mailable->assertHasAttachmentFromStorageDisk('s3', '/path/to/file', 'name.pdf', ['mime' => 'application/pdf']);
31}
 1use App\Mail\InvoicePaid;
 2use App\Models\User;
 3 
 4public function test_mailable_content(): void
 5{
 6    $user = User::factory()->create();
 7 
 8    $mailable = new InvoicePaid($user);
 9 
10    $mailable->assertFrom('[email protected]');
11    $mailable->assertTo('[email protected]');
12    $mailable->assertHasCc('[email protected]');
13    $mailable->assertHasBcc('[email protected]');
14    $mailable->assertHasReplyTo('[email protected]');
15    $mailable->assertHasSubject('Invoice Paid');
16    $mailable->assertHasTag('example-tag');
17    $mailable->assertHasMetadata('key', 'value');
18 
19    $mailable->assertSeeInHtml($user->email);
20    $mailable->assertSeeInHtml('Invoice Paid');
21    $mailable->assertSeeInOrderInHtml(['Invoice Paid', 'Thanks']);
22 
23    $mailable->assertSeeInText($user->email);
24    $mailable->assertSeeInOrderInText(['Invoice Paid', 'Thanks']);
25 
26    $mailable->assertHasAttachment('/path/to/file');
27    $mailable->assertHasAttachment(Attachment::fromPath('/path/to/file'));
28    $mailable->assertHasAttachedData($pdfData, 'name.pdf', ['mime' => 'application/pdf']);
29    $mailable->assertHasAttachmentFromStorage('/path/to/file', 'name.pdf', ['mime' => 'application/pdf']);
30    $mailable->assertHasAttachmentFromStorageDisk('s3', '/path/to/file', 'name.pdf', ['mime' => 'application/pdf']);
31}