Site icon Mailtrap

Comment Envoyer des Emails en Python avec Gmail SMTP et API

Denys Kontorskyy
How to send emails in Python with Gmail

Dans ce tutoriel, à l’aide d’exemples de code, nous verrons comment utiliser différents modules en Python pour construire et envoyer divers types d’email, examiner les méthodes d’authentification existantes, et plus encore. À titre d’exemple, nous utiliserons à la fois le serveur SMTP de Gmail et l’API Gmail.

Si vous souhaitez découvrir d’autres méthodes d’envoi d’emails en Python, consultez notre guide complet.

Prêt à envoyer vos emails ?
Essayez Mailtrap Gratuitement

Configuration des bibliothèques Python smtplib et email

Pour envoyer un email avec Python via Gmail SMTP, vous devez utiliser le module smtplib et le module email. Le module smtplib fournit essentiellement des fonctions pour se connecter et envoyer des emails en utilisant un serveur SMTP (Simple Mail Transfer Protocol).

Quant au module email, il fournit des classes pour construire et analyser les emails (To ; From ; Subject ; etc.) et permet d’encoder et de décoder les emails avec la norme MIME (Multipurpose Internet Mail Extensions).

Décomposons les étapes réelles à effectuer. Et, dans la section suivante, vous pourrez consulter le code réel.

  1. Importez les bibliothèques requises : smtplib et MIMEText depuis email.
  2. Créez l’email à l’aide de l’objet MIMEText, et définissez les valeurs souhaitées dans les champs « Subject », « Sender » et « Recipients ».
  3. Établissez la connexion SMTP au serveur de Gmail via une connexion SSL sécurisée à l’aide de la fonction SMTP_SSL.
  4. Appelez la méthode sendmail de l’objet SMTP, et spécifiez les adresses email de l’expéditeur et du destinataire ainsi que l’email comme arguments.

Une fois cela fait, vous êtes prêt à envoyer des emails via Gmail en Python. Je couvrirai la méthodologie, les exemples et d’autres cas d’utilisation dans les sections suivantes. Si vous avez besoin de rafraîchir vos compétences, consultez ces cours Python en ligne au préalable.

Envoyer un email en Python en utilisant Gmail SMTP

Sur la base de ce que j’ai couvert dans la section précédente, voici un script simple pour envoyer des emails :

import smtplib
from email.mime.text import MIMEText

subject = "Objet de l'email"
body = "Ceci est le corps de l’email"
sender = "expediteur@gmail.com"
recipients = ["destinataire1@gmail.com", "destinataire2@gmail.com"]
password = "motdepasse"


def send_email(subject, body, sender, recipients, password):
    msg = MIMEText(body)
    msg['Subject'] = subject
    msg['From'] = sender
    msg['To'] = ', '.join(recipients)
    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp_server:
       smtp_server.login(sender, password)
       smtp_server.sendmail(sender, recipients, msg.as_string())
    print("Message envoyé !")


send_email(subject, body, sender, recipients, password)

Notes importantes :

Avant le 30 mai 2022, il était possible de se connecter au serveur SMTP de Gmail en utilisant votre mot de passe Gmail habituel si la « vérification en 2 étapes » était activée. Pour un niveau de sécurité plus élevé, Google exige désormais que vous utilisiez un « mot de passe d’application ».

Il s’agit d’un code d’accès à 16 chiffres généré dans votre compte Google et qui permet aux applications ou appareils moins sécurisés ne prenant pas en charge la vérification en 2 étapes de se connecter à votre compte Gmail.

Alternativement, il existe le mode d’authentification OAuth 2.0 de Gmail, mais dans ce cas, vous devrez utiliser la méthode d’envoi de l’API Gmail dans votre script Python.

Envoyer un email à plusieurs destinataires

Pour envoyer l’email à plusieurs destinataires, je vais définir une liste d’adresses email pour permettre l’envoi à plusieurs destinataires. De plus, le champ « To » définit les destinataires dans les en-têtes du message. Il est converti d’une liste en une chaîne de caractères séparée par des virgules, un format accepté par la plupart des en-têtes d’email.

