Dev Life
Transaktions-E-Mail: Best Practices für Entwickler
Haben Sie eine sofortige Benachrichtigungs-E-Mail erhalten, als Sie etwas online gekauft haben? Das ist im Wesentlichen eine Transaktionsnachricht ist. Transaktionsnachrichten sind automatisierte E-Mails oder Benachrichtigungen, die Sie erhalten, wenn Sie sich für einen Dienst anmelden, einen Kauf tätigen oder ein Passwort zurücksetzen. Dazu gehören auch Betrugswarnungen, Erinnerungen an abgebrochene Einkäufe sowie Zustellungs- und Bank-Updates. Im Gegensatz zu Marketing-E-Mails bestätigen sie Aktionen und halten Sie auf dem Laufenden, was Vertrauen aufbaut und das Nutzer-Engagement fördert.
In diesem Artikel erfahren Sie, wie Sie Transaktionsnachrichten aus Ihrer Anwendung mithilfe von API-Workflows automatisieren können, um das Kundenerlebnis zu verbessern.
Warum ist die Transaktions-E-Mail wichtig für das Kundenerlebnis?
Im Gegensatz zum Massenversand Marketing-E-Mails, sind Transaktionsnachrichten personalisiert, zeitgerecht und erwartet, da sie für die Aktivität des Nutzers hochgradig relevant sind. Diese Nachrichten erfolgen eins-zu-eins und enthalten Informationen, die in direktem Zusammenhang mit den Aktivitäten des Nutzers stehen.
Zeitgerechte Transaktionsnachrichten – wie Bestellbestätigungen und Kontowarnungen – Kundenzufriedenheit steigern, erhöhen die Transparenz und stärken das Vertrauen, indem sie Kundeninteraktionen und potenziellen Betrug effizient behandeln. Sie unterstützen Kunden auch, indem sie Self-Service-Optionen anbieten und den Kundensupport entlasten.
Im Gegensatz zu Werbe-E-Mails, die oft unbemerkt bleiben, werden Transaktions-E-Mails sehnsüchtig erwartet und oft sofort geöffnet; Nutzer begeben sich sogar in ihren Spam-Ordnern auf Schatzsuche, um sie aufzuspüren.
Wie erstellt man einen API-Workflow, um Transaktions-E-Mails zu automatisieren?
In diesem Tutorial erfahren Sie, wie Sie Transaktions-E-Mails aus Ihrer Anwendung senden, indem Sie einfache Workflows einrichten mit Mailgun-APIs. Mailgun ist eine E-Mail-Versandplattform, die es Ihnen ermöglicht, E-Mails zu senden und zu verfolgen. Sie vereinfacht die Automatisierung von Transaktions-E-Mails mit zuverlässigen und benutzerfreundlichen APIs. Sie werden Mailgun verwenden, um Transaktionsnachrichten mit Python in den folgenden Szenarien zu automatisieren:
- Registrierung eines Nutzerkontos
- Double-Opt-in für Newsletter-Abonnements
- Passwort zurücksetzen
Bevor Sie beginnen, stellen Sie sicher, dass Sie über Folgendes verfügen:
- Python 3.9 oder höher
- Ein Mailgun-Konto (die kostenlose 30-Tage-Testversion ist für dieses Tutorial ausreichend)
Richten Sie ein neues Python-Projekt ein
Erstellen Sie zu Beginn ein Verzeichnis für Ihr Python-Projekt und fügen Sie eine leere .env-Datei darin ein.
Bevor Sie fortfahren, empfiehlt es sich als Best Practice, eine neue virtuelle Umgebung zu erstellen und zu aktivieren, um Ihr Projekt zu isolieren und Abhängigkeitskonflikte zu vermeiden.
Sobald Ihre virtuelle Umgebung aktiv ist, installieren Sie die erforderlichen Bibliotheken (requests und python-dotenv), indem Sie Folgendes ausführen:
```python
pip install requests python-dotenv
```
Die requests-Bibliothek ermöglicht es Ihnen, API-Aufrufe zu tätigen, und python-dotenv hilft Ihnen, Ihren API-Schlüssel sicher außerhalb Ihres Codes zu speichern.
Beziehen Sie einen API-Schlüssel
Um API-Aufrufe an Mailgun zu tätigen, benötigen Sie einen API-Schlüssel aus Ihrem Mailgun-Konto.
Melden Sie sich bei Ihrem Mailgun-Konto an und navigieren Sie zur API-Sicherheit Seite. . Sie finden diese unter dem Dropdown-Menü unter Ihrem Namen in der oberen rechten Ecke:
Erstellen Sie einen API-Schlüssel und kopieren Sie ihn dann:
Speichern Sie ihn sicher, indem Sie den Schlüssel in die .env-Datei Ihres Projekts einfügen:
```python
MAILGUN_API_KEY="Your API Key Here"
```
Wenn Sie Mailgun verwenden, beachten Sie Ihre Absenderdomains auf dem Dashboard:
Wenn Sie ein kostenloses Abonnement nutzen, sehen Sie eine Sandbox-Domain, die Sie im API-Endpunkt und als „from“-E-Mail-Adresse verwenden, wenn Sie E-Mails über die Mailgun-APIs senden. Die Sandbox-Domain sieht typischerweise so aus: .mailgun.org.
Module importieren und initialisieren
Um Transaktions-E-Mails zu automatisieren, beginnen Sie mit der Erstellung einer main.py-Datei in Ihrem Projektverzeichnis und fügen Sie den folgenden Code hinzu:
```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 "
```
Die Funktion load_dotenv() aus der python-dotenv-Bibliothek lädt Umgebungsvariablen aus Ihrer .env-Datei in Ihren Python-Code. Dies ist eine Best Practice für die sichere Speicherung und den Zugriff auf sensible Informationen wie Anmeldedaten und API-Schlüssel.
MAILGUN_API_URL legt die API-URL für Ihr Python-Skript fest, während FROM_EMAIL_ADDRESS die E-Mail-Adresse des Absenders angibt (beide müssen Ihre E-Mail-Absenderdomain oder die zuvor erwähnte Sandbox-Domain verwenden).
Senden einer E-Mail über die Mailgun-API
Der folgende Code zeigt Ihnen, wie Sie mithilfe der Mailgun-API eine E-Mail an eine einzelne Adresse senden. Sie sollten diesen Code der zuvor erstellten main.py-Datei unterhalb der Initialisierung hinzufügen:
```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}")
```
Die Funktion _send_email() nimmt drei Argumente entgegen: to_address, subject und message. to_address ist die E-Mail des Empfängers, während subject und message jeweils den Betreff und Inhalt der E-Mail definieren.
Die Funktion liest den Mailgun-API-Schlüssel aus der .env-Datei aus, der dann zur Authentifizierung des API-Aufrufs an die angegebene MAILGUN_API_URL verwendet wird. Dieser Schlüssel identifiziert Ihr Konto eindeutig, sodass Mailgun Ihre Anfrage verifizieren kann.
Um sicherzustellen, dass die E-Mail korrekt gesendet wird, müssen Sie Ihren eindeutigen API-Schlüssel verwenden; die „from“-E-Mail-Adresse muss mit Ihrer gültigen Domain oder der Sandbox-Domain von Mailgun verknüpft sein. Andernfalls schlägt der API-Aufruf fehl und gibt einen Fehler zurück.
Die E-Mail-Daten werden mithilfe der HTTP-POST-Methode über den Aufruf requests.post() gesendet. Wenn der API-Aufruf erfolgreich ist, wird die E-Mail für die Zustellung in die Warteschlange gestellt, und die API gibt den Status HTTP 200 OK zurück. Wenn ein Fehler auftritt, liefert die API eine Fehlernachricht zusammen mit einem entsprechenden HTTP-Statuscode. Beide Szenarien werden von dieser Funktion als Referenz für Sie protokolliert.
Alle Automatisierungen von Transaktions-E-Mails in den folgenden Abschnitten stützen sich auf die Funktion _send_email() , um E-Mails über die Mailgun-API zu senden.
Best Practice: E-Mails zur Kontoregistrierung automatisieren
Die Registrierung von Nutzerkonten ist einer der wichtigsten Anwendungsfälle für Transaktions-E-Mails, da sie als Einstiegspunkt des Nutzers in Ihr System dient. Der erste Eindruck zählt, und diese anfängliche Interaktion ist eine Gelegenheit, Vertrauen aufzubauen und eine positive Beziehung zum Nutzer herzustellen. Eine gut getimte Gratulations-E-Mail bei der Registrierung bestätigt nicht nur den Erfolg des Prozesses, sondern versichert dem Nutzer auch, dass sein Konto einsatzbereit ist.
Um dies zu erreichen, sollte Ihr System sofort eine automatisierte Bestätigungs-E-Mail senden, um den Nutzer wissen zu lassen, dass seine Registrierung erfolgreich war.
Hier ist ein Beispiel, wie man dies implementiert:
```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)
```
Die erste Funktion, _notify_registration(), ist für das Senden einer E-Mail-Benachrichtigung an einen Nutzer verantwortlich, der sich gerade registriert hat. Sie nimmt zwei Parameter entgegen: user_name und user_email. Innerhalb dieser Funktion wird eine einfache HTML-Nachricht konstruiert unter Verwendung eines f-Strings, der das einfache Einfügen des Namens des Nutzers in die Nachricht ermöglicht. Diese Funktion ruft dann die zuvor besprochene Funktion _send_email() auf, um die E-Mail zu senden.
Die zweite Stub-Funktion, register_user(), schlägt den Haupteinstiegspunkt für den Nutzerregistrierungsprozess innerhalb Ihres Systems vor. Sie nimmt ebenfalls user_name und user_email als Parameter entgegen. Im echten Leben würde sie typischerweise mehr Parameter oder „Nutzer“-Objekte mit weiteren Details enthalten. Diese Funktion ist für die Abwicklung des Registrierungsprozesses verantwortlich. Wie hier gezeigt, protokolliert sie den E-Mail-Versand und ruft die Funktion _notify_registration() auf, um die automatisierte Bestätigungs-E-Mail nach Abschluss der Nutzerregistrierung zu initiieren.
Die Nutzerregistrierung dient als Trigger für diese Transaktions-E-Mail, und Sie können diese mithilfe des oben gezeigten API-Workflows automatisieren. Es ist auch eine großartige Chance, Nutzer über Ihre Dienste und wichtigsten Funktionen zu informieren.
Best Practice: Double-Opt-in-Bestätigungs-E-Mails automatisieren
Wenn ein Nutzer Ihren Newsletter abonniert, können Sie ihm, anstatt ihn sofort zu Ihrer Abonnentenliste hinzuzufügen, eine E-Mail senden und ihn bitten, sein Abonnement zu bestätigen. Dieser Prozess, Double-Opt-in-Bestätigung genannt, ist in einigen Ländern aus Gründen der Compliance gesetzlich vorgeschrieben.
Hier fungiert das Abonnement des Nutzers als Trigger, und Sie können die Double-Opt-in-Bestätigung mit dem folgenden Code automatisieren:
```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)
```
Die erste Funktion, _notify_subscription(), ist für das Senden einer Double-Opt-in-Bestätigungs-E-Mail an einen Nutzer verantwortlich, der beantragt hat, einen Newsletter zu abonnieren. Sie nimmt zwei Parameter entgegen: user_name und user_email. Innerhalb dieser Funktion wird eine HTML-Nachricht mithilfe eines f-Strings konstruiert, die den Namen des Nutzers und einen Dummy-Bestätigungslink enthält. Erneut ruft diese Funktion dann die Funktion _send_email() auf, um die E-Mail zu senden.
Die zweite Stub-Funktion, subscribe_user(), ist der Haupteinstiegspunkt für den Nutzer-Abonnementprozess. Sie nimmt ebenfalls user_name und user_email als Parameter entgegen. Diese Funktion verarbeitet in der Regel den anfänglichen Abonnementprozess und speichert wahrscheinlich die Informationen des Nutzers mit dem Status „ausstehend“. Am Ende protokolliert sie den E-Mail-Versand und ruft dann die Funktion _notify_subscription() auf, um die Double-Opt-in-Bestätigungs-E-Mail zu erstellen und zu senden.
Best Practice: E-Mails zum Passwort zurücksetzen automatisieren
Wollten Sie sich schon einmal anmelden, nur um dann festzustellen, dass Sie Ihr Passwort vergessen haben und auf den Link „Passwort vergessen“ klicken müssen? Ein Klick auf diesen Link ist der Trigger für eine E-Mail, auf die Sie sehnsüchtig warten.
Hier ist ein Beispiel-Code, der zeigt, wie diese Art von Transaktions-E-Mail automatisiert wird:
```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)
```
Die Funktion _notify_password_reset() ist für das Erstellen und Senden einer E-Mail an den Nutzer zum Passwort zurücksetzen verantwortlich. Sie nimmt den Namen und die E-Mail-Adresse des Nutzers als Eingaben entgegen. Innerhalb der Funktion wird eine HTML-Nachricht mithilfe eines f-Strings erstellt, die den Namen des Nutzers und eine eindeutige URL zum Passwort zurücksetzen enthält. Die Funktion verwendet dann die Funktion _send_email(), um diese Nachricht in den Posteingang des Nutzers zuzustellen.
Die Funktion reset_user_password() arbeitet parallel dazu als Startpunkt, wenn ein Nutzer sein Passwort zurücksetzen möchte. Sie erfordert ebenfalls den Namen und die E-Mail des Nutzers als Eingaben. Diese Funktion würde normalerweise einige Hintergrundarbeiten erledigen, um das Passwort zurücksetzen vorzubereiten (nicht in diesem Code gezeigt). Sie protokolliert dann den E-Mail-Versand und ruft _notify_password_reset() auf, um die Anweisungen zum Zurücksetzen zu senden.
Ähnlich wie bei den vorherigen zwei Anwendungsfällen demonstriert dieses Funktionspaar einen modularen Ansatz für das Passwort zurücksetzen. Indem die Benachrichtigungs- und Trigger-Prozesse getrennt gehalten werden, macht dieses Design das System wartungsfreundlicher und ermöglicht zukünftige Verbesserungen am Workflow für das Passwort zurücksetzen.
Sie können diese Funktionen zur Demonstration von der Hauptfunktion (Main) aus aufrufen, wie hier:
```python
# Demo of automated transactional emails
if __name__ == "__main__":
register_user("Kirstin", "Kirstin ")
subscribe_user("Jakkie", "Jakkie ")
reset_user_password("Manish", "Manish ")
```
Diese drei Beispiele zeigen, wie Sie Transaktions-E-Mails in Ihrem System automatisieren können. Jedes folgt einem ähnlichen Muster:
- Es wird eine spezifische Funktion für eine bestimmte Art von Benachrichtigung (Registrierung, Abonnement oder Passwort zurücksetzen) erstellt, die durch das entsprechende Ereignis oder den entsprechenden Workflow als Trigger ausgelöst wird.
- Die Funktion bereitet eine relevante E-Mail-Nachricht vor.
- Eine separate Hilfsfunktion (unter Verwendung der Mailgun-API) wird aufgerufen, um die E-Mail tatsächlich zu senden.
Dieser Ansatz stellt sicher, dass Transaktions-E-Mails automatisch in Schlüsselmomenten gesendet werden, z. B. wenn sich ein Nutzer registriert, etwas abonniert oder ein Passwort zurücksetzen anfordert.
Wie geht es weiter, nachdem Sie diese Workflows eingeführt haben?
In diesem Artikel haben wir die Stärke von Transaktions-E-Mails in der Nutzer-Kommunikation analysiert. Im Gegensatz zu Marketing-E-Mails werden diese Nachrichten durch spezifische Aktionen ausgelöst (als Trigger) – wie einen Kauf oder ein Passwort zurücksetzen – und liefern wichtige, zeitkritische Informationen, die die Nutzer bei der Stange halten und informieren.
Wir haben auch behandelt, wie Sie diese E-Mails mithilfe von API-Workflows automatisieren können, und Sie durch die Einrichtung von Funktionen für Dinge wie Willkommens-E-Mails, Abonnement-Bestätigungen und das Passwort zurücksetzen geführt. Diese Automatisierung stellt sicher, dass Ihre E-Mails genau dann im Posteingang landen, wenn Ihre Nutzer sie benötigen.
Sind Sie bereit, Ihre Transaktions-E-Mails zu optimieren? Mit den robusten APIs und Tracking-Tools von Mailgun können Sie Nachrichten einfach automatisieren und das Nutzer-Erlebnis von Anfang bis Ende verbessern, aber verlassen Sie sich nicht nur auf unser Wort, überzeugen Sie sich selbst.
