Comment envoyer des emails en Python : méthodes SMTP et API expliquées

On août 27, 2024
27min read
Aleksandr Varnin Full Stack Developer @ Railsware
Veljko Ristić Content Manager @ Mailtrap
How to Send an Email in Python
Table of Contents

Envoyer des emails en Python ? Pas de problème. Cet article couvre tout ce que vous devez savoir sur l’envoi d’emails en Python, y compris des exemples de code, la sécurité et le testing des emails.

Configuration de ‘smtplib‘

Le module smtplib de Python simplifie le processus d’envoi d’emails directement depuis vos applications, offrant une interface simple pour interagir avec les serveurs SMTP.

Cette section vous guide à travers l’importation de `smtplib`, la création d’un objet SMTP pour votre serveur et l’utilisation de ses fonctions principales pour envoyer des emails. Suivez ce guide pour apprendre à intégrer des fonctionnalités d’email dans vos scripts Python.

Le module intégré smtplib peut être importé en utilisant le code suivant :

import smtplib

Pour envoyer un email plus tard, créez un objet SMTP (Simple Mail Transfer Protocol) :

smtpObj = smtplib.SMTP( [host [, port]] )

Détails des paramètres :

  • host : cet argument est optionnel et représente l’hôte exécutant votre serveur SMTP. L’adresse IP de l’hôte ou un nom de domaine peut être spécifié.
  • port : si l’argument host est spécifié, indiquez un port où le serveur SMTP écoute.
  • local_hostname : si le serveur SMTP utilisé fonctionne sur votre machine locale, spécifiez localhost.

Un objet SMTP possède une méthode d’instance appelée sendmail qui est utilisée pour envoyer un message et comporte trois paramètres :

  • sender : chaîne contenant l’adresse de l’expéditeur.
  • receivers : liste de chaînes, une pour chaque destinataire.
  • message : un message sous forme de chaîne formatée comme spécifié dans les RFC.
smtpObj.sendmail(sender, receivers, message)

Pour vous assurer que le module d’email a été correctement importé et obtenir la description complète de ses classes et arguments, tapez dans une session interactive Python :

help(smtplib)

Consultez la documentation de Python pour examiner le reste des objets SMTP (par exemple, smtp.ehlo; smtp.send_message(msg), etc.) et comment les utiliser.

La section suivante explique comment envoyer des emails via Python en utilisant l’Email API/SMTP de Mailtrap, une fonctionnalité de la Plateforme de l’Email Delivery de Mailtrap. D’abord, je couvrirai la méthode SMTP et ensuite, je vous montrerai comment le faire avec notre SDK Python.

Envoyer des emails en utilisant SMTP

La méthode est très similaire à celle couverte dans la section smtplib ci-dessus, cependant, vous devez configurer des informations d’identification SMTP personnalisées. Ici, je suppose que vous êtes déjà inscrit sur Mailtrap et que vous avez vérifié votre domaine.

Si ce n’est pas le cas, consultez notre guide détaillé.

Assurez-vous également de consulter nos instructions vidéo sur comment envoyer des emails en Python avec Mailtrap en utilisant smtplib.

Note : Le code ci-dessous contient des informations d’identification fictives de Mailtrap (à l’exception de l’endpoint du serveur). Assurez-vous de les remplacer par vos véritables informations d’identification.

Voici un script de base pour envoyer des emails ‘plaintext’ avec Python en utilisant le SMTP de Mailtrap.

import smtplib
from email.mime.text import MIMEText

# Configuration
port = 587
smtp_server = "live.smtp.mailtrap.io"
login = "api"  # Votre identifiant généré par Mailtrap
password = "1a2b3c4d5e6f7g"  # Votre mot de passe généré par Mailtrap

sender_email = "mailtrap@exemple.com"
receiver_email = "nouveau@exemple.com"

# Contenu en texte brut
text = """\
Salut,
Consultez le nouvel article sur le blog de Mailtrap :
Serveur SMTP pour le testing : basé sur le cloud ou local ?
https://blog.mailtrap.io/2018/09/27/cloud-or-local-smtp-server/
N'hésitez pas à nous dire quel contenu vous serait utile !
"""

# Créer un objet MIMEText
message = MIMEText(text, "plain")
message["Subject"] = "Email en texte brut""
message["From"] = sender_email
message["To"] = receiver_email

# Envoyer l'email
with smtplib.SMTP(smtp_server, port) as server:
    server.starttls()  # Sécuriser la connexion
    server.login(login, password)
    server.sendmail(sender_email, receiver_email, message.as_string())

print('Envoyé')

Explication rapide :

  • Imports et configuration : J’ai importé les modules nécessaires de la bibliothèque standard de Python pour l’envoi d’emails (smtplib et MIMEText).
  • Configuration du serveur d’email : Les détails du serveur SMTP, y compris l’adresse du serveur, le numéro du port et les informations d’authentification.
  • Contenu de l’email : J’ai créé un message MIMEText qui ne peut contenir que du texte brut. Plus tard, je vous montrerai comment inclure des versions HTML et texte brut de l’email.
  • Envoi de l’email : J’ai utilisé un gestionnaire de contexte (instruction with) pour garantir que la connexion au serveur SMTP soit correctement fermée après l’envoi de l’email.

Astuce bonus : Le hardcoding de données sensibles telles que les informations d’identification et les informations du serveur dans votre script peut représenter un risque pour la sécurité. C’est pourquoi je recommande d’utiliser des variables d’environnement pour stocker des informations sensibles. Cela rend votre code plus sécurisé et flexible lors du passage entre différents environnements (développement, testing, production).

Envoyer un email HTML

Si vous souhaitez en savoir plus sur l’envoi d’emails HTML en Python, consultez notre tutoriel dédié.

Pour modifier le script afin d’envoyer des emails HTML (tout en incluant plusieurs destinataires), je vais ajuster la façon dont le corps de l’email est créé et attaché. Voici le script révisé :

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

# Configuration
port = 587
smtp_server = "live.smtp.mailtrap.io"
login = "api"  # Votre identifiant généré par Mailtrap
password = "1a2b3c4d5e6f7g"  # Votre mot de passe généré par Mailtrap

sender_email = "mailtrap@exemple.com"
receiver_email = "nouveau1@exemple.com"

# Contenu de l'email
subject = "Email HTML Sans Pièce Jointe"
html = """\
<html>
  <body>
    <p>Salut,<br>
    Ceci est un email <b>de test</b> sans pièce jointe envoyé en utilisant <a href="https://www.python.org">Python</a>.</p>
  </body>
</html>
"""

# Créer un message multipart et définir les en-têtes
message = MIMEMultipart()
message["From"] = sender_email
message["To"] = receiver_email
message["Subject"] = subject

# Joindre la partie HTML
message.attach(MIMEText(html, "html"))