Voici le code :

import smtplib
from email.mime.text import MIMEText

# Définir l'objet et le corps de l'email.
subject = "Objet de l'email"
body = "Ceci est le corps de l’email"
# Définir l'adresse email de l'expéditeur.
sender = "expediteur@gmail.com"
# Liste des destinataires auxquels l'email sera envoyé.
recipients = ["destinataire1@gmail.com", "destinataire2@gmail.com"]
# Mot de passe du compte email de l'expéditeur.
password = "motdepasse" # Remplacez par votre vrai mot de passe

def send_email(subject, body, sender, recipients, password):
    # Créer un objet MIMEText avec le corps de l'email.
    msg = MIMEText(body)
    # Définir l'objet de l'email.
    msg['Subject'] = subject
    # Définir l'email de l'expéditeur.
    msg['From'] = sender
    # Joindre la liste des destinataires en une seule chaîne séparée par des virgules.
    msg['To'] = ', '.join(recipients)
    
    # Se connecter au serveur SMTP de Gmail en utilisant SSL.
    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp_server:
        # Se connecter au serveur SMTP en utilisant les identifiants de l'expéditeur.
        smtp_server.login(sender, password)
        # Envoyer l'email. La fonction sendmail nécessite l'email de l'expéditeur, la liste des destinataires et le message de l'email sous forme de chaîne.
        smtp_server.sendmail(sender, recipients, msg.as_string())
    # Afficher un message dans la console après l'envoi réussi de l'email.
    print("Message envoyé !")

# Appeler la fonction pour envoyer l'email.
send_email(subject, body, sender, recipients, password)

Envoyer un email avec des pièces jointes

Vous devez importer les bibliothèques nécessaires. Dans ce cas, vous aurez également besoin de MIMEBase qui vous permet de représenter un fichier joint et d’encoders, qui est utilisé pour encoder la pièce jointe au format base64.

Voici le script complet incluant des commentaires qui vous aideront à comprendre comment envoyer un email avec des pièces jointes :

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

sender_email = "expediteur@gmail.com"
sender_password = "motdepasse"
recipient_email = "destinataire@gmail.com"
subject = "Bonjour de Python"
body = "avec pièce jointe"


with open("attachment.txt", "rb") as attachment:
    # Ajouter la pièce jointe au message
    part = MIMEBase("application", "octet-stream")
    part.set_payload(attachment.read())
encoders.encode_base64(part)
part.add_header(
    "Content-Disposition",
    f"attachment; filename= 'attachment.txt'",
)

message = MIMEMultipart()
message['Subject'] = subject
message['From'] = sender_email
message['To'] = recipient_email
html_part = MIMEText(body)
message.attach(html_part)
message.attach(part)

with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
   server.login(sender_email, sender_password)
   server.sendmail(sender_email, recipient_email, message.as_string())

Envoyer un email HTML

Tout comme vous le feriez avec un email ordinaire, pour envoyer un email HTML en utilisant le serveur SMTP de Gmail en Python, utilisez la classe MIMEText du package email. Ensuite, utilisez l’objet html_message au lieu de l’objet texte brut msg et collez le contenu HTML dans le corps de l’email.

Voici un exemple de code complet :

import smtplib
from email.mime.text import MIMEText

sender_email = "expediteur@gmail.com"
sender_password = "motdepasse"
recipient_email = "destinataire@gmail.com"
subject = "Bonjour de Python"
body = """
<html>
  <body>
    <p>Ceci est un email <b>HTML</b> envoyé depuis Python en utilisant le serveur SMTP de Gmail.</p>
  </body>
</html>
"""
html_message = MIMEText(body, 'html')
html_message['Subject'] = subject
html_message['From'] = sender_email
html_message['To'] = recipient_email
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
   server.login(sender_email, sender_password)
   server.sendmail(sender_email, recipient_email, html_message.as_string())

