So senden Sie E-Mails in Python: SMTP- & E-Mail-API-Methoden erklärt

Dieser Artikel behandelt alles, was Sie über das Senden von E-Mails in Python wissen müssen, einschließlich Codebeispielen, Sicherheit und E-Mail-Tests.

Wenn Sie smtplib konfiguriert haben, gehen Sie direkt zum Senden mit SMTP oder Senden mit E-Mail-API.

Einrichtung von „smtplib“

Das Python-Modul „smtplib“ vereinfacht das Senden von E-Mails direkt aus Ihren Anwendungen heraus und bietet eine unkomplizierte Schnittstelle zur Interaktion mit SMTP-Servern.

Dieser Abschnitt führt Sie durch den Import von „smtplib“, die Erstellung eines SMTP-Objekts für Ihren Server und die Nutzung seiner Kernfunktionen zum Senden von E-Mails. Folgen Sie den Anweisungen, um zu lernen, wie Sie E-Mail-Funktionalitäten in Ihre Python-Skripte integrieren.

Das eingebaute Modul smtplib kann mit der folgenden Anweisung importiert werden:

import smtplib

Um später eine E-Mail zu senden, erstellen Sie ein SMTP-Objekt (Simple Mail Transfer Protocol):

smtpObj = smtplib.SMTP(host, port)

Parameterdetails:

• host − dies ist ein optionales Argument und der Host, auf dem Ihr SMTP-Server läuft. Es kann die IP-Adresse des Hosts oder ein Domainname angegeben werden.
• port − wenn das Argument host angegeben ist, geben Sie einen Port an, an dem der SMTP-Server lauscht.
• local_hostname − wenn der verwendete SMTP-Server auf Ihrer lokalen Maschine läuft, geben Sie localhost an.

Ein SMTP-Objekt hat eine Instanzmethode namens sendmail, die zum Senden einer Nachricht verwendet wird und drei Parameter hat:

• sender − Zeichenkette mit der Adresse des Absenders.
• receivers − Liste von Zeichenketten, eine für jeden Empfänger.
• message − eine Nachricht als Zeichenkette, formatiert wie in RFCs spezifiziert.

smtpObj.sendmail(sender, receivers, message)

Um sicherzustellen, dass das E-Mail-Modul ordnungsgemäß importiert wurde und um die vollständige Beschreibung seiner Klassen und Argumente zu erhalten, geben Sie in einer interaktiven Python-Sitzung Folgendes ein:

help(smtplib)

Lesen Sie die Python-Dokumentation, um die restlichen SMTP-Objekte (z. B. smtp.ehlo; smtp.send_message(msg) usw.) und deren Anwendung weiter zu überprüfen.

Der folgende Abschnitt erklärt, wie Sie E-Mails über Python mit dem E-Mail-Versand von Mailtrap senden, einer Funktion der E-Mail-Zustellungsplattform von Mailtrap. Zuerst behandle ich die SMTP-Methode und zeige später, wie man es mit unserem Python SDK macht.

E-Mails mit SMTP senden

Die Methode ist der oben unter „smtplib“ behandelten sehr ähnlich, Sie müssen jedoch benutzerdefinierte SMTP-Anmeldeinformationen einrichten. Hier gehe ich davon aus, dass Sie sich bereits bei Mailtrap angemeldet und Ihre Domain verifiziert haben.

Falls nicht, lesen Sie unsere detaillierte Anleitung.

Schauen Sie sich auch unsere Videoanleitung an, wie Sie E-Mails in Python mit Mailtrap unter Verwendung von smtplib senden.

Hinweis: Der folgende Code enthält Dummy-Mailtrap-Anmeldeinformationen (außer dem Server-Endpunkt). Stellen Sie sicher, dass Sie diese durch Ihre echten Anmeldeinformationen ersetzen.

Hier ist ein grundlegendes Skript zum Senden von „Nur-Text“-E-Mails mit Python unter Verwendung von Mailtrap SMTP.

import smtplib
from email.mime.text import MIMEText

# Configuration
port = 587
smtp_server = "live.smtp.mailtrap.io"
login = "api"  # Ihr von Mailtrap generierter Login
password = "IhrPasswortVonMailtrap"  # Ihr von Mailtrap generiertes Passwort

sender_email = "mailtrap@beispiel.com"
receiver_email = "neu@beispiel.com"

# Nur-Text-Inhalt
text = """\
Hallo,
Schauen Sie sich den neuen Beitrag im Mailtrap-Blog an:
SMTP-Server zum Testen: Cloud-basiert oder lokal?
https://mailtrap.io/de/blog/cloud-or-local-smtp-server/
Teilen Sie uns gerne mit, welche Inhalte für Sie nützlich wären!
"""

# MIMEText-Objekt erstellen
message = MIMEText(text, "plain")
message["Subject"] = "Nur-Text E-Mail"
message["From"] = sender_email
message["To"] = receiver_email

# Die E-Mail senden
with smtplib.SMTP(smtp_server, port) as server:
    server.starttls()  # Die Verbindung sichern
    server.login(login, password)
    server.sendmail(sender_email, receiver_email, message.as_string())

print('Gesendet')

Kurze Zusammenfassung:

• Importe und Einrichtung – Ich habe die notwendigen Module aus der Standardbibliothek von Python für E-Mails importiert („smtplib“ und „MIMEText“).
• E-Mail-Server-Konfiguration – Die SMTP-Serverdetails einschließlich der Serveradresse, Portnummer und Authentifizierungsdaten.
• E-Mail-Inhalt – Ich habe eine „MIMEText“-Nachricht erstellt, die nur reinen Text enthalten kann. Später zeige ich Ihnen, wie Sie HTML- und Nur-Text-Versionen der E-Mail einfügen können.
• Senden der E-Mail – Ich habe einen Kontextmanager (with-Statement) verwendet, um sicherzustellen, dass die Verbindung zum SMTP-Server nach dem Senden der E-Mail ordnungsgemäß geschlossen wird.

Bonus-Tipp: Das Hartcodieren sensibler Daten wie Anmeldeinformationen und Serverinformationen in Ihrem Skript kann ein Sicherheitsrisiko darstellen. Deshalb empfehle ich die Verwendung von Umgebungsvariablen zur Speicherung sensibler Informationen. Dies macht Ihren Code sicherer und flexibler beim Wechsel zwischen verschiedenen Umgebungen (Entwicklung, Test, Produktion).

Eine HTML-E-Mail senden

Wenn Sie mehr über das Senden von HTML-E-Mails in Python erfahren möchten, lesen Sie unser spezielles Tutorial.

Um das Skript für das Senden von HTML-E-Mails anzupassen (während weiterhin mehrere Empfänger berücksichtigt werden), werde ich anpassen, wie der E-Mail-Textkörper erstellt und angehängt wird. Hier ist das überarbeitete Skript:

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

# Konfiguration
port = 587
smtp_server = "live.smtp.mailtrap.io"
login = "api"  # Ihr von Mailtrap generierter Login
password = "IhrPasswortVonMailtrap"  # Ihr von Mailtrap generiertes Passwort

sender_email = "mailtrap@beispiel.com"
receiver_email = "neu1@beispiel.com"

# E-Mail-Inhalt
subject = "HTML E-Mail ohne Anhang"
html = """\
<html>
  <body>
    <p>Hallo,<br>
    Dies ist eine <b>Test</b>-E-Mail ohne Anhang, gesendet mit <a href="https://www.python.org">Python</a>.</p>
  </body>
</html>
"""