# Envoyer l'email
with smtplib.SMTP(smtp_server, port) as server:
    server.starttls()
    server.login(login, password)
    server.sendmail(sender_email, receiver_email, message.as_string())

print('Envoyé')

Explication rapide :

  • Joindre le contenu HTML : Le contenu HTML est joint au message de l’email en utilisant MIMEText(html, "html") au lieu de MIMEText(text, "plain"). En spécifiant html comme deuxième argument, nous informons le fournisseur de messagerie que cette partie de l’email doit être interprétée comme du HTML.
Envoyer des emails avec Mailtrap gratuitement

Envoyer un email à plusieurs destinataires

Ici, je vais réutiliser le script ci-dessus et ajuster la gestion des adresses des destinataires.

import smtplib
from email.mime.text import MIMEText

# Configuration
port = 587
smtp_server = "live.smtp.mailtrap.io"
login = "api"  # Votre identifiant généré par Mailtrap
password = "1a2b3c4d5e6f7g"  # Votre mot de passe généré par Mailtrap

sender_email = "mailtrap@exemple.com"
# Liste des adresses email des destinataires
receiver_emails = ["nouveau1@exemple.com", "nouveau2@exemple.com", "nouveau3@exemple.com"]

# Contenu en texte brut
text = """\
Salut,
Consultez le nouvel article sur le blog de Mailtrap :
Serveur SMTP pour le testing : basé sur le cloud ou local ?
https://blog.mailtrap.io/2018/09/27/cloud-or-local-smtp-server/
N'hésitez pas à nous dire quel contenu vous serait utile !
"""

# Créer un objet MIMEText
message = MIMEText(text, "plain")
message["Subject"] = "Email en texte brut"
message["From"] = sender_email
# Joindre la liste des emails des destinataires en une chaîne séparée par des virgules
message["To"] = ", ".join(receiver_emails)

# Envoyer l'email
with smtplib.SMTP(smtp_server, port) as server:
    server.starttls()  # Sécuriser la connexion
    server.login(login, password)
    # Boucler à travers chaque destinataire et envoyer l'email individuellement
    for recipient in receiver_emails:
        server.sendmail(sender_email, recipient, message.as_string())

print('Envoyé')

Explication rapide de ce qui est différent par rapport au script original plaintext :

  • Configuration des destinataires multiples : J’ai modifié la variable receiver_email en receiver_emails. Il s’agit maintenant d’une liste d’adresses email au lieu d’une seule chaîne.
  • Définir l’en-tête To : L’en-tête To dans l’objet message MIMEText est défini en joignant la liste des emails des destinataires en une seule chaîne séparée par des virgules. Cela est important pour que l’en-tête de l’email affiche correctement tous les destinataires lorsqu’ils reçoivent l’email.
    • Note : Certains fournisseurs de messagerie (Outlook, Yahoo, Gmail, etc.) peuvent afficher tous les destinataires dans le champ To pour chaque destinataire, ce qui n’est pas souhaitable pour des raisons de confidentialité. Vous pouvez “corriger” cela en utilisant CC et/ou BCC.
  • Envoi des emails en boucle : Au lieu d’envoyer l’email une seule fois, le script boucle maintenant à travers chaque destinataire dans la liste receiver_emails et leur envoie l’email individuellement.

Astuce pro : ⬆️ Cette approche fonctionne bien pour un petit nombre de destinataires. Cependant, pour envoyer des emails à un grand nombre de destinataires, il pourrait être plus efficace d’utiliser la capacité du serveur SMTP à gérer plusieurs destinataires en une seule opération d’envoi, selon les limitations et politiques du serveur.

Envoyer un email avec des pièces jointes

Je vais utiliser MIMEMultipart car les pièces jointes nécessitent un email multipart. De plus, j’utiliserai la classe MIMEBase pour joindre des fichiers. Voici le script mis à jour :

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email import encoders

# Configuration
port = 587
smtp_server = "live.smtp.mailtrap.io"
login = "api"  # Votre identifiant généré par Mailtrap
password = "1a2b3c4d5e6f7g"  # Votre mot de passe généré par Mailtrap

sender_email = "mailtrap@exemple.com"
receiver_email = "nouveau@exemple.com"  # Un seul destinataire

# Contenu de l'email
subject = "Email avec pièce jointe"
body = "Salut,\nCeci est un email de test avec une pièce jointe."

# Créer un message multipart et définir les en-têtes
message = MIMEMultipart()
message["From"] = sender_email
message["To"] = receiver_email
message["Subject"] = subject

# Ajouter le corps à l'email
message.attach(MIMEText(body, "plain"))

# Spécifier le chemin du fichier à joindre
filename = "path/to/votre/fichier.pdf"  # Modifiez cela avec le bon chemin

# Ouvrir le fichier en mode binaire
with open(filename, "rb") as attachment:
    part = MIMEBase("application", "octet-stream")
    part.set_payload(attachment.read())

# Encoder le fichier en caractères ASCII pour l'envoyer par email
encoders.encode_base64(part)

# Ajouter un en-tête en tant que paire clé/valeur à la partie pièce jointe
part.add_header("Content-Disposition", f"attachment; filename= {filename}")

# Ajouter la pièce jointe au message
message.attach(part)

# Envoyer l'email
with smtplib.SMTP(smtp_server, port) as server:
    server.starttls()
    server.login(login, password)
    server.sendmail(sender_email, receiver_email, message.as_string())

print('Envoyé')

Explication rapide :

  • Utilisation de MIMEMultipart : J’ai opté pour MIMEMultipart pour la structure globale du message au lieu de MIMEText pour le corps. Cela nous permet d’ajouter à la fois la partie texte et la pièce jointe en tant que parties séparées de l’email.
  • Ajout de la pièce jointe :
    • Préparation du fichier : Le fichier à joindre est ouvert en mode binaire rb, et son contenu est lu.
    • Objet MIMEBase : Un objet MIMEBase est créé pour la pièce jointe, avec le type défini sur application/octet-stream. Ce type est un flux binaire générique, ce qui signifie qu’il convient à tout type de fichier, et les fournisseurs de messagerie le traiteront généralement comme une pièce jointe.
    • Encodage : Le contenu du fichier est encodé en base64 pour s’assurer qu’il puisse être transmis en toute sécurité par email. Cela est fait en utilisant la fonction encoders.encode_base64(part).
    • Ajout d’en-têtes : Un en-tête est ajouté à la partie pièce jointe pour indiquer le nom du fichier et le fait qu’il doive être traité comme une pièce jointe (Content-Disposition).
    • Ajout du fichier au message : La partie pièce jointe est ensuite ajoutée au message à l’aide de message.attach(part).

Envoyer un email avec une image intégrée