Si vous souhaitez envoyer un email en utilisant un modèle HTML au lieu d’avoir le HTML dans le corps, vous pouvez utiliser la classe Template du package jinja2, un moteur de modèle rapide, expressif et extensible.

pip install jinja2

Voici le script pour toutes les étapes nécessaires :

import smtplib
from email.mime.text import MIMEText
from jinja2 import Template

sender_email = "xpediteur@gmail.com"
sender_password = "motdepasse"
recipient_email = "destinataire@gmail.com"
with open('template.html', 'r') as f:
    template = Template(f.read())
context = {
    'subject': 'Bonjour de Python',
    'body': 'Ceci est un email envoyé depuis Python en utilisant un modèle HTML et le serveur SMTP de Gmail.'
}
html = template.render(context)
html_message = MIMEText(context['body'], 'html')
html_message['Subject'] = context['subject']
html_message['From'] = sender_email
html_message['To'] = recipient_email
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
   server.login(sender_email, sender_password)
   server.sendmail(sender_email, recipient_email, html_message.as_string())

Si vous souhaitez en savoir plus sur l’envoi de contenu dynamique depuis votre application Python, nous vous recommandons de consulter notre article sur le publipostage (Mail Merge).

Envoyer des emails en masse

Je vais vous montrer comment envoyer des emails en masse via Gmail, mais gardez à l’esprit qu’il ne s’agit que d’une démonstration, pas une méthode que vous devriez exécuter en production.

Gmail a des politiques assez strictes concernant l’envoi d’emails en masse et de campagnes, j’en parle dans une section ultérieure (passez directement à cette section en cliquant sur le lien). De plus, votre délivrabilité pourrait en souffrir, en particulier avec un nouveau domaine ou une notation de domaine relativement basse. Ou si vous essayez simplement d’envoyer depuis une adresse @gmail.com.

Ceci étant dit, le script ci-dessous est adapté aux scénarios où chaque destinataire doit recevoir un email séparé et individuel, ce qui est courant dans les campagnes marketing personnalisées, les notifications, etc.

Simplement, le même message est envoyé à plusieurs personnes sans les regrouper dans un seul email. Cette méthode évite également de divulguer la liste des destinataires les uns aux autres, préservant ainsi la confidentialité.

Consultez le script ci-dessous.

import smtplib
from email.mime.text import MIMEText

# Contenu de l'email
subject = "Objet de l'email"
body = "Ceci est le corps de l’email"
sender = "expediteur@gmail.com"
recipients = ["destinataire1@gmail.com", "destinataire2@gmail.com", "destinataire3@gmail.com"]  # Liste des destinataires
password = "motdepasse"

def send_bulk_emails(subject, body, sender, recipients, password):
    # Se connecter au serveur SMTP de Gmail en utilisant SSL
    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp_server:
        smtp_server.login(sender, password)  # Se connecter au serveur

        # Parcourir chaque destinataire et lui envoyer un email individuel
        for recipient in recipients:
            msg = MIMEText(body)  # Créer un objet MIMEText avec le corps de l'email
            msg['Subject'] = subject  # Définir l'objet de l'email
            msg['From'] = sender  # Définir l'expéditeur
            msg['To'] = recipient  # Définir le destinataire actuel

            smtp_server.sendmail(sender, recipient, msg.as_string())  # Envoyer l'email
            print(f"Message envoyé à {recipient} !")

# Appeler la fonction pour envoyer des emails en masse
send_bulk_emails(subject, body, sender, recipients, password)