# Eine mehrteilige Nachricht erstellen und Kopfzeilen setzen
message = MIMEMultipart()
message["From"] = sender_email
message["To"] = receiver_email
message["Subject"] = subject

# Den HTML-Teil anhängen
message.attach(MIMEText(html, "html"))

# Die E-Mail senden
with smtplib.SMTP(smtp_server, port) as server:
    server.starttls()
    server.login(login, password)
    server.sendmail(sender_email, receiver_email, message.as_string())

print('Gesendet')

Kurze Zusammenfassung:

• Anhängen des HTML-Inhalts – Der HTML-Inhalt wird an die E-Mail-Nachricht mit „MIMEText(html, “html”)“ anstelle von „MIMEText (text, “plain”)“ angehängt. Indem wir „html“ als zweites Argument angeben, informieren wir den E-Mail-Client, dass dieser Teil der E-Mail als HTML interpretiert werden soll.

E-Mail an mehrere Empfänger senden

Hier werde ich das obige Skript wiederverwenden und anpassen, wie die Adressen der Empfänger gehandhabt werden.

import smtplib
from email.mime.text import MIMEText

# Konfiguration
port = 587
smtp_server = "live.smtp.mailtrap.io"
login = "api"  # Ihr von Mailtrap generierter Login
password = "IhrPasswortVonMailtrap"  # Ihr von Mailtrap generiertes Passwort

sender_email = "mailtrap@beispiel.com"
receiver_emails = ["neu1@beispiel.com", "neu2@beispiel.com", "neu3@beispiel.com"]

# Nur-Text-Inhalt
text = """\
Hallo,
Schauen Sie sich den neuen Beitrag im Mailtrap-Blog an:
SMTP-Server zum Testen: Cloud-basiert oder lokal?
https://mailtrap.io/de/blog/cloud-or-local-smtp-server/
Teilen Sie uns gerne mit, welche Inhalte für Sie nützlich wären!
"""

# MIMEText-Objekt erstellen
message = MIMEText(text, "plain")
message["Subject"] = "Nur-Text E-Mail"
message["From"] = sender_email
# Die Liste der Empfänger-E-Mails zu einer durch Kommas getrennten Zeichenkette verbinden
message["To"] = ", ".join(receiver_emails)

# Die E-Mail senden
with smtplib.SMTP(smtp_server, port) as server:
    server.starttls()  # Die Verbindung sichern
    server.login(login, password)
    server.sendmail(sender_email, receiver_emails, message.as_string())

print('Gesendet')

Kurze Zusammenfassung dessen, was sich vom ursprünglichen „Nur-Text“-Skript unterscheidet:

• Konfiguration für mehrere Empfänger – Ich habe die Variable „receiver_email“ in „receiver_emails“ geändert. Es ist jetzt eine Liste von E-Mail-Adressen anstelle einer einzelnen Zeichenkette.

• Setzen des „An“-Headers – Der „An“-Header im MIMEText-Nachrichtenobjekt wird gesetzt, indem die Liste der Empfänger-E-Mails zu einer einzelnen, durch Kommas getrennten Zeichenkette verbunden wird. Dies ist wichtig, damit der E-Mail-Header alle Empfänger korrekt anzeigt, wenn sie die E-Mail erhalten.
  • Hinweis: Einige E-Mail-Clients (Outlook, Yahoo, Gmail usw.) zeigen möglicherweise alle Empfänger im Feld „An“ für jeden Empfänger an, was aus Datenschutzgründen nicht wünschenswert ist. Sie können dies „beheben“, indem Sie „CC“ und/oder „BCC“ verwenden.

• Mehrere E-Mails gleichzeitig senden – Anstatt die E-Mail einmal zu senden, sendet das Skript nun mehrere E-Mails gleichzeitig, indem es die Liste „receiver_emails“ an die sendmail-Methode übergibt.

E-Mail mit Anhängen senden

Ich werde MIMEMultipart verwenden, da Anhänge eine mehrteilige E-Mail erfordern. Außerdem werde ich die Klasse MIMEBase zum Anhängen von Dateien verwenden. Hier ist das aktualisierte Skript:

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

# Konfiguration
port = 587
smtp_server = "live.smtp.mailtrap.io"
login = "api"  # Ihr von Mailtrap generierter Login
password = "IhrPasswortVonMailtrap"  # Ihr von Mailtrap generiertes Passwort

sender_email = "mailtrap@beispiel.com"
receiver_email = "neu@beispiel.com"  # Einzelner Empfänger

# E-Mail-Inhalt
subject = "E-Mail mit Anhang"
body = "Hallo,\nDies ist eine Test-E-Mail mit Anhang."

# Eine mehrteilige Nachricht erstellen und Kopfzeilen setzen
message = MIMEMultipart()
message["From"] = sender_email
message["To"] = receiver_email
message["Subject"] = subject

# Textkörper zur E-Mail hinzufügen
message.attach(MIMEText(body, "plain"))

# Den Pfad zur Anhangsdatei angeben
filename = "pfad/zu/ihrer/datei.pdf"  # Ändern Sie dies in den korrekten Pfad

# Die Datei im Binärmodus öffnen
with open(filename, "rb") as attachment:
    part = MIMEBase("application", "octet-stream")
    part.set_payload(attachment.read())

# Datei in ASCII-Zeichen kodieren, um sie per E-Mail zu senden
encoders.encode_base64(part)

# Kopfzeile als Schlüssel/Wert-Paar zum Anhangsteil hinzufügen
part.add_header("Content-Disposition", f"attachment; filename= {filename}")

# Anhang zur Nachricht hinzufügen
message.attach(part)

# Die E-Mail senden
with smtplib.SMTP(smtp_server, port) as server:
    server.starttls()
    server.login(login, password)
    server.sendmail(sender_email, receiver_email, message.as_string())

print('Gesendet')

Kurze Zusammenfassung:

• Verwendung von MIMEMultipart – Ich habe von MIMEText für den Textkörper auf MIMEMultipart für die Gesamtstruktur der Nachricht umgestellt. Dies ermöglicht es uns, sowohl den Textteil als auch den Anhang als separate Teile der E-Mail hinzuzufügen.
• Hinzufügen des Anhangs:
  • Dateivorbereitung – Die Anhangsdatei wird im Binärmodus „rb“ geöffnet und ihr Inhalt gelesen.
  • – MIMEBase-Objekt – Für den Anhang wird ein MIMEBase-Objekt erstellt, dessen Typ auf application/octet-stream gesetzt wird. Dieser Typ ist ein generischer Binärstrom, was bedeutet, dass er für jeden Dateityp geeignet ist und E-Mail-Clients ihn typischerweise als Anhang behandeln.
  • – Kodierung – Der Dateiinhalt wird in Base64 kodiert, um sicherzustellen, dass er sicher per E-Mail übertragen werden kann. Dies geschieht mit der Funktion encoders.encode_base64(part).
  • – Hinzufügen von Kopfzeilen – Dem Anhangsteil wird eine Kopfzeile hinzugefügt, um den Dateinamen anzugeben und dass er als Anhang behandelt werden soll (Content-Disposition-Header).
  • – Anhängen der Datei an die Nachricht – Der Anhangsteil wird dann mit message.attach(part) an die Nachricht angehängt.

Eine E-Mail mit einem eingebetteten Bild senden

Um E-Mails mit einem eingebetteten Bild (im HTML-Inhalt) zu senden, werde ich die Klasse MIMEImage verwenden.

Das direkte Einbetten eines Bildes in die E-Mail ermöglicht dessen Anzeige als Teil des E-Mail-Inhalts anstatt als separater Anhang. So geht’s:

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