Pour envoyer des emails avec une image intégrée (dans le contenu HTML), j’utiliserai la classe MIMEImage.

Intégrer une image directement dans l’email permet de l’afficher comme partie intégrante du contenu de l’email plutôt que comme une pièce jointe séparée. Voici comment vous pouvez le faire :

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.image import MIMEImage
from email.mime.base import MIMEBase
from email import encoders
import os

# Configuration
port = 587
smtp_server = "live.smtp.mailtrap.io"
login = "api"  # Votre identifiant généré par Mailtrap
password = "1a2b3c4d5e6f7g"  # Votre mot de passe généré par Mailtrap

sender_email = "mailtrap@exemple.com"
receiver_email = "noveau1@exemple.com"

# Contenu HTML avec une image intégrée
html = """\
<html>
  <body>
    <p>Salut,<br>
    Ceci est un email <b>de test</b> avec une image intégrée.<br>
    Voici une image : <img src="cid:image1">.</p>
  </body>
</html>
"""

# Créer un message multipart et définir les en-têtes
message = MIMEMultipart()
message["From"] = sender_email
message["To"] = receiver_email
message["Subject"] = "Email HTML avec image intégrée"

# Attacher la partie HTML
message.attach(MIMEText(html, "html"))

# Spécifier le chemin de votre image
image_path = "path/to/votre/image.jpg"  # Modifiez cela avec le bon chemin

# Ouvrir le fichier image en mode binaire
with open(image_path, 'rb') as img:
    # Joindre le fichier image
    msg_img = MIMEImage(img.read(), name=os.path.basename(image_path))
    # Définir l'en-tête Content-ID à utiliser dans le corps HTML
    msg_img.add_header('Content-ID', '<image1>')
    # Joindre l'image au message
    message.attach(msg_img)

# Envoyer l'email
with smtplib.SMTP(smtp_server, port) as server:
    server.starttls()
    server.login(login, password)
    server.sendmail(sender_email, receiver_email, message.as_string())

print('Envoyé')

Explication rapide :

  • Mise à jour du contenu HTML : Le contenu HTML inclut désormais une balise <img> avec un attribut src pointant vers le Content-ID (cid) de l’image que vous souhaitez intégrer. Ce cid doit correspondre à la valeur de l’en-tête Content-ID de l’image jointe.
  • Intégration de l’image :
    • Utilisation de MIMEImage : Le script inclut maintenant la classe MIMEImage pour gérer le fichier image. Cette classe est spécialement conçue pour joindre des images aux emails.
    • Ouverture du fichier image : L’image que vous souhaitez intégrer est ouverte en mode binaire.
    • Création de l’objet MIMEImage : Les données binaires de l’image sont utilisées pour créer un objet MIMEImage. Cet objet représente la pièce jointe de l’image.
    • En-tête Content-ID : L’objet MIMEImage reçoit un en-tête Content-ID, qui est référencé par l’attribut src dans la balise <img> du contenu HTML. Ce lien permet au fournisseur de messagerie d’intégrer l’image directement dans le corps de l’email au lieu de la montrer comme une pièce jointe téléchargeable.
    • Joindre l’image : L’objet MIMEImage est joint au message multipart, de la même manière que les autres parties y sont jointes.

Envoi asynchrone d’emails

Pour l’envoi asynchrone d’emails, vous devez utiliser la bibliothèque asyncio de Python avec aiosmtplib, un client SMTP asynchrone.

Cette modification permet à votre script d’envoyer des emails sans bloquer l’exécution de votre programme, le rendant plus efficace, en particulier lors de l’envoi de plusieurs emails ou de l’exécution d’autres tâches simultanément.

Par souci de simplicité, j’enverrai un email texte/brut à un seul destinataire sans pièces jointes ni images intégrées. Voici comment cela fonctionne.

Tout d’abord, assurez-vous d’installer aiosmtplib.

pip install aiosmtplib

Maintenant, voici le script :

import asyncio
from email.mime.text import MIMEText
from aiosmtplib import SMTP

async def send_email_async(sender_email, receiver_email, smtp_server, port, login, password, subject, body):
    message = MIMEText(body)
    message["From"] = sender_email
    message["To"] = receiver_email
    message["Subject"] = subject
    
    async with SMTP(hostname=smtp_server, port=port) as smtp:
        await smtp.connect()
        await smtp.starttls()
        await smtp.login(login, password)
        await smtp.send_message(message)

async def main():
    # Configuration de l'email
    smtp_server = "live.smtp.mailtrap.io"
    port = 587
    sender_email = "mailtrap@exemple.com"
    receiver_email = "noveau@exemple.com"  # Un seul destinataire
    login = "api"  # Votre identifiant généré par Mailtrap
    password = "1a2b3c4d5e6f7g"  # Votre mot de passe généré par Mailtrap
    subject = "Test d'Email Asynchrone"
    body = "Ceci est un email en texte brut envoyé de manière asynchrone."
    
    await send_email_async(sender_email=sender_email, receiver_email=receiver_email, smtp_server=smtp_server, port=port, login=login, password=password, subject=subject, body=body)
    print("Email envoyé de manière asynchrone.")

if __name__ == "__main__":
    asyncio.run(main())

Explication rapide :

  • Définition de fonction asynchrone : Le script définit maintenant des fonctions asynchrones en utilisant async def.
  • Fonctionnalité asynchrone : En utilisant asyncio et aiosmtplib, le script établit une connexion SMTP de manière asynchrone, se connecte, et envoie l’email. Cette approche permet d’éviter le blocage lors de l’envoi d’emails, particulièrement utile dans les applications nécessitant de maintenir la réactivité tout en effectuant des opérations réseau.
  • Exécution du script : La fonction async main configure les détails de l’email et appelle send_email_async pour envoyer l’email. Elle démontre comment exécuter efficacement des tâches asynchrones en Python, avec asyncio.run(main()) démarrant l’exécution asynchrone.

Envoi d’emails en masse

Le code ci-dessus utilise live.smtp.mailtrap.io qui est l’endpoint pour les emails transactionnels. Le package de la Plateforme d’Email Delivery de Mailtrap permet d’envoyer des emails en masse via un stream séparé bulk.smtp.mailtrap.io sous le même plan.

Paramètres du Bulk Stream de Mailtrap Bulk

Maintenant, la seule chose différente est l’Hôte (endpoint), et vous devez ajuster votre script en conséquence. Mais gardez en tête que les emails Transactionnels et en Masse ont des infrastructures séparées, même si vos informations d’identification sont presque les mêmes. Cela aide à améliorer la délivrabilité et la gestion des emails.

Pour illustrer les changements, j’ai créé un script simple en utilisant l’endpoint SMTP fourni.

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