Now, I’d like to give you a quick breakdownMaintenant, j’aimerais vous donner une brève explication pour explorer comment tout cela fonctionne :

  1. Lors de l’initialisation, le script définit l’objet, le corps, l’adresse email de l’expéditeur, la liste des destinataires et le mot de passe.
  2. Avec send_bulk_emails, le script établit une connexion sécurisée au serveur SMTP de Gmail sur le port 465 via smtplib.SMTP_SSL. Après avoir établi une connexion, le script se connecte au serveur SMTP en utilisant les informations d’identification Gmail de l’expéditeur.
  3. Ensuite, le script parcourt les destinataires, effectuant ce qui suit pour chacun d’eux.
    • Un objet MIMEText est créé pour le corps de l’email.
    • Les en-têtes de l’email (Objet, De, À) sont définis. À est défini individuellement pour chaque destinataire afin de garantir que chaque email est personnalisé.
    • L’email est envoyé au destinataire actuel. La méthode sendmail prend l’expéditeur, le destinataire actuel et le contenu de l’email comme arguments.

L’avantage de cette méthode est que chaque message est journalisé ou traité séparément. Cela aide à suivre plus efficacement le succès de chaque email envoyé, ce qui est essentiel pour les opérations en masse.

Envoyer un email en Python en utilisant l’API Gmail

L’API Gmail est une API RESTful qui permet à votre application d’envoyer et de recevoir des emails en utilisant les serveurs de messagerie de Google. De plus, elle vous donne la possibilité de récupérer et de gérer les messages et d’utiliser les fonctionnalités de Gmail telles que les libellés, les fils de discussion, etc.

Analysons chaque étape de l’envoi d’un email avec Python via l’API Gmail en utilisant l’authentification OAuth2.

  1. Configurez un projet Google Cloud Platform, cliquez sur le bouton menu et sélectionnez « view all products » (Afficher tous les produits). Dans la section de gestion, sélectionnez « APIs and services » (API et services).
  2. Ensuite, sélectionnez « Library » (Bibliothèque), tapez « Gmail API » dans la barre de recherche, et cliquez sur la carte Gmail API.
  3. Enfin, sélectionnez le bouton pour activer l’API Gmail.
  4. Maintenant, vous devrez télécharger le fichier des secrets client pour votre projet. Commencez par sélectionner « Create Credentials » (Créer des identifiants). Dans cette section, sélectionnez l’API Gmail comme API préférée et les données utilisateur comme type de données auquel vous accéderez.
  5. Pour obtenir l’ID client OAuth, sélectionnez votre type d’application comme « Desktop App » (Application de bureau), définissez le nom de l’application et sélectionnez « create » (Créer). Ensuite, téléchargez et stockez les informations d’identification dans votre système de fichiers local.

Après avoir téléchargé le fichier secret, vous devriez avoir le fichier dans ce format :

{
    "installed": {
        "client_id": "463220703866-un8ijck75igunsbh4nhclm74edprhj5p.apps.googleusercontent.com",
        "project_id": "geocaching-366015",
        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
        "token_uri": "https://oauth2.googleapis.com/token",
        "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
        "client_secret": "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",
        "redirect_uris": [
            "http://localhost"
        ]
    }
}

Avant de commencer avec le code, vous devrez installer les bibliothèques google-auth, google-auth-oauthlib, google-auth-httplib2 et google-api-python-client en utilisant la commande :

pip install google-auth google-auth-oauthlib google-auth-httplib2 google-api-python-client

Après avoir installé avec succès les bibliothèques, vous créerez une variable appelée SCOPES qui contiendra une liste de chaînes spécifiant les autorisations dont dispose une application lorsqu’elle accède aux données d’un utilisateur.

À ce stade, créez une autre variable appelée flow qui utilisera la classe InstalledAppFlow pour créer un flux OAuth 2.0 pour une application installée et spécifie les portées OAuth 2.0 dont l’application a besoin dans la variable SCOPES.

Le code démarre ensuite le flux OAuth 2.0 en appelant la méthode run_local_server et en spécifiant un numéro de port, ce qui démarre un serveur web local pour gérer le flux d’autorisation et renvoyer les informations d’identification OAuth 2.0 lorsque le flux est terminé.

Ensuite, construisez le service Gmail en appelant la fonction build du module googleapiclient.discovery, en passant ‘gmail’ comme nom de service et ‘v1’ comme version en arguments, et en prenant les informations d’identification que vous avez appelées plus tôt.

