TOC

Envoi d’emails avec Python

Envoi d'emails avec Python

Vous avez probablement trouvé ce didacticiel car vous souhaitez envoyer des e-mails à l'aide de Python. Vous souhaitez peut-être recevoir des rappels par e-mail de votre code, envoyer un e-mail de confirmation aux utilisateurs lorsqu'ils créent un compte ou envoyer des e-mails aux membres de votre organisation pour leur rappeler de payer leurs cotisations. L'envoi d'e-mails manuellement est une tâche longue et sujette aux erreurs, mais elle est facile à automatiser avec Python.

In this tutorial you’ll learn how to:

  • Configurer unsecure connection en utilisantSMTP_SSL() et.starttls()

  • Utilisez la bibliothèquesmtplib intégrée de Python pour envoyer desbasic emails

  • Envoyer des e-mails avecHTML content etattachments en utilisant le packageemail

  • Envoyer plusieurspersonalized emails à l'aide d'un fichier CSV avec des données de contact

  • Utilisez le packageYagmail pour envoyer des e-mails via votre compte Gmail en utilisant seulement quelques lignes de code

À la fin de ce didacticiel, vous trouverez quelques services de messagerie transactionnelle, qui vous seront utiles lorsque vous souhaitez envoyer un grand nombre de courriels.

Free Bonus:Click here to get access to a chapter from Python Tricks: The Book qui vous montre les meilleures pratiques de Python avec des exemples simples que vous pouvez appliquer instantanément pour écrire du code + Pythonic plus beau.

Commencer

Python est livré avec le module intégrésmtplib pour l'envoi d'e-mails à l'aide du protocole SMTP (Simple Mail Transfer Protocol). smtplib utilise le protocoleRFC 821 pour SMTP. Les exemples de ce didacticiel utilisent le serveur SMTP Gmail pour envoyer des e-mails, mais les mêmes principes s'appliquent aux autres services de messagerie. Bien que la majorité des fournisseurs de messagerie utilisent les mêmes ports de connexion que ceux de ce didacticiel, vous pouvez exécuter un rapideGoogle search pour confirmer le vôtre.

Pour commencer avec ce didacticiel,set up a Gmail account for development ouset up an SMTP debugging server supprime les e-mails que vous envoyez et les imprime à l'invite de commande à la place. Les deux options sont présentées ci-dessous. Un serveur de débogage SMTP local peut être utile pour résoudre tous les problèmes de fonctionnalité de messagerie et garantir que vos fonctions de messagerie sont exemptes de bogues avant d'envoyer des e-mails.

Option 1: configurer un compte Gmail pour le développement

Si vous décidez d'utiliser un compte Gmail pour envoyer vos e-mails, je vous recommande fortement de créer un compte jetable pour le développement de votre code. En effet, vous devrez ajuster les paramètres de sécurité de votre compte Gmail pour autoriser l'accès à partir de votre code Python, et parce que vous risquez d'exposer accidentellement vos informations de connexion. J'ai également constaté que la boîte de réception de mon compte de test se remplissait rapidement d'e-mails de test, ce qui est une raison suffisante pour configurer un nouveau compte Gmail pour le développement.

Une fonctionnalité intéressante de Gmail est que vous pouvez utiliser le signe+ pour ajouter des modificateurs à votre adresse e-mail, juste avant le signe@. Par exemple, les e-mails envoyés à[email protected] et[email protected] arriveront tous les deux à[email protected]. Lorsque vous testez la fonctionnalité de messagerie, vous pouvez l'utiliser pour émuler plusieurs adresses qui pointent toutes vers la même boîte de réception.

Pour configurer une adresse Gmail pour tester votre code, procédez comme suit:

Si vous ne souhaitez pas réduire les paramètres de sécurité de votre compte Gmail, consultez lesdocumentation de Google pour savoir comment obtenir les identifiants d'accès pour votre script Python, à l'aide du cadre d'autorisation OAuth2.