# Configuration pour le serveur SMTP Bulk de Mailtrap
smtp_server = "bulk.smtp.mailtrap.io"
port = 587
login = "api"  # Votre identifiant Mailtrap
password = "1a2b3c4d5e6f7g"  # Votre mot de passe Mailtrap

sender_email = "mailtrap@exemple.com"
receiver_email = "noveau@exemple.com"  # Un seul destinataire

# Créer un message MIMEText pour du texte brut
subject = "Email en texte brut via SMTP Bulk"
body = "Ceci est un email en texte brut envoyé via le serveur SMTP Bulk de Mailtrap."

# Créer un message MIMEMultipart et définir les en-têtes
message = MIMEMultipart()
message["From"] = sender_email
message["To"] = receiver_email
message["Subject"] = subject

# Joindre la partie texte
message.attach(MIMEText(body, "plain"))

# Envoyer l'email
with smtplib.SMTP(smtp_server, port) as server:
    server.starttls()  # Sécuriser la connexion
    server.login(login, password)  # Se connecter au serveur SMTP
    server.sendmail(sender_email, receiver_email, message.as_string())  # Envoyer l'email

print('Email envoyé avec succès.')

Explication rapide :

  • Utilisation de MIMEMultipart : Même si l’email est en texte brut et envoyé à un seul destinataire, j’ai gardé l’utilisation de MIMEMultipart. Cette approche offre de la flexibilité si vous décidez d’ajouter des pièces jointes ou du contenu HTML à l’avenir. Cependant, vous pourriez simplifier davantage en utilisant uniquement MIMEText.
  • Envoi de l’email : L’appel à server.sendmail est simple, spécifiant l’expéditeur, le destinataire, et convertissant l’objet du message en une chaîne de caractères à envoyer.

Astuce Pro : Si vous utilisez des variables d’environnement ou un fichier de configuration externe pour les informations d’identification SMTP, il est préférable d’avoir des fichiers séparés pour la configuration Transactionnelle et Bulk.

Envoyer des emails en utilisant l’API

Pour simplifier votre intégration, Mailtrap dispose d’un SDK Python officiel (consultez le lien GitHub ◀️). Je l’utiliserai pour vous montrer comment envoyer un email en texte brut, l’envoyer à plusieurs destinataires, envoyer des emails en masse, etc.

Ici, je ne couvrirai pas la méthode d’envoi d’emails asynchrone car Mailtrap ne la prend pas en charge, et cela n’a pas beaucoup de sens dans les contextes API.

Pour rappel, vous devrez connecter et vérifier votre domaine avec Mailtrap. Consultez notre guide détaillé et une vidéo bonus pour vous montrer comment faire.

Une fois cela fait, retournez à votre application Python et installez le SDK Python officiel de Mailtrap avec la commande suivante :

pip install mailtrap

Note : assurez-vous que la version du package est 3.6 ou plus.

Ensuite, vous devez créer l’objet d’email et remplir les variables (comme l’email et le nom) avec vos informations d’identification Mailtrap. Gardez en tête que vous devez indiquer l’adresse du domaine d’envoi vérifié.

import mailtrap as mt

# Créer un objet Mail
mail = mt.Mail(
    sender=mt.Address(email="mailtrap@exemple.com", name="Test de Mailtrap"),
    to=[mt.Address(email="votre@email.com")],
    subject="Vous êtes génial !",
    text="Félicitations pour l’envoi d'un email de test avec Mailtrap !",
)

# Créer un client et envoyer
client = mt.MailtrapClient(token="votre-clé-api")
client.send(mail)

Vous devrez également créer le client avec votre jeton API. Allez dans votre compte Mailtrap en ouvrant le menu déroulant ‘Settings’, puis choisissez l’onglet “API Token”. Copiez les informations d’identification en appuyant sur ‘Copy’ à côté de votre jeton.

Ensuite, vous pouvez utiliser la commande ci-dessous pour envoyer l’email.

# Créer un client et envoyer
client = mt.MailtrapClient(token="votre-clé-api")
client.send(mail)

Ceci étant fait, je vais vous montrer comment utiliser le SDK pour différents cas d’utilisation.

Voici un script de base pour envoyer un email en texte brut :

from mailtrap import Mail, Address, MailtrapClient

# Créer un objet Mail avec les détails de base pour un email en texte brut
mail = Mail(
    # Spécifiez l'adresse email de l'expéditeur et un nom optionnel
    sender=Address(email="mailtrap@exemple.com", name="Test de Mailtrap"),
    # Spécifiez un ou plusieurs destinataires ; ici, nous utilisons une liste avec un seul destinataire
    to=[Address(email="votre@email.com", name="Votre Nom")],
    # Objet de l'email
    subject="Email en texte brut simple",
    # Le contenu en texte brut de l'email
    text="Ceci est un email en texte brut envoyé en utilisant le SDK Mailtrap. Simple et direct.",
    # Optionnel : catégoriser cet email pour faciliter le tri ou la gestion dans le service Mailtrap
    category="Test",
    # Optionnel : des en-têtes supplémentaires peuvent être spécifiés, mais ne sont pas nécessaires pour les emails en texte brut
    headers={"X-Example-Header": "HeaderValue"}
)

# Initialiser le MailtrapClient avec votre clé API
client = MailtrapClient(token="votre-clé-api")

# Envoyer l'email en utilisant la méthode send du client
client.send(mail)

print("Email en texte brut envoyé avec succès.")

Explication rapide :

  • Importation des classes : Seules les classes Mail, Address, et MailtrapClient de la bibliothèque Mailtrap sont importées, car nous nous concentrons sur l’envoi d’un simple email en texte brut.
  • Création de l’objet Mail :
    • Mail : Le constructeur est utilisé pour créer un objet d’email.
    • Sender : Utilise la classe Address pour définir l’adresse email et le nom de l’expéditeur.
    • to : Une liste d’objets Address pour chaque destinataire. Pour un email en texte brut, vous avez généralement un ou plusieurs destinataires directs listés ici.
    • subject : La ligne d’objet de l’email.
    • text : Le contenu réel de l’email, au format texte brut.
    • category et headers : Champs optionnels qui permettent une catégorisation supplémentaire et des en-têtes personnalisés. Bien qu’ils ne soient pas strictement nécessaires pour envoyer un email en texte brut, ils peuvent être utiles pour des raisons organisationnelles ou techniques au sein du service Mailtrap ou pour la gestion des fournisseurs de messagerie.
  • Envoi de l’email :
    • Une instance de MailtrapClient est créée et authentifiée avec un jeton API.
    • La méthode send du MailtrapClient est ensuite appelée, en passant l’objet mail comme argument pour envoyer l’email.
    • Enfin, un message de confirmation est imprimé pour indiquer que l’email a été envoyé.

Envoyer un email HTML

Je vais ajuster le script en spécifiant le paramètre html dans l’objet Mail avec le contenu HTML.

