Dev Life
Bonnes pratiques des emails transactionnels pour les développeurs
Avez-vous reçu un email de notification instantanée lorsque vous avez acheté quelque chose en ligne ? C’est essentiellement ce qu’est un message transactionnel est. Les messages transactionnels sont des emails ou des notifications automatisés que vous recevez lorsque vous vous inscrivez à un service, effectuez un achat ou réinitialisez un mot de passe. Ils incluent également les alertes de fraude, les rappels de panier abandonné, ainsi que les mises à jour de livraison et bancaires. Contrairement aux emails de marketing, ils confirment des actions et vous tiennent informé, renforçant la confiance et améliorant l’engagement des utilisateurs.
Dans cet article, vous apprendrez comment automatiser les messages transactionnels depuis votre application en utilisant des flux de travail d’API pour améliorer l’expérience client.
Pourquoi l’email transactionnel est-il important pour l’expérience client ?
Contrairement aux envois en masse emails de marketing, les messages transactionnels sont personnalisés, opportuns et attendus car ils sont très pertinents pour l’activité de l’utilisateur. Ces messages sont individuels et contiennent des informations directement liées aux activités de l’utilisateur.
Les messages transactionnels opportuns – comme les confirmations de commande et les alertes de compte – améliorer la satisfaction des clients, améliorent la transparence et renforcent la confiance en traitant efficacement les interactions avec les clients et la fraude potentielle. Ils aident également les clients en offrant des options de libre-service et en réduisant la charge pesant sur le support client.
Contrairement aux emails promotionnels qui passent souvent inaperçus, les emails transactionnels sont très attendus et souvent ouverts instantanément ; les utilisateurs iront même jusqu’à mener une chasse au trésor dans leurs dossiers spam pour les retrouver.
Dans ce tutoriel, vous apprendrez comment envoyer des emails transactionnels depuis votre application en configurant des flux de travail simples avec les API de Mailgun. Mailgun est une plateforme d’envoi d’emails qui vous permet d’envoyer et de suivre des emails. Elle simplifie l’automatisation des emails transactionnels grâce à des API fiables et faciles à utiliser. Vous utiliserez Mailgun pour automatiser les messages transactionnels avec Python dans les scénarios suivants :
- Inscription de compte utilisateur
- Double opt-in pour les abonnements à la newsletter
- Réinitialisation de mot de passe
Avant de commencer, assurez-vous de disposer de ce qui suit :
- Python 3.9 ou version ultérieure
- Un compte Mailgun (l’ essai gratuit de 30 jours est suffisant pour ce tutoriel)
Configurer un nouveau projet Python
Pour commencer, créez un répertoire pour votre projet Python et ajoutez-y un fichier .env vide.
Avant de continuer, c’est une bonne pratique de créer et d’activer un nouveau environnement virtuel pour isoler votre projet et éviter les conflits de dépendances.
Une fois votre environnement virtuel actif, installez les bibliothèques nécessaires (requests et python-dotenv) en exécutant la commande suivante :
```python
pip install requests python-dotenv
```
La bibliothèque requests vous permet d’effectuer des appels d’API, et python-dotenv vous aide à stocker en toute sécurité votre clé API en dehors de votre code.
Obtenir une clé API
Pour effectuer des appels d’API vers Mailgun, vous avez besoin d’une clé API depuis votre compte Mailgun.
Connectez-vous à votre compte Mailgun et accédez à la page Sécurité de l’API . Vous pouvez trouver cela dans le menu déroulant sous votre nom dans le coin supérieur droit :
Créez une clé API puis copiez-la :
Stockez-la en toute sécurité en collant la clé dans le fichier .env de votre projet :
```python
MAILGUN_API_KEY="Your API Key Here"
```
Lorsque vous utilisez Mailgun, prenez note de vos domaines d’envoi sur le tableau de bord :
Si vous avez un abonnement gratuit, vous verrez un domaine sandbox, que vous utiliserez dans le point de terminaison de l’API et comme adresse email « d’expédition » lors de l’envoi d’emails via les API de Mailgun. Le domaine sandbox ressemble généralement à ceci : .mailgun.org.
Importer les modules et initialiser
Pour automatiser les emails transactionnels, commencez par créer un fichier main.py dans le répertoire de votre projet et ajoutez le code suivant :
```python
import requests
import logging
import os
from dotenv import load_dotenv
logging.basicConfig(level=logging.INFO) # Set log level
load_dotenv() # For reading the API key from the `.env` file
# Sandbox API URL format: https://api.mailgun.net/v3/sandbox.mailgun.org/messages
MAILGUN_API_URL = "https://api.mailgun.net/v3/YOUR_DOMAIN_NAME/messages"
FROM_EMAIL_ADDRESS = "Sender Name "
```
La fonction load_dotenv(), de la bibliothèque python-dotenv , charge les variables d’environnement depuis votre fichier .env dans votre code Python. C’est une bonne pratique pour stocker et accéder en toute sécurité à des informations sensibles telles que les identifiants et les clés API.
MAILGUN_API_URL définit l’URL de l’API pour votre script Python, tandis que FROM_EMAIL_ADDRESS spécifie l’adresse email de l’expéditeur (les deux doivent utiliser votre domaine d’envoi d’emails ou le domaine sandbox mentionné précédemment).
Envoyer un email à l’aide de l’API de Mailgun
Le code suivant vous montre comment envoyer un email à une seule adresse à l’aide de l’API de Mailgun. Vous devez ajouter ce code au fichier main.py que vous avez créé précédemment, en dessous de l’initialisation :
```python
def _send_email(to_address: str, subject: str, message: str):
"""
Send single email to the given email address using Mailgun API.
:param to_address:
:param subject:
:param message:
"""
try:
api_key = os.getenv("MAILGUN_API_KEY") # Get API key from the `.env` file
resp = requests.post(MAILGUN_API_URL, auth=("api", api_key),
data={"from": FROM_EMAIL_ADDRESS,
"to": to_address, "subject": subject, "html": message})
if resp.status_code == 200: # Success
logging.info(f"Successfully sent an email to '{to_address}' via Mailgun API.")
else: # Error
logging.error(f"Could not send the email, reason: {resp.text}")
except Exception as ex:
logging.exception(f"Mailgun error: {ex}")
```
La fonction _send_email() prend trois arguments : to_address, subject, et message. to_address est l’email du destinataire, tandis que subject et message définissent respectivement l’objet et le contenu de l’email.
La fonction lit la clé API de Mailgun depuis le fichier .env, qui est ensuite utilisée pour authentifier l’appel d’API vers la MAILGUN_API_URL spécifiée. Cette clé identifie votre compte de manière unique, permettant à Mailgun de vérifier votre requête.
Pour garantir que l’email est envoyé correctement, vous devez utiliser votre clé API unique ; l’adresse email « d’expédition » doit être associée à votre domaine valide ou au domaine sandbox de Mailgun. Sinon, l’appel d’API échouera et renverra une erreur.
Les données de l’email sont envoyées en utilisant la méthode HTTP POST via l’appel requests.post(). Si l’appel d’API réussit, l’email est mis en file d’attente pour la livraison, et l’API renvoie un statut HTTP 200 OK. Si une erreur se produit, l’API fournit un message d’erreur ainsi qu’un code d’état HTTP approprié. Les deux scénarios sont consignés par cette fonction pour votre référence.
Toutes les automatisations des emails transactionnels dans les sections suivantes s’appuient sur la fonction _send_email() pour envoyer des emails via l’API de Mailgun.
Bonne pratique : Automatiser les emails d’inscription de compte
L’inscription de compte utilisateur est l’un des cas d’utilisation les plus importants pour les emails transactionnels, car elle sert de point d’entrée de l’utilisateur dans votre système. La première impression compte, et cette interaction initiale est une opportunité de renforcer la confiance et d’établir une relation positive avec l’utilisateur. Un email de félicitations bien opportun lors de l’inscription confirme non seulement le succès du processus, mais rassure également l’utilisateur quant au fait que son compte est prêt à être utilisé.
Pour ce faire, votre système doit envoyer immédiatement un email de confirmation automatisé pour faire savoir à l’utilisateur que son inscription a réussi.
Voici un exemple de la façon de mettre cela en œuvre :
```python
def _notify_registration(user_name: str, user_email: str):
"""
Notify user on successful registration using `_send_email`
:param user_name:
:param user_email:
"""
# Use your own formatted HTML message here, with an appropriate link
registration_msg = f'Dear {user_name},<br /><br /> You have successfully registered on our site.'
_send_email(user_email, "Registration successful", registration_msg)
def register_user(user_name: str, user_email: str):
"""
Register the user and notify the user on successful registration.
:param user_name:
:param user_email:
"""
# Actual code to register the user
logging.info(f"Sending registration email to the user: {user_name}...")
_notify_registration(user_name, user_email)
```
La première fonction, _notify_registration(), est responsable de l’envoi d’une notification par email à un utilisateur qui vient de s’inscrire. Elle prend deux paramètres : user_name et user_email. À l’intérieur de cette fonction, un simple message HTML est construit en utilisant une f-string, ce qui permet d’insérer facilement le nom de l’utilisateur dans le message. Cette fonction appelle ensuite la fonction précédemment abordée _send_email() pour envoyer l’email.
La deuxième fonction stub, register_user(), suggère le point d’entrée principal pour le processus d’inscription de l’utilisateur dans votre système. Elle prend également user_name et user_email comme paramètres. Dans la réalité, elle aurait généralement plus de paramètres ou des objets ‘utilisateur’ avec plus de détails. Cette fonction est responsable du traitement du processus d’inscription. Comme indiqué ici, elle consigne l’envoi de l’email et appelle la fonction _notify_registration() pour initier l’email de confirmation automatisé après avoir terminé l’inscription de l’utilisateur.
L’inscription de l’utilisateur agit comme un événement déclencheur pour cet email transactionnel, et vous pouvez l’automatiser en utilisant le flux de travail d’API illustré ci-dessus. C’est également une excellente occasion d’informer les utilisateurs de vos services et fonctionnalités clés.
Bonne pratique : Automatiser les emails de confirmation de double opt-in
Lorsqu’un utilisateur s’inscrit à votre newsletter, au lieu de l’ajouter immédiatement à votre liste d’abonnés, vous pouvez envoyer un email lui demandant de confirmer son abonnement. Ce processus, appelé confirmation de double opt-in, est légalement requis dans certains pays pour la conformité réglementaire.
Ici, l’abonnement de l’utilisateur agit comme déclencheur, et vous pouvez automatiser la confirmation de double opt-in avec le code suivant :
```python
def _notify_subscription(user_name: str, user_email: str):
"""
Double opt-in confirmation for user subscription.
:param user_name:
:param user_email:
"""
# Use your own formatted HTML message here, with an appropriate link
subscription_msg = f'Dear {user_name},<br /><br /> Please confirm your subscription to our newsletter by clicking ' \
f'this link: <a href="https://example.com/confirm-subscription?id=abcdef1234567xyz">' \
f'https://example.com/confirm-subscription?id=abcdef1234567xyz</a>'
_send_email(user_email, "Confirm subscription", subscription_msg)
def subscribe_user(user_name: str, user_email: str):
"""
Subscribe user and send opt-in confirmation message.
:param user_name:
:param user_email:
"""
# Code to subscribe user with pending confirmation
logging.info(f"Sending subscription confirmation email to the user: {user_name}...")
_notify_subscription(user_name, user_email)
```
La première fonction, _notify_subscription(), est responsable de l’envoi d’un email de confirmation de double opt-in à un utilisateur qui a demandé à s’inscrire à une newsletter. Elle prend deux paramètres : user_name et user_email. À l’intérieur de cette fonction, un message HTML est construit à l’aide d’une f-string, qui inclut le nom de l’utilisateur et un lien de confirmation factice. À nouveau, cette fonction appelle ensuite la fonction _send_email() pour envoyer l’email.
La deuxième fonction stub, subscribe_user(), est le point d’entrée principal pour le processus d’abonnement de l’utilisateur. Elle prend également user_name et user_email comme paramètres. Cette fonction traite généralement le processus d’abonnement initial, stockant probablement les informations de l’utilisateur avec un statut ‘en attente’. À la fin, elle consigne l’envoi de l’email et appelle ensuite la fonction _notify_subscription() pour créer et envoyer l’email de confirmation de double opt-in.
Bonne pratique : Automatiser les emails de réinitialisation de mot de passe
Vous êtes-vous déjà retrouvé à devoir vous connecter, pour réaliser que vous avez oublié votre mot de passe et devoir cliquer sur le lien « mot de passe oublié » ? Cliquer sur ce lien déclenche un email que vous attendez avec impatience.
Voici un exemple de code qui démontre comment automatiser ce type d’email transactionnel :
```python
def _notify_password_reset(user_name: str, user_email: str):
"""
Send password reset email to the user
:param user_name:
:param user_email:
"""
# Use your own formatted HTML message here
registration_msg = f'Dear {user_name},<br /><br /> Please use the following link to reset your password: ' \
f'<a href="https://example.com/password-reset?token=lmnopqr7654321abc">' \
f'https://example.com/password-reset?token=lmnopqr7654321abc</a>'
_send_email(user_email, "Reset password", registration_msg)
def reset_user_password(user_name: str, user_email: str):
"""
Initiate password-reset and notify user
:param user_name:
:param user_email:
"""
# Password reset code for the user
logging.info(f"Sending password reset email to the user: {user_name}...")
_notify_password_reset(user_name, user_email)
```
La fonction _notify_password_reset() est responsable de la création et de l’envoi d’un email de réinitialisation de mot de passe à l’utilisateur. Elle prend le nom et l’adresse email de l’utilisateur comme entrées. À l’intérieur de la fonction, un message HTML est créé à l’aide d’une f-string, qui inclut le nom de l’utilisateur et une URL de réinitialisation de mot de passe unique. La fonction utilise ensuite la fonction _send_email() pour livrer ce message dans la boîte de réception de l’utilisateur.
La fonction reset_user_password() travaille à ses côtés comme point de départ lorsqu’un utilisateur souhaite réinitialiser son mot de passe. Elle nécessite également le nom et l’email de l’utilisateur comme entrées. Cette fonction ferait normalement un travail en coulisses pour configurer la réinitialisation de mot de passe (non illustré dans ce code). Elle consigne ensuite l’envoi de l’email et appelle _notify_password_reset() pour envoyer les instructions de réinitialisation.
Tout comme les deux cas d’utilisation précédents, cette paire de fonctions démontre une approche modulaire pour gérer les réinitialisations de mots de passe. En gardant les processus de notification et de déclenchement séparés, cette conception rend le système plus facile à maintenir et permet de futures améliorations au flux de travail de réinitialisation de mot de passe.
Vous pouvez appeler ces fonctions depuis la fonction principale pour démonstration, comme ceci :
```python
# Demo of automated transactional emails
if __name__ == "__main__":
register_user("Kirstin", "Kirstin ")
subscribe_user("Jakkie", "Jakkie ")
reset_user_password("Manish", "Manish ")
```
Ces trois exemples montrent comment automatiser les emails transactionnels au sein de votre système. Chacun suit un modèle similaire :
- Une fonction spécifique est créée pour un type particulier de notification (inscription, abonnement ou réinitialisation de mot de passe), qui est déclenchée par l’événement ou le flux de travail correspondant.
- La fonction prépare un message d’email pertinent.
- Une fonction utilitaire distincte (utilisant l’API de Mailgun) est appelée pour envoyer réellement l’email.
Cette approche garantit que les emails transactionnels sont envoyés automatiquement à des moments clés, par exemple lorsqu’un utilisateur s’enregistre, s’inscrit, ou demande à réinitialiser un mot de passe.
Et après avoir déployé ces flux de travail ?
Dans cet article, nous avons détaillé la puissance des emails transactionnels dans la communication avec l’utilisateur. Contrairement aux emails de marketing, ces messages sont déclenchés par des actions spécifiques — comme un achat ou une réinitialisation de mot de passe — et fournissent des informations cruciales et urgentes qui maintiennent les utilisateurs engagés et informés.
Nous avons également couvert la façon d’automatiser ces emails en utilisant des flux de travail d’API, en vous guidant dans la configuration de fonctions pour des choses comme les emails de bienvenue, les confirmations d’abonnement et les réinitialisations de mots de passe. Cette automatisation garantit que vos emails arrivent dans les boîtes de réception au moment précis où vos utilisateurs en ont besoin.
Prêt à rationaliser vos emails transactionnels ? Avec les API robustes et les outils de suivi de Mailgun, vous pouvez facilement automatiser les messages et améliorer l’expérience utilisateur du début à la fin, mais ne nous croyez pas sur parole, vérifiez-le par vous-même.
Comment créer un flux de travail d’API pour automatiser l’email transactionnel ?