Skip to Navigation
Neste artigo, vou mostrar como enviar emails no Laravel passo a passo usando Mailtrap, com foco principal na entregabilidade.
Como desenvolvedor Laravel, você pode ter ouvido falar do Mailtrap sendo mencionado exclusivamente como uma solução de teste de email na documentação oficial do Laravel. No entanto, essa plataforma também oferece Email API/SMTP.
Os processos e snippets de código que vou mostrar neste artigo são compatíveis com Laravel 9.x e versões superiores.
Configurando o serviço de email do Laravel antes de enviar emails
O Laravel possui seus próprios serviços de email, que permitem o envio de emails através de serviços locais ou baseados na nuvem.
Por exemplo, a combinação Laravel e Symfony Mailer oferece aos usuários uma variedade de drivers que eles podem usar para enviar emails via SMTP, serviços de envio de email de terceiros e o Sendmail MTA.
Embora tecnicamente você pudesse usar sendmail para enviar emails do seu aplicativo web, é provável que seus emails sejam marcados como spam.
Você também poderia enviar emails no Laravel sem um serviço SMTP ou API externo, usando o log driver, mas isso não enviará realmente seus emails. Em vez disso, escreverá todas as mensagens de email nos arquivos do seu aplicativo.
Outras funcionalidades notáveis dos serviços de email do Laravel incluem:
- Enfileiramento de emails.
- Criação de mensagens de email em texto simples e HTML.
- Anexar arquivos em diferentes formatos e tipos MIME, além de dados brutos.
- Incluir anexos inline e incorporar dados brutos em templates de email.
- Visualizar mensagens no navegador.
- Suporte a Markdown (em vários frameworks) – crie templates bonitos e inclua facilmente botões, tabelas ou painéis.
- Sistema de templating – use vários templates e configure visualizações.
- Métodos de localização – defina o idioma desejado para um usuário específico.
- Envio de emails para desenvolvimento local – evite enviar emails de teste para caixas de entrada reais.
Gerando e redigindo mailables
No Laravel, o arquivo config.mail.php será a ferramenta principal que usaremos para configurar os serviços de email. Ele possui uma seção mailers, que contém uma entrada de configuração de exemplo para cada driver de email/transportes principais suportados pelo Laravel.
Por padrão, o Laravel escolhe qual serviço usar com base em como configuramos este arquivo. A configuração nos permite escolher diferentes serviços de email para diferentes tipos de emails.
Além disso, o Laravel usa uma classe “mailable” para representar diferentes tipos de email. Estas são armazenadas no diretório app/Mail, mas você não as verá imediatamente em seu projeto. Em vez disso, elas serão geradas quando você criar sua primeira classe mailable.
Para criar uma classe mailable, usei este comando Artisan (incluído no Laravel):
php artisan make:mail MailableNameDepois de criar uma classe mailable, consegui ver o conteúdo e configurar a própria classe. Para isso, usei os métodos da tabela a seguir:
| Método | Explicação |
| Envelope | Retorna o objeto Illuminate\Mail\Mailables\Envelope, que define o assunto e os destinatários. |
| Conteúdo | Retorna o objeto Illuminate\Mail\Mailables\Content, que define o modelo Blade usado para gerar o conteúdo da mensagem. |
| Anexos | Retorna uma matriz de anexos. |
Configuração do remetente
Agora, precisamos especificar o endereço de email e o nome do remetente ou from. Para isso, podemos:
- Especificar o remetente no objeto Envelope da mensagem, assim:
use Illuminate\Mail\Mailables\Address;
use Illuminate\Mail\Mailables\Envelope;
/**
* Obter o envelope da mensagem.
*
* @return \Illuminate\Mail\Mailables\Envelope
*/
public function envelope()
{
return new Envelope(
from: new Address('exemplo@exemplo.com', 'Remetente de Teste'),
subject: 'Email de Teste',
);
}- Especificar o remetente em config/mail.php com um endereço global
from, assim:
'from' => ['address' => 'exemplo@exemplo.com', 'name' => 'Nome do App']Dica Pro: você deve usar o endereço global from se planeja usá-lo em todos os emails que seu aplicativo enviar. Achei isso bastante conveniente, pois evitou a necessidade de chamar o método from em cada uma das minhas classes mailable. Além disso, ele serviu como meu endereço from padrão, já que não especifiquei nenhum outro.
Enviar emails no Laravel usando SMTP
Agora que você configurou o serviço de email do Laravel, vou mostrar como configurar o Email API/SMTP do Mailtrap como o provedor de serviço SMTP em seu aplicativo/projeto e, em seguida, como criei classes mailable e executei testes.
Etapa 1. Use as credenciais SMTP do Mailtrap para integração com seu app
A primeira coisa que fiz foi inserir minhas credenciais de servidor SMTP fornecidas pelo Email API/SMTP do Mailtrap no .env do meu aplicativo web.
Para fazer isso, tudo o que você precisa fazer é criar uma conta no Mailtrap, fazer login e navegar até Sending Domains. Lá, você precisa adicionar e verificar seu domínio, o que leva apenas alguns segundos.
Se você aprende melhor de forma visual, o Mailtrap tem um vídeo fácil de seguir.
Depois de verificar seu domínio, o Mailtrap o levará para a página de onde você pode copiar as credenciais SMTP e colá-las facilmente em seu projeto, app ou serviço de envio de email.
Nota: usaremos o Transactional Stream para este capítulo, e mostrarei como você pode usar o Bulk Stream mais adiante no artigo.
E aqui está como suas credenciais de email SMTP devem ficar depois de integrá-las ao seu código Laravel:
// .env file
MAIL_MAILER=smtp
MAIL_HOST=live.smtp.mailtrap.io
MAIL_PORT=2525
MAIL_USERNAME=//seu nome de usuário
MAIL_PASSWORD=//sua senha
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=from@exemplo.com
MAIL_FROM_NAME=//nome do seu aplicativoEtapa 2. Verifique sua configuração SMTP
Depois de inserir as credenciais e enviar um email de teste do meu projeto Laravel, o Mailtrap verificou minha configuração SMTP.
Aqui está o que você deve receber como resposta se o seu email de teste for enviado com sucesso:
- “250 2.0.0 Ok: queued as …”
Então, basta clicar em “Verify Setup”, que iniciará o processo de verificação.
Etapa 3. Ativar as configurações de rastreamento do Mailtrap (opcional)
Agora, esta etapa é opcional, mas recomendo fortemente, pois me permite monitorar o desempenho dos meus emails.
Especificamente, o Mailtrap fornece análises detalhadas que permitem monitorar aberturas, cliques, bounces e mais.
Isso é o que vejo quando abro minhas estatísticas:
Etapa 4. Criar classes mailable
Lembra das classes mailable que mencionei anteriormente? É hora de criá-las com o seguinte comando:
php artisan make:mail MyTestEmailDepois de executar esse comando, você deverá ver a classe MyTestEmail em “app/mailMyTestEmail.php“.
Aqui está o código da classe para sua conveniência:
<?php
namespace App\Mail;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Queue\SerializesModels;
class MyTestEmail extends Mailable
{
use Queueable, SerializesModels;
/**
* Cria uma nova instância de mensagem.
*
* @return void
*/
public function __construct()
{
//
}
/**
* Obter o envelope da mensagem.
*
* @return \Illuminate\Mail\Mailables\Envelope
*/
public function envelope()
{
return new Envelope(
subject: 'Meu Email de Teste',
);
}
/**
* Obter a definição do conteúdo da mensagem.
*
* @return \Illuminate\Mail\Mailables\Content
*/
public function content()
{
return new Content(
view: 'view.name',
);
}
/**
* Obter os anexos para a mensagem.
*
* @return array
*/
public function attachments()
{
return [];
}
}Viu algo interessante? Isso mesmo, o método content() retorna uma visualização. Então, vamos para resources/views e criar uma nova pasta com um arquivo blade.php.
Pronto para finalmente escrever algum texto? Você pode fazer isso no arquivo blade.php, assim:
Agora, vamos voltar ao método content() e substituir o nome da visualização retornada pelo nome da nossa recém-criada.
Você também pode tornar as coisas um pouco mais dinâmicas, fazendo com que seu arquivo template/blade.php de email inclua o nome do destinatário usando o atributo with para passar o nome.
Veja:
<?php
namespace App\Mail;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Queue\SerializesModels;
class MyTestEmail extends Mailable
{
use Queueable, SerializesModels;
/**
* Cria uma nova instância de mensagem.
*
* @return void
*/
public function __construct(private $name)
{
//
}
/**
* Obter o envelope da mensagem.
*
* @return \Illuminate\Mail\Mailables\Envelope
*/
public function envelope()
{
return new Envelope(
subject: 'Meu Email de Teste',
);
}
/**
* Obter a definição do conteúdo da mensagem.
*
* @return \Illuminate\Mail\Mailables\Content
*/
public function content()
{
return new Content(
view: 'mail.test-email',
with: ['name' => $this->name],
);
}
}Para que isso funcione, tive que fazer uma pequena alteração no arquivo test-email.blade.php da visualização também. Isso permite que ele aceite a variável $name.
// resources/views/mail/test-email.blade.php
Oi {{$name}},
Seu app Laravel já consegue enviar emails? 😉
MailtrapE, por fim, vamos criar uma rota no arquivo routes/web.php com este código:
<?php
use Illuminate\Support\Facades\Route;
use App\Mail\MyTestEmail;
use Illuminate\Support\Facades\Mail;
Route::get('/testroute', function() {
$name = "Funny Coder";
// O envio de emails é feito usando o método "to" na facade Mail
Mail::to('destinatarioteste@gmail.com'')->send(new MyTestEmail($name));
});E assim deve ficar o arquivo:
E, o momento da verdade chegou. Testei as coisas executando o comando php artisan serve e fui ao meu navegador, onde colei a rota que criei. No meu caso, foi localhost:8000/testroute.
Se tudo funcionar, seu email deve chegar à caixa de entrada do endereço “to” (para) especificado.
Envio de emails em HTML
Para configurações avançadas de personalização de email HTML no Laravel, confira nosso artigo dedicado.
Enviar emails que chamam a atenção no Laravel é bastante simples. Tudo o que você precisa fazer é adicionar código HTML ao seu arquivo de visualização Blade. Se você se lembrar, usamos test-email.blade.php neste guia.
Aqui está um snippet de código que você pode usar para enviar uma mensagem HTML básica:
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport"
content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<style>
p {
font-size: 12px;
}
.signature {
font-style: italic;
}
</style>
</head>
<body>
<div>
<p>Oi {{ $name }},</p>
<p>Seu app Laravel já consegue enviar emails? 😉 </p>
<p class="signature">Mailtrap</p>
</div>
</body>
</html>Envio de emails para vários destinatários
Para enviar emails para várias pessoas no Laravel, usei o seguinte código:
foreach (['First Coder' => 'primeiro-destinatario@gmail.com', 'Second Coder' => 'segundo-destinatario@gmail.com'] as $name => $recipient) {
Mail::to($recipient)->send(new MyTestEmail($name));
}O que esse código faz é iterar sobre uma matriz de destinatários. Ele também recria a instância mailable a cada vez, o que é super útil, pois evita o envio de outro email para cada destinatário anterior a cada iteração no loop. Apenas imagine a dor de cabeça. 🤕
“Mas como envio emails para apenas um destinatário enquanto também adiciono cc e bcc para alguns outros?”, você deve estar se perguntando. Basta seguir este exemplo na classe MyTestEmail:
return new Envelope(
subject: 'Meu Email de Teste',
cc: ['destinatarioteste-cc@gmail.com'],
bcc: ['destinatarioteste-bcc@gmail.com']
);Envio de emails com anexos
Para adicionar anexos aos meus emails no Laravel, simplesmente modifiquei o método attachments no exemplo de código para envio de emails que mostrei anteriormente.
Primeiro, fiz isso na classe MyTestEmail:
<?php
namespace App\Mail;
use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Queue\SerializesModels;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Mail\Mailables\Attachment;
use Illuminate\Contracts\Queue\ShouldQueue;
class MyTestEmail extends Mailable
{
use Queueable, SerializesModels;
/**
* Cria uma nova instância de mensagem.
*
* @return void
*/
public function __construct(private $name, public $attachedFile){ }
/**
* Obter o envelope de mensagem.
*
* @return \Illuminate\Mail\Mailables\Envelope
*/
public function envelope()
{
return new Envelope(
subject: 'Meu Email de Teste',
);
}
/**
* Obter a definição do conteúdo da mensagem.
*
* @return \Illuminate\Mail\Mailables\Content
*/
public function content()
{
return new Content(
view: 'mail.test-email',
with: ['name' => $this->name],
);
}
/**
* Obter os anexos da mensagem.
*
* @return array
*/
public function attachments()
{
return [
Attachment::fromPath($this->attachedFile),
];
}
}Depois, fiz algumas alterações no código testroute em routes/web.php:
<?php
use Illuminate\Support\Facades\Route;
use App\Mail\MyTestEmail;
Route::get('/testroute', function () {
$filePath = public_path('favicon.ico');
$name = "Funny Coder";
Mail::to('destinatarioteste@gmail.com'')->send(new MyTestEmail($name, $filePath));
});E é basicamente isso! Se você usou esse código, seu email agora deve vir com um anexo ICO chamado favicon.ico, como você pode ver no snippet acima.
Envio de emails com imagens incorporadas
Para enviar um email com uma imagem incorporada no Laravel, usei o método embed no template Blade. O método embed permite que você anexe imagens diretamente ao conteúdo do seu email, que serão exibidas inline.
Primeiro, certifique-se de que sua classe mailable (MyTestEmail neste exemplo) passe os dados necessários para a visualização. Você não precisa mudar nada na classe especificamente para a imagem.
No seu template Blade de email, use o método embed para incluir a imagem. Suponha que você tenha uma imagem em, digamos, public/images/logo.png.
// resources/views/mail/test-email.blade.php
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
</head>
<body>
<div>
<p>Oi {{$name}},</p>
<p>Seu app Laravel já consegue enviar emails? 😉</p>
<img src="{{ $message->embed(public_path('images/logo.png')) }}" alt="Logo">
</div>
</body>
</html>Como você pode ver, adicionei essencialmente esta linha de código:
<img src="{{ $message->embed(public_path('images/logo.png')) }}" alt="Logo">Isso incorpora a imagem localizada em public/images/logo.png no email, e o método embed retorna uma URL que aponta para a imagem incorporada. A imagem retornada é então usada como o atributo src da tag \, exibindo a imagem inline no email.
Enfileiramento de emails para envio assíncrono
Para envio de emails assíncrono, usei o sistema de filas do Laravel ShouldQueue.
Então, primeiro certifique-se de que sua classe mailable implemente a interface ShouldQueue e use o trait Queueable:
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Mail\Mailable;
use Illuminate\Queue\SerializesModels;
class MyTestEmail extends Mailable implements ShouldQueue
{
use Queueable, SerializesModels;
// Resto da sua classe...
}Em seguida, configure seu driver de fila no arquivo .env definindo QUEUE_CONNECTION para um driver de fila (por exemplo, database, redis, sqs, etc.).
Por fim, quando você enviar um email com o comando a seguir, o Laravel o colocará automaticamente na fila se a classe mailable implementar ShouldQueue:
Mail::to('destinatarioteste@exemplo.com')->send(new MyTestEmail($name));Nota: para iniciar seu worker de fila para processar os jobs enfileirados, você pode executar o comando php artisan queue:work no seu terminal.
Envio de emails em massa no Laravel
Lembra das credenciais SMTP Bulk Stream do Mailtrap que mencionei anteriormente? Bem, vamos usá-las para enviar, como você deve ter adivinhado, emails em massa.
Primeiro, faça login na sua conta Mailtrap e navegue até a guia ‘SMTP/API Settings’. Lá, você encontrará as credenciais do Bulk Stream à direita.
Depois, abra seu .env e insira essas credenciais. O arquivo de configuração deve ficar assim:
MAIL_MAILER=smtp
MAIL_HOST=bulk.smtp.mailtrap.io
MAIL_PORT=2525
MAIL_USERNAME=seu_nome_de_usuario_bulk_do_mailtrap
MAIL_PASSWORD=sua_senha_bulk_do_mailtrap
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=from@exemplo.com
MAIL_FROM_NAME="Nome do Seu Aplicativo"
Substitua seu_nome_de_usuario_bulk_do_mailtrap e sua_senha_bulk_do_mailtrap pelas suas credenciais SMTP reais do Mailtrap para o fluxo em massa.Agora, se você ainda não fez isso, precisa gerar uma classe Mailable que usará para enviar emails. Você pode personalizá-la para adequar os emails que está planejando enviar em massa, e é assim que deve parecer:
php artisan make:mail BulkEmailDepois de gerar sua classe mailable BulkEmail, defina as propriedades e métodos que configuram o conteúdo do email.
Você pode passar dados para sua classe Mailable através de seu construtor e usar esses dados nas visualizações do seu email.
Por fim, percorri meus destinatários e enviei emails individualmente com a conexão SMTP configurada para uso em massa.
Aqui está um exemplo:
use App\Mail\BulkEmail;
use Illuminate\Support\Facades\Mail;
$users = User::all(); // Exemplo: Obtendo todos os usuários a quem deseja enviar emails
foreach ($users as $user) {
Mail::to($user->email)->send(new BulkEmail($data));
}No entanto, há algumas coisas a ter em mente para melhorar sua escalabilidade e desempenho:
- Limitação de taxa e atrasos – Considere limitar as taxas ou implementar atrasos entre os emails se você estiver enviando para um grande número de destinatários.
- Fragmentação (Chunking) – Para listas muito grandes, o método chunk do Laravel pode ajudá-lo a processar os usuários em lotes menores.
- Por exemplo:
User::chunk(200, function ($users) use ($data) {
foreach ($users as $user) {
Mail::to($user->email)->queue(new BulkEmail($data));
}
});- Job queues – Ao despachar um job para cada email, o Laravel pode enfileirar os emails e enviá-los em segundo plano, liberando seu aplicativo para lidar com outras solicitações.
- Por exemplo:
class SendBulkEmailJob implements ShouldQueue
{
use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
protected $user;
protected $data;
public function __construct($user, $data)
{
$this->user = $user;
$this->data = $data;
}
public function handle()
{
Mail::to($this->user->email)->send(new BulkEmail($this->data));
}
}
// Expedindo o job para cada usuário
foreach ($users as $user) {
SendBulkEmailJob::dispatch($user, $data)->onQueue('emails');
}Por fim, fique de olho nos logs do seu aplicativo e nos painéis do Mailtrap, pois isso pode ajudar a garantir que seus emails estejam sendo processados e enviados conforme o esperado.
Enviar emails no Laravel usando API
Se você deseja automatizar seu processo de envio, o Email API/SMTP do Mailtrap API é a solução que você está procurando.
Integrar a API de email do Mailtrap ao seu aplicativo Laravel é super fácil, pois você pode usar o SDK oficial em PHP e a documentação para o framework Laravel. Com isso, você não precisará escrever manualmente o código de integração para o seu projeto, tornando a integração muito mais fácil e eficiente. Além disso, a biblioteca do Mailtrap é totalmente compatível com Laravel 9.x e versões superiores.
Para começar, siga estas etapas:
- Crie uma conta do Mailtrap e faça login.
- Adicione e verifique seu domínio.
- Instale o cliente PHP Mailtrap e as dependências usando o Composer.
composer require railsware/mailtrap-php symfony/http-client nyholm/psr7- Adicione o transporte do Mailtrap ao seu arquivo config.mail.php.
<?php
return [
/*
|--------------------------------------------------------------------------
| Configurações Mailer
|--------------------------------------------------------------------------
*/
'mailers' => [
// início do transporte do mailtrap
'mailtrap' => [
'transport' => 'mailtrap'
],
// fim do transporte do mailtrap
]
];- Adicione suas credenciais do Mailtrap ao arquivo .env do seu Laravel (certifique-se de selecionar o Transactional Stream; usaremos o Bulk Stream mais tarde).
MAIL_MAILER="mailtrap"
MAILTRAP_HOST="send.api.mailtrap.io"
MAILTRAP_API_KEY="SUA_CHAVE_API_AQUI"
MAIL_FROM_ADDRESS=”nome@dominio_registrado.com”- Crie uma classe mailable para enviar emails.
php artisan make:mail WelcomeMail- Configure a classe app/Mail/WelcomeMail.php seguindo este exemplo.
<?php
namespace App\Mail;
use Illuminate\Bus\Queueable;
use Illuminate\Mail\Attachment;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Address;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Mail\Mailables\Headers;
use Illuminate\Queue\SerializesModels;
use Mailtrap\EmailHeader\CategoryHeader;
use Mailtrap\EmailHeader\CustomVariableHeader;
use Symfony\Component\Mime\Email;
use Symfony\Component\Mime\Header\UnstructuredHeader;
class WelcomeMail extends Mailable
{
use Queueable, SerializesModels;
private string $name;
/**
* Cria uma nova instância de mensagem.
*/
public function __construct(string $name)
{
$this->name = $name;
}
/**
* Obter o envelope da mensagem.
*/
public function envelope(): Envelope
{
return new Envelope(
from: new Address('jeffrey@exemplo.com', 'Jeffrey Way'),
replyTo: [
new Address('taylor@exemplo.com', 'Taylor Otwell'),
],
subject: 'Email de Boas-Vindas',
using: [
function (Email $email) {
// Cabeçalhos
$email->getHeaders()
->addTextHeader('X-Message-Source', 'exemplo.com')
->add(new UnstructuredHeader('X-Mailer', 'Mailtrap PHP Client'))
;
// Variáveis Customizadas
$email->getHeaders()
->add(new CustomVariableHeader('user_id', '45982'))
->add(new CustomVariableHeader('batch_id', 'PSJ-12'))
;
// Categoria (deve ser apenas uma)
$email->getHeaders()
->add(new CategoryHeader('Teste de Integração'))
;
},
]
);
}
/**
* Obter a definição do conteúdo da mensagem.
*/
public function content(): Content
{
return new Content(
view: 'mail.welcome-email',
with: ['name' => $this->name],
);
}
/**
* Obter os anexos para a mensagem.
*
* @return array<int, \Illuminate\Mail\Mailables\Attachment>
*/
public function attachments(): array
{
return [
Attachment::fromPath('https://mailtrap.io/wp-content/uploads/2021/04/mailtrap-new-logo.svg')
->as('logo.svg')
->withMime('image/svg+xml'),
];
}
/**
* Obter os cabeçalhos da mensagem.
*/
public function headers(): Headers
{
return new Headers(
'id-da-mensagem-personalizada@exemplo.com',
['mensagem-anterior@exemplo.com'],
[
'X-Custom-Header' => 'Custom Value',
],
);
}
}- Crie um template de email em resources/views/mail/welcome-email.blade.php.
Oi, {{$name}} e bem-vindo 😉
<br>
Funny Coder- Adicione o roteador CLI ao arquivo app/routes/console.php.
<?php
use App\Mail\WelcomeMail;
use Illuminate\Support\Facades\Artisan;
use Illuminate\Support\Facades\Mail;
/*
|--------------------------------------------------------------------------
| Rotas de Console
|--------------------------------------------------------------------------
|
*/
Artisan::command('send-welcome-mail', function () {
Mail::to('destinatarioteste@gmail.com')->send(new WelcomeMail("Jon"));
// Além disso, você pode usar um mailer específico se o seu mailer padrão não for "mailtrap", mas você quiser usá-lo para emails de boas-vindas
// Mail::mailer('mailtrap')->to('destinatarioteste@gmail.com')->send(new WelcomeMail("Jon"));
})->purpose('Enviar email de boas-vindas');- Chame o comando CLI para enviar seu email.
php artisan send-welcome-mailDepois de completar essas etapas, você deve ser capaz de usar a API de email do Mailtrap para enviar emails transacionais sem obter nenhum erro.
Além disso, lembra das configurações de rastreamento que mencionei anteriormente? Você pode ativá-las se usar a API de email também.
Envio de emails em HTML
Para enviar emails em HTML no Laravel, tudo o que você precisa fazer é adicionar código HTML ao seu arquivo de visualização Blade, que, no caso deste tutorial, é test-email.blade.php.
E aqui está como o email em texto simples fica em formato HTML:
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport"
content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<style>
p {
font-size: 12px;
}
.signature {
font-style: italic;
}
</style>
</head>
<body>
<div>
<p>Oi {{ $name }},</p>
<p>Seu app Laravel já consegue enviar emails? 😉 </p>
<p class="signature">Mailtrap</p>
</div>
</body>
</html>Envio de emails para vários destinatários
De acordo com a documentação do Laravel, você pode enviar um email para vários destinatários com o seguinte código:
foreach (['First Coder' => 'primeiro-destinatario@gmail.com', 'Second Coder' => 'segundo-destinatario@gmail.com'] as $name => $recipient) {
Mail::to($recipient)->send(new MyTestEmail($name));
}Você também pode enviar seu email para apenas um destinatário e “cc” e “bcc” para alguns outros com o seguinte código na classe MyTestEmail:
return new Envelope(
subject: 'Meu Email de Teste',
cc: ['destinatarioteste-cc@gmail.com'],
bcc: ['destinatarioteste-bcc@gmail.com']
);Envio de emails com anexos
Da mesma forma, como com SMTP, modifiquei o método attachments para adicionar anexos aos meus emails.
Primeiro, fiz isso na classe MyTestEmail:
<?php
namespace App\Mail;
use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Queue\SerializesModels;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Mail\Mailables\Attachment;
use Illuminate\Contracts\Queue\ShouldQueue;
class MyTestEmail extends Mailable
{
use Queueable, SerializesModels;
/**
* Cria uma nova instância de mensagem.
*
* @return void
*/
public function __construct(private $name, public $attachedFile){ }
/**
* Obter o envelope da mensagem.
*
* @return \Illuminate\Mail\Mailables\Envelope
*/
public function envelope()
{
return new Envelope(
subject: 'Meu Email de Teste',
);
}
/**
* Obter a definição do conteúdo da mensagem.
*
* @return \Illuminate\Mail\Mailables\Content
*/
public function content()
{
return new Content(
view: 'mail.test-email',
with: ['name' => $this->name],
);
}
/**
* Obter os anexos para a mensagem.
*
* @return array
*/
public function attachments()
{
return [
Attachment::fromPath($this->attachedFile),
];
}
}Depois, fiz algumas alterações no código testroute em routes/web.php:
<?php
use Illuminate\Support\Facades\Route;
use App\Mail\MyTestEmail;
Route::get('/testroute', function () {
$filePath = public_path('favicon.ico');
$name = "Funny Coder";
Mail::to('destinatarioteste@gmail.com'')->send(new MyTestEmail($name, $filePath));
});E, como com SMTP, seu email agora deve vir com um anexo ICO chamado favicon.ico.
Envio de emails com imagens incorporadas
Para enviar um email com uma imagem incorporada, use o método embed no template Blade para incluir a imagem. Por exemplo, vamos imaginar que você tenha uma imagem em public/images/logo.php.
Aqui está como seu código ficaria então:
// resources/views/mail/test-email.blade.php
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
</head>
<body>
<div>
<p>Oi {{$name}},</p>
<p>Seu app Laravel já consegue enviar emails? 😉</p>
<img src="{{ $message->embed(public_path('images/logo.png')) }}" alt="Logo">
</div>
</body>
</html>Enfileiramento de emails para envio assíncrono
Da mesma forma que com SMTP, você pode usar o ShouldQueue do Laravel para envio assíncrono.
Para fazer isso funcionar, sua classe mailable deve implementar a interface ShouldQueue e usar o trait Queueable:
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Mail\Mailable;
use Illuminate\Queue\SerializesModels;
class MyTestEmail extends Mailable implements ShouldQueue
{
use Queueable, SerializesModels;
// Resto da sua classe...
}Você pode configurar seu driver de fila no arquivo .env definindo QUEUE_CONNECTION para um driver de fila como database, redis, sqs, etc.
E para enviar um email, você pode usar o seguinte comando:
Mail::to('destinatarioteste@exemplo.com')->send(new MyTestEmail($name));Lembre-se de que você pode executar o comando php artisan queue:work no seu terminal para iniciar seu worker de fila para processar o job enfileirado.
Envio de emails em massa
Para começar a enviar emails em massa, primeiro você precisa inserir as credenciais Bulk Stream, que pode encontrar na guia ‘SMTP/API Settings’ quando fizer login na sua conta Mailtrap.
Depois de encontrar as credenciais, adicione-as ao seu arquivo .env do Laravel (certifique-se de selecionar o Bulk Stream).
Aqui está como deve ficar o seu arquivo .env quando você inserir suas credenciais Bulk Stream:
MAIL_MAILER="mailtrap"
MAILTRAP_HOST="bulk.smtp.mailtrap.io"
MAILTRAP_API_KEY="SUA_CHAVE_API_DO_BULK_STREAM_AQUI"Depois de substituir suas credenciais, você precisa gerar uma classe Mailable para enviar emails:
php artisan make:mail BulkEmailA partir daqui, você tem três opções para enviar email em massa, a saber:
- Percorrer o loop
Se você estiver enviando uma pequena quantidade de emails em massa, pode percorrer seus destinatários e enviar emails individualmente. Assim:
use App\Mail\BulkEmail;
use Illuminate\Support\Facades\Mail;
$users = User::all(); // Exemplo: Obtendo todos os usuários a quem deseja enviar emails
foreach ($users as $user) {
Mail::to($user->email)->send(new BulkEmail($data));
}- Chunking
Se você planeja enviar uma grande quantidade de emails em massa, o método de fragmentação pode ajudá-lo a processar os usuários em pequenos lotes.
Veja:
User::chunk(200, function ($users) use ($data) {
foreach ($users as $user) {
Mail::to($user->email)->queue(new BulkEmail($data));
}
});- Job queues
Se você planeja enviar uma grande quantidade de emails em massa e liberar seu aplicativo para lidar com outras solicitações, pode despachar um job para cada email:
class SendBulkEmailJob implements ShouldQueue
{
use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
protected $user;
protected $data;
public function __construct($user, $data)
{
$this->user = $user;
$this->data = $data;
}
public function handle()
{
Mail::to($this->user->email)->send(new BulkEmail($this->data));
}
}
// Expedindo o job para cada usuário
foreach ($users as $user) {
SendBulkEmailJob::dispatch($user, $data)->onQueue('emails');
}Independentemente do método de envio em massa que você escolher, você deve sempre ficar de olho nos Logs do seu aplicativo e no painel do Mailtrap para garantir que seus emails estejam sendo processados e enviados.
Além disso, considere limitar as taxas ou implementar atrasos entre os emails se você estiver enviando para um grande número de destinatários.
Teste e envio de emails: porquê e como
Com todo esse código escrito, você não gostaria de ter seus emails enviados de um domínio na lista de bloqueio, marcados como spam ou com seu template HTML mal renderizado por alguns navegadores. Por isso, você deve testar seus emails no Laravel antes de enviá-los.
Tecnicamente, você poderia fazer isso com sua caixa de entrada pessoal ou driver de log, mas por que afetar a reputação do seu domínio e inundar sua caixa de entrada com lixo, quando você pode usar Email Testing do Mailtrap?
O Mailtrap também é suportado pelo Laravel na documentação oficial.
Essa plataforma de envio de email também possui muitos recursos que podem ajudá-lo a resolver inúmeros problemas de teste, enquanto mantém o processo de teste de email seguro.
Com o Email Testing do Mailtrap, você pode capturar emails de teste e visualizá-los em um ambiente sandbox seguro. Você também pode verificar a pontuação de spam dos seus emails, analisar seu HTML/CSS e mais, tudo antes de enviá-los.
Basicamente, o que o Email Testing do Mailtrap faz é garantir que seus emails cheguem onde e quando deveriam, em vez de ir para as pastas de spam.
O Email Testing do Mailtrap também permite que você compartilhe facilmente o processo de teste com os membros da sua equipe, crie novos projetos e adicione vários objetos dentro.
Você também pode encaminhar os emails para os endereços reais manual ou automaticamente, uma vez que esteja satisfeito com os resultados que está obtendo.
Essencialmente, testar emails com o Mailtrap é muito fácil.
SMTP
Para testar seus emails com o Mailtrap, tudo o que você precisa fazer é criar uma conta gratuita no Mailtrap, que lhe dará acesso a toda a Plataforma de Email Delivery do Mailtrap. Isso significa que você poderá usar tanto o Email Testing quanto o Email API/SMTP.
Depois de criar sua conta e fazer login, siga estas etapas:
- Navegue até Email Testing → Inboxes → SMTP Settings
- Selecione a versão desejada do Laravel na lista de integrações (recomendo a versão 9+)
- Copie o snippet de código gerado no arquivo .env localizado no diretório raiz do seu projeto. Deve parecer algo assim:
MAIL_MAILER=smtp
MAIL_HOST=sandbox.smtp.mailtrap.io
MAIL_PORT=2525
MAIL_USERNAME=07f4dbf61b8122
MAIL_PASSWORD=d7fc5d57bc6eac
MAIL_ENCRYPTION=tlsDepois de terminar, você poderá enviar o primeiro email de teste com o seguinte código:
<?php
use App\Mail\JustTesting;
use Illuminate\Support\Facades\Mail;
Route::get('/send-mail', function () {
Mail::to('novousuario@exemplo.com')->send(new JustTesting());
return 'Uma mensagem foi enviada para o Mailtrap!';
});Dica Pro: certifique-se de estar usando Laravel 5.8 ou uma versão mais recente e que você especificou a rota no arquivo routes/web.php.
Para enviar o email de teste, inicie o aplicativo e acesse o caminho /send-mail em seu navegador. Você logo poderá ver o email em Email Testing → Inboxes.
API
Alternativamente, você pode integrar o Email Testing ao seu app e usar a Testing API para teste, automação e teste de sequências automatizadas.
Dependendo de qual cliente HTTP você usar, execute um dos seguintes comandos:
# Com o cliente symfony http (recomendado)
composer require railsware/mailtrap-php symfony/http-client nyholm/psr7
# Ou com o cliente guzzle http
composer require railsware/mailtrap-php guzzlehttp/guzzle php-http/guzzle7-adapterAdicione o transporte do Mailtrap ao seu arquivo config.mail.php:
<?php
return [
/*
|--------------------------------------------------------------------------
| Configurações Mailer
|--------------------------------------------------------------------------
*/
'mailers' => [
// início do transporte do mailtrap
'mailtrap' => [
'transport' => 'mailtrap'
],
// fim do transporte do mailtrap
]
]Em seguida, você precisa definir a chave de API na variável MAILTRAP_API_KEY e definir o ID da sua caixa de entrada no MAILTRAP_INBOX_ID, assim:
MAIL_MAILER="mailtrap"
MAILTRAP_HOST="sandbox.api.mailtrap.io"
MAILTRAP_API_KEY="SUA_CHAVE_API_AQUI"
MAILTRAP_INBOX_ID=1000001Notas:
- Você pode encontrar sua chave/token de API acessando sua conta Mailtrap e navegando até Sending Domains → SMTP/API Settings
- Certifique-se de executar o comando de limpar o cache de configuração para configurar novas variáveis com:
php artisan config:clearE para testar seu primeiro email, você precisa gerar uma classe Mailable, assim como no envio:
php artisan make:mail WelcomeMailDepois de criar sua classe Mailable, você pode configurar seu email. Aqui está um exemplo:
# app/Mail/WelcomeMail.php
<?php
namespace App\Mail;
use Illuminate\Bus\Queueable;
use Illuminate\Mail\Attachment;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Address;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Mail\Mailables\Headers;
use Illuminate\Queue\SerializesModels;
use Mailtrap\EmailHeader\CategoryHeader;
use Mailtrap\EmailHeader\CustomVariableHeader;
use Symfony\Component\Mime\Email;
use Symfony\Component\Mime\Header\UnstructuredHeader;
class WelcomeMail extends Mailable
{
use Queueable, SerializesModels;
private string $name;
/**
* Cria uma nova instância de mensagem.
*/
public function __construct(string $name)
{
$this->name = $name;
}
/**
* Obter o envelope de mensagem.
*/
public function envelope(): Envelope
{
return new Envelope(
from: new Address('jeffrey@exemplo.com', 'Jeffrey Way'),
replyTo: [
new Address('taylor@exemplo.com', 'Taylor Otwell'),
],
subject: 'Email de Boas-Vindas',
using: [
function (Email $email) {
// Cabeçalhos
$email->getHeaders()
->addTextHeader('X-Message-Source', 'exemplo.com')
->add(new UnstructuredHeader('X-Mailer', 'Mailtrap PHP Client'))
;
// Variáveis Personalizadas
$email->getHeaders()
->add(new CustomVariableHeader('user_id', '45982'))
->add(new CustomVariableHeader('batch_id', 'PSJ-12'))
;
// Categoria (deverá ser apenas uma)
$email->getHeaders()
->add(new CategoryHeader('Teste de Integração'))
;
},
]
);
}
/**
* Obter a definição do conteúdo da mensagem.
*/
public function content(): Content
{
return new Content(
view: 'mail.welcome-email',
with: ['name' => $this->name],
);
}
/**
* Obter os anexos para a mensagem.
*
* @return array<int, \Illuminate\Mail\Mailables\Attachment>
*/
public function attachments(): array
{
return [
Attachment::fromPath('https://mailtrap.io/wp-content/uploads/2021/04/mailtrap-new-logo.svg')
->as('logo.svg')
->withMime('image/svg+xml'),
];
}
/**
* Obter os cabeçalhos da mensagem.
*/
public function headers(): Headers
{
return new Headers(
'id–da-mensagem-personalizada@exemplo.com',
['mensagem-anterior@exemplo.com'],
[
'X-Custom-Header' => 'Custom Value',
],
);
}
}Além disso, você pode usar um template de email:
# resources/views/mail/welcome-email.blade.php
Oi, {{$name}} e bem-vindo 😉
<br>
Funny CoderE adicione o roteador CLI:
# app/routes/console.php
<?php
use App\Mail\WelcomeMail;
use Illuminate\Support\Facades\Artisan;
use Illuminate\Support\Facades\Mail;
/*
|--------------------------------------------------------------------------
| Rotas de Console
|--------------------------------------------------------------------------
|
*/
Artisan::command('send-welcome-mail', function () {
Mail::to('destinatarioteste@gmail.com')->send(new WelcomeMail("Jon"));
// Além disso, você pode usar um mailer específico se o seu mailer padrão não for "mailtrap", mas você quiser usá-lo para emails de boas-vindas
// Mail::mailer('mailtrap')->to('destinatarioteste@gmail.com')->send(new WelcomeMail("Jon"));
})->purpose('Enviar email de boas-vindas');E para enviar seu email, basta chamar este comando CLI:
php artisan send-welcome-mailPara informações adicionais, dê uma olhada na documentação oficial para a API do Mailtrap.
Concluindo
E com isso, terminamos nosso guia de envio de email do Laravel.
Cobrimos muitos tópicos, desde configurar o Laravel para enviar email com SMTP até enviar email via API. Independentemente da opção que você escolher, você sempre pode consultar este artigo para obter instruções passo a passo.
Para saber mais sobre o Laravel, confira a documentação oficial. E se você está procurando mais conteúdo sobre envio de email com Laravel, não deixe de visitar o blog do Mailtrap, onde você pode encontrar mais artigos úteis, como:
