Nodemailer : Tutoriel avec Exemples de Code [2024]

Ajouter la fonctionnalité d’envoi d’emails à votre backend Node.js avec le module Nodemailer est extrêmement simple.

Dans ce tutoriel, je détaille le processus, de l’installation à l’envoi de divers types d’emails, en passant par leur test pour s’assurer qu’ils atteignent les boîtes de réception de vos destinataires sans souci.

Si vous avez déjà installé Nodemailer et êtes prêt à commencer à envoyer des emails, cliquez ici.

Comment installer Nodemailer

Pour installer et commencer à utiliser Nodemailer, vous devez d’abord installer Node.js — téléchargez-le depuis le site officiel ou consultez ce guide mis à jour sur l’installation de Node.js.

Pour installer Nodemailer, vous pouvez utiliser le gestionnaire de package npm :

npm install nodemailer

Ou le gestionnaire de package Yarn :

yarn add nodemailer

Une fois installé, incluez-le dans votre application web avec le code suivant :

const nodemailer = require('nodemailer');

Ou ce code, si vous utilisez des modules ES :

import nodemailer from 'nodemailer';

Comment envoyer des emails avec Nodemailer

Pour commencer à envoyer des emails avec Nodemailer, il vous suffit de :

Créer un objet transporteur
Configurer l’objet mailOptions
Envoyer un message avec sendMail()

Pour simplifier les choses, j’ai créé un exemple de code que vous pouvez utiliser — copiez-le simplement dans votre fichier de configuration JavaScript (par exemple, index.js) :

// Importer la bibliothèque Nodemailer
const nodemailer = require('nodemailer');

// Créer un objet transporteur
const transporter = nodemailer.createTransport({
  host: 'live.smtp.mailtrap.io',
  port: 587,
  secure: false, // utilise SSL
  auth: {
    user: '1a2b3c4d5e6f7g',
    pass: '1a2b3c4d5e6f7g',
  }
});

// Configurer l'objet mailOptions
const mailOptions = {
  from: 'votreutilisateur@email.com',
  to: 'votreami@email.com',
  subject: 'Envoyer un Email en utilisant Node.js',
  text: 'C\'était facile !'
};

// Envoyer l'email
transporter.sendMail(mailOptions, function(error, info){
  if (error) {
    console.log(‘Erreur :’ error);
  } else {
    console.log('Email envoyé : ' + info.response);
  }
});

Pour sauvegarder et exécuter le script, utilisez la commande suivante :

node src/index.js

Et voilà, votre application peut désormais envoyer des emails !

Avec cet exemple de code, vous pouvez envoyer des emails en texte brut et en HTML en utilisant le service de messagerie de votre choix (par exemple, Gmail, Office, etc.). Mais, comme vous pouvez le voir dans l’objet ‘transporter’, j’ai utilisé l’Email API/SMTP de Mailtrap, qui offre un SMTP fiable avec des capacités d’envoi robustes.

De plus, Mailtrap propose un plan gratuit généreux, et contrairement à Gmail par exemple, me fournit des analyses approfondies, des IP dédiées, des échauffements IP automatiques, des listes de suppression, et d’autres fonctionnalités avancées pour peaufiner mon infrastructure d’email.

Envoyer des Emails avec Mailtrap Gratuitement

Astuce : Pour vérifier que votre connexion SMTP est correcte, ajoutez l’appel verify(callback) pour tester la connexion et l’authentification, comme ceci :

transporter.verify(function(error, success) {
  if (error) {
        console.log(‘Erreur de connexion :’ error);
  } else {
        console.log('Le serveur est prêt à prendre nos messages');
  }
});

Si vous rencontrez des problèmes, consultez la documentation officielle de Nodemailer sur GitHub.

Envoyer un email HTML

Pour envoyer un email avec du contenu HTML dans Nodemailer, ajoutez le champ html à vos options de message et utilisez les balises appropriées (par exemple, <h1>, <p>, etc.).

Voici un exemple :

const mailOptions = {
  from: 'votreemail@email.com',
  to: 'votreami@yahoo.com',
  subject: 'Envoyer un email HTML avec Node.js est un jeu d\'enfant',
  text: 'C\'était facile !',
  html: '<h1>Bienvenue</h1><p>C\'était facile !</p>'
}