Option 2: configuration d'un serveur SMTP local

Vous pouvez tester la fonctionnalité de messagerie en exécutant un serveur de débogage SMTP local, à l'aide du modulesmtpd qui est pré-installé avec Python. Plutôt que d'envoyer des e-mails à l'adresse spécifiée, il les supprime et imprime leur contenu sur la console. L'exécution d'un serveur de débogage local signifie qu'il n'est pas nécessaire de traiter le chiffrement des messages ou d'utiliser des informations d'identification pour se connecter à un serveur de messagerie.

Vous pouvez démarrer un serveur de débogage SMTP local en tapant ce qui suit dans l'invite de commandes: 

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

Sous Linux, utilisez la même commande précédée desudo.

Tous les e-mails envoyés via ce serveur seront supprimés et affichés dans la fenêtre du terminal en tant qu'objetbytes pour chaque ligne: 

---------- MESSAGE FOLLOWS ----------
b'X-Peer: ::1'
b''
b'From: [email protected]'
b'To: [email protected]'
b'Subject: a local test mail'
b''
b'Hello there, here is a test email'
------------ END MESSAGE ------------

Pour le reste du didacticiel, je suppose que vous utilisez un compte Gmail, mais si vous utilisez un serveur de débogage local, assurez-vous simplement d'utiliserlocalhost comme serveur SMTP et utilisez le port 1025 plutôt que port 465 ou 587. De plus, vous n’avez pas besoin d’utiliserlogin() ou de crypter la communication à l’aide de SSL / TLS.

Envoi d'un e-mail en texte brut

Avant de commencer à envoyer des e-mails avec du contenu HTML et des pièces jointes, vous apprendrez à envoyer des e-mails en texte brut à l'aide de Python. Ce sont des e-mails que vous pouvez rédiger dans un simple éditeur de texte. Il n'y a pas de trucs fantaisistes comme le formatage de texte ou les hyperliens. Vous l'apprendrez un peu plus tard.

Démarrage d'une connexion SMTP sécurisée

Lorsque vous envoyez des e-mails via Python, vous devez vous assurer que votre connexion SMTP est cryptée, afin que votre message et vos informations de connexion ne soient pas facilement accessibles par d'autres. SSL (Secure Sockets Layer) et TLS (Transport Layer Security) sont deux protocoles qui peuvent être utilisés pour crypter une connexion SMTP. Il n'est pas nécessaire d'utiliser l'un ou l'autre de ces éléments lors de l'utilisation d'un serveur de débogage local.

Il existe deux façons de démarrer une connexion sécurisée avec votre serveur de messagerie:

  • Démarrez une connexion SMTP sécurisée depuis le début à l'aide deSMTP_SSL().

  • Démarrez une connexion SMTP non sécurisée qui peut ensuite être chiffrée à l'aide de.starttls().

Dans les deux cas, Gmail chiffrera les e-mails à l'aide de TLS, car il s'agit du successeur le plus sécurisé de SSL. Conformément auxSecurity considerations de Python, il est fortement recommandé d'utilisercreate_default_context() du modulessl. Cela chargera les certificats d'autorité de certification de confiance du système, activera la vérification du nom d'hôte et la validation des certificats et tentera de choisir des paramètres de protocole et de chiffrement raisonnablement sécurisés.

Si vous souhaitez vérifier le cryptage d'un e-mail dans votre boîte de réception Gmail, accédez àMore →Show original pour voir le type de cryptage répertorié sous l'en-têteReceived.

smtplib est le module intégré de Python pour envoyer des e-mails à n'importe quelle machine Internet avec un démon d'écoute SMTP ou ESMTP.

Je vais d'abord vous montrer comment utiliserSMTP_SSL(), car il instancie une connexion sécurisée dès le départ et légèrement plus concise que l'alternative.starttls(). Gardez à l'esprit que Gmail nécessite que vous vous connectiez au port 465 si vous utilisezSMTP_SSL() et au port 587 lorsque vous utilisez.starttls().