Maintenant, construisez l’email en créant un objet MIMEText, et en définissant les champs ‘to’ et ‘subject’ aux valeurs souhaitées. De plus, encodez l’email en une chaîne codée en base64.

Enfin, vous pouvez envoyer l’email en appelant la méthode send de la ressource messages et en lui passant le dictionnaire create_message comme corps de la requête.

Voici à quoi ressemble le code Python lorsque toutes ces étapes sont assemblées :

import base64
from email.mime.text import MIMEText
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build
from requests import HTTPError
SCOPES = [
        "https://www.googleapis.com/auth/gmail.send"
    ]
flow = InstalledAppFlow.from_client_secrets_file(
            'credentials.json', SCOPES)
creds = flow.run_local_server(port=0)
service = build('gmail', 'v1', credentials=creds)
message = MIMEText('Ceci est le corps de l\'email')
message['to'] = 'destinataire@exemple.com'
message['subject'] = 'Objet de l\'email'
create_message = {'raw': base64.urlsafe_b64encode(message.as_bytes()).decode()}
try:
    message = (service.users().messages().send(userId="me", body=create_message).execute())
    print(F'Message envoyé à {message_envoye} ID du Message : {message["id"]}')
except HTTPError as error:
    print(F'Une erreur s\'est produite : {error}')
    message = None

C’est tout! Juste avec quelques lignes de code, vous pouvez ajouter une fonctionnalité d’envoi d’emails rapide à l’application que vous construisez, et bien sûr, n’oubliez pas de valider les adresses email collectées auprès de vos utilisateurs.

Limitations SMTP et API de Gmail

L’utilisation de l’API Gmail ou de SMTP est une option pratique et fiable pour l’automatisation de vos envois d’emails, mais, comme mentionné, elle présente certaines limitations.

Pour garantir qu’un seul utilisateur ou une seule application ne consomme pas trop de ressources, l’API limite le nombre d’emails que vous pouvez envoyer quotidiennement et impose une limite de taille maximale des emails. Pour des chiffres précis concernant ces limitations, consultez la documentation de Google.

L’API peut ne pas prendre en charge toutes les fonctionnalités disponibles via l’interface web de Gmail, telles que la possibilité de programmer l’envoi d’emails à une date ultérieure ou d’utiliser certains types de formatage ou de pièces jointes.

Lorsque vous authentifiez votre application, vous devez demander les portées OAuth appropriées pour accéder aux données dont vous avez besoin. L’utilisateur doit ensuite accorder à votre application l’accès à ses données, en respectant le principe du moindre privilège et en utilisant potentiellement les autorisations juste-à-temps pour une sécurité renforcée. Sans les portées OAuth appropriées, vos demandes d’accès aux données utilisateur seront refusées et entraîneront une erreur.

L’API Gmail est soumise à une limite d’utilisation quotidienne, qui s’applique à toutes les requêtes effectuées depuis votre application, et à des limites de débit par utilisateur. Chaque limite est identifiée en termes d’unités de quota, ou une unité de mesure abstraite représentant l’utilisation des ressources Gmail.

Par exemple, l’envoi d’un message consomme 100 unités de quota, tandis que la plupart des autres actions comme la récupération d’un message ou la création d’un brouillon consomment beaucoup moins d’unités de quota.

L’accès au SMTP de Gmail a des limites strictes pour prévenir les abus et assurer la disponibilité du service. Généralement, ces limites sont inférieures à celles de l’API Gmail, limitant souvent les utilisateurs à envoyer moins d’emails par jour.

Comme l’API, le service SMTP limite la taille des pièces jointes des emails. La taille combinée de l’email (corps et total des pièces jointes) ne doit pas dépasser 25 Mo.

Si trop de connexions ou de tentatives d’authentification sont effectuées sur une courte période, Gmail peut limiter votre connexion, restreignant temporairement votre capacité à envoyer plus d’emails. Cela fait partie des efforts de Gmail pour identifier et prévenir les spams potentiels ou les comportements abusifs via SMTP.