Vous pouvez également ajouter tout type de données comme contenu du corps principal, en dehors du texte et du HTML.

Par exemple :

let message = {
    ...
    html: '<b>Hello World !</b>',
    alternatives: [
        {
            contentType: 'text/x-web-markdown',
            content: '**Hello World !**'
        }
    ]
}

Notez que vous pouvez ajouter autant d’alternatives que vous le souhaitez.

Envoyer un email à plusieurs destinataires

Dans d’autres langages de programmation et frameworks, vous utilisez cc et bcc pour ajouter plusieurs destinataires. Avec Nodemailer cependant, c’est beaucoup plus simple, car vous pouvez ajouter les adresses dans le même champ to, comme ceci :

const mailOptions = {
  from: 'votreemail@email.com',
  to: 'votreami@email.com, votreautreami@email.com',
  subject: 'Envoyer un Email en utilisant Node.js',
  text: 'C\'était facile !'
}

Envoyer un email avec des pièces jointes

Pour ajouter des pièces jointes dans Nodemailer, vous pouvez utiliser l’option attachments dans l’objet du message :

Voyez par vous-même :

let message = {
    ...
    attachments: [
        {   // chaîne de caractères utf-8 en tant que pièce jointe
            filename: 'text1.txt',
            content: 'hello world!'
        },
        {   // buffer binaire en tant que pièce jointe
            filename: 'text2.txt',
            content: Buffer.from('hello world!','utf-8')
        },
        {   // fichier sur le disque en tant que pièce jointe
            filename: 'text3.txt',
            path: '/path/to/fichier.txt' // stream ce fichier
        },
        {   // nom de fichier et type de contenu dérivés du chemin
            path: '/path/to/fichier.txt'
        },
        {   // stream en tant que pièce jointe
            filename: 'text4.txt',
            content: fs.createReadStream('fichier.txt')
        },
        {   // définir un type de contenu personnalisé pour la pièce jointe
            filename: 'text.bin',
            content: 'hello world!',
            contentType: 'text/plain'
        },
        {   // utiliser une URL comme pièce jointe
            filename: 'license.txt',
            path: 'https://raw.github.com/nodemailer/nodemailer/master/LICENSE'
        },
        {   // chaîne de caractères encodée en tant que pièce jointe
            filename: 'text1.txt',
            content: 'aGVsbG8gd29ybGQh',
            encoding: 'base64'
        },
        {   // URI de données en tant que pièce jointe
            path: 'data:text/plain;base64,aGVsbG8gd29ybGQ='
        },
        {
            // utiliser un nœud MIME pré-généré
            raw: 'Content-Type: text/plain\r\n' +
                 'Content-Disposition: attachment;\r\n' +
                 '\r\n' +
                 'Hello world !'
        }
    ]
}

Envoyer un email avec une image intégrée

Pour ajouter une image intégrée dans le corps HTML, vous pouvez également utiliser l’option attachments. Tout ce que vous avez à faire est de définir une propriété supplémentaire de la pièce jointe ‘cid’ qui fait référence au fichier joint.

Gardez en tête que la valeur cid doit être utilisée comme URL de l’image dans le code HTML, comme ceci :

let message = {
    ...
    html: 'Embedded image: <img src="cid:unique@nodemailer.com"/>',
    attachments: [{
        filename: 'image.png',
        path: '/path/to/fichier',
        cid: 'unique@nodemailer.com' // même valeur cid que dans le src de l'image html
    }]
}

Envoi d’emails asynchrone

Pour envoyer des emails de manière asynchrone dans Nodemailer, nous devrons utiliser un logiciel de file d’attente de messages, tel que RabbitMQ.

Voici à quoi ressemble tout le processus :

1. Configurer RabbitMQ

Pour installer et configurer RabbitMQ, visitez le site officiel et suivez les instructions pour votre système d’exploitation. Vous pouvez consulter les instructions détaillées fournies par RabbitMQ comme guide.

2. Installer amqlib