Option 1: Utilisation deSMTP_SSL()

L'exemple de code ci-dessous crée une connexion sécurisée avec le serveur SMTP de Gmail, en utilisant lesSMTP_SSL() desmtplib pour lancer une connexion cryptée TLS. Le contexte par défaut dessl valide le nom d'hôte et ses certificats et optimise la sécurité de la connexion. Assurez-vous de renseigner votre propre adresse e-mail au lieu de[email protected]: 

import smtplib, ssl

port = 465  # For SSL
password = input("Type your password and press enter: ")

# Create a secure SSL context
context = ssl.create_default_context()

with smtplib.SMTP_SSL("smtp.gmail.com", port, context=context) as server:
    server.login("[email protected]", password)
    # TODO: Send email here

L'utilisation dewith smtplib.SMTP_SSL() as server: garantit que la connexion est automatiquement fermée à la fin du bloc de code indenté. Siport est égal à zéro ou n'est pas spécifié,.SMTP_SSL() utilisera le port standard pour SMTP sur SSL (port 465).

Il n'est pas prudent de stocker votre mot de passe de messagerie dans votre code, surtout si vous avez l'intention de le partager avec d'autres. À la place, utilisezinput() pour permettre à l'utilisateur de saisir son mot de passe lors de l'exécution du script, comme dans l'exemple ci-dessus. Si vous ne souhaitez pas que votre mot de passe s'affiche sur votre écran lorsque vous le saisissez, vous pouvez importer le modulegetpass et utiliser.getpass() à la place pour la saisie aveugle de votre mot de passe.

Option 2: Utilisation de.starttls()

Au lieu d'utiliser.SMTP_SSL() pour créer une connexion sécurisée dès le départ, nous pouvons créer une connexion SMTP non sécurisée et la chiffrer à l'aide de.starttls().

Pour ce faire, créez une instance desmtplib.SMTP, qui encapsule une connexion SMTP et vous permet d'accéder à ses méthodes. Je recommande de définir votre serveur et port SMTP au début de votre script pour les configurer facilement.

L'extrait de code ci-dessous utilise la constructionserver = SMTP(), plutôt que le formatwith SMTP() as server: que nous avons utilisé dans l'exemple précédent. Pour vous assurer que votre code ne plante pas en cas de problème, placez votre code principal dans un bloctry et laissez un blocexcept imprimer tous les messages d'erreur dansstdout: 

import smtplib, ssl

smtp_server = "smtp.gmail.com"
port = 587  # For starttls
sender_email = "[email protected]"
password = input("Type your password and press enter: ")

# Create a secure SSL context
context = ssl.create_default_context()

# Try to log in to server and send email
try:
    server = smtplib.SMTP(smtp_server,port)
    server.ehlo() # Can be omitted
    server.starttls(context=context) # Secure the connection
    server.ehlo() # Can be omitted
    server.login(sender_email, password)
    # TODO: Send email here
except Exception as e:
    # Print any error messages to stdout
    print(e)
finally:
    server.quit()

Pour vous identifier auprès du serveur,.helo() (SMTP) ou.ehlo() (ESMTP) doivent être appelés après la création d'un objet.SMTP(), et à nouveau après.starttls(). Cette fonction est implicitement appelée par.starttls() et.sendmail() si nécessaire, donc à moins que vous ne souhaitiez vérifier les extensions de service SMTP du serveur, il n'est pas nécessaire d'utiliser.helo() ou.ehlo() explicitement.

Envoi de votre e-mail en texte brut

Après avoir lancé une connexion SMTP sécurisée à l'aide de l'une des méthodes ci-dessus, vous pouvez envoyer votre courrier électronique en utilisant.sendmail(), qui fait à peu près ce qu'il dit sur la boîte: 

server.sendmail(sender_email, receiver_email, message)

Je recommande de définir les adresses e-mail et le contenu des messages en haut de votre script, après les importations, afin de pouvoir les modifier facilement: 