# Konfiguration
port = 587
smtp_server = "live.smtp.mailtrap.io"
login = "api"  # Ihr von Mailtrap generierter Login
password = "IhrPasswortVonMailtrap"  # Ihr von Mailtrap generiertes Passwort

sender_email = "mailtrap@beispiel.com"
receiver_email = "neu1@beispiel.com"

# HTML-Inhalt mit einem eingebetteten Bild
html = """\
<html>
  <body>
    <p>Hallo,<br>
    Dies ist eine <b>Test</b>-E-Mail mit einem eingebetteten Bild.<br>
    Hier ist ein Bild: <img src="cid:image1">.</p>
  </body>
</html>
"""

# Eine mehrteilige Nachricht erstellen und Kopfzeilen setzen
message = MIMEMultipart()
message["From"] = sender_email
message["To"] = receiver_email
message["Subject"] = "HTML E-Mail mit eingebettetem Bild"

# Den HTML-Teil anhängen
message.attach(MIMEText(html, "html"))

# Den Pfad zu Ihrem Bild angeben
image_path = "pfad/zu/ihrem/bild.jpg"  # Ändern Sie dies in den korrekten Pfad

# Die Bilddatei im Binärmodus öffnen
with open(image_path, 'rb') as img:
    # Die Bilddatei anhängen
    msg_img = MIMEImage(img.read(), name=os.path.basename(image_path))
    # Den Content-ID-Header definieren, der im HTML-Textkörper verwendet werden soll
    msg_img.add_header('Content-ID', '<image1>')
    # Das Bild an die Nachricht anhängen
    message.attach(msg_img)

# Die E-Mail senden
mit smtplib.SMTP(smtp_server, port) als server:
    server.starttls()
    server.login(login, password)
    server.sendmail(sender_email, receiver_email, message.as_string())

print('Gesendet')

Kurze Zusammenfassung:

• Aktualisierung des HTML-Inhalts: Der HTML-Inhalt enthält nun ein <img>-Tag mit einem src-Attribut, das auf die Content-ID (cid) des Bildes verweist, das Sie einbetten möchten. Diese cid muss mit dem Wert des Content-ID-Headers des Bildanhangs übereinstimmen.
• Einbetten des Bildes:
  • Verwendung von MIMEImage – Das Skript enthält nun die Klasse MIMEImage zur Behandlung der Bilddatei. Diese Klasse ist speziell für das Anhängen von Bildern an E-Mails konzipiert.
  • Bilddatei öffnen – Das Bild, das Sie einbetten möchten, wird im Binärmodus geöffnet.
  • MIMEImage-Objekt erstellen – Die Binärdaten des Bildes werden verwendet, um ein MIMEImage-Objekt zu erstellen. Dieses Objekt repräsentiert den Bildanhang.
  • Content-ID-Header – Dem MIMEImage-Objekt wird ein Content-ID-Header zugewiesen, auf den das src-Attribut im <img>-Tag des HTML-Inhalts verweist. Diese Verknüpfung ermöglicht es dem E-Mail-Client, das Bild direkt im E-Mail-Textkörper einzubetten, anstatt es als herunterladbaren Anhang anzuzeigen.
  • Anhängen des Bildes – Das MIMEImage-Objekt wird ähnlich wie andere Teile an die mehrteilige Nachricht angehängt.

Asynchroner E-Mail-Versand

Für den asynchronen E-Mail-Versand benötigen Sie die Python-Bibliothek asyncio zusammen mit aiosmtplib, einem asynchronen SMTP-Client.

Diese Modifikation ermöglicht es Ihrem Skript, E-Mails zu senden, ohne die Ausführung Ihres Programms zu blockieren, was es effizienter macht, insbesondere beim Senden mehrerer E-Mails oder bei gleichzeitiger Ausführung anderer Aufgaben.

Der Einfachheit halber sende ich eine Text/Plain-E-Mail an einen einzelnen Empfänger ohne Anhänge und eingebettete Bilder. So funktioniert es.

Stellen Sie zunächst sicher, dass Sie aiosmtplib installieren.

pip install aiosmtplib

Hier ist nun das Skript:

import asyncio
from email.mime.text import MIMEText
from aiosmtplib import SMTP

async def send_email_async(sender_email, receiver_email, smtp_server, port, login, password, subject, body):
    message = MIMEText(body)
    message["From"] = sender_email
    message["To"] = receiver_email
    message["Subject"] = subject
    
    async with SMTP(hostname=smtp_server, port=port) as smtp:
        await smtp.login(login, password)
        await smtp.send_message(message)

async def main():
    # E-Mail-Konfiguration
    smtp_server = "live.smtp.mailtrap.io"
    port = 587
    sender_email = "mailtrap@beispiel.com"
    receiver_email = "neu@beispiel.com"  # Einzelner Empfänger
    login = "api"  # Ihr von Mailtrap generierter Login
    password = "IhrPasswortVonMailtrap"  # Ihr von Mailtrap generiertes Passwort
    subject = "Test Async E-Mail"
    body = "Dies ist eine reine Text-E-Mail, die asynchron gesendet wurde."
    
    await send_email_async(sender_email=sender_email, receiver_email=receiver_email, smtp_server=smtp_server, port=port, login=login, password=password, subject=subject, body=body)
    print("E-Mail asynchron gesendet.")

if __name__ == "__main__":
    asyncio.run(main())

Kurze Zusammenfassung:

• Definition asynchroner Funktionen: Das Skript definiert nun asynchrone Funktionen mit async def.
• Asynchrone Funktionalität: Unter Verwendung von asyncio und aiosmtplib stellt das Skript eine SMTP-Verbindung asynchron her, meldet sich an und sendet die E-Mail. Dieser Ansatz ermöglicht einen nicht blockierenden E-Mail-Versand, was besonders nützlich in Anwendungen ist, die Reaktionsfähigkeit bei der Durchführung von Netzwerkoperationen aufrechterhalten müssen.
• Ausführen des Skripts: Die asynchrone Funktion main richtet die E-Mail-Details ein und ruft send_email_async auf, um die E-Mail zu senden. Es demonstriert, wie asynchrone Aufgaben in Python effektiv ausgeführt werden, wobei asyncio.run(main()) die asynchrone Ausführung startet.

Massen-E-Mail-Versand

Der obige Code verwendet live.smtp.mailtrap.io, den Endpunkt für transaktionale E-Mails. Aber das E-Mail-Paket der E-Mail-Zustellungsplattform von Mailtrap ermöglicht es Ihnen, Massen-E-Mails über einen separaten Stream bulk.smtp.mailtrap.io unter demselben Plan zu senden.

Jetzt ist das Einzige, was anders ist, der Host (Endpunkt), und Sie müssten Ihr Skript darauf anpassen. Beachten Sie jedoch, dass transaktionale und Massen-E-Mails separate Infrastrukturen haben, auch wenn Ihre Anmeldeinformationen fast identisch sind. Das hilft, die Zustellbarkeit und das E-Mail-Management zu verbessern.

Um die Änderungen zu veranschaulichen, habe ich ein einfaches Skript mit dem angegebenen SMTP-Endpunkt erstellt.

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

# Konfiguration für den Massen-SMTP-Server von Mailtrap
smtp_server = "bulk.smtp.mailtrap.io"
port = 587
login = "api"  # Ihr von Mailtrap generierter Login
password = "IhrPasswortVonMailtrap"  # Ihr von Mailtrap generiertes Passwort

sender_email = "mailtrap@beispiel.com"
receiver_email = "neu@beispiel.com"  # Einzelner Empfänger

