# Como enviar e-mails com Laravel

> Aprenda a enviar e-mails no Laravel com o pacote Emailit Laravel. Ele se integra como um transporte de e-mail nativo e dá acesso completo à API do Emailit por meio de uma Facade.

2026-03-04 · George (https://x.com/thegeorge, https://www.linkedin.com/in/jiri-zizka/)

O Laravel já vem com um excelente suporte nativo a e-mail, mas você ainda precisa de um serviço de entrega confiável por trás dele. O pacote **Emailit Laravel** se conecta diretamente ao sistema de e-mail do Laravel como um transporte nativo. Seus Mailables, Notifications e chamadas `Mail::send()` existentes funcionam sem nenhuma alteração no código. Além disso, você tem acesso completo à API do Emailit por meio de uma Facade prática.

Enviar e-mails é uma das tarefas mais comuns em qualquer aplicação Laravel. Confirmações de cadastro, redefinições de senha, recibos de pedidos, atualizações de entrega e newsletters de marketing dependem de uma entrega de e-mail confiável. Embora o Laravel forneça uma poderosa camada de abstração de e-mail, a entrega real ainda depende do transporte que você configurar. Usar uma API de e-mail como o Emailit oferece alta entregabilidade, rastreamento de entrega, gerenciamento de bounces e análises detalhadas, sem ter que gerenciar servidores SMTP ou se preocupar com reputação de IP.

Neste guia, vamos configurar o Emailit em uma aplicação Laravel e enviar e-mails tanto pelo sistema de e-mail padrão do Laravel quanto pela Facade do Emailit.

## Requisitos

- PHP 8.1 ou superior
- Laravel 10, 11 ou 12
- Uma [conta no Emailit](https://app.emailit.com/register) com uma chave de API

## Instalação

Instale o pacote via Composer:

```bash
composer require emailit/emailit-laravel
```

O pacote registra o próprio service provider automaticamente (auto-discovery), então não é preciso registrá-lo à mão. Ele funciona com Laravel 10, 11 e 12 sem nenhuma configuração extra.

## Configuração

Adicione sua chave de API ao `.env`:

```
EMAILIT_API_KEY=sua_chave_api
```

Defina o Emailit como seu mailer padrão:

```
MAIL_MAILER=emailit
```

Adicione o mailer `emailit` ao array de mailers do seu `config/mail.php`:

```php
'mailers' => [
    // ...

    'emailit' => [
        'transport' => 'emailit',
    ],
],
```

Opcionalmente, publique o arquivo de configuração para personalizar a URL base da API:

```bash
php artisan vendor:publish --tag=emailit-config
```

A configuração é mínima de propósito. Depois que você define a chave de API e o mailer padrão, o Laravel passa a enviar automaticamente todos os e-mails de saída pelo Emailit. Não há necessidade de configurar hosts SMTP, portas, configurações de criptografia ou credenciais de autenticação como você faria com uma configuração tradicional de servidor de e-mail.

## Como enviar e-mails com o Laravel Mail

Depois da configuração, todos os recursos de e-mail do Laravel funcionam normalmente. Nada no seu código atual precisa mudar.

### Com um Mailable

Crie uma classe Mailable como você normalmente faria:

```php
namespace App\Mail;

use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Queue\SerializesModels;

class EmailBoasVindas extends Mailable
{
    use Queueable, SerializesModels;

    public function __construct(
        public readonly User $user,
    ) {}

    public function envelope(): Envelope
    {
        return new Envelope(
            subject: 'Bem-vindo ao Nosso App',
        );
    }

    public function content(): Content
    {
        return new Content(
            view: 'emails.boas-vindas',
        );
    }
}
```

Depois, envie:

```php
use Illuminate\Support\Facades\Mail;
use App\Mail\EmailBoasVindas;

Mail::to('usuario@exemplo.com')->send(new EmailBoasVindas($user));
```

E-mails em fila, Mailables Markdown e Notifications funcionam exatamente como você esperaria. O Emailit fica, de forma transparente, por trás da camada de e-mail do Laravel, então você pode colocá-lo no lugar de qualquer transporte que já usa, como SMTP, Mailgun ou SES, sem mexer no código da aplicação. Assim fica fácil testar o Emailit ao lado do seu provedor atual ou migrar aos poucos.

## Com a Facade do Emailit

Para recursos que vão além do que o sistema de e-mail do Laravel oferece, como templates com variáveis, envios agendados ou gerenciamento de recursos da API, use a Facade `Emailit`. Ela oferece acesso direto ao [SDK PHP do Emailit](https://github.com/emailit/emailit-php) completo.

### Enviar um e-mail via API

```php
use Emailit\Laravel\Facades\Emailit;

$email = Emailit::emails()->send([
    'from'    => 'ola@seudominio.com',
    'to'      => ['usuario@exemplo.com'],
    'subject' => 'Olá do Emailit',
    'html'    => '<h1>Bem-vindo!</h1>',
]);

echo $email->id;
echo $email->status;
```

### Enviar com um template

Use os templates que você criou no painel do Emailit e passe variáveis dinâmicas:

```php
use Emailit\Laravel\Facades\Emailit;

$email = Emailit::emails()->send([
    'from'      => 'ola@seudominio.com',
    'to'        => 'usuario@exemplo.com',
    'template'  => 'email_boas_vindas',
    'variables' => [
        'nome'    => 'João Silva',
        'empresa' => 'Acme Ltda',
    ],
]);
```

Usar templates do lado do servidor é um padrão poderoso para aplicações Laravel. Designers e profissionais de marketing podem atualizar o conteúdo, o estilo e o layout dos e-mails no painel do Emailit sem mudanças no código nem novos deploys. O código PHP só precisa passar os dados, e o template cuida da renderização.

### Agendar um e-mail

```php
use Emailit\Laravel\Facades\Emailit;

$email = Emailit::emails()->send([
    'from'         => 'lembretes@seudominio.com',
    'to'           => 'usuario@exemplo.com',
    'subject'      => 'Lembrete de Consulta',
    'html'         => '<p>Sua consulta é amanhã às 14h.</p>',
    'scheduled_at' => '2026-04-10T09:00:00Z',
]);
```

E-mails agendados são tratados inteiramente pela API do Emailit, o que significa que funcionam independentemente do seu sistema de filas do Laravel. Isso é ideal para lembretes de consultas, avisos de renovação de assinatura e campanhas com hora marcada, em que você quer a entrega garantida em um horário específico, mesmo que o seu servidor de aplicação fique fora do ar.

### Enviar com anexos

```php
use Emailit\Laravel\Facades\Emailit;

$email = Emailit::emails()->send([
    'from'        => 'faturas@seudominio.com',
    'to'          => 'cliente@exemplo.com',
    'subject'     => 'Sua Fatura #12345',
    'html'        => '<p>Segue sua fatura em anexo.</p>',
    'attachments' => [
        [
            'filename'     => 'fatura.pdf',
            'content'      => base64_encode(file_get_contents('fatura.pdf')),
            'content_type' => 'application/pdf',
        ],
    ],
]);
```

## Gestão de recursos

A Facade expõe todos os serviços da API do Emailit, então você pode gerenciar toda a sua infraestrutura de e-mail a partir do Laravel.

### Domínios

```php
use Emailit\Laravel\Facades\Emailit;

$domain = Emailit::domains()->create([
    'name' => 'exemplo.com',
    'track_loads' => true,
    'track_clicks' => true,
]);

$domain = Emailit::domains()->verify('sd_123');
```

Gerenciar domínios de envio pela API é útil para plataformas SaaS que precisam configurar domínios personalizados para cada cliente. Você pode automatizar todo o fluxo de verificação de domínio, incluindo verificações de registros DNS, diretamente da sua aplicação Laravel.

### Contatos

```php
use Emailit\Laravel\Facades\Emailit;

$contact = Emailit::contacts()->create([
    'email' => 'usuario@exemplo.com',
    'first_name' => 'João',
    'last_name' => 'Silva',
]);

$contacts = Emailit::contacts()->list();
```

### Verificação de e-mail

```php
use Emailit\Laravel\Facades\Emailit;

$result = Emailit::emailVerifications()->verify([
    'email' => 'teste@exemplo.com',
]);

echo $result->status; // valid
echo $result->risk;   // low
```

Verificar os endereços de e-mail no cadastro ou no envio de um formulário ajuda você a manter a lista de contatos limpa e protege a sua reputação de remetente. Altas taxas de bounce de endereços inválidos podem fazer seus e-mails caírem em pastas de spam, então a verificação é uma boa prática para qualquer aplicação Laravel que envia e-mails transacionais ou de marketing em escala.

## Injeção de dependência

Se preferir não usar Facades, você pode injetar o cliente diretamente:

```php
use Emailit\EmailitClient;

class EmailController extends Controller
{
    public function send(EmailitClient $emailit)
    {
        $email = $emailit->emails()->send([
            'from'    => 'ola@seudominio.com',
            'to'      => ['usuario@exemplo.com'],
            'subject' => 'Olá',
            'html'    => '<p>Oi!</p>',
        ]);

        return response()->json(['id' => $email->id]);
    }
}
```

O container de serviços do Laravel resolve automaticamente a instância `EmailitClient` com a chave de API da sua configuração, então você tem a mesma praticidade da Facade com os benefícios de testabilidade da injeção de dependência.

## Tratamento de erros

O SDK PHP subjacente lança exceções tipadas, então você pode capturar tipos específicos de erro:

```php
use Emailit\Exceptions\AuthenticationException;
use Emailit\Exceptions\RateLimitException;
use Emailit\Exceptions\ApiErrorException;
use Emailit\Laravel\Facades\Emailit;

try {
    Emailit::emails()->send([...]);
} catch (AuthenticationException $e) {
    // Chave de API inválida (401)
} catch (RateLimitException $e) {
    // Muitas requisições (429)
} catch (ApiErrorException $e) {
    // Qualquer outro erro da API
    echo $e->getHttpStatus();
}
```

Em uma aplicação Laravel, você também pode tratar essas exceções globalmente no seu exception handler ou usar um middleware para capturar erros de limite de taxa e implementar novas tentativas automáticas. Isso garante que sua aplicação permaneça resiliente mesmo ao enviar grandes volumes de e-mail.

## Todos os serviços disponíveis

A Facade oferece acesso a tudo na API do Emailit:

| Serviço | Uso | Descrição |
| --- | --- | --- |
| Emails | `Emailit::emails()` | Enviar, listar, obter, cancelar e tentar de novo e-mails |
| Domains | `Emailit::domains()` | Criar, verificar, listar e gerenciar domínios de envio |
| API Keys | `Emailit::apiKeys()` | Criar, listar e gerenciar chaves de API |
| Audiences | `Emailit::audiences()` | Criar, listar e gerenciar listas de contatos |
| Subscribers | `Emailit::subscribers()` | Adicionar, listar e gerenciar inscritos |
| Templates | `Emailit::templates()` | Criar, listar e publicar templates de e-mail |
| Suppressions | `Emailit::suppressions()` | Criar, listar e gerenciar endereços suprimidos |
| Email Verifications | `Emailit::emailVerifications()` | Verificar endereços de e-mail |
| Email Verification Lists | `Emailit::emailVerificationLists()` | Verificação de e-mails em massa |
| Webhooks | `Emailit::webhooks()` | Criar, listar e gerenciar webhooks |
| Contacts | `Emailit::contacts()` | Criar, listar e gerenciar contatos |
| Events | `Emailit::events()` | Listar e obter eventos |

## Comece agora

Instale o pacote e comece a enviar em menos de um minuto:

```bash
composer require emailit/emailit-laravel
```

Confira a documentação completa do pacote no [GitHub](https://github.com/emailit/emailit-laravel), o [SDK PHP do Emailit](https://github.com/emailit/emailit-php), que é o cliente por trás do pacote, ou consulte a [referência da API](https://emailit.com/docs/api-reference/endpoints) para ver os detalhes de cada endpoint.

---

Source: https://emailit.com/pt/blog/envio-de-emails-usando-laravel/