sender_email = "[email protected]"
receiver_email = "[email protected]"
message = """\
Subject: Hi there

This message is sent from Python."""

# Send email here

Lemessagestring commence par"Subject: Hi there" suivi de deux nouvelles lignes ( ). Cela garantit queHi there apparaîtra comme sujet de l'e-mail et que le texte suivant les nouvelles lignes sera traité comme le corps du message.

L'exemple de code ci-dessous envoie un e-mail en texte brut en utilisantSMTP_SSL(): 

import smtplib, ssl

port = 465  # For SSL
smtp_server = "smtp.gmail.com"
sender_email = "[email protected]"  # Enter your address
receiver_email = "[email protected]"  # Enter receiver address
password = input("Type your password and press enter: ")
message = """\
Subject: Hi there

This message is sent from Python."""

context = ssl.create_default_context()
with smtplib.SMTP_SSL(smtp_server, port, context=context) as server:
    server.login(sender_email, password)
    server.sendmail(sender_email, receiver_email, message)

À titre de comparaison, voici un exemple de code qui envoie un e-mail en texte brut via une connexion SMTP sécurisée avec.starttls(). Les lignesserver.ehlo() peuvent être omises, car elles sont appelées implicitement par.starttls() et.sendmail(), si nécessaire: 

import smtplib, ssl

port = 587  # For starttls
smtp_server = "smtp.gmail.com"
sender_email = "[email protected]"
receiver_email = "[email protected]"
password = input("Type your password and press enter:")
message = """\
Subject: Hi there

This message is sent from Python."""

context = ssl.create_default_context()
with smtplib.SMTP(smtp_server, port) as server:
    server.ehlo()  # Can be omitted
    server.starttls(context=context)
    server.ehlo()  # Can be omitted
    server.login(sender_email, password)
    server.sendmail(sender_email, receiver_email, message)

Envoi d'emails fantaisistes

Le packageemail intégré de Python vous permet de structurer des e-mails plus sophistiqués, qui peuvent ensuite être transférés avecsmtplib comme vous l'avez déjà fait. Ci-dessous, vous découvrirez comment utiliser le packageemail pour envoyer des e-mails avec du contenu HTML et des pièces jointes.

Inclusion de contenu HTML

Si vous souhaitez formater le texte de votre e-mail (bold,italics, etc.), ou si vous souhaitez ajouter des images, des hyperliens ou du contenu réactif, le HTML est très pratique. Le type de courrier électronique le plus courant est le courrier électronique multipartite MIME (Multipurpose Internet Mail Extensions), combinant HTML et texte brut. Les messages MIME sont gérés par le moduleemail.mime de Python. Pour une description détaillée, vérifiezthe documentation.

Comme tous les clients de messagerie n'affichent pas de contenu HTML par défaut, et certaines personnes choisissent de ne recevoir que des e-mails en texte brut pour des raisons de sécurité, il est important d'inclure une alternative en texte brut pour les messages HTML. Comme le client de messagerie restituera d'abord la dernière pièce jointe en plusieurs parties, assurez-vous d'ajouter le message HTML après la version en texte brut.

Dans l'exemple ci-dessous, nos objetsMIMEText() contiendront les versions HTML et texte brut de notre message, et l'instanceMIMEMultipart("alternative") les combine en un seul message avec deux options de rendu alternatives: 

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

sender_email = "[email protected]"
receiver_email = "[email protected]"
password = input("Type your password and press enter:")

message = MIMEMultipart("alternative")
message["Subject"] = "multipart test"
message["From"] = sender_email
message["To"] = receiver_email

# Create the plain-text and HTML version of your message
text = """\
Hi,
How are you?
Real Python has many great tutorials:
www.realpython.com"""
html = """\

  
    
Hi,

       How are you?

       Real Python
       has many great tutorials.
    

  

"""

# Turn these into plain/html MIMEText objects
part1 = MIMEText(text, "plain")
part2 = MIMEText(html, "html")