from mailtrap import Mail, Address, MailtrapClient

# Créer un objet Mail pour envoyer un email HTML
mail = Mail(
    sender=Address(email="mailtrap@exemple.com", name="Test de Mailtrap"),
    to=[Address(email="destinataire@email.com", name="Nom du Destinataire")],
    subject="Votre Objet d'Email HTML Ici",
    text="Ceci est un texte de secours pour les fournisseurs de messagerie qui ne supportent pas l’HTML",
    html="""
    <!DOCTYPE html>
    <html>
        <head>
            <title>Titre de l'Email</title>
        </head>
        <body>
            <h1>Hello, World !</h1>
            <p>Ceci est un email <strong>HTML</strong> envoyé depuis le SDK Python de Mailtrap.</p>
            <p>Voici un lien : <a href="https://example.com">Visitez Exemple.com</a></p>
        </body>
    </html>
    """,
    # Vous pouvez catégoriser cet email ou ajouter des en-têtes personnalisés si nécessaire
    category="Email HTML",
    headers={"X-Custom-Header": "Valeur"}
)

# Initialiser le MailtrapClient avec votre clé API
client = MailtrapClient(token="votre-clé-api")

# Envoyer l'email
client.send(mail)

print("Email HTML envoyé avec succès.")

Explication rapide :

  • Contenu HTML : Le paramètre html de l’objet Mail est l’endroit où vous mettez votre contenu HTML. C’est la partie de l’email qui sera affichée par les fournisseurs de messagerie capables d’afficher du HTML.
  • Contenu texte de secours : La version en texte brut du contenu de l’email sert de secours pour les fournisseurs de messagerie qui n’affichent pas l’HTML ou pour les utilisateurs qui préfèrent les emails en texte brut.
  • Envoi de l’email : Avec le contenu HTML défini, le reste du processus pour envoyer l’email reste le même.
Envoyer des emails avec Mailtrap gratuitement

Envoyer un email à plusieurs destinataires

Je vais modifier la partie destinataires de la configuration de l’email pour inclure plusieurs destinataires.

Il y a des commentaires tout au long du script pour expliquer comment gérer plusieurs destinataires pour le champ To et ajouter des destinataires Cc (Copie Carbone) et Bcc (Copie Carbone Invisible). Je n’ajouterai donc pas la section Explication rapide dans ce cas car la méthode est simple et la logique est évidente dans le script.

from mailtrap import Mail, Address, MailtrapClient

# Créer un objet Mail visant plusieurs destinataires, y compris les adresses Cc et Bcc
mail = Mail(
    # Spécifiez l'adresse email de l'expéditeur et un nom optionnel
    sender=Address(email="mailtrap@exemple.com", name="Test de Mailtrap"),
    # Spécifiez plusieurs destinataires dans le champ "A"
    to=[
        Address(email="destinataire1@email.com", name="Destinataire Un"),
        Address(email="destinataire2@email.com", name="Destinataire Deux"),
    ],
    # De plus, spécifiez des destinataires dans le champ "Cc"
    cc=[
        Address(email="cc1@email.com", name="Cc Destinataire Un"),
        Address(email="cc2@email.com", name="Cc Destinataire Deux"),
    ],
    # Et des destinataires dans le champ "Bcc" pour des copies cachées
    bcc=[
        Address(email="bcc1@email.com", name="Bcc Destinataire Un"),
        Address(email="bcc2@email.com", name="Bcc Destinataire Deux"),
    ],
    # Objet de l'email
    subject="Email à Plusieurs Destinataires",
    # Le contenu de l’email en texte brut
    text="Cet email est envoyé à plusieurs destinataires, y compris les adresses Cc et Bcc.",
    # Optionnel : catégoriser cet email ou ajouter des en-têtes personnalisés si nécessaire
    category="Email en masse",
    headers={"X-Custom-Header": "Valeur"}
)

# Initialiser le MailtrapClient avec votre clé API
client = MailtrapClient(token="votre-clé-api")

# Envoyer l'email en utilisant la méthode send du client
client.send(mail)

print("Email envoyé à plusieurs destinataires avec succès.")

Envoyer un email avec des pièces jointes

Ici, je vais principalement me concentrer sur la manière dont la classe Attachment est utilisée pour inclure des fichiers dans votre email. Cet exemple démontrera comment joindre un fichier générique, mais l’approche est similaire pour tout type de fichier.

from mailtrap import Mail, Address, MailtrapClient, Attachment, Disposition
import base64
from pathlib import Path

# Préparer le fichier que vous souhaitez joindre
file_path = Path("path/to/votre/fichier.pdf")  # Remplacez ceci avec le chemin de votre fichier
file_content = file_path.read_bytes()  # Lire le contenu du fichier en tant que bytes

# Encoder le contenu du fichier en base64
encoded_content = base64.b64encode(file_content)

# Créer un objet Mail avec une pièce jointe
mail = Mail(
    sender=Address(email="mailtrap@exemple.com", name="Test de Mailtrap"),
    to=[Address(email="destinataire@email.com", name="Nom du Destinataire")],
    subject="Email avec pièce jointe",
    text="Cet email contient une pièce jointe. Ouvrez-la !",
    # Définir la pièce jointe
    attachments=[
        Attachment(
            content=encoded_content,  # Le contenu encodé en base64 du fichier
            filename=file_path.name,  # Le nom du fichier tel qu'il doit apparaître dans l'email
            disposition=Disposition.ATTACHMENT,  # Indique que le fichier est une pièce jointe
            mimetype="application/pdf",  # Le type MIME du fichier
            # `content_id` est optionnel et généralement utilisé pour intégrer des images directement dans le corps HTML
        )
    ],
)

# Initialiser le MailtrapClient avec votre clé API
client = MailtrapClient(token="votre-clé-api")

# Envoyer l'email
client.send(mail)

print("Email avec pièce jointe envoyé avec succès.")

Explication rapide :

  • Préparation du fichier : Le script commence par spécifier le chemin du fichier que vous souhaitez joindre et en lire le contenu en tant que bytes. Il est important de lire le fichier en mode binaire (read_bytes()) pour s’assurer que le contenu est correctement encodé et transmis.
  • Encodage en base64 : Comme les protocoles de messagerie ne sont pas sûrs pour les binaires, le contenu du fichier doit être encodé en base64. Cet encodage convertit les données binaires en un format texte qui peut être transmis en toute sécurité par email. La méthode base64.b64encode est utilisée à cette fin.
  • Création de la pièce jointe : La classe ‘Attachment’ est instanciée avec plusieurs paramètres :
    • content : Le contenu encodé en base64 du fichier.
    • filename : Le nom du fichier tel que vous souhaitez qu’il apparaisse dans l’email.
    • disposition : Ceci est défini sur ‘Disposition.ATTACHMENT’ pour indiquer que le fichier est une pièce jointe (par opposition à inline, qui serait utilisé pour des images intégrées).
    • mimetype : Le type MIME du fichier, ce qui aide les fournisseurs de messagerie à comprendre comment gérer le fichier. Pour un PDF, il s’agit d’ ‘application/pdf’.

