Envoyer des e-mails avec PHP

Envoyer des e-mails depuis PHP a longtemps voulu dire se battre avec mail(), configurer des serveurs SMTP ou embarquer des dépendances lourdes. Le SDK PHP d’Emailit vous offre une alternative moderne et propre. Vous pouvez envoyer des e-mails transactionnels, gérer des domaines, vérifier des adresses et traiter les webhooks, le tout via un client API simple.

PHP reste l’un des langages les plus utilisés pour le développement web, et l’envoi d’e-mails est un besoin de base de presque toutes les applications PHP. Que vous construisiez un produit SaaS, une boutique en ligne ou un système de gestion de contenu, une livraison d’e-mails fiable est indispensable pour l’onboarding des utilisateurs, la réinitialisation des mots de passe, les confirmations de commande et les campagnes marketing. Plutôt que de compter sur la fonction native mail() de PHP, qui offre peu de contrôle et aucune garantie de livraison, passer par une API e-mail dédiée permet à vos messages d’arriver réellement en boîte de réception.

Dans ce guide, nous verrons comment installer le SDK et l’utiliser pour envoyer des e-mails depuis n’importe quelle application PHP.

Prérequis

• PHP 8.1 ou supérieur
• Un compte Emailit avec une clé API
• Composer

Installation

Installez le SDK avec Composer :

composer require emailit/emailit-php

Le SDK PHP d’Emailit est disponible sous forme de paquet Composer : il s’intègre donc sans effort dans tout projet PHP qui gère ses dépendances avec Composer. Pas besoin d’inclusions manuelles de fichiers ni d’autoloader maison.

Initialiser le client

Créez une instance du client avec votre clé API :

require 'vendor/autoload.php';

$emailit = Emailit::client('your_api_key');

Votre clé API se trouve dans le tableau de bord Emailit, sous API Keys.

Envoyer un e-mail simple

Un seul appel de méthode suffit pour envoyer un e-mail :

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

echo $email->id;     // em_abc123...
echo $email->status; // pending

Toutes les méthodes de service renvoient des objets ressources typés, avec un accès direct aux propriétés : vous savez toujours exactement ce que vous manipulez.

Par rapport à la fonction native mail() de PHP, envoyer vos e-mails via une API vous apporte le suivi de livraison, la gestion des rebonds et un statut détaillé pour chaque message. Plus besoin de configurer Sendmail ou Postfix sur votre serveur, et vous bénéficiez d’une livraison fiable chez tous les grands fournisseurs de messagerie, comme Gmail, Outlook et Yahoo.

Envoyer avec un modèle

Si vous avez créé un modèle dans le tableau de bord Emailit, vous pouvez l’appeler par son slug et lui passer des variables :

$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 sortent le contenu de vos e-mails de votre base de code et permettent aux non-développeurs de modifier les textes sans déploiement. C’est particulièrement utile pour les e-mails transactionnels, comme les messages de bienvenue, les liens de réinitialisation de mot de passe, les factures et les notifications d’expédition, dont le design et la formulation changent plus souvent que le code qui les déclenche.

Envoyer avec des pièces jointes

Joignez des fichiers en passant leur contenu encodé en base64 :

$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',
        ],
    ],
]);

Vous pouvez joindre des PDF, des images, des feuilles de calcul ou tout autre type de fichier. C’est la méthode courante pour envoyer des factures, des rapports ou des documents générés directement depuis votre application PHP, sans lien de téléchargement séparé.

Programmer un e-mail

Passez un horodatage scheduled_at pour envoyer à une date ultérieure :

$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',
]);

echo $email->status;       // scheduled
echo $email->scheduled_at; // 2026-04-10T09:00:00Z

Les e-mails programmés peuvent être annulés avant leur envoi :

$emailit->emails()->cancel('em_abc123');

La programmation est utile pour les communications liées à une échéance, comme les rappels de rendez-vous, les avis de renouvellement d’abonnement et les campagnes goutte-à-goutte, où le moment de l’envoi compte autant que le contenu.

Lister et gérer les e-mails envoyés

Récupérez une liste paginée de vos e-mails :

$emails = $emailit->emails()->list(['page' => 1, 'limit' => 10]);