# Add HTML/plain-text parts to MIMEMultipart message
# The email client will try to render the last part first
message.attach(part1)
message.attach(part2)

# Create secure connection with server and send email
context = ssl.create_default_context()
with smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) as server:
    server.login(sender_email, password)
    server.sendmail(
        sender_email, receiver_email, message.as_string()
    )

Dans cet exemple, vous définissez d'abord le message en texte brut et HTML en tant que chaînes littérales, puis vous les stockez en tant qu'objetsplain /htmlMIMEText. Ceux-ci peuvent ensuite être ajoutés dans cet ordre au messageMIMEMultipart("alternative") et envoyés via votre connexion sécurisée avec le serveur de messagerie. N'oubliez pas d'ajouter le message HTML après l'alternative en texte brut, car les clients de messagerie tenteront de restituer la dernière sous-partie en premier.

Ajout de pièces jointes à l'aide du packageemail

Pour envoyer des fichiers binaires à un serveur de messagerie conçu pour fonctionner avec des données textuelles, ils doivent être codés avant le transport. Ceci est le plus souvent fait en utilisantbase64, qui encode les données binaires en caractères ASCII imprimables.

L'exemple de code ci-dessous montre comment envoyer un e-mail avec un fichier PDF en pièce jointe: 

import email, smtplib, ssl

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

subject = "An email with attachment from Python"
body = "This is an email with attachment sent from Python"
sender_email = "[email protected]"
receiver_email = "[email protected]"
password = input("Type your password and press enter:")

# Create a multipart message and set headers
message = MIMEMultipart()
message["From"] = sender_email
message["To"] = receiver_email
message["Subject"] = subject
message["Bcc"] = receiver_email  # Recommended for mass emails

# Add body to email
message.attach(MIMEText(body, "plain"))

filename = "document.pdf"  # In same directory as script

# Open PDF file in binary mode
with open(filename, "rb") as attachment:
    # Add file as application/octet-stream
    # Email client can usually download this automatically as attachment
    part = MIMEBase("application", "octet-stream")
    part.set_payload(attachment.read())

# Encode file in ASCII characters to send by email
encoders.encode_base64(part)

# Add header as key/value pair to attachment part
part.add_header(
    "Content-Disposition",
    f"attachment; filename= {filename}",
)

# Add attachment to message and convert message to string
message.attach(part)
text = message.as_string()

# Log in to server using secure context and send email
context = ssl.create_default_context()
with smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) as server:
    server.login(sender_email, password)
    server.sendmail(sender_email, receiver_email, text)

Le messageMIMEultipart() accepte des paramètres sous la forme de paires clé / valeur de styleRFC5233, qui sont stockées dans un dictionnaire et transmises aux.add_header method de la classe de baseMessage.

Consultez le moduledocumentation pour Pythonemail.mime pour en savoir plus sur l'utilisation des classes MIME.

Envoi de plusieurs e-mails personnalisés

Imaginez que vous souhaitiez envoyer des e-mails aux membres de votre organisation pour leur rappeler de payer leurs frais de contribution. Ou peut-être souhaitez-vous envoyer aux étudiants de votre classe des e-mails personnalisés avec les notes de leur récent devoir. Ces tâches sont un jeu d'enfant en Python.

Créer un fichier CSV avec des informations personnelles pertinentes

Un point de départ facile pour envoyer plusieurs e-mails personnalisés est àcreate a CSV (comma-separated values) file qui contient toutes les informations personnelles requises. (Assurez-vous de ne pas partager les informations privées des autres sans leur consentement.) Un fichier CSV peut être considéré comme un simple tableau, où la première ligne contient souvent les en-têtes de colonne.

Voici le contenu du fichiercontacts_file.csv, que j'ai enregistré dans le même dossier que mon code Python. Il contient les noms, adresses et notes d'un ensemble de personnes fictives. J'ai utilisé les constructions[email protected] pour m'assurer que tous les e-mails se retrouvent dans ma propre boîte de réception, qui dans cet exemple est[email protected]: 