# Eine MIMEText-Nachricht für reinen Text erstellen
subject = "Reine Text-E-Mail über Massen-SMTP"
body = "Dies ist eine reine Text-E-Mail, gesendet über den Massen-SMTP-Server von Mailtrap."

# Eine MIMEMultipart-Nachricht erstellen und Kopfzeilen setzen
message = MIMEMultipart()
message["From"] = sender_email
message["To"] = receiver_email
message["Subject"] = subject

# Den Textteil anhängen
message.attach(MIMEText(body, "plain"))

# Die E-Mail senden
with smtplib.SMTP(smtp_server, port) as server:
    server.starttls()  # Die Verbindung sichern
    server.login(login, password)  # Am SMTP-Server anmelden
    server.sendmail(sender_email, receiver_email, message.as_string())  # Die E-Mail senden

print('E-Mail erfolgreich gesendet.')

Kurze Zusammenfassung:

• Verwendung von MIMEMultipart: Obwohl die E-Mail reiner Text ist und an einen einzelnen Empfänger gesendet wird, habe ich die Verwendung von MIMEMultipart beibehalten. Dieser Ansatz bietet Flexibilität, falls Sie in Zukunft Anhänge oder HTML-Inhalte hinzufügen möchten. Sie könnten es jedoch weiter vereinfachen, indem Sie nur MIMEText verwenden.
• Senden der E-Mail: Der Aufruf von server.sendmail ist unkompliziert und gibt den Absender und den Empfänger an und konvertiert das Nachrichtenobjekt in ein Zeichenkettenformat, das gesendet werden soll.

Profi-Tipp: Wenn Sie Umgebungsvariablen oder eine externe Konfigurationsdatei für die SMTP-Anmeldeinformationen verwenden, ist es am besten, separate Dateien für die transaktionale und die Massenkonfiguration zu haben.

E-Mails mit E-Mail-API senden

Um Ihre Integration unkomplizierter zu gestalten, verfügt Mailtrap über ein offizielles Python SDK (siehe GitHub-Link ◀️). Ich werde das verwenden, um Ihnen zu zeigen, wie Sie eine reine Text-E-Mail senden, sie an mehrere Empfänger senden, Massen-E-Mails senden usw.

Hier werde ich die asynchrone E-Mail-Versandmethode nicht behandeln, da Mailtrap sie nicht unterstützt und sie im API-Kontext wenig Sinn ergibt.

Zur Erinnerung: Sie müssen Ihre Domain mit Mailtrap verbinden und verifizieren. Lesen Sie unsere detaillierte Anleitung und eine zusätzliche Videoanleitung dazu.

Sobald das erledigt ist, kehren Sie zu Ihrer Python-App zurück und installieren Sie das offizielle Python SDK von Mailtrap mit dem folgenden Befehl:

pip install mailtrap

Hinweis: Stellen Sie sicher, dass die Paketversion 3.6+ oder höher ist.

Dann sollten Sie das Mail-Objekt erstellen und Variablen (wie E-Mail und Name) mit Ihren Mailtrap-Anmeldeinformationen füllen. Beachten Sie, dass Sie die Adresse mit der verifizierten Sendedomäne darin angeben sollten.

import mailtrap as mt

# Mail-Objekt erstellen
mail = mt.Mail(
    sender=mt.Address(email="mailtrap@beispiel.com", name="Mailtrap Test"),
    to=[mt.Address(email="ihre@email.com")], # Ersetzen Sie dies durch eine echte Empfänger-E-Mail
    subject="Sie sind großartig!",
    text="Glückwunsch zum Senden einer Test-E-Mail mit Mailtrap!",
)

# Client erstellen und senden
client = mt.MailtrapClient(token="ihr-api-key")
client.send(mail)

Sie müssen auch den Client mit Ihrem API-Token erstellen. Gehen Sie zu Ihrem Mailtrap-Konto, indem Sie das Dropdown-Menü „Settings“ (Einstellungen) erweitern und dann den Tab „API Tokens“ (API-Tokens) auswählen. Kopieren Sie die Anmeldeinformationen, indem Sie neben Ihrem Token auf „Kopieren“ klicken.

Dann können Sie den folgenden Befehl verwenden, um die E-Mail zu senden.

# Client erstellen und senden
client = mt.MailtrapClient(token="ihr-api-key")
client.send(mail)

Damit ist das erledigt, und ich zeige Ihnen nun, wie Sie das SDK für verschiedene Anwendungsfälle nutzen können.

Hier ist ein grundlegendes Skript zum Senden einer reinen Text-E-Mail:

from mailtrap import Mail, Address, MailtrapClient

# Ein Mail-Objekt mit grundlegenden Details für eine reine Text-E-Mail erstellen
mail = Mail(
    # Die E-Mail-Adresse des Absenders und optional den Namen angeben
    sender=Address(email="mailtrap@beispiel.com", name="Mailtrap Test"),
    # Einen oder mehrere Empfänger angeben; hier verwenden wir eine Liste mit einem einzelnen Empfänger
    to=[Address(email="ihre@email.com", name="Ihr Name")], # Ersetzen Sie dies
    # Betreff der E-Mail
    subject="Einfache reine Text-E-Mail",
    # Der reine Textinhalt der E-Mail
    text="Dies ist eine reine Text-E-Mail, gesendet mit dem Mailtrap SDK. Einfach und unkompliziert.",
    # Optional: Kategorisieren Sie diese E-Mail zur einfacheren Sortierung oder Verwaltung im Mailtrap-Dienst
    category="Test",
    # Optional: Zusätzliche Header können angegeben werden, sind aber für reine Text-E-Mails nicht erforderlich
    headers={"X-Beispiel-Header": "HeaderWert"}
)

# Den MailtrapClient mit Ihrem API-Token initialisieren
client = MailtrapClient(token="ihr-api-key") # Ersetzen Sie dies

# Die E-Mail mit der send-Methode des Clients senden
client.send(mail)

print("Reine Text-E-Mail erfolgreich gesendet.")

Kurze Zusammenfassung:

• Importieren von Klassen: Nur die Klassen „Mail“, „Address“ und „MailtrapClient“ aus der Mailtrap-Bibliothek werden importiert, da wir uns auf das Senden einer einfachen reinen Text-E-Mail konzentrieren.
• Erstellen des Mail-Objekts:
  • Mail – Der Konstruktor wird verwendet, um ein E-Mail-Objekt zu erstellen.
  • Sender – Verwendet die Klasse „Address“, um die E-Mail und den Namen des Absenders zu definieren.
  • to – Eine Liste von „Address“-Objekten für jeden Empfänger. Für eine reine Text-E-Mail haben Sie hier typischerweise einen oder mehrere direkte Empfänger aufgelistet.
  • subject – Die Betreffzeile der E-Mail.
  • text – Der eigentliche Inhalt der E-Mail im reinen Textformat.
  • category und headers – Optionale Felder, die eine zusätzliche Kategorisierung und benutzerdefinierte Header ermöglichen. Obwohl nicht unbedingt notwendig für das Senden einer reinen Text-E-Mail, können diese für organisatorische oder technische Zwecke innerhalb des Mailtrap-Dienstes oder für die Handhabung durch E-Mail-Clients nützlich sein.
• Senden der E-Mail:
  • Eine Instanz von MailtrapClient wird erstellt und mit einem API-Token authentifiziert.
  • Die send-Methode des MailtrapClient wird dann aufgerufen, wobei das mail-Objekt als Argument übergeben wird, um die E-Mail zu senden.
  • Schließlich wird eine Bestätigungsmeldung ausgegeben, um anzuzeigen, dass die E-Mail gesendet wurde.

