# Envoyer des e-mails avec Laravel

> Apprenez à envoyer des e-mails dans Laravel avec le package Emailit pour Laravel. Il s’intègre comme transport mail natif et donne accès à toute l’API Emailit via une Facade.

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

Laravel gère très bien l’e-mail dès l’installation, mais il vous faut tout de même un service de livraison fiable derrière. Le package **Emailit Laravel** se branche directement sur le système mail de Laravel en tant que transport natif. Vos Mailables, vos Notifications et vos appels à `Mail::send()` existants fonctionnent sans aucune modification du code. En prime, vous accédez à toute l’API Emailit via une Facade pratique.

L’envoi d’e-mails est l’une des tâches les plus courantes d’une application Laravel. Confirmations d’inscription, réinitialisations de mot de passe, reçus de commande, suivis d’expédition et newsletters marketing dépendent tous d’une livraison fiable. Laravel fournit une couche d’abstraction mail puissante, mais la livraison elle-même dépend du transport que vous configurez. Une API e-mail comme Emailit vous apporte une excellente délivrabilité, le suivi des livraisons, la gestion des rebonds et des statistiques détaillées, sans gérer de serveurs SMTP ni vous soucier de la réputation de vos IP.

Dans ce guide, nous verrons comment configurer Emailit dans une application Laravel et envoyer des e-mails à la fois avec le système mail standard de Laravel et avec la Facade Emailit.

## Prérequis