name,email,grade
Ron Obvious,[email protected],B+
Killer Rabbit of Caerbannog,[email protected],A
Brian Cohen,[email protected],C

Lors de la création d'un fichier CSV, assurez-vous de séparer vos valeurs par une virgule, sans espaces blancs environnants.

Boucle sur des lignes pour envoyer plusieurs e-mails

L'exemple de code ci-dessous vous montre comment ouvrir un fichier CSV et boucler sur ses lignes de contenu (en sautant la ligne d'en-tête). Pour m'assurer que le code fonctionne correctement avant d'envoyer des e-mails à tous vos contacts, j'ai impriméSending email to ... pour chaque contact, que nous pourrons remplacer ultérieurement par une fonctionnalité qui envoie réellement des e-mails: 

import csv

with open("contacts_file.csv") as file:
    reader = csv.reader(file)
    next(reader)  # Skip header row
    for name, email, grade in reader:
        print(f"Sending email to {name}")
        # Send email here

Dans l'exemple ci-dessus, l'utilisation dewith open(filename) as file:+`makes sure that your file closes at the end of the code block. `+csv.reader() facilite la lecture d'un fichier CSV ligne par ligne et l'extraction de ses valeurs. La lignenext(reader) ignore la ligne d'en-tête, de sorte que la ligne suivantefor name, email, grade in reader: divise les lignes suivantes à chaque virgule et stocke les valeurs résultantes dans les chaînesname,email etgrade pour le contact actuel.

Si les valeurs de votre fichier CSV contiennent des espaces sur l'un ou les deux côtés, vous pouvez les supprimer à l'aide de la méthode.strip().

Contenu personnalisé

Vous pouvez mettre du contenu personnalisé dans un message en utilisantstr.format() pour remplir les espaces réservés entre crochets. Par exemple,"hi {name}, you {result} your assignment".format(name="John", result="passed") vous donnera"hi John, you passed your assignment".

Depuis Python 3.6, le formatage des chaînes peut être fait plus élégamment en utilisantf-strings, mais ceux-ci nécessitent que les espaces réservés soient définis avant la chaîne f elle-même. Afin de définir le message électronique au début du script et de remplir des espaces réservés pour chaque contact lors de la boucle sur le fichier CSV, l'ancienne méthode.format() est utilisée.

Dans cet esprit, vous pouvez mettre en place un corps de message général, avec des espaces réservés qui peuvent être adaptés aux individus.

Exemple de code

L'exemple de code suivant vous permet d'envoyer des e-mails personnalisés à plusieurs contacts. Il boucle sur un fichier CSV avecname,email,grade pour chaque contact, comme dans lesexample above.

Le message général est défini au début du script, et pour chaque contact du fichier CSV, ses espaces réservés{name} et{grade} sont renseignés, et un e-mail personnalisé est envoyé via une connexion sécurisée avec le Serveur Gmail, comme vous l'avez vu précédemment: 

import csv, smtplib, ssl

message = """Subject: Your grade

Hi {name}, your grade is {grade}"""
from_address = "[email protected]"
password = input("Type your password and press enter: ")

context = ssl.create_default_context()
with smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) as server:
    server.login(from_address, password)
    with open("contacts_file.csv") as file:
        reader = csv.reader(file)
        next(reader)  # Skip header row
        for name, email, grade in reader:
            server.sendmail(
                from_address,
                email,
                message.format(name=name,grade=grade),
            )

Yagmail

Il existe plusieurs bibliothèques conçues pour faciliter l'envoi d'e-mails, telles queEnvelopes,Flanker etYagmail. Yagmail est conçu pour fonctionner spécifiquement avec Gmail, et il simplifie considérablement le processus d'envoi d'e-mails via une API conviviale, comme vous pouvez le voir dans l'exemple de code ci-dessous: 

import yagmail

receiver = "[email protected]"
body = "Hello there from Yagmail"
filename = "document.pdf"