Envoyer un email avec une image intégrée

Ici, je vais joindre l’image pour qu’elle puisse être affichée directement dans le contenu HTML de l’email. Cela est généralement réalisé en joignant l’image avec un Content-ID (cid) qui peut être référencé dans le HTML. Voici comment le faire :

from mailtrap import Mail, Address, MailtrapClient, Attachment, Disposition
import base64
from pathlib import Path

# Spécifiez le chemin de votre image
image_path = Path("path/to/votre/image.jpg")
image_content = image_path.read_bytes()  # Lire le contenu de l'image en tant que bytes

# Encoder le contenu de l'image en base64
encoded_image = base64.b64encode(image_content)

# Créer un objet Mail avec du contenu HTML et une image intégrée
mail = Mail(
    sender=Address(email="mailtrap@exemple.com", name="Test de Mailtrap"),
    to=[Address(email="destinataire@email.com", name="Nom du Destinataire")],
    subject="Email avec image intégrée",
    text="Ceci est un texte de secours pour les fournisseurs de messagerie qui ne supportent pas l’HTML.",
    html="""
    <!DOCTYPE html>
    <html>
        <body>
            <h1>Hello, World !</h1>
            <p>Cet email contient une image intégrée.</p>
            <!-- Utilisez 'cid:image_cid' dans l\'attribut src pour intégrer l\'image -->
            <img src="cid:image_cid">
        </body>
    </html>
    """,
    attachments=[
        Attachment(
            content=encoded_image,
            filename=image_path.name,
            disposition=Disposition.INLINE,  # Marquez la pièce jointe comme intégrée
            mimetype="image/jpeg",  # Le type MIME de l'image
            content_id="image_cid",  # Content-ID utilisé pour référencer l'image dans l'attribut src HTML
        )
    ],
)

# Initialiser le MailtrapClient avec votre clé API
client = MailtrapClient(token="votre-clé-api")

# Envoyer l'email
client.send(mail)

print("Email avec une image intégrée envoyé avec succès.")

Explication rapide :

  • Préparer l’image : Avant de joindre l’image, vous devez lire son contenu en bytes, puis l’encoder en base64. Cet encodage est nécessaire car le contenu des emails (y compris les pièces jointes) doit être transmis dans un format texte.
  • Contenu HTML : Dans le paramètre html de l’objet Mail, vous devez inclure une balise <img> où l’attribut src utilise un schéma cid: suivi du Content-ID de l’image ajoutée en pièce jointe (image_cid dans ce cas). Ce cid relie l’image intégrée dans le contenu HTML à l’image ajoutée en pièce jointe.
  • Joindre l’image : L’image est jointe en utilisant la classe Attachment avec plusieurs paramètres spécifiques :
    • content : Le contenu encodé en base64 de l’image.
    • filename : Le nom du fichier. Il est utilisé comme secours chez certains fournisseurs de messagerie si l’image ne peut pas être affichée.
    • disposition : Défini sur Disposition.INLINE pour indiquer que la pièce jointe doit être affichée en ligne avec le contenu HTML, et non comme une pièce jointe séparée et téléchargeable.
    • mimetype : Spécifie le type MIME de l’image (par exemple, “image/jpeg”). Cela aide le fournisseur de messagerie à comprendre comment gérer le fichier.
    • content_id : Un identifiant unique pour la pièce jointe référencée dans l’attribut src du HTML pour intégrer l’image.

Envoi d’emails en masse

Petit rappel, la Plateforme d’Email Delivery de Mailtrap vous permet d’envoyer des emails en masse en plus des emails transactionnels, sous le même plan. Vous devez sélectionner le stream, cliquer sur le bouton API, et choisir l’intégration Python.

Paramètres API Bulk Stream de Mailtrap

Ceci étant fait, voici ce que vous devez faire d’autre.

  1. Assurez-vous d’avoir installé la bibliothèque requests. Si ce n’est pas le cas, vous pouvez l’installer en utilisant pip :
pip install requests
  1. Construisez un payload JSON qui spécifie les détails de l’email et ajustez le champ to pour inclure plusieurs destinataires.
  1. En utilisant la bibliothèque requests, faites une requête POST à l’endpoint de l’API Bulk de Mailtrap, en fournissant les en-têtes nécessaires (y compris l’autorisation) et le payload. Consultez le script exemplaire ci-dessous.
import requests
import json

def send_mailtrap_email(payload):
    url = "https://bulk.api.mailtrap.io/api/send"
    headers = {
      "Authorization": "Bearer votre_clé_api",  # Remplacez par votre clé API Mailtrap
      "Content-Type": "application/json"
    }

    response = requests.post(url, headers=headers, data=json.dumps(payload))
    return response.text

payload = {
    "from": {"email": "mailtrap@mailtrapdemo.com", "nom": "Test de Mailtrap"},
    "to": [{"email": "destinataire@exemple.com"}],  # Ajoutez d'autres destinataires si nécessaire
    "subject": "Vous êtes génial !",
    "text": "Félicitations pour l'envoi d'un email de test avec Mailtrap !",
    "category": "Test d'intégration"
}

response_text = send_mailtrap_email(payload)
print(response_text)

Explication rapide :

  • payload : C’est un dictionnaire qui correspond à la structure JSON attendue par l’API Bulk de Mailtrap. Vous pouvez modifier ce dictionnaire pour inclure les détails de votre email, tels que l’expéditeur, les destinataires, l’objet et le corps.
  • send_mailtrap_email : La fonction encapsule le processus d’envoi de l’email. Elle prend le payload en entrée, le convertit en format JSON et fait une requête POST à l’API Bulk de Mailtrap.

Considérations de sécurité lors de l’envoi d’emails

Si vous envisagez d’automatiser l’envoi d’emails et de les envoyer à un grand nombre de destinataires de manière régulière, il est préférable de prendre des précautions supplémentaires. (Surtout en ce qui concerne la méthode SMTP.)

Ici, je vais couvrir quelques méthodes éprouvées pour éviter de coder trop d’informations d’identification dans vos scripts et gérer les erreurs. Notez que les conseils ci-dessous s’appliquent quel que soit le fournisseur de services de messagerie que vous utilisez (SendGrid, SES, compte Gmail, etc.)

Utilisation des variables d’environnement pour les informations sensibles

Les variables d’environnement sont un moyen sûr de gérer les paramètres de configuration et les informations sensibles en dehors de votre code source.