Eine HTML-E-Mail senden

Ich werde das Skript anpassen, indem ich den Parameter html im Mail-Objekt mit dem HTML-Inhalt spezifiziere.

from mailtrap import Mail, Address, MailtrapClient

# Ein Mail-Objekt zum Senden einer HTML-E-Mail erstellen
mail = Mail(
    sender=Address(email="mailtrap@beispiel.com", name="Mailtrap Test"),
    to=[Address(email="empfaenger@email.com", name="Name des Empfängers")], # Ersetzen Sie dies
    subject="Ihr HTML-E-Mail-Betreff hier",
    text="Dies ist ein Fallback-Text für E-Mail-Clients, die HTML nicht rendern",
    html="""
    <!DOCTYPE html>
    <html>
        <head>
            <title>E-Mail-Titel</title>
        </head>
        <body>
            <h1>Hallo, Welt!</h1>
            <p>Dies ist eine <strong>HTML-E-Mail</strong>, gesendet vom Mailtrap Python SDK.</p>
            <p>Hier ist ein Link: <a href="https://beispiel.com">Besuchen Sie Beispiel.com</a></p>
        </body>
    </html>
    """,
    # Sie können diese E-Mail kategorisieren oder benutzerdefinierte Header nach Bedarf hinzufügen
    category="HTML E-Mail",
    headers={"X-Custom-Header": "Value"}
)

# Den MailtrapClient mit Ihrem API-Token initialisieren
client = MailtrapClient(token="ihr-api-key") # Ersetzen Sie dies

# Die E-Mail senden
client.send(mail)

print("HTML-E-Mail erfolgreich gesendet.")

Kurze Zusammenfassung:

• HTML-Inhalt: Der Parameter html des „Mail“-Objekts ist der Ort, an dem Sie Ihren HTML-Inhalt einfügen. Dies ist der Teil der E-Mail, der von E-Mail-Clients gerendert wird, die HTML anzeigen können.
• Fallback-Textinhalt: Die reine Textversion des E-Mail-Inhalts dient als Fallback für E-Mail-Clients, die HTML nicht rendern, oder für Benutzer, die reine Text-E-Mails bevorzugen.
• Senden der E-Mail: Nachdem der HTML-Inhalt definiert wurde, bleibt der restliche Prozess zum Senden der E-Mail derselbe.

E-Mail an mehrere Empfänger senden

Ich werde den Empfängerteil der E-Mail-Einrichtung ändern, um mehrere Empfänger einzuschließen.

Das Skript enthält Kommentare, die erklären, wie mehrere Empfänger sowohl für das Feld An als auch für das Hinzufügen von Cc– (Carbon Copy) und Bcc-Empfängern (Blind Carbon Copy) behandelt werden. Daher werde ich in diesem Fall den Abschnitt Kurze Zusammenfassung nicht hinzufügen, da die Methode einfach ist und die Logik im Skript offensichtlich ist.

from mailtrap import Mail, Address, MailtrapClient

# Ein Mail-Objekt erstellen, das auf mehrere Empfänger abzielt, einschließlich Cc- und Bcc-Adressen
mail = Mail(
    # Die E-Mail-Adresse des Absenders und optional den Namen angeben
    sender=Address(email="mailtrap@beispiel.com", name="Mailtrap Test"),
    # Mehrere Empfänger im Feld "An" angeben
    to=[
        Address(email="empfaenger1@email.com", name="Empfänger Eins"),
        Address(email="empfaenger2@email.com", name="Empfänger Zwei"),
    ],
    # usätzlich Empfänger im Feld "Cc" angeben
    cc=[
        Address(email="cc1@email.com", name="Cc Empfänger Eins"),
        Address(email="cc2@email.com", name="Cc Empfänger Zwei"),
    ],
    # Und Empfänger im Feld "Bcc" für versteckte Kopien
    bcc=[
        Address(email="bcc1@email.com", name="Bcc Empfänger Eins"),
        Address(email="bcc2@email.com", name="Bcc Empfänger Zwei"),
    ],
    # Betreff der E-Mail
    subject="E-Mail an mehrere Empfänger",
    # Der reine Textinhalt der E-Mail
    text="Diese E-Mail wird an mehrere Empfänger gesendet, einschließlich Cc- und Bcc-Adressen.",
    # Optional: Kategorisieren Sie diese E-Mail oder fügen Sie benutzerdefinierte Header nach Bedarf hinzu
    category="Massen-E-Mail",
    headers={"X-Custom-Header": "Value"}
)

# Den MailtrapClient mit Ihrem API-Token initialisieren
client = MailtrapClient(token="ihr-api-key")

# Die E-Mail mit der send-Methode des Clients senden
client.send(mail)

print("E-Mail erfolgreich an mehrere Empfänger gesendet.")

Eine E-Mail mit Anhängen senden

Hier werde ich mich hauptsächlich darauf konzentrieren, wie die Klasse Attachment verwendet wird, um Dateien in Ihre E-Mail einzufügen. Dieses Beispiel demonstriert das Anhängen einer generischen Datei, aber der Ansatz ist für jeden Dateityp ähnlich.

from mailtrap import Mail, Address, MailtrapClient, Attachment, Disposition
import base64
from pathlib import Path

# Die Datei vorbereiten, die Sie anhängen möchten
file_path = Path("pfad/zu/ihrer/datei.pdf")  # Aktualisieren Sie dies auf den Pfad Ihrer Datei
file_content = file_path.read_bytes()  # Den Dateiinhalt als Bytes lesen

# Den Dateiinhalt in Base64 kodieren
encoded_content = base64.b64encode(file_content)

# Ein Mail-Objekt mit einem Anhang erstellen
mail = Mail(
    sender=Address(email="mailtrap@beispiel.com", name="Mailtrap Test"),
    to=[Address(email="empfaenger@email.com", name="Name des Empfängers")],
    subject="E-Mail mit Anhang",
    text="Diese E-Mail enthält einen Anhang. Schauen Sie ihn sich an!",
    # Den Anhang definieren
    attachments=[
        Attachment(
            content=encoded_content,  # Der base64-kodierte Inhalt der Datei
            filename=file_path.name,  # Der Name der Datei, wie er in der E-Mail erscheinen soll
            disposition=Disposition.ATTACHMENT,  # Gibt an, dass die Datei ein Anhang ist
            mimetype="application/pdf",  # Der MIME-Typ der Datei
            # `content_id` ist optional und wird normalerweise zum Einbetten von Bildern direkt im HTML-Textkörper verwendet
        )
    ],
)

# Den MailtrapClient mit Ihrem API-Token initialisieren
client = MailtrapClient(token="ihr-api-key") # Ersetzen Sie dies

# Die E-Mail senden
client.send(mail)

print("E-Mail mit Anhang erfolgreich gesendet.")

Kurze Zusammenfassung:

• Vorbereiten der Datei: Das Skript beginnt damit, den Pfad zur anzuhängenden Datei anzugeben und deren Inhalt als Bytes zu lesen. Es ist wichtig, die Datei im Binärmodus zu lesen (Methode „read_bytes()“), um sicherzustellen, dass der Inhalt korrekt kodiert und übertragen wird.
• Base64-Kodierung: Da E-Mail-Protokolle nicht binärsicher sind, muss der Dateiinhalt in Base64 kodiert werden. Diese Kodierung wandelt Binärdaten in ein Textformat um, das sicher per E-Mail übertragen werden kann. Dafür wird die Methode „base64.b64encode“ verwendet.
• Erstellen des Anhangs: Die Klasse „Attachment“ wird mit mehreren Parametern instanziiert:
  • content – Der base64-kodierte Inhalt der Datei.
  • filename – Der Name der Datei, wie er in der E-Mail erscheinen soll.
  • disposition – Dies wird auf Disposition.ATTACHMENT gesetzt, um anzuzeigen, dass die Datei ein Anhang ist (im Gegensatz zu inline, was für eingebettete Bilder verwendet würde).
  • mimetype – Der MIME-Dateityp, der E-Mail-Clients hilft, zu verstehen, wie die Datei zu behandeln ist. Für ein PDF ist dies application/pdf.