yag = yagmail.SMTP("[email protected]")
yag.send(
    to=receiver,
    subject="Yagmail test with attachment",
    contents=body,
    attachments=filename,
)

Cet exemple de code envoie un e-mail avec une pièce jointe PDF dans une fraction des lignes nécessaires pour nosexample using email and smtplib.

Lors de la configuration de Yagmail, vous pouvez ajouter vos validations Gmail au trousseau de clés de votre système d'exploitation, comme décrit dansthe documentation. Si vous ne le faites pas, Yagmail vous demandera de saisir votre mot de passe si nécessaire et de le stocker automatiquement dans le trousseau de clés.

Services de messagerie transactionnelle

Si vous prévoyez d'envoyer un grand volume d'e-mails, que vous souhaitez voir les statistiques des e-mails et que vous souhaitez garantir une livraison fiable, il peut être utile de se pencher sur les services de messagerie transactionnelle. Bien que tous les services suivants aient des plans payants pour l'envoi de gros volumes d'e-mails, ils sont également livrés avec un plan gratuit afin que vous puissiez les essayer. Certains de ces plans gratuits sont valables indéfiniment et peuvent être suffisants pour vos besoins de messagerie.

Vous trouverez ci-dessous un aperçu des plans gratuits pour certains des principaux services de messagerie transactionnelle. En cliquant sur le nom du fournisseur, vous accédez à la section des prix de leur site Web.

Fournisseur Plan gratuit

Sendgrid

40000 e-mails pour vos 30 premiers jours, puis 100 / jour

Sendinblue

300 emails / jour

Mailgun

10 000 premiers e-mails gratuits

Mailjet

200 emails / jour

Amazon SES

62000 emails / mois

Vous pouvez exécuter unGoogle search pour voir quel fournisseur correspond le mieux à vos besoins, ou simplement essayer quelques-uns des plans gratuits pour voir avec quelle API vous aimez le plus travailler.

Exemple de code Sendgrid

Voici un exemple de code pour envoyer des e-mails avecSendgrid pour vous donner une idée de l'utilisation d'un service de messagerie transactionnel avec Python: 

import os
import sendgrid
from sendgrid.helpers.mail import Content, Email, Mail

sg = sendgrid.SendGridAPIClient(
    apikey=os.environ.get("SENDGRID_API_KEY")
)
from_email = Email("[email protected]")
to_email = Email("[email protected]")
subject = "A test email from Sendgrid"
content = Content(
    "text/plain", "Here's a test email sent through Python"
)
mail = Mail(from_email, subject, to_email, content)
response = sg.client.mail.send.post(request_body=mail.get())

# The statements below can be included for debugging purposes
print(response.status_code)
print(response.body)
print(response.headers)

Pour exécuter ce code, vous devez d'abord:

  • Créez un compte Sendgrid (gratuit)

  • Request an API key pour la validation utilisateur

  • Ajoutez votre clé API en tapantsetx SENDGRID_API_KEY "YOUR_API_KEY" dans l'invite de commande (pour stocker cette clé API de manière permanente) ouset SENDGRID_API_KEY YOUR_API_KEY pour la stocker uniquement pour la session client en cours

Vous trouverez plus d'informations sur la configuration de Sendgrid pour Mac et Windows dans le fichier README du référentiel surGithub.

Conclusion

Vous pouvez maintenant démarrer une connexion SMTP sécurisée et envoyer plusieurs e-mails personnalisés aux personnes de votre liste de contacts!

Vous avez appris à envoyer un e-mail HTML avec une alternative en texte brut et à joindre des fichiers à vos e-mails. Le packageYagmail simplifie toutes ces tâches lorsque vous utilisez un compte Gmail. Si vous prévoyez d'envoyer de gros volumes d'e-mails, il convient de se pencher sur les services de messagerie transactionnelle.

Profitez de l'envoi d'e-mails avec Python et rappelez-vous:no spam please!

Related