Pour communiquer avec RabbitMQ, votre application aura besoin d’un protocole de messagerie tel que amqplib. Installez-le avec la commande suivante :

npm install amqplib

3. Créer un producteur pour mettre les messages en file d’attente

Ensuite, nous avons besoin d’un producteur qui mettra les messages à la file d’attente. Pour cela, vous pouvez utiliser l’exemple de code suivant et l’ajouter à votre fichier de configuration :

const amqp = require('amqplib');

async function sendToQueue(emailData) {
    const conn = await amqp.connect('amqp://localhost'); // Se connecter au serveur RabbitMQ
    const channel = await conn.createChannel(); // Créer un canal
    const queue = 'emails'; // Nom de la file d'attente

    await channel.assertQueue(queue, { durable: true }); // S'assurer que la file d'attente existe et est durable
    channel.sendToQueue(queue, Buffer.from(JSON.stringify(emailData)), { persistent: true }); // Envoyer les données d'email à la file d'attente

    console.log('Demande d\'email envoyée à la file d\'attente');
    setTimeout(() => {
        channel.close();
        conn.close();
    }, 500);
}

// Exemple de données d'email
const emailData = {
    from: 'expediteur@exemple.com',
    to: 'destinataire@exemple.com',
    subject: 'Email de Test',
    text: 'Ceci est un email de test envoyé de manière asynchrone en utilisant RabbitMQ et Nodemailer.'
};

sendToQueue(emailData);

4. Créer un worker pour envoyer les messages

Enfin, créons un worker qui détecte les messages dans la file d’attente et les envoie via Nodemailer :

const amqp = require('amqplib');
const nodemailer = require('nodemailer');

async function startWorker() {
    try {
        const conn = await amqp.connect('amqp://localhost');
        const channel = await conn.createChannel();
        const queue = 'emails';

        await channel.assertQueue(queue, { durable: true });
        console.log("En attente de messages dans %s. Pour quitter, appuyez sur CTRL+C", queue);

        channel.consume(queue, async msg => {
            if (msg !== null) {
                const emailData = JSON.parse(msg.content.toString());
                await sendEmail(emailData);
                channel.ack(msg);
            }
        });
    } catch (error) {
        console.error('Erreur lors du démarrage du worker :', error);
    }
}


async function sendEmail(emailData) {
    let transporter = nodemailer.createTransport({
        service: 'gmail', // ou votre service de messagerie
        auth: {
            user: 'adresse de l\'expéditeur (par exemple, votremail@email.com)’,
            pass: 'votre-mot-de-passe'
        }
    });

    try {
        let info = await transporter.sendMail(emailData);
        console.log('Email envoyé : %s', info.messageId);
    } catch (error) {
        console.error('Erreur lors de l\'envoi de l\'email :', error);
    }
}

startWorker();

N’oubliez pas de remplacer les variables telles que user et pass par vos véritables identifiants de messagerie.

Envoyer des emails en masse

Envoyer des emails en masse avec Nodemailer est à peu près la même chose que l’envoi de messages asynchrones, avec bien sûr quelques ajustements.

Pour ce faire, vous devriez :

Utiliser le SMTP en pool — Pour éviter que votre code ne fasse le “handshake” SMTP pour chaque email que vous envoyez en masse, définissez l’option [pool] sur [true] si vous utilisez les mêmes identifiants.
Augmenter la valeur d’envoi par défaut — La valeur par défaut pour [maxMessages] est de 100, ce qui signifie que la connexion sera interrompue une fois que 100 messages seront envoyés depuis le pool. Pour contourner cela, définissez simplement l’option [maxMessages] sur [Infinity].
Ajuster le nombre maximal de connexions — En fonction de la quantité de connexions que votre système peut gérer, vous devez définir la valeur [maxConnections] en conséquence.
Utiliser des chemins de fichiers au lieu d’URLs pour les pièces jointes — Lire le même fichier depuis le disque plusieurs fois lors de l’envoi d’emails en masse est beaucoup plus rapide que d’utiliser des URLs, auquel cas tous les nouveaux messages doivent faire une nouvelle requête HTTP pour recevoir le fichier du serveur.
Utiliser un fournisseur dédié à la livraison en masse — L’une des raisons pour lesquelles je n’utilise pas mon compte Gmail est qu’il n’est pas conçu pour l’envoi d’emails en masse. Si vous ne voulez pas avoir des limites strictes ou être étiqueté comme spammeur, vous devez utiliser un fournisseur qui offre un SMTP dédié pour les emails en masse.