- PHP 8.1 ou supérieur
- Laravel 10, 11 ou 12
- Un [compte Emailit](https://app.emailit.com/register) avec une clé API

## Installation

Installez le package avec Composer :

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

Le package découvre automatiquement son service provider : aucun enregistrement manuel n’est nécessaire. Il fonctionne directement avec Laravel 10, 11 et 12.

## Configuration

Ajoutez votre clé API dans `.env` :

```
EMAILIT_API_KEY=your_api_key
```

Définissez Emailit comme mailer par défaut :

```
MAIL_MAILER=emailit
```

Ajoutez le mailer `emailit` au tableau `mailers` de votre fichier `config/mail.php` :

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

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

Si besoin, publiez le fichier de configuration pour personnaliser l’URL de base de l’API :

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

La configuration est volontairement minimale. Une fois votre clé API et votre mailer par défaut définis, Laravel fait automatiquement passer tous les e-mails sortants par Emailit. Inutile de configurer hôtes SMTP, ports, chiffrement ou identifiants, comme avec un serveur mail traditionnel.

## Envoyer des e-mails avec Laravel Mail

Une fois la configuration faite, toutes les fonctionnalités mail de Laravel fonctionnent telles quelles. Rien ne change dans votre code existant.

### Avec un Mailable

Créez une classe Mailable comme d’habitude :

```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 WelcomeEmail extends Mailable
{
    use Queueable, SerializesModels;

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

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

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

Puis envoyez-la :

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

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

Les e-mails en file d’attente, les Mailables Markdown et les Notifications fonctionnent exactement comme prévu. Emailit se place de façon transparente derrière la couche mail de Laravel : vous pouvez le substituer à n’importe quel transport existant, comme SMTP, Mailgun ou SES, sans toucher au code de votre application. Il est donc facile de tester Emailit en parallèle de votre fournisseur actuel ou de migrer progressivement.

## Utiliser la Facade Emailit

Pour les fonctionnalités qui dépassent le système mail de Laravel, comme les modèles avec variables, les envois programmés ou la gestion des ressources de l’API, utilisez la Facade `Emailit`. Elle vous donne un accès direct à l’ensemble du [SDK PHP d’Emailit](https://github.com/emailit/emailit-php).

### Envoyer un e-mail via l’API

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

$email = Emailit::emails()->send([
    'from'    => 'hello@yourdomain.com',
    'to'      => ['user@example.com'],
    'subject' => 'Hello from Emailit',
    'html'    => '<h1>Welcome!</h1>',
]);

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

### Envoyer avec un modèle

Appelez les modèles créés dans le tableau de bord Emailit et passez-leur des variables dynamiques :

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

$email = Emailit::emails()->send([
    'from'      => 'hello@yourdomain.com',
    'to'        => 'user@example.com',
    'template'  => 'welcome_email',
    'variables' => [
        'name'    => 'John Doe',
        'company' => 'Acme Inc',
    ],
]);
```

Les modèles côté serveur sont une approche très efficace pour les applications Laravel. Vos designers et vos marketeurs peuvent modifier le contenu, le style et la mise en page des e-mails dans le tableau de bord Emailit, sans changement de code ni nouveau déploiement. Le code PHP se contente de transmettre les données, et le modèle se charge du rendu.

### Programmer un e-mail

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

$email = Emailit::emails()->send([
    'from'         => 'reminders@yourdomain.com',
    'to'           => 'user@example.com',
    'subject'      => 'Appointment Reminder',
    'html'         => '<p>Your appointment is tomorrow at 2 PM.</p>',
    'scheduled_at' => '2026-04-10T09:00:00Z',
]);
```

Les e-mails programmés sont entièrement gérés par l’API Emailit : ils fonctionnent donc indépendamment du système de files d’attente de Laravel. C’est idéal pour les rappels de rendez-vous, les avis de renouvellement d’abonnement et les campagnes liées à une échéance, quand vous voulez une livraison garantie à une heure précise, même si votre serveur d’application tombe en panne.

### Envoyer avec des pièces jointes

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

$email = Emailit::emails()->send([
    'from'        => 'invoices@yourdomain.com',
    'to'          => 'customer@example.com',
    'subject'     => 'Your Invoice #12345',
    'html'        => '<p>Please find your invoice attached.</p>',
    'attachments' => [
        [
            'filename'     => 'invoice.pdf',
            'content'      => base64_encode(file_get_contents('invoice.pdf')),
            'content_type' => 'application/pdf',
        ],
    ],
]);
```

## Gérer les ressources

La Facade expose tous les services de l’API Emailit : vous pouvez gérer toute votre infrastructure e-mail depuis Laravel.

### Domaines

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

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

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

Gérer les domaines d’envoi via l’API est utile pour les plateformes SaaS qui doivent configurer un domaine personnalisé pour chaque client. Vous pouvez automatiser tout le processus de vérification des domaines, y compris le contrôle des enregistrements DNS, directement depuis votre application Laravel.

### Contacts

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

$contact = Emailit::contacts()->create([
    'email' => 'user@example.com',
    'first_name' => 'John',
    'last_name' => 'Doe',
]);

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

### Vérification d’e-mails

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

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

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

Vérifier les adresses dès l’inscription ou l’envoi d’un formulaire vous aide à garder une liste de contacts propre et protège votre réputation d’expéditeur. Un taux de rebond élevé dû à des adresses invalides peut envoyer vos e-mails dans les spams : la vérification est donc une bonne pratique pour toute application Laravel qui envoie des e-mails transactionnels ou marketing à grande échelle.

## Injection de dépendances

Si vous préférez ne pas utiliser de Facades, vous pouvez injecter directement le client :

```php
use Emailit\EmailitClient;

class EmailController extends Controller
{
    public function send(EmailitClient $emailit)
    {
        $email = $emailit->emails()->send([
            'from'    => 'hello@yourdomain.com',
            'to'      => ['user@example.com'],
            'subject' => 'Hello',
            'html'    => '<p>Hi there!</p>',
        ]);

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

Le conteneur de services de Laravel résout automatiquement l’instance `EmailitClient` avec la clé API de votre configuration : vous profitez du même confort que la Facade, avec la testabilité de l’injection de dépendances.

## Gestion des erreurs

Le SDK PHP sous-jacent lève des exceptions typées : vous pouvez donc intercepter chaque type d’erreur :

```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) {
    // Invalid API key (401)
} catch (RateLimitException $e) {
    // Too many requests (429)
} catch (ApiErrorException $e) {
    // Any other API error
    echo $e->getHttpStatus();
}
```

Dans une application Laravel, vous pouvez aussi traiter ces exceptions de façon globale dans votre gestionnaire d’exceptions, ou utiliser un middleware pour intercepter les erreurs de limite de débit et relancer automatiquement. Votre application reste ainsi résiliente, même lorsqu’elle envoie de gros volumes d’e-mails.

## Tous les services disponibles

La Facade vous donne accès à toute l’API Emailit :

| Service | Utilisation | Description |
| --- | --- | --- |
| E-mails | `Emailit::emails()` | Envoyer, lister, récupérer, annuler et relancer des e-mails |
| Domaines | `Emailit::domains()` | Créer, vérifier, lister et gérer les domaines d’envoi |
| Clés API | `Emailit::apiKeys()` | Créer, lister et gérer les clés API |
| Listes de contacts | `Emailit::audiences()` | Créer, lister et gérer les listes de contacts |
| Abonnés | `Emailit::subscribers()` | Ajouter, lister et gérer les abonnés |
| Modèles | `Emailit::templates()` | Créer, lister et publier des modèles d’e-mails |
| Adresses bloquées | `Emailit::suppressions()` | Créer, lister et gérer les adresses bloquées |
| Vérifications d’e-mails | `Emailit::emailVerifications()` | Vérifier des adresses e-mail |
| Listes de vérification | `Emailit::emailVerificationLists()` | Vérifier des adresses en masse |
| Webhooks | `Emailit::webhooks()` | Créer, lister et gérer les webhooks |
| Contacts | `Emailit::contacts()` | Créer, lister et gérer les contacts |
| Événements | `Emailit::events()` | Lister et récupérer les événements |

## Pour commencer

Installez le package et commencez à envoyer en moins d’une minute :

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

Consultez la documentation complète du package sur [GitHub](https://github.com/emailit/emailit-laravel), le [SDK PHP d’Emailit](https://github.com/emailit/emailit-php) pour le client sous-jacent, ou la [référence de l’API](https://emailit.com/docs/api-reference/endpoints) pour le détail de chaque endpoint.

---

Source: https://emailit.com/fr/blog/envoi-emails-avec-laravel/