Eine E-Mail mit einem eingebetteten Bild senden

Hier werde ich das Bild so anhängen, dass es direkt im HTML-Inhalt der E-Mail angezeigt werden kann. Dies wird normalerweise erreicht, indem das Bild mit einer Content-ID (cid) angehängt wird, auf die im HTML verwiesen werden kann. So geht’s:

from mailtrap import Mail, Address, MailtrapClient, Attachment, Disposition
import base64
from pathlib import Path

# Den Pfad zu Ihrem Bild angeben
image_path = Path("pfad/zu/ihrem/bild.jpg") # Ersetzen Sie dies
image_content = image_path.read_bytes()  # Den Bildinhalt als Bytes lesen

# Den Bildinhalt in Base64 kodieren
encoded_image = base64.b64encode(image_content)

# Ein Mail-Objekt mit HTML-Inhalt und einem eingebetteten Bild erstellen
mail = Mail(
    sender=Address(email="mailtrap@beispiel.com", name="Mailtrap Test"),
    to=[Address(email="empfaenger@email.com", name="Name des Empfängers")], # Ersetzen Sie dies
    subject="E-Mail mit eingebettetem Bild",
    text="Dies ist ein Fallback-Text für E-Mail-Clients, die HTML nicht rendern.",
    html="""
    <!DOCTYPE html>
    <html>
        <body>
            <h1>Hallo, Welt!</h1>
            <p>Diese E-Mail enthält ein eingebettetes Bild.</p>
            <!-- Verwenden Sie „cid:image_cid“ im src-Attribut, um das Bild einzubetten -->
            <img src="cid:image_cid">
        </body>
    </html>
    """,
    attachments=[
        Attachment(
            content=encoded_image,
            filename=image_path.name,
            disposition=Disposition.INLINE,  # Den Anhang als inline markieren
            mimetype="image/jpeg",  # Der MIME-Typ des Bildes
            content_id="image_cid",  # Content-ID, die verwendet wird, um im HTML-src-Attribut auf das Bild zu verweisen
        )
    ],
)

# Den MailtrapClient mit Ihrem API-Token initialisieren
client = MailtrapClient(token="ihr-api-key") # Ersetzen Sie dies

# Die E-Mail senden
client.send(mail)

print("E-Mail mit einem eingebetteten Bild erfolgreich gesendet.")

Kurze Zusammenfassung:

• Bild vorbereiten: Bevor Sie das Bild anhängen, lesen Sie seinen Inhalt als Bytes und kodieren ihn dann in Base64. Diese Kodierung ist notwendig, da E-Mail-Inhalte (einschließlich Anhänge) in einem textbasierten Format übertragen werden müssen.
• HTML-Inhalt: Im Parameter html des Mail-Objekts fügen Sie ein <img>-Tag ein, dessen src-Attribut ein cid:-Schema gefolgt von der Content-ID des Bildanhangs verwendet (image_cid in diesem Fall). Diese cid verknüpft das eingebettete Bild im HTML-Inhalt mit der angehängten Bilddatei.
• Anhängen des Bildes: Das Bild wird mit der Klasse „Attachment“ mit mehreren spezifischen Parametern angehängt:
  • content – Der base64-kodierte Bildinhalt.
  • filename – Der Dateiname des Bildes. Er wird in einigen E-Mail-Clients als Fallback verwendet, wenn das Bild nicht angezeigt werden kann.
  • disposition – Auf Disposition.INLINE gesetzt, um anzuzeigen, dass der Anhang inline mit dem HTML-Inhalt angezeigt werden soll, nicht als separater, herunterladbarer Anhang.
  • mimetype – Gibt den MIME-Typ des Bildes an (z. B. „image/jpeg“). Dies hilft dem E-Mail-Client zu verstehen, wie die Datei zu behandeln ist.
  • content_id – Ein eindeutiger Bezeichner für den Anhang, auf den im HTML-Attribut src verwiesen wird, um das Bild einzubetten.
  • Senden der E-Mail – Der Prozess zum Senden der E-Mail bleibt unverändert.

Massen-E-Mail-Versand

Zur Erinnerung: Die E-Mail-Zustellungsplattform von Mailtrap ermöglicht es Ihnen, zusätzlich zu transaktionalen E-Mails auch Massen-E-Mails unter demselben Plan zu versenden. Sie müssen den Stream auswählen, auf die Schaltfläche API klicken und die Python-Integration auswählen.

Damit ist das erledigt, hier ist, was Sie sonst noch tun müssen.

1. Stellen Sie sicher, dass Sie die Bibliothek „requests“ installiert haben. Falls nicht, können Sie sie mit pip installiere

pip install requests

2. Erstellen Sie eine JSON-Nutzlast, die die Details der E-Mail angibt, und passen Sie das Feld to an, um mehrere Empfänger einzuschließen.

3. Mithilfe der Requests-Bibliothek stellen Sie eine POST-Anfrage an den Mailtrap-Massenversand-API-Endpunkt und geben die erforderlichen Header (einschließlich Autorisierung) und die Nutzlast an. Überprüfen Sie das nachstehende Beispielskript.

import requests
import json

def send_mailtrap_email(payload):
    url = "https://bulk.api.mailtrap.io/api/send"
    headers = {
      "Authorization": "Bearer ihr_api_token",  # Ersetzen Sie dies durch Ihren
      "Content-Type": "application/json"
    }

    response = requests.post(url, headers=headers, data=json.dumps(payload))
    return response.text

payload = {
    "from": {"email": "mailtrap@mailtrapdemo.com", "name": "Mailtrap Test"},
    "to": [{"email": "empfaenger@beispiel.com"}],  # Fügen Sie bei Bedarf weitere Empfänger hinzu
    "subject": "Sie sind großartig!",
    "text": "Glückwunsch zum Senden einer Test-E-Mail mit Mailtrap!",
    "category": "Integrationstest"
}

response_text = send_mailtrap_email(payload)
print(response_text)

Kurze Zusammenfassung:

• payload – Es handelt sich um ein Dictionary, das der von der Mailtrap-Massenversand-API erwarteten JSON-Struktur entspricht. Sie können dieses Dictionary ändern, um die Details Ihrer E-Mail einzuschließen, wie Absender, Empfänger, Betreff und Textkörper.
• send_mailtrap_email – Die Funktion kapselt den Prozess des E-Mail-Versands. Sie nimmt die Nutzlast als Eingabe entgegen, konvertiert sie in das JSON-Format und stellt eine POST-Anfrage an die Mailtrap-Massenversand-API.

Sicherheitsaspekte beim E-Mail-Versand

Wenn Sie planen, den E-Mail-Versand zu automatisieren und regelmäßig an eine große Anzahl von Empfängern zu senden, ist es am besten, zusätzliche Vorsichtsmaßnahmen zu treffen. (Meistens bezogen auf die SMTP-Methode.)