En Python, vous pouvez utiliser le module os pour accéder aux variables d’environnement.

import os

smtp_server = os.getenv("SMTP_SERVER", "default.smtp.server")
login = os.getenv("SMTP_LOGIN")
password = os.getenv("SMTP_PASSWORD")

# Exemple d'utilisation dans une configuration de connexion SMTP
# smtp.login(login, password)

Avant d’exécuter votre script, définissez les variables d’environnement dans votre système d’exploitation. Par exemple, dans un terminal Linux ou macOS, vous pouvez les définir temporairement comme ceci :

export SMTP_SERVER=live.smtp.mailtrap.io
export SMTP_LOGIN=votre_identifiant
export SMTP_PASSWORD=votre_mot_de_passe

Sous Windows, vous pouvez les définir via la ligne de commande comme suit :

set SMTP_SERVER=live.smtp.mailtrap.io
set SMTP_LOGIN=votre_identifiant
set SMTP_PASSWORD=votre_mot_de_passe

Gestion des erreurs

Voici comment gérer les erreurs inattendues, telles que les erreurs réseau, les problèmes d’authentification ou d’autres exceptions pouvant survenir lors de l’envoi de l’email.

try:
    # Tentative d’envoi d’un email
    server.sendmail(sender_email, recipient_email, message.as_string())
except smtplib.SMTPException as e:
    print(f"Une erreur SMTP s'est produite : {e}")
except Exception as e:
    print(f"Une erreur s'est produite : {e}")

Utilisation de SSL

Voici un aperçu de base de la façon dont vous pourriez utiliser smtplib.SMTP_SSL dans un script pour envoyer un email :

import smtplib
from email.mime.text import MIMEText


# Configuration
port = 465
smtp_server = "live.smtp.mailtrap.io"
login = "identifiant"
password = "mot de passe"


sender_email = "expediteur@domaine_enregistre.com"
receiver_email = "destinataire@gmail.com"


text = """\
Bonjour,
N'hésitez pas à nous dire quel contenu vous serait utile !
"""


message = MIMEText(text, "plain")
message["Subject"] = "Email en texte brut"
message["From"] = sender_email
message["To"] = receiver_email




with smtplib.SMTP_SSL(smtp_server, port) as server:
    server.login(login, password)
    server.sendmail(sender_email, receiver_email, message.as_string())
    print("Email envoyé avec succès !")

Configuration externe

Stocker les données de configuration (comme les détails du serveur SMTP et les adresses email) dans des fichiers externes ou des variables d’environnement améliore la sécurité et la flexibilité de votre script. Pour des configurations plus complexes, vous pourriez envisager d’utiliser un fichier JSON ou similaire.

  • Exemple de configuration JSON (config.json) :
{
    "smtp_server": "live.smtp.mailtrap.io",
    "smtp_port": 587,
    "login": "votre_identifiant",
    "password": "votre_mot_de_passe"
}
  • Comment charger la configuration :
import json

with open('config.json', 'r') as config_file:
    config = json.load(config_file)

smtp_server = config.get('smtp_server')
smtp_port = config.get('smtp_port')
login = config.get('login')
password = config.get('password')

Conseil : Si vous souhaitez envoyer des emails depuis votre compte Google et utiliser le serveur SMTP de Gmail (smtp.gmail.com), nous avons déjà écrit un article à ce sujet. Consultez l’article ici.

Tester les emails et l’envoi d’emails dans un environnement de test

Lors de la création d’une nouvelle application ou de l’ajout de fonctionnalités, en particulier lorsqu’il s’agit de la première fois, il est essentiel d’expérimenter sur un serveur de test. Voici une liste rapide des raisons :

  1. Vous n’enverrez pas d’emails à vos amis et clients, ce qui est crucial lorsque vous testez l’envoi d’emails en masse ou travaillez avec une base de données d’emails.
  2. Vous ne spammerez pas votre boîte de récéption d’emails de test.
  3. Votre domaine ne sera pas mis sur liste noire pour spam.

Un serveur SMTP de test imite le travail d’un serveur web tiers réel. Dans les exemples suivants, j’utiliserai l’Email Testing de Mailtrap, qui permet aux développeurs de capturer le trafic SMTP depuis le staging et d’inspecter et de déboguer les emails avant qu’ils ne soient réellement envoyés aux destinataires.

En plus de cela, l’Email Testing peut aider à valider votre HTML/CSS, analyser le contenu de l’email, prévisualiser le `txt` et le contenu, et donner un score de spam pertinent. L’outil est facile à configurer ; tout ce que vous avez à faire est de copier les informations d’identification générées par l’application et de les coller dans votre code.

Note : Je couvrirai les méthodes SMTP et API séparément. Et si vous voulez un tutoriel approfondi sur les tests avec Python, consultez cet article.

SMTP

Allez sur Mailtrap, sélectionnez Email Testing, puis My Inbox. Sous l’onglet SMTP Settings, cliquez sur “Afficher les informations d’identification” pour révéler les informations d’identification de test.

Paramètres SMTP de l’Email Testing de Mailtrap

Voici à quoi cela ressemble en pratique :

import smtplib
port = 2525 
smtp_server = "sandbox.smtp.mailtrap.io"
login = "1b2c3d4e5d66f" # votre identifiant généré par Mailtrap
password = "1b2c3d4e5d66f" # votre mot de passe généré par Mailtrap

Mailtrap simplifie encore les choses. Allez dans la section Integrations dans l’onglet SMTP Settings et obtenez le modèle prêt à l’emploi du message texte simple grâce à vos informations d’identification Mailtrap.

Note importante : Les extraits utilisent des informations d’identification fictives pour des raisons de sécurité, assurez-vous de copier-coller vos vraies informations d’identification dans le code.

L’option la plus basique pour instruire votre code Python sur qui envoie quoi à qui est la méthode d’instance sendmail(), que j’utiliserai ici. Mais nous avons également des intégrations exemplaires pour Django et Flask.

Intégration de l’Email Testing de Mailtrap smtplib