Si cela vous semble compliqué, ne vous inquiétez pas, j’ai ce qu’il vous faut. Voici un exemple de code que vous pouvez facilement utiliser pour l’envoi d’emails en masse :

const nodemailer = require('nodemailer');


// Configurer Nodemailer pour utiliser Mailtrap pour le SMTP avec connexion en pool
const transporter = nodemailer.createTransport({
   host: 'bulk.smtp.mailtrap.io',
   port: 587,
   pool: true, // Utiliser le pool SMTP pour garder la connexion ouverte pour plusieurs emails
   auth: {
       user: 'votre-nom-d-utilisateur-mailtrap', // Remplacez par votre nom d'utilisateur Mailtrap
       pass: 'votre-mot-de-passe-mailtrap'  // Remplacez par votre mot de passe Mailtrap
   },
   maxMessages: Infinity, // Autoriser un nombre illimité de messages par connexion
   maxConnections: 5 // Limiter le nombre de connexions simultanées
});


// Exemple de liste de destinataires pour l'envoi en masse
const recipients = [
   {email: 'destinataire1@exemple.com', name: 'Destinataire Un'},
   {email: 'destinataire2@exemple.com', name: 'Destinataire Deux'},
   {email: 'destinataire3@exemple.com', name: 'Destinataire Trois'},
   // Ajoutez d'autres destinataires selon vos besoins
];


// Préparer des promesses d'email pour l'envoi en masse
const emailPromises = recipients.map(recipient =>
   transporter.sendMail({
       from: '"Nom de l\'expéditeur" <expediteur@exemple.com>',
       to: `${recipient.name} <${recipient.email}>`, // Personnalisé pour chaque destinataire
       subject: 'Test d\'Email en Masse',
       text: 'Ceci est un email de test envoyé en masse en utilisant Nodemailer et Mailtrap.',
       html: `<b>Bonjour ${recipient.name},</b><p>Ceci est un email de test envoyé en masse en utilisant Nodemailer et Mailtrap.</p>`
   })
);


// Envoyer tous les emails en parallèle et gérer les résultats
Promise.all(emailPromises)
   .then(results => {
       console.log('Tous les emails ont été envoyés avec succès');
       results.forEach(result => {
           console.log(`Message à ${result.envelope.to} envoyé : ${result.messageId}`);
       });
   })
   .catch(errors => {
       console.error('Échec de l\'envoi d\'un ou plusieurs emails :', errors);
   });

Pour cela, j’utilise également l’Email API/SMTP de Mailtrap, car il me fournit un flux pour les messages transactionnels et un flux séparé pour l’envoi d’emails en masse. De cette façon, je peux maintenir ma délivrabilité des emails élevée sur les deux flux sans frais supplémentaires.

Paramètres SMTP/API de l’Email API/SMTP de Mailtrap

De plus, Mailtrap propose une API d’email compatible avec les envois en masse, ce qui signifie que vous pouvez envoyer un email HTML personnalisé à 1 000 000 destinataires avec un seul appel d’API, et il compilera lui-même les informations dans les emails.

Débogage avec Nodemailer

Pour tester avec succès l’envoi des emails, utilisons le débogage natif.

C’est simple avec Nodemailer : définissez à la fois debug et logger sur true et vous pourrez voir toutes les données qui sont passées au serveur en tant que sortie dans la console.

De cette façon, vous pourrez analyser le processus d’envoi d’emails et corriger rapidement les erreurs, s’il y en a.

Spécifiez les options de débogage dans la section transporteur du script de messagerie dans votre application Node.js :

const transport = nodemailer.createTransport({
  host: "live.smtp.mailtrap.io",
  port: 587,
  auth: {
    user: "1a2b3c4d5e6f7g",
    pass: "1a2b3c4d5e6f7g"
  },
  debug: true, // afficher la sortie de débogage
  logger: true // enregistrer les informations dans la console
});