Hier werde ich einige bewährte Methoden behandeln, um das Hartcodieren von Anmeldeinformationen in Ihren Skripten zu vermeiden und Fehler zu behandeln. Beachten Sie, dass die folgenden Tipps unabhängig vom verwendeten E-Mail-Anbieter gelten (SendGrid, SES, Gmail-Konto usw.).

Verwendung von Umgebungsvariablen für sensible Informationen

Umgebungsvariablen sind eine sichere Möglichkeit, Konfigurationseinstellungen und sensible Informationen außerhalb Ihres Anwendungscodes zu verwalten.

In Python können Sie das Modul os verwenden, um auf Umgebungsvariablen zuzugreifen.

import os

smtp_server = os.getenv("SMTP_SERVER", "default.smtp.server")
login = os.getenv("SMTP_LOGIN")
password = os.getenv("SMTP_PASSWORD")

# Example usage in an SMTP connection setup
# smtp.login(login, password)

Bevor Sie Ihr Skript ausführen, setzen Sie die Umgebungsvariablen in Ihrem Betriebssystem. In einem Linux- oder macOS-Terminal können Sie sie beispielsweise vorübergehend wie folgt setzen:

export SMTP_SERVER=live.smtp.mailtrap.io
export SMTP_LOGIN=ihr_login
export SMTP_PASSWORD=ihr_passwort

Unter Windows können Sie sie über die Kommandozeile wie folgt setzen:

set SMTP_SERVER=live.smtp.mailtrap.io
set SMTP_LOGIN=ihr_login
set SMTP_PASSWORD=ihr_passwort

Fehlerbehandlung

So gehen Sie mit unerwarteten Fehlern um, wie z. B. Netzwerkfehlern, Authentifizierungsproblemen oder anderen Ausnahmen, die während des E-Mail-Versands auftreten können.

try:
    # Versuch, eine E-Mail zu senden
    server.sendmail(sender_email, recipient_email, message.as_string())
except smtplib.SMTPException as e:
    print(f"SMTP-Fehler aufgetreten: {e}")
except Exception as e:
    print(f"Ein Fehler ist aufgetreten: {e}")

Verwendung von SSL

Hier ist ein grundlegender Überblick darüber, wie Sie smtplib.SMTP_SSL in einem Skript zum Senden einer E-Mail verwenden könnten:

import smtplib
from email.mime.text import MIMEText


# Konfiguration
port = 465
smtp_server = "live.smtp.mailtrap.io"
login = "benutzername"
password = "passwort"

sender_email = "absender@registrierte_domain.com"
receiver_email = "empfaenger@gmail.com"

text = """\
Hallo,
Teilen Sie uns gerne mit, welche Inhalte für Sie nützlich wären!
"""

message = MIMEText(text, "plain")
message["Subject"] = "Nur-Text E-Mail"
message["From"] = sender_email
message["To"] = receiver_email


with smtplib.SMTP_SSL(smtp_server, port) as server:
    server.login(login, password)
    server.sendmail(sender_email, receiver_email, message.as_string())
    print("E-Mail erfolgreich gesendet!")

Externe Konfiguration

Das Speichern von Konfigurationsdaten (wie SMTP-Serverdetails und E-Mail-Adressen) in externen Dateien oder Umgebungsvariablen erhöht die Sicherheit und Flexibilität Ihres Skripts. Für komplexere Konfigurationen könnten Sie eine JSON-Datei oder Ähnliches in Betracht ziehen.

• Beispiel JSON-Konfiguration (config.json):

{
    "smtp_server": "live.smtp.mailtrap.io",
    "smtp_port": 587,
    "login": "ihr_login",
    "password": "ihr_password"
}

• So laden Sie die Konfiguration:

import json

with open('config.json', 'r') as config_file:
    config = json.load(config_file)

smtp_server = config.get('smtp_server')
smtp_port = config.get('smtp_port')
login = config.get('login')
password = config.get('password')

Tipp: Wenn Sie E-Mails von Ihrem Google-Konto senden und den SMTP-Server von Gmail (smtp.gmail.com) nutzen möchten, haben wir bereits darüber gebloggt. Lesen Sie den Artikel hier.

E-Mails und E-Mail-Versand im Staging testen

Beim Erstellen einer neuen App oder Hinzufügen von Funktionalitäten, insbesondere wenn man es zum ersten Mal macht, ist es unerlässlich, auf einem Testserver zu experimentieren. Hier ist eine kurze Liste von Gründen:

1. Sie werden die Posteingänge Ihrer Freunde und Kunden nicht belästigen. Dies ist unerlässlich, wenn Sie den Massen-E-Mail-Versand testen oder mit einer E-Mail-Datenbank arbeiten.
2. Sie werden Ihren Posteingang nicht mit Test-E-Mails überfluten.
3. Ihre Domain wird nicht wegen Spam auf eine Blacklist gesetzt.

Eine Test-SMTP-Serverumgebung imitiert die Arbeit eines echten Drittanbieter-Webservers. In den folgenden Beispielen verwende ich die Email-Sandbox von Mailtrap, mit denen Entwickler SMTP-Verkehr aus dem Staging erfassen und E-Mails überprüfen und debuggen können, bevor sie an tatsächliche Empfänger gesendet werden.

Darüber hinaus können die E-Mail-Sandbox Ihnen helfen, Ihr HTML/CSS zu validieren, den Inhalt der E-Mail zu analysieren, txt– und Inhaltsvorschauen anzuzeigen und einen relevanten Spam-Score zu ermitteln. Das Tool ist einfach einzurichten; Sie müssen lediglich die von der App generierten Anmeldeinformationen kopieren und in Ihren Code einfügen.

Hinweis: Ich werde SMTP- und API-Methoden separat behandeln. Und wenn Sie ein ausführliches Tutorial zum Testen mit Python wünschen, lesen Sie diesen Artikel.

SMTP

Gehen Sie zu Mailtrap, wählen Sie E-Mail-Sandbox und dann „My Inbox“. Klicken Sie im Tab „SMTP Settings“ auf „Show credentials“, um die Testanmeldeinformationen anzuzeigen.

So sieht es in der Praxis aus:

import smtplib
port = 2525 
smtp_server = "sandbox.smtp.mailtrap.io"
login = "1b2c3d4e5d66f" # Ihr von Mailtrap generierter Login
password = "1b2c3d4e5d66f" # Ihr von Mailtrap generiertes Passwort

Mailtrap macht die Dinge noch einfacher. Gehen Sie zum Abschnitt „Integrations“ im Tab „SMTP settings“ und holen Sie sich die gebrauchsfertige Vorlage der einfachen Textnachricht mit Ihren Mailtrap-Anmeldeinformationen.

Wichtiger Hinweis: Die Snippets verwenden aus Sicherheitsgründen Dummy-Anmeldeinformationen. Bitte stellen Sie sicher, dass Sie Ihre echten Anmeldeinformationen in den Code kopieren und einfügen.

Die grundlegendste Option, um Ihrem Python-Code mitzuteilen, wer was an wen sendet, ist die Instanzmethode sendmail(), die ich hier verwenden werde. Aber wir haben auch Beispiel-Integrationen für Django und Flask.