Existe-t-il une alternative à l’infrastructure email de Gmail ?

La réponse courte est oui.

Il existe de nombreuses alternatives à l’utilisation du serveur SMTP de Gmail pour envoyer des emails. Vous pouvez utiliser n’importe quel autre fournisseur de messagerie de votre choix. Il est important de s’assurer que leur infrastructure serveur répond à vos exigences et besoins.

Une autre option consiste à utiliser un fournisseur de services de messagerie tiers doté d’une API qui permet d’envoyer des emails depuis votre propre application en utilisant leurs serveurs. De plus, avant d’implémenter la fonctionnalité d’envoi d’emails dans votre application, il est important de la tester.

C’est là que la Plateforme de Livraison d’Email de Mailtrap s’avère utile.
La plateforme offre un Service Email API/SMTP de Mailtrap, qui est utilisé pour livrer les emails tout en vous donnant plus de contrôle sur votre infrastructure email, et l’Email Sandbox, un outil qui permet de tester et de déboguer ces emails avant qu’ils ne soient envoyés.

Si vous souhaitez utiliser l’Email API de Mailtrap avec votre application Python, après avoir vérifié votre nom de domaine, allez à la section « Sending Domains » (Domaines d’envoi), et sélectionnez l’onglet « API and SMTP » (API et SMTP). Dans le menu déroulant, sélectionnez Python et copiez-collez le code généré avec vos identifiants dans votre script.

Astuce : Consultez la documentation GitHub officielle sur le SDK Python de Mailtrap.

import requests

url = "https://send.api.mailtrap.io/api/send"

payload = "{\"from\":{\"email\":\"mailtrap@mailtrap.club\",\"name\":\"Test Mailtrap\"},\"to\":[{\"email\":\"exemple@railsware.com\"}],\"subject\":\"Vous êtes formidable !\",\"text\":\"Félicitations pour l'envoi de l'email de test avec Mailtrap !\",\"category\":\"Test d'Intégration\"}"
headers = {
  "Authorization": "Bearer 48d3783bde8152*******************",
  "Content-Type": "application/json"
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

Vous pouvez également sélectionner la méthode SMTP et copier les configurations pertinentes depuis l’application. Assurez-vous simplement de choisir le bon flux d’envoi – Transactional ou Bulk (Transactionnel ou Envoi en Masse), en fonction du type d’emails que vous souhaitez envoyer.

Voici un exemple :

import smtplib
from email.mime.text import MIMEText

# Définissez le contenu de votre email et vos identifiants
subject = "Objet de l'email"
body = "Ceci est le corps de l'email."
sender_email = "expediteur@gmail.com"
receiver_email = "destinataire@gmail.com"
password = "votre_mot_de_passe"  # Soyez prudent avec les mots de passe dans le code !

# Créez un objet MIMEText
message = MIMEText(body)
message['Subject'] = subject
message['From'] = sender_email
message['To'] = receiver_email

# Connectez-vous au serveur SMTP de Mailtrap (notez que ce n'est pas Gmail)
with smtplib.SMTP('live.smtp.mailtrap.io', 587) as server:  # Notez l'utilisation du port 587 pour STARTTLS
    server.ehlo()  # Peut être appelé facultativement (il est appelé automatiquement après une connexion)
    server.starttls()  # Sécurisez la connexion
    server.ehlo()  # Peut être appelé facultativement (il nous réidentifie auprès du serveur après STARTTLS)
    server.login(sender_email, password)
    server.send_message(message)  # Envoyez l'email

    print("Email envoyé avec succès !")

Notes : 

Envoyez des Emails Gratuitement avec Mailtrap

Conclusion

Nous espérons que cela vous aidera à développer la fonctionnalité d’envoi d’emails dans votre application! N’oubliez pas, avant de commencer à la construire, assurez-vous de rechercher quel framework Python choisir, car chacun a son propre ensemble de fonctionnalités et d’avantages :

Quitter la version mobile