Regardons de plus près l’exemple et ajoutons une gestion des erreurs (voir les #explications entre les lignes). Pour capturer les erreurs, nous utilisons les blocs try et except. Référez-vous à la documentation pour la liste des exceptions ici.

# la première étape est toujours la même : importer tous les composants nécessaires :
import smtplib
from socket import gaierror

# maintenant, vous pouvez jouer avec votre code. Définissons le serveur SMTP séparément ici :
port = 2525 
smtp_server = "sandbox.smtp.mailtrap.io"
login = "1b2c3d4e5d66f" # collez votre identifiant généré par Mailtrap
password = "1b2c3d4e5d66f" # collez votre mot de passe généré par Mailtrap
# spécifiez les adresses email de l'expéditeur et du destinataire
sender = "de@exemple.com"
receiver = "mailtrap@exemple.com"
# tapez votre message : utilisez deux nouvelles lignes (\n) pour séparer l’objet du corps du message, et utilisez 'f' pour insérer automatiquement des variables dans le texte
message = f"""\
Subject: Bonjour Mailtrap
To: {receiver}
From: {sender}

Ceci est mon premier message avec Python."""

try:
    # envoyez votre message avec les informations d'identification spécifiées ci-dessus
    with smtplib.SMTP(smtp_server, port) as server:
        server.login(login, password)
        server.sendmail(sender, receiver, message)
    # indiquez au script de vous informer si votre message a été envoyé ou les erreurs qui doivent être corrigées
    print('Envoyé')
except (gaierror, ConnectionRefusedError):
    print('Échec de la connexion au serveur. Mauvais paramètres de connexion ?')
except smtplib.SMTPServerDisconnected:
    print('Échec de la connexion au serveur. Mauvais identifiant/mot de passe ?')
except smtplib.SMTPException as e:
    print('Une erreur SMTP s\'est produite : ' + str(e))

Une fois que vous obtenez le résultat “Envoyé” dans Shell, vous devriez voir votre message dans votre boîte de réception Mailtrap :

Message de test Python dans Mailtrap

Si vous préférez travailler dans l’environnement local, le serveur de débogage SMTP local peut être une option. À cette fin, Python propose un module smtpd. Il dispose d’une fonctionnalité DebuggingServer, qui rejettera les messages que vous envoyez et les imprimera dans stdout. Il est compatible avec tous les systèmes d’exploitation.

Définissez votre serveur SMTP sur localhost:1025

python -m smtpd -n -c DebuggingServer localhost:1025

Pour exécuter un serveur de messagerie SMTP sur le port 25, vous aurez besoin des permissions root :

sudo python -m smtpd -n -c DebuggingServer localhost:25

Cela vous aidera à vérifier si votre code fonctionne et à identifier les problèmes potentiels. Cependant, cela ne vous permettra pas de vérifier à quoi ressemble votre modèle d’email HTML.

Testez les emails avec Mailtrap gratuitement

API

Vous pouvez consulter notre documentation API pour tous les détails sur les tests API. J’utiliserai Python 3 pour vous montrer la méthode, et vous guider étape par étape.

  1. Établissez une connexion avec l’endpoint API d’Email Testing de Mailtrap en utilisant http.client.HTTPSConnection.
  2. Définissez le contenu de votre email, y compris les destinataires (to, cc, bcc), l’expéditeur (from), l’objet, le contenu du texte et toute pièce jointe ou variable personnalisée sous forme de payload JSON.
  3. Faites une requête POST à l’API de Email Testing de Mailtrap avec votre payload et les en-têtes nécessaires, y compris votre jeton API pour l’autorisation. Voici un exemple :
import http.client
import json

def test_send_email():
    conn = http.client.HTTPSConnection("sandbox.api.mailtrap.io")
    
    payload = {
        "to": [{"email": "john_doe@exemple.com", "name": "John Doe"}],
        "cc": [{"email": "jane_doe@exemple.com", "name": "Jane Doe"}],
        "bcc": [{"email": "james_doe@exemple.com", "name": "Jim Doe"}],
        "from": {"email": "ventes@exemple.com", "name": "Exemple d’Équipe de vente"},
        "attachments": [
            {
                "content": "base64_encoded_content_here",
                "filename": "index.html",
                "type": "text/html",
                "disposition": "attachment"
            }
        ],
        "custom_variables": {"user_id": "45982", "batch_id": "PSJ-12"},
        "headers": {"X-Message-Source": "dev.mondomaine.com"},
        "subject": "Votre exemple de confirmation de commande",
        "text": "Félicitations pour votre commande n°1234",
        "category": "Test API"
    }

    headers = {
        'Content-Type': "application/json",
        'Accept': "application/json",
        'Api-Token': "votre_jeton_api_ici"  # Remplacez par votre vrai jeton API

    # Convertir le payload en chaîne JSON
    json_payload = json.dumps(payload)

    # Faire la requête POST
    conn.request("POST", "/api/send/inbox_id", json_payload, headers)  # Remplacez 'inbox_id' par votre véritable ID de boîte de réception

    # Obtenir la réponse
    response = conn.getresponse()
    data = response.read()

    print(data.decode("utf-8"))

if __name__ == "__main__":
    test_send_email()

Notes:

  • Payload : Le dictionnaire contient tous les détails de l’email que vous souhaitez tester. Assurez-vous de remplacer les valeurs remplaçables par des données réelles pertinentes pour votre cas de test. Pour les pièces jointes, encodez votre contenu de fichier en Base64 et incluez-le dans le champ content.
  • Headers : Incluez vos en-têtes Content-Type, Accept, et Api-Token. Le jeton API doit être votre jeton API Mailtrap.
  • Requête et réponse : Le script fait une requête POST à l’endpoint /api/send/inbox_id, en remplaçant inbox_id par votre ID de boîte de réception réel. Ensuite, il lit et imprime la réponse pour vérifier le résultat.

Prochaines étapes avec les emails en Python

J’ai démontré les options d’envoi d’emails avec Python pour décrire la logique et l’éventail de ses capacités. Mais je recommande de consulter la documentation de Python et de tester votre propre code pour obtenir de bons résultats !

Il existe de nombreux frameworks et bibliothèques Python qui rendent la création d’applications plus élégante et dédiée. De plus, certains d’entre eux peuvent améliorer votre expérience en termes de construction de fonctionnalités d’envoi d’emails :

Les frameworks les plus populaires sont :

  1. Flask, qui offre une interface simple pour l’envoi d’emails — Flask Mail. N’hésitez pas à en apprendre davantage dans notre guide sur comment envoyer des emails avec Flask.
  2. Django peut être une excellente option pour créer des modèles HTML. Consultez également notre tutoriel sur l’envoi d’emails avec Django.
  3. Zope est utile pour le développement de sites Web.
  4. Marrow Mailer est un framework dédié à la livraison d’emails, offrant diverses configurations utiles.
  5. Plotly et son Dash peuvent aider à envoyer des graphiques et des rapports par email.

Bonne chance, et n’oubliez pas de rester prudent lorsque vous envoyez vos emails !

Article by Aleksandr Varnin Full Stack Developer @ Railsware
Article by Veljko Ristić Content Manager @ Mailtrap

Linguist by trade, digital marketer at heart, I’m a Content Manager who’s been in the online space for 10+ years. From ads to e-books, I’ve covered it all as a writer, editor, project manager, and everything in between. Now, my passion is with email infrastructure with a strong focus on technical content and the cutting-edge in programming logic and flows. But I still like spreading my gospels while blogging purely about marketing.