Schauen wir uns das Beispiel genauer an und fügen eine Fehlerbehandlung hinzu (siehe die #Erklärungen dazwischen). Um Fehler abzufangen, verwenden wir die „try“- und „except“-Blöcke. Eine Liste der Ausnahmen finden Sie in der Dokumentation hier.

# Der erste Schritt ist immer derselbe: Importieren Sie alle notwendigen Komponenten:
import smtplib
from socket import gaierror

# Jetzt können Sie mit Ihrem Code spielen. Definieren wir hier den SMTP-Server separat:
port = 2525 
smtp_server = "sandbox.smtp.mailtrap.io"
login = "1b2c3d4e5d66f" # Fügen Sie Ihren von Mailtrap generierten Login ein
password = "1b2c3d4e5d66f" # Fügen Sie Ihr von Mailtrap generiertes Passwort ein
# Geben Sie die E-Mail-Adressen des Absenders und des Empfängers an
sender = "von@beispiel.com"
receiver = "mailtrap@beispiel.com" # Dies sollte eine Ihrer Test-Inbox-Adressen sein
message = f"""\
Subject: Hallo Mailtrap
To: {receiver}
From: {sender}

Dies ist meine erste Nachricht mit Python."""

try:
    #Senden Sie Ihre Nachricht mit den oben angegebenen
    with smtplib.SMTP(smtp_server, port) as server:
        server.login(login, password)
        server.sendmail(sender, receiver, message)
    # Lassen Sie das Skript berichten, ob Ihre Nachricht gesendet wurde oder welche Fehler behoben werden müssen
    print('Gesendet')
except (gaierror, ConnectionRefusedError):
    print('Verbindung zum Server fehlgeschlagen. Falsche Verbindungseinstellungen?')
except smtplib.SMTPServerDisconnected:
    print('Verbindung zum Server fehlgeschlagen. Falscher Benutzer/Passwort?')
except smtplib.SMTPException as e:
    print('SMTP-Fehler aufgetreten: ' + str(e))

Sobald Sie das Ergebnis Gesendet in der Shell erhalten, sollten Sie Ihre Nachricht in Ihrem Mailtrap-Posteingang sehen:

Wenn Sie lieber in der lokalen Umgebung arbeiten, könnte der lokale SMTP-Debugging-Server eine Option sein. Zu diesem Zweck bietet Python ein smtpd-Modul an. Es verfügt über eine DebuggingServer-Funktion, die von Ihnen gesendete Nachrichten verwirft und auf stdout ausgibt. Es ist mit allen Betriebssystemen kompatibel.

Setzen Sie Ihren SMTP-Server auf localhost:1025

python -m aiosmtpd -n -l localhost:1025

Um den SMTP-E-Mail-Server auf Portnummer 25 auszuführen, benötigen Sie Root-Berechtigungen:

sudo python -m aiosmtpd -n -l localhost:25

Dies hilft Ihnen zu überprüfen, ob Ihr Code funktioniert, und weist auf mögliche Probleme hin, falls vorhanden. Es ermöglicht Ihnen jedoch nicht zu überprüfen, wie Ihre HTML-E-Mail-Vorlage gerendert wird.

API

Sie können unsere API-Dokumentation für vollständige Details zum API-Testen einsehen. Ich werde Python 3 verwenden, um Ihnen die Methode zu zeigen, und Sie Schritt für Schritt anleiten.

1. Stellen Sie eine Verbindung zum API-Endpunkt der E-Mail-Sandbox von Mailtrap her, indem Sie „http.client.HTTPSConnection“ verwenden.
2. Definieren Sie Ihren E-Mail-Inhalt, einschließlich Empfänger (to, cc, bcc), Absender (from), Betreff, Textinhalt und etwaige Anhänge oder benutzerdefinierte Variablen als JSON-Payload.
3. Stellen Sie eine POST-Anfrage an die API der E-Mail-Sandbox von Mailtrap mit Ihrer Payload und den erforderlichen Headern, einschließlich Ihres API-Tokens zur Autorisierung. Hier ist ein Beispiel:

import http.client
import json

def test_send_email():
    conn = http.client.HTTPSConnection("sandbox.api.mailtrap.io")
    
    payload = {
        "to": [{"email": "max_mustermann@beispiel.com", "name": "Max Mustermann"}],
        "cc": [{"email": "erika_mustermann@beispiel.com", "name": "Erika Mustermann"}],
        "bcc": [{"email": "james_doe@beispiel.com", "name": "James Doe"}], # Beispielname beibehalten oder anpassen
        "from": {"email": "vertrieb@beispiel.com", "name": "Beispiel Vertriebsteam"},
        "attachments": [
            {
                "content": "hier_den_base64_kodierten_Inhalt_einfügen",
                "filename": "index.html",
                "type": "text/html",
                "disposition": "attachment"
            }
        ],
        "custom_variables": {"user_id": "45982", "batch_id": "PSJ-12"},
        "headers": {"X-Message-Source": "dev.meinedomain.com"},
        "subject": "Ihre Beispiel-Bestellbestätigung",
        "text": "Herzlichen Glückwunsch zu Ihrer Bestellung Nr. 1234", # Nummer 1234 bleibt eine Ziffer
        "category": "API Test"
    }

    headers = {
        'Content-Type': "application/json",
        'Accept': "application/json",
        'Api-Token': "hier_Ihren_API_Token_einfügen"
    }

    # Den Payload in einen JSON-String umwandeln
    json_payload = json.dumps(payload)

    # Die POST-Anfrage stellen
    conn.request("POST", "/api/send/hier__Ihre_Posteingangs_ID", json_payload, headers)

    # Die Antwort erhalten
    response = conn.getresponse()
    data = response.read()

    print(data.decode("utf-8"))

if __name__ == "__main__":
    test_send_email()

Hinweise:

• Payload: Das Dictionary enthält alle Details der E-Mail, die Sie testen möchten. Stellen Sie sicher, dass Sie Platzhalterwerte durch tatsächliche Daten ersetzen, die für Ihren Testfall relevant sind. Für Anhänge kodieren Sie Ihren Dateiinhalt in Base64 und fügen ihn in das Feld content ein.
• Header: Fügen Sie Ihre Content-Type-, Accept– und Api-Token-Header hinzu. Der Api-Token sollte Ihr Mailtrap-API-Token sein.
• Anfrage und Antwort: Das Skript stellt eine POST-Anfrage an den Endpunkt /api/send/inbox_id und ersetzt inbox_id durch Ihre tatsächliche Posteingangs-ID. Dann liest und druckt es die Antwort, um das Ergebnis zu überprüfen.

Nächste Schritte mit E-Mails in Python

Ich habe die Optionen zum Senden von E-Mails mit Python demonstriert, um die Logik und eine Reihe seiner Fähigkeiten zu beschreiben. Aber ich empfehle, die Python-Dokumentation zu überprüfen und mit Ihrem eigenen Code zu experimentieren, um großartige Ergebnisse zu erzielen!

Es gibt eine Reihe verschiedener Python-Frameworks und -Bibliotheken, die das Erstellen von Apps eleganter und dedizierter machen. Insbesondere einige von ihnen können dazu beitragen, Ihre Erfahrung beim Erstellen von E-Mail-Versandfunktionen zu verbessern.

Die beliebtesten Frameworks sind:

1. Flask, das eine einfache Schnittstelle für den E-Mail-Versand bietet – Flask Mail. Erfahren Sie mehr in unserer Anleitung zum Senden von E-Mails mit Flask.
2. Django kann eine großartige Option zum Erstellen von HTML-Vorlagen sein. Sehen Sie sich auch unser Django E-Mail-Versand-Tutorial an.
3. Zope ist praktisch für die Website-Entwicklung.
4. Marrow Mailer ist ein dediziertes Mail-Delivery-Framework, das verschiedene hilfreiche Konfigurationen hinzufügt.
5. Plotly und sein Dash können beim Versenden von Diagrammen und Berichten helfen.

Viel Glück, und vergessen Sie nicht, beim Senden Ihrer E-Mails auf der sicheren Seite zu bleiben!