Voici ce que vous obtiendrez dans la console :

[2018-12-28 18:05:10] DEBUG Creating transport: nodemailer (5.0.0; +https://nodemailer.com/; SMTP/5.0.0[client:5.0.0])
[2018-12-28 18:05:10] DEBUG Sending mail using SMTP/5.0.0[client:5.0.0]
[2018-12-28 18:05:10] DEBUG [nJWMVEIqQCE] Resolved smtp.mailtrap.io as 54.87.153.8 [cache miss]
[2018-12-28 18:05:10] INFO  [nJWMVEIqQCE] Connection established to 54.87.153.8:587
[2018-12-28 18:05:10] DEBUG [nJWMVEIqQCE] S: 220 smtp.mailtrap.io ESMTP ready
[2018-12-28 18:05:10] DEBUG [nJWMVEIqQCE] C: EHLO [127.0.0.1]
[2018-12-28 18:05:10] DEBUG [nJWMVEIqQCE] S: 250-smtp.mailtrap.io
[2018-12-28 18:05:10] DEBUG [nJWMVEIqQCE] S: 250-SIZE 5242880
[2018-12-28 18:05:10] DEBUG [nJWMVEIqQCE] S: 250-PIPELINING
[2018-12-28 18:05:10] DEBUG [nJWMVEIqQCE] S: 250-ENHANCEDSTATUSCODES
[2018-12-28 18:05:10] DEBUG [nJWMVEIqQCE] S: 250-8BITMIME
[2018-12-28 18:05:10] DEBUG [nJWMVEIqQCE] S: 250-DSN
[2018-12-28 18:05:10] DEBUG [nJWMVEIqQCE] S: 250-AUTH PLAIN LOGIN CRAM-MD5
[2018-12-28 18:05:10] DEBUG [nJWMVEIqQCE] S: 250 STARTTLS
[2018-12-28 18:05:10] DEBUG [nJWMVEIqQCE] C: STARTTLS
[2018-12-28 18:05:10] DEBUG [nJWMVEIqQCE] S: 220 2.0.0 Start TLS
[2018-12-28 18:05:10] INFO  [nJWMVEIqQCE] Connection upgraded with STARTTLS
[2018-12-28 18:05:10] DEBUG [nJWMVEIqQCE] C: EHLO [127.0.0.1]
[2018-12-28 18:05:11] DEBUG [nJWMVEIqQCE] S: 250-smtp.mailtrap.io
[2018-12-28 18:05:11] DEBUG [nJWMVEIqQCE] S: 250-SIZE 5242880
[2018-12-28 18:05:11] DEBUG [nJWMVEIqQCE] S: 250-PIPELINING
[2018-12-28 18:05:11] DEBUG [nJWMVEIqQCE] S: 250-ENHANCEDSTATUSCODES
[2018-12-28 18:05:11] DEBUG [nJWMVEIqQCE] S: 250-8BITMIME
[2018-12-28 18:05:11] DEBUG [nJWMVEIqQCE] S: 250-DSN
[2018-12-28 18:05:11] DEBUG [nJWMVEIqQCE] S: 250 AUTH PLAIN LOGIN CRAM-MD5
[2018-12-28 18:05:11] DEBUG [nJWMVEIqQCE] SMTP handshake finished
[2018-12-28 18:05:11] DEBUG [nJWMVEIqQCE] C: MAIL FROM:<from@example.com>
[2018-12-28 18:05:11] DEBUG [nJWMVEIqQCE] S: 250 2.1.0 Ok
[2018-12-28 18:05:11] DEBUG [nJWMVEIqQCE] C: RCPT TO:<user1@example.com>
[2018-12-28 18:05:11] DEBUG [nJWMVEIqQCE] C: RCPT TO:<user2@example.com>
[2018-12-28 18:05:11] DEBUG [nJWMVEIqQCE] S: 250 2.1.0 Ok
[2018-12-28 18:05:11] DEBUG [nJWMVEIqQCE] S: 250 2.1.0 Ok
[2018-12-28 18:05:11] DEBUG [nJWMVEIqQCE] C: DATA
[2018-12-28 18:05:11] DEBUG [nJWMVEIqQCE] S: 354 Go ahead
…
[2018-12-28 18:05:12] DEBUG [nJWMVEIqQCE] S: 250 2.0.0 Ok: queued
[2018-12-28 18:05:12] DEBUG [nJWMVEIqQCE] Closing connection to the server using "end"
Message sent: <74bfe12e-92fa-91f8-8643-a166b66c62d7@example.com>
[2018-12-28 18:05:12] INFO  [nJWMVEIqQCE] Connection closed

Tester les emails et l’envoi d’emails en staging

Le débogage permet de s’assurer que la fonctionnalité d’envoi d’emails fonctionne, mais comment s’assurer que vos messages ont l’apparence souhaitée et qu’ils arrivent dans les boîtes de réception de vos destinataires ?

Vous pouvez utiliser Ethereal, un service SMTP factice pour tester les emails dans Nodemailer. Ou, vous pouvez utiliser NodemailerApp, qui dispose de serveurs POP3 et SMTP locaux. Bien que ces deux solutions fonctionnent bien, vous devez garder en tête qu’elles sont limitées en termes de fonctionnalités.

Par exemple, Ethereal n’a pas de capacités de prévisualisation d’emails et NodemailerApp n’a pas de fonctionnalités anti-spam, entre autres choses.

Maintenant, si vous souhaitez les utiliser, n’hésitez pas, mais comme elles sont assez minimalistes, j’utilise personnellement l’Email Testing de Mailtrap, une partie de la Plateforme d’Email Delivery de Mailtrap. Contrairement à Ethereal, il me permet d’inspecter le HTML/CSS de mes emails et de corriger facilement les lignes de code défectueuses, de prévisualiser mes messages, et plus encore.

Fonction de vérification HTML de Mailtrap

Et contrairement à NodemailerApp, Mailtrap me permet de vérifier mon score de spam, ce qui, si je le maintiens en dessous de 5, évite de nombreux problèmes de délivrabilité que je pourrais rencontrer une fois que mon application passera en production.

Mailtrap propose également une API d’email, qui vous permet de tester facilement vos modèles d’emails et de passer du staging à la production une fois que vous êtes prêt à commencer à envoyer. Tout ce que vous avez à faire est d’activer la sandbox, de spécifier l’ID de la boîte de réception, de recevoir le test du modèle, puis de l’envoyer via l’API.

Fonction des modèles d'email de Mailtrap

C’est aussi super facile à utiliser !

Tout d’abord, créez un compte Mailtrap gratuit puis :

Naviguez vers Email Testing et choisissez votre boîte de réception
Copiez vos identifiants depuis l’onglet SMTP Settings
Insérez les identifiants dans le script de votre application Node.js

De plus, vous pouvez utiliser l’intégration prête à l’emploi de Mailtrap avec Nodemailer :

Sélectionnez Nodemailer dans la liste des intégrations
Copiez et collez l’extrait de code dans le code de votre application

L’extrait de code contient les attributs transporter et syntaxis, et ressemble à ceci :

const transport = nodemailer.createTransport({
  host: "sandbox.smtp.mailtrap.io",
  port: 2525,
  auth: {
    user: "1a2b3c4d5e6f7g",
    pass: "1a2b3c4d5e6f7g"
  }
});

Testez les Emails avec Mailtrap Gratuitement

Conclusion

Comme vous pouvez le voir, envoyer des emails avec Nodemailer, open-source, est vraiment, comme le dit son créateur, “un jeu d’enfant”.🧸

Maintenant, pour simplifier encore plus les choses, assurez-vous de tirer parti des capacités de test et d’envoi d’emails de Mailtrap, et assurez-vous que vos messages arrivent quand et où ils le doivent.

De plus, si cette partie de Nodemailer a éveillé votre soif de connaissances, consultez notre blog, où vous pouvez trouver d’autres articles connexes tels que :

Guide Nodemailer : Configuration, Installation SMTP, et Envoi d’Emails