In modernen E-Commerce-Anwendungen gehen Transaktions-E-Mails über Bestellbestätigungen und Versandaktualisierungen hinaus. Sie reagieren auch auf das Verhalten der Nutzer. Wenn ein Nutzer beispielsweise Artikel in seinen Warenkorb legt, den Kauf aber nicht abschließt, können Sie eine Erinnerung versenden, die gemeinhin als Benachrichtigung über einen „Warenkorbabbruch“ bekannt ist. Dies fördert nicht nur den Abschluss, sondern bietet auch einen hilfreichen Berührungspunkt für den Fall, dass der Nutzer während des Bezahlvorgangs auf Probleme stößt.

In diesem Tutorial (Wissensbibliothek) erfahren Sie, wie Sie mithilfe der Mailgun-APIs eine E-Mail zu einem Warenkorbabbruch an Nutzer versenden.

Um Workflows für Transaktions-E-Mails bei Warenkorbabbrüchen zu implementieren, erstellen Sie eine einfache UI zur Simulation eines Warenkorbs und ein Flask -Backend, um Warenkorbabbrüche zu verfolgen und Transaktions-E-Mails auszulösen.

Bevor Sie beginnen, stellen Sie sicher, dass Sie über Folgendes verfügen:

• Ein Mailgun-Konto um E-Mails über die Mailgun-API zu versenden. Wenn Sie noch kein Konto haben, folgen Sie dem leitfaden für den Schnelleinstieg um kostenlos eines einzurichten
• Python 3.8 oder höher auf Ihrem Computer installiert
• Einige Kenntnisse in HTML und JavaScript, um den UI-Code zu verstehen

Melden Sie sich zunächst bei Ihrem Mailgun-Konto an und notieren Sie sich Ihre Absenderdomain im Mailgun-Dashboard. Wenn Sie ein Free-Abonnement nutzen, sehen Sie eine Sandbox-Domain, die sowohl für den API-Endpunkt als auch für die „from“ -E-Mail-Adresse beim Versand von E-Mails verwendet wird. Die Sandbox-Domain hat folgendes Format: sandbox.mailgun.org:

Hinweis: Wenn Sie E-Mails von Ihrer eigenen individualisierbaren Domain versenden möchten, benötigen Sie ein kostenpflichtiges Mailgun-Abonnement. Das Free-Abonnement unterstützt nur die Sandbox-Domain und begrenzt den Versand auf fünf autorisierte Empfänger.

Als Nächstes müssen Sie auf der Seite API-Sicherheit einen API-Schlüssel erstellen. Sie finden diese Option im Dropdown-Menü unter Ihrem Namen in der oberen rechten Ecke des Mailgun-Dashboards:

Sie verwenden diesen API-Schlüssel in Ihrer Flask-Anwendung, um Benachrichtigungen über Warenkorbabbrüche über die Mailgun-API zu versenden.

Um ein neues Projekt einzurichten, öffnen Sie ein Terminal in Ihrem bevorzugten Projektverzeichnis und führen Sie die folgenden Befehle aus, um den erforderlichen Code – sowohl für die Benutzeroberfläche als auch für das Backend – auf Ihren Computer herunterzuladen:

git clone https://github.com/manishh/gifts-giveaways.git cd gifts-giveaways/python/mailgun-abandoned-cart-notifications

Benennen Sie als Nächstes im Verzeichnis mailgun-abandoned-cart-notifications die Datei .env.example in .env um und aktualisieren Sie sie mit Ihren Mailgun-API-Kundenmeinungen:
# Replace with your actual Mailgun API key and domain MAILGUN_API_KEY="YOUR-API-KEY" MAILGUN_DOMAIN="YOUR-MAILGUN-DOMAIN"