foreach ($emails as $email) {
    echo $email->id . ' - ' . $email->status . "\n";
}

Relancez un e-mail en échec :

$emailit->emails()->retry('em_abc123');

Une visibilité complète sur vos e-mails envoyés et leur statut de livraison, avec la possibilité de relancer les échecs, vous donne un niveau de contrôle que la fonction mail() de PHP ne peut tout simplement pas offrir. C’est essentiel pour les applications où chaque e-mail compte : reçus transactionnels, liens de vérification de compte, codes d’authentification à deux facteurs.

Vérifier les adresses avant l’envoi

Réduisez les rebonds en vérifiant les adresses en amont :

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

echo $result->status; // valid
echo $result->score;  // 0.95
echo $result->risk;   // low

La vérification des adresses est une bonne pratique pour protéger votre réputation d’expéditeur. Envoyer vers des adresses invalides ou jetables fait grimper votre taux de rebond, ce qui peut déclencher les filtres anti-spam et pénaliser la délivrabilité de tout votre domaine. En vérifiant les adresses avant l’envoi, vous gardez un taux de rebond bas et une réputation intacte.

Traiter les événements webhook

Le SDK inclut des classes d’événements typées et la vérification de signature des webhooks. Vous pouvez ainsi réagir aux événements de livraison en temps réel :

use Emailit\WebhookSignature;
use Emailit\Events\EmailDelivered;
use Emailit\Events\EmailBounced;

$event = WebhookSignature::verify(
    file_get_contents('php://input'),
    $_SERVER['HTTP_X_EMAILIT_SIGNATURE'],
    $_SERVER['HTTP_X_EMAILIT_TIMESTAMP'],
    'your_webhook_signing_secret'
);

match (true) {
    $event instanceof EmailDelivered => handleDelivered($event),
    $event instanceof EmailBounced   => handleBounce($event),
    default                          => log("Unhandled: {$event->type}"),
};

Grâce aux webhooks, votre application PHP réagit immédiatement quand un e-mail est livré, rebondit, est ouvert ou cliqué. C’est indispensable pour construire des workflows pilotés par les événements : mettre à jour un CRM quand un message est livré, alerter votre équipe support en cas de rebond ou suivre les indicateurs d’engagement de vos campagnes.

Gestion des erreurs

Le SDK lève des exceptions typées pour que vous puissiez traiter chaque cas d’erreur avec précision :

use Emailit\Exceptions\AuthenticationException;
use Emailit\Exceptions\RateLimitException;
use Emailit\Exceptions\UnprocessableEntityException;
use Emailit\Exceptions\ApiErrorException;

try {
    $emailit->emails()->send([...]);
} catch (AuthenticationException $e) {
    // Invalid API key (401)
} catch (RateLimitException $e) {
    // Too many requests (429)
} catch (UnprocessableEntityException $e) {
    // Validation failed (422)
} catch (ApiErrorException $e) {
    // Any other API error
    echo $e->getHttpStatus();
}

Une bonne gestion des erreurs permet à votre application de se dégrader proprement en cas de problème. Les exceptions de limite de débit, par exemple, peuvent être traitées avec une stratégie de relance, tandis que les erreurs d’authentification doivent déclencher une alerte pour que vous renouveliez votre clé API.

Bien plus que l’envoi

Le SDK vous donne accès à toute l’API Emailit, pas seulement à l’envoi. Vous pouvez gérer domaines, clés API, listes de contacts, abonnés, modèles, adresses bloquées, contacts et événements, le tout depuis PHP :

$domain = $emailit->domains()->create(['name' => 'example.com']);
$contact = $emailit->contacts()->create(['email' => 'user@example.com']);
$templates = $emailit->templates()->list();

Le SDK PHP d’Emailit devient ainsi une boîte à outils complète pour votre infrastructure e-mail. Au lieu de multiplier bibliothèques et services pour la gestion des domaines, les listes de contacts et l’envoi, vous gérez tout avec un seul client PHP cohérent.

Pour commencer

Installez le SDK et envoyez votre premier e-mail en moins d’une minute :

composer require emailit/emailit-php

Consultez la documentation complète du SDK sur GitHub, ou rendez-vous dans la référence de l’API pour le détail de chaque endpoint.