Bevor Sie fortfahren, wird empfohlen, dass Sie eine neue virtuelle Umgebung erstellen und aktivieren, um Ihr Projekt zu isolieren und Abhängigkeitskonflikte zu vermeiden.
Sobald Ihre virtuelle Umgebung aktiv ist, installieren Sie die erforderlichen Abhängigkeiten:
pip install -r requirements.txt
Dadurch werden alle erforderlichen Pakete installiert, einschließlich Flask, dem leichtgewichtigen Web-Framework, auf dem das Backend ausgeführt wird.
Nachdem die Installation abgeschlossen ist, starten Sie die Flask-Anwendung mit diesem Befehl:
python app.py
Die UI der Anwendung ist dann verfügbar unter http://localhost:5000/.

Der Screenshot unten zeigt eine einfache E-Commerce-UI zur Simulation von Warenkorbabbruch-Szenarien. Oben in der Kopfzeile wird der Titel zusammen mit einem Nutzerprofil (das Name und E-Mail anzeigt) und einem Warenkorbsymbol angezeigt, das die Anzahl der Artikel im Warenkorb angibt. Es gibt vier Produktkarten, die Bilder, Namen, Preise und Beschreibungen präsentieren, und Nutzer können Mengen auswählen, bevor sie Artikel mit dem Button In den Warenkorb hinzufügen. Unten links in den Einstellungen können Sie das Timeout für den Warenkorbabbruch (in Sekunden) konfigurieren und den Warenkorb bei Bedarf zurücksetzen. In der Realität würde das Timeout in Stunden gemessen und vom Backend verfolgt werden.
Sie können diese Benutzeroberfläche verwenden, um ein Ereignis auszulösen, wenn ein Nutzer Artikel in seinem Warenkorb belässt, ohne den Kauf abzuschließen:

Den Code für diese Warenkorb-Benutzeroberfläche finden Sie in templates/shopping_cart.html. Diese Datei hat zwei wichtige Abschnitte: die UI-Konfiguration und eine Funktion, um Daten zu Warenkorbabbrüchen an das Backend zu versenden.

Suchen und bearbeiten Sie für die UI-Konfiguration USER_NAME und USER_EMAIL innerhalb des -Tags, um die korrekten Daten an Ihr Backend zu versenden. Diese beiden Parameter repräsentieren den angemeldeten Nutzer in Ihrer E-Commerce-Anwendung:

// Configuration: Replace these with your own values const USER_NAME = "John Smith"; const USER_EMAIL = "john.smith@example.com"; // Verified email for Mailgun sandbox account const BACKEND_URL = 'http://localhost:5000/abandoned-cart'; // Update to your Flask API endpoint, if needed let ABANDONED_CART_TIMEOUT = 60; // Default timeout in seconds

Die folgende JavaScript-Funktion, sendToBackend(data), übernimmt den Prozess des Versands von Details zum Warenkorbabbruch – wie Nutzerinformationen, Artikel im Warenkorb und den Gesamtwert – an das Backend, um eine Benachrichtigung auszulösen:

// Send data to backend function sendToBackend(data) { console.log('Sending abandoned cart data to backend...'); fetch(BACKEND_URL, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify(data) }) .then(response => { // Check if the response status is 200 (OK) if (response.status === 200) { return response.json(); } else { // Throw an error if the status is not 200 throw new Error(`HTTP error! Status: ${response.status}`); } }) .then(result => { console.log('Backend response:', result); alert('Abandoned cart notification sent successfully!'); resetCart(); }) .catch(error => { console.error('Error sending abandoned cart notification:', error); alert('Error sending abandoned cart notification. Check console for details.'); }); }

Diese Funktion sendet zunächst eine HTTP-Artikel-Anfrage (POST) an BACKEND_URL unter Verwendung des fetch-Aufrufs, wodurch die Warenkorbdaten in einen JSON-Payload konvertiert werden.
Wenn der Server erfolgreich antwortet (HTTP 200), wird die Antwort verarbeitet und in der Konsole protokolliert, und ein Alert bestätigt, dass die Benachrichtigung über den Warenkorbabbruch versendet wurde. Der Warenkorb wird dann zurückgesetzt.

Wenn die Anfrage fehlschlägt – aufgrund von Netzwerkproblemen oder einem serverseitigen Problem (wie HTTP-5XX-Fehlern) –, fängt die Funktion den Fehler ab, protokolliert ihn in der Konsole und benachrichtigt den Nutzer mit einem Alert, dass etwas schiefgelaufen ist. Auf diese Weise stellt die Funktion sicher, dass sowohl erfolgreiche als auch fehlgeschlagene Versuche, das Backend zu benachrichtigen, ordnungsgemäß behandelt werden, sodass der Nutzer während des gesamten Prozesses auf dem Laufenden bleibt.

Der verbleibende Code in shopping_cart.html übernimmt das CSS-Styling für ein sauberes und optisch ansprechendes Layout, die JavaScript-Logik zur Berechnung des Gesamtwerts des Warenkorbs sowie die Verwaltung des Timers, um einen Warenkorbabbruch zu simulieren.

Wenn die UI Daten zu Warenkorbabbrüchen als Artikel an die BACKEND_URL sendet, verarbeitet die Flask-Anwendung (app.py) diese mit der folgenden Funktion:
@app.route('/abandoned-cart', methods=['POST']) def abandoned_cart(): """ Endpoint to receive abandoned cart data including user information. Sie versendet eine E-Mail-Benachrichtigung an den betreffenden Nutzer. """ try: # Get cart data from request cart_data = request.json # Extract user information user_info = cart_data.get('user', {}) user_email = user_info.get('email', 'unknown') # Log the received data logger.info(f"Abandoned cart received from {user_email} at {datetime.datetime.now()}, Total items: {len(cart_data.get('items', []))}") # Send email about the abandoned cart html_message = _generate_abandoned_cart_email(cart_data) _send_email(f"{user_info.get('name', user_email)} ", "Your cart is waiting...", html_message) # Return success response return jsonify({ "status": "success", "message": f"Abandoned cart notification sent to: {user_info.get('email')}", "timestamp": datetime.datetime.now().isoformat(), }), 200 except Exception as e: logger.error(f"Error processing abandoned cart: {str(e)}") return jsonify({"status": "error", "message": str(e)}), 500

Dieser API-Endpunkt (/abandoned-cart) lauscht auf Artikel-Anfragen (POST), wenn ein Nutzer seinen Warenkorb verlässt. Er extrahiert die Details zum Warenkorb aus dem JSON-Payload der Anfrage, ruft die E-Mail und den Namen des Nutzers ab und protokolliert das Ereignis zusammen mit dem Zeitstempel und der Anzahl der Artikel.

Als Nächstes wird eine E-Mail generiert unter Verwendung von _generate_abandoned_cart_email(cart_data), wodurch die Details zum Warenkorb in eine saubere HTML-E-Mail-Vorlage konvertiert werden. Die E-Mail wird dann über _send_email() an die user_email versendet, wobei der Betreff „Ihr Warenkorb wartet…“ verwendet wird, um den Nutzer an seinen ausstehenden Kauf (Über uns) zu erinnern.
Wenn dies erfolgreich war, gibt die Funktion eine JSON-Antwort zurück, die bestätigt, dass die E-Mail versendet wurde. Wenn ein Fehler auftritt, wie z. B. ein Problem mit der Anfrage oder dem E-Mail-Service, wird der Fehler protokolliert und eine HTTP 500 Internal Server Error-Antwort zurückgegeben, die die UI verwenden kann, um den Nutzer über den Status der Benachrichtigung zu informieren.

Erinnerungs-E-Mails bei Warenkorbabbrüchen müssen nicht nur informativ, sondern auch optisch ansprechend sein. Eine gut gestaltete HTML-E-Mail mit Bildern präsentiert die Details zum Warenkorb klar und erhöht die Chancen, dass der Nutzer zurückkehrt, um seinen Kauf abzuschließen. Die Funktion _generate_abandoned_cart_email(...) kümmert sich darum:

def _generate_abandoned_cart_email(cart_data: Dict[str, Any]) -> str: """ Generate an HTML email for an abandoned cart using the provided cart data. Args: cart_data: Dictionary containing cart information including user details and items Returns: HTML string for the email """ try: # Extract data with error handling user_name = cart_data.get('user', {}).get('name', 'Valued Customer') first_name = user_name.split()[0] if ' ' in user_name else user_name items = cart_data.get('items', []) total_value = cart_data.get('totalValue', 0) # Format timestamp if available timestamp_str = cart_data.get('timestamp', '') timezone_offset = cart_data.get('timezoneOffset', 0) # Represent the user's time zone if timestamp_str: try: timestamp = datetime.datetime.fromisoformat(timestamp_str.replace('Z', '+00:00')) - datetime.timedelta(minutes=timezone_offset) abandonment_time = f"on {timestamp.strftime('%B %d at %I:%M %p')}" except (ValueError, TypeError): abandonment_time = 'recently' else: abandonment_time = 'recently' # Generate the HTML content with minimal, combined CSS html = f""" /* CSS styling here */

Ihr Warenkorb wartet!

Hallo {first_name},

Wir haben bemerkt, dass Sie {abandonment_time} einige Artikel in Ihrem Warenkorb gelassen haben. Keine Sorge, wir haben sie für Sie gespeichert!

Ihre Warenkorb-Artikel:

""" # Add each item to the email for item in items: item_name = item.get('name', 'Product') item_price = item.get('price', 0) item_quantity = item.get('quantity', 1) item_image = item.get('image', '') item_description = item.get('description', '') # Format image tag with fallback image_tag = f'' if item_image else item_name[0].upper() html += f"""

{image_tag}

{item_name}

{item_description}

Menge: {item_quantity}

${item_price:.2f}

""" # Add total and call to action html += f"""

Gesamt: ${total_value:.2f}

Kauf abschließen

Wenn Sie Fragen (Über uns) zu Ihrer Bestellung haben, zögern Sie bitte nicht, in Kontakt mit unserem Kundenservice-Team zu treten.

Vielen Dank für Ihren Einkauf bei uns!

© 2025 Ihr Unternehmensname. Alle Rechte vorbehalten.

Diese Funktion erstellt eine HTML-E-Mail, die einen Nutzer (Über uns) an seinen abgebrochenen Warenkorb erinnert. Sie extrahiert zunächst wichtige Details aus den bereitgestellten Daten, einschließlich des Namens des Nutzers, der Warenkorb-Artikel und des Gesamtpreises. Wenn ein Zeitstempel verfügbar ist, wird dieser in die Zeitzone des Nutzers konvertiert (da sich Server- und Client-Zeitzonen unterscheiden) und in einen benutzerfreundlichen Datums- und Zeitstring formatiert (wie „am 25. März um 15:49 Uhr“). Andernfalls wird standardmäßig „kürzlich“ verwendet.

Die E-Mail informiert den Nutzer darüber, dass sein Warenkorb gespeichert wurde, und listet die zurückgelassenen Artikel auf, einschließlich Produktname, Menge, Preis, Beschreibung und eines Bildes. Der Gesamtwert des Warenkorbs wird gut sichtbar angezeigt, gefolgt von einem Button Kauf abschließen, um den Nutzer zu ermutigen, zurückzukehren und den Bezahlvorgang abzuschließen.
Wenn ein Fehler auftritt, z. B. fehlende Daten oder Formatierungsprobleme, greift die Funktion auf eine einfache E-Mail mit einer Basic-Nachricht und einem Kauf-Link zurück. Dadurch wird sichergestellt, dass Nutzer selbst dann eine Erinnerung zum Abschluss ihrer Transaktion erhalten, wenn die detaillierte Version fehlschlägt.

Navigieren Sie in Ihrem Mailgun-Konto zu Mailgun Send > Versand > Vorlagen, um Ihre eigenen E-Mail-Vorlagen zu designen:

Sobald der E-Mail-Inhalt generiert ist, muss er zuverlässig zugestellt werden. Die Funktion _send_email(...) übernimmt den Versand von Benachrichtigungen über Warenkorbabbrüche über die Mailgun-API:

def _send_email(to_address: str, subject: str, html_message: str): """ Sends a single email to the given email address using Mailgun API. :param to_address: :param subject: :param message: """ 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": html_message}) if resp.status_code == 200: # Success logging.info(f"Successfully sent an email to '{to_address}' via Mailgun API.") else: # Error raise RuntimeError(f"Could not send the email, reason: {resp.text}")

Diese Funktion liest den MAILGUN_API_KEY und versendet dann eine E-Mail über die Mailgun-API mittels einer HTTP-Artikel-Anfrage (POST). Die Anfrage enthält Essential-E-Mail-Details, einschließlich Absenderadressen, Empfängeradresse, Betreff und des durch die Funktion _generate_abandoned_cart_email(...) generierten HTML-Inhalts.
Wenn die Anfrage erfolgreich ist (resp.status_code == 200), wird eine Erfolgs-Nachricht protokolliert. Andernfalls wird eine Ausnahme mit den Antwort-Details ausgelöst.
Es ist wichtig zu verstehen, dass _send_email(...) Fehler absichtlich nicht behandelt und dies der aufrufenden Funktion (abandoned_cart(), die den Endpunkt /abandoned-cart bedient) überlässt, damit diese Ausnahmen abfangen und eine entsprechende HTTP-Antwort zurückgeben kann. Wenn die E-Mail erfolgreich versendet wurde, gibt abandoned_cart() eine HTTP-200-Antwort zurück, die bestätigt, dass die Benachrichtigung versendet wurde. Wenn ein Fehler auftritt, wie z. B. ein ungültiger API-Schlüssel oder ein Netzwerkausfall, wird eine HTTP-500-Antwort zurückgegeben, um sicherzustellen, dass die Benutzeroberfläche über das Problem informiert wird.

Nachdem Sie nun alle wichtigen Komponenten kennengelernt haben, ist es an der Zeit, den Workflow für E-Mails bei Warenkorbabbrüchen von Anfang bis Ende zu testen.
Stellen Sie zunächst sicher, dass Ihr Flask-Server läuft und die Benutzeroberfläche in Ihrem Browser zugänglich ist unter http://localhost:5000/. Sie können das Timeout für den Warenkorbabbruch in den Einstellungen unten links auf der Seite nach Bedarf anpassen.

Fügen Sie als Nächstes einige Artikel zu Ihrem Warenkorb hinzu. Jedes Mal, wenn Sie einen Artikel hinzufügen, wird der Countdown-Timer des Warenkorbs zurückgesetzt und beginnt von vorn. Wenn Sie fertig sind, klicken Sie auf das Warenkorbsymbol, um das Slide-out-Panel anzuzeigen, in dem die ausgewählten Produkte, deren Preise und der Button Zur Kasse gehen angezeigt werden:

Anstatt mit dem Bezahlvorgang fortzufahren, lassen Sie den Timer seinen Countdown beenden. Sobald der Countdown null erreicht, sollte auf der Benutzeroberfläche ein Alert erscheinen, der bestätigt, dass die Benachrichtigung über den Warenkorbabbruch versendet wurde. Die Alert-Nachricht sollte lauten:
Abandoned cart notification sent successfully!

Gleichzeitig sollte das Terminal Ihrer Flask-App solche Nachrichten protokollieren:
INFO:__main__:Abandoned cart received from at 2025-03-24 14:02:00.077949, Total items: 3 INFO:root:Successfully sent an email to 'Name ' via Mailgun API.

Überprüfen Sie abschließend Ihren Posteingang auf die E-Mail zum Warenkorbabbruch. Wenn alles richtig funktioniert hat, sollten Sie diese Nachricht erhalten:

Hinweis: Wenn Sie das Free-Abonnement von Mailgun nutzen, landet die E-Mail möglicherweise im Spam-Ordner.

Herzlichen Glückwunsch! Sie haben den Workflow zur E-Mail-Benachrichtigung bei Warenkorbabbrüchen mithilfe der Mailgun-API erfolgreich implementiert und getestet.

Sobald Ihre E-Mails zu Warenkorbabbrüchen versendet werden, ist es wichtig, deren Zustellung zu überwachen, die Interaktion zu verfolgen und Ausfälle effektiv zu behandeln. Mailgun bietet integrierte Tools zur Kampagnenübersicht, um versendete E-Mails, Öffnungsraten und Ausfälle zu überwachen.

Um auf diese Ressourcen zuzugreifen, navigieren Sie in Ihrem Mailgun-Dashboard zu Mailgun Send > Kampagnenübersicht > Metriken:

Hier finden Sie eine grafische Aufschlüsselung der wichtigsten E-Mail-Statistiken, wie z. B.:
Gesendete Anzahl: Gesamtanzahl der versuchten E-Mails
Zugestellte Anzahl: E-Mails, die erfolgreich von Empfängern empfangen wurden
Geöffnete Anzahl: Anzahl der E-Mails, die von Empfängern geöffnet wurden (wenn das Tracking der Öffnungsraten aktiviert ist)
Fehlgeschlagene Anzahl: E-Mails, die aufgrund von Problemen wie ungültigen Adressen oder Spamfiltern fehlgeschlagen sind

Für eine tiefergehende Analyse bietet der Tab Protokolle detaillierte Aufzeichnungen über den Status jeder E-Mail, während der Tab Bounce-Klassifizierung Hilfe bei der Diagnose von Fehlern bietet.
Hohe Bounce-Raten können sich negativ auf Ihre E-Mail-Zustellbarkeit auswirken. Um Bounces zu reduzieren, überprüfen Sie regelmäßig den Tab Bounce-Klassifizierung in Mailgun, entfernen Sie ungültige E-Mails und verwenden Sie Unterdrückungslisten, um ein erneutes Versenden an gebouncte Adressen zu vermeiden.

In diesem Tutorial (Wissensbibliothek) haben Sie erfahren, wie Sie mit Mailgun einen E-Mail-Workflow für Warenkorbabbrüche implementieren. Der Prozess umfasste den Aufbau einer einfachen Benutzeroberfläche zur Simulation einer E-Commerce-Website, das Versenden von Warenkorbdaten an das Backend, deren Verarbeitung mit Flask, die Generierung von E-Mail-Vorlagen, den Versand von Benachrichtigungen über die Mailgun-API und das Verfolgen von Zustellungsmetriken. Transaktions-E-Mails wie diese bieten Hilfe dabei, verlorene Verkäufe zurückzugewinnen und die Kundeninteraktion zu verbessern.

Sie finden den gesamten Code für dieses Tutorial (Wissensbibliothek) in diesem GitHub-Repository.

Jetzt können Sie dieses Wissen in die Tat umsetzen – integrieren Sie Mailgun in Ihre Projekte und beginnen Sie mit der Nutzung von Transaktions-E-Mails, um das Nutzererlebnis zu verbessern. Mehr entdecken Vorlagen für Transaktions-E-Mails und die Mailgun-API heute noch kostenlos ausprobieren!

Author: Manish Hatwalne Manish, with over 20 years of diverse coding experience, wears two hats: coder by day, writer by night. His knack lies in demystifying complex concepts and translating "geek speak" into everyday language.