Skip to Navigation
In diesem Tutorial behandeln wir anhand von Codebeispielen, wie Sie verschiedene Module in Python verwenden, um diverse Arten von E-Mail-Nachrichten zu erstellen und zu versenden, bestehende Authentifizierungsmethoden zu überprüfen und vieles mehr. Als Beispiel verwenden wir sowohl den Gmail-SMTP-Server als auch die API.
Wenn Sie mehr über andere Methoden zum Senden von E-Mails in Python erfahren möchten, lesen Sie unseren umfassenden Leitfaden.
Einrichtung der Python-Bibliotheken smtplib und email
Um eine E-Mail mit Python über Gmail SMTP zu senden, müssen Sie das Modul smtplib und das Modul email verwenden. Das Modul smtplib stellt im Wesentlichen Funktionen zum Verbinden und Senden von E-Mails über einen SMTP-Server (Simple Mail Transfer Protocol) bereit.
Das Modul email wiederum stellt Klassen zum Erstellen und Analysieren von E-Mail-Nachrichten (An; Von; Betreff; usw.) bereit und ermöglicht das Kodieren und Dekodieren von E-Mails mit dem MIME-Standard (Multipurpose Internet Mail Extensions).
Lassen Sie uns die tatsächlich durchzuführenden Schritte aufschlüsseln. Im folgenden Abschnitt können Sie den tatsächlichen Code überprüfen.
- Importieren Sie die erforderlichen Bibliotheken: smtplib und MIMEText aus dem Modul email.
- Erstellen Sie die E-Mail-Nachricht mit dem MIMEText-Objekt und legen Sie die gewünschten Werte in den Feldern
Betreff,AbsenderundEmpfängerfest. - Stellen Sie die SMTP-Verbindung zum Gmail-Server über eine sichere SSL-Verbindung mit der Funktion SMTP_SSL her.
- Rufen Sie die Methode sendmail des SMTP-Objekts auf und geben Sie die E-Mail-Adressen des Absenders und des Empfängers sowie die E-Mail-Nachricht als Argumente an.
Sobald dies erledigt ist, können Sie E-Mails über Gmail in Python senden. Methodik, Beispiele und andere Anwendungsfälle werde ich in den folgenden Abschnitten behandeln. Falls Sie Ihre Kenntnisse auffrischen müssen, sehen Sie sich vorher diese Python-Onlinekurse an.
E-Mail in Python mit Gmail SMTP senden
Basierend auf dem, was ich im vorherigen Abschnitt behandelt habe, hier ein einfaches Skript zum Senden von E-Mails:
import smtplib
from email.mime.text import MIMEText
subject = "Betreff der E-Mail"
body = "Dies ist der Textkörper der Nachricht"
sender = "absender@gmail.com"
recipients = ["empfaenger1@gmail.com", "empfaenger2@gmail.com"]
password = "Passwort"
def send_email(subject, body, sender, recipients, password):
msg = MIMEText(body)
msg['Subject'] = subject
msg['From'] = sender
msg['To'] = ', '.join(recipients)
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp_server:
smtp_server.login(sender, password)
smtp_server.sendmail(sender, recipients, msg.as_string())
print("Nachricht gesendet!")
send_email(subject, body, sender, recipients, password)Wichtige Hinweise:
Vor dem 30. Mai 2022 war es möglich, sich mit Ihrem regulären Gmail-Passwort mit dem SMTP-Server von Gmail zu verbinden, wenn die Zwei-Faktor-Authentisierung aktiviert war. Für einen höheren Sicherheitsstandard verlangt Google nun die Verwendung eines App-Passworts.
Dies ist ein 16-stelliger Passcode, der in Ihrem Google-Konto generiert wird und es weniger sicheren Apps oder Geräten, die die Bestätigung in zwei Schritten nicht unterstützen, ermöglicht, sich bei Ihrem Gmail-Konto anzumelden.
Alternativ gibt es den OAuth 2.0-Gmail-Authentifizierungsmodus, aber in diesem Fall müssen Sie die Gmail-API-Sendemethode in Ihrem Python-Skript verwenden.
E-Mail an mehrere Empfänger senden
Um die E-Mail an mehrere Empfänger zu senden, definiere ich eine Liste von E-Mail-Adressen, um den Versand an mehrere Empfänger zu ermöglichen. Außerdem legt das Feld An die Empfänger in den Nachrichtenkopfzeilen fest. Es wird von einer Liste in eine durch Kommas getrennte Zeichenkette konvertiert, ein Format, das von den meisten E-Mail-Kopfzeilen akzeptiert wird.
Hier ist der Code:
import smtplib
from email.mime.text import MIMEText
# Betreff und Text der E-Mail definieren.
subject = "Betreff der E-Mail"
body = "Dies ist der Textkörper der Nachricht"
# E-Mail-Adresse des Absenders definieren.
sender = "absender@gmail.com"
# Liste der Empfänger, an die die E-Mail gesendet wird.
recipients = ["empfaenger1@gmail.com", "empfaenger2@gmail.com"]
# Passwort für das E-Mail-Konto des Absenders.
password = "passwort"
def send_email(subject, body, sender, recipients, password):
# Ein MIMEText-Objekt mit dem Text der E-Mail erstellen.
msg = MIMEText(body)
# Den Betreff der E-Mail festlegen.
msg['Subject'] = subject
# Die E-Mail des Absenders festlegen.
msg['From'] = sender
# Die Liste der Empfänger zu einer einzelnen, durch Kommas getrennten Zeichenkette zusammenfügen.
msg['To'] = ', '.join(recipients)
# Über SSL eine Verbindung zum SMTP-Server von Gmail herstellen.
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp_server:
# Sich mit den Anmeldeinformationen des Absenders beim SMTP-Server anmelden.
smtp_server.login(sender, password)
# Die E-Mail senden. Die Funktion sendmail benötigt die E-Mail des Absenders, die Liste der Empfänger und die E-Mail-Nachricht als Zeichenkette.
smtp_server.sendmail(sender, recipients, msg.as_string())
# Druckt eine Nachricht auf der Konsole, nachdem die E-Mail erfolgreich gesendet wurde.
print("Nachricht gesendet!")
# Die Funktion zum Senden der E-Mail aufrufen.
send_email(subject, body, sender, recipients, password)E-Mail mit Anhängen senden
Sie müssen die erforderlichen Bibliotheken importieren. In diesem Fall benötigen Sie auch MIMEBase, mit dem Sie eine Anhangsdatei darstellen können, und encoders, das zum Kodieren des Anhangs im Base64-Format verwendet wird.
Hier ist das vollständige Skript inklusive Kommentaren, die Ihnen helfen zu verstehen, wie man eine E-Mail mit Anhängen sendet:
import smtplib
from email import encoders
from email.mime.base import MIMEBase
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
sender_email = "absender@gmail.com"
sender_password = "passwort"
recipient_email = "empfaenger@gmail.com"
subject = "Hallo von Python"
body = "mit Anhang"
with open("attachment.txt", "rb") as attachment:
# Den Anhang zur Nachricht hinzufügen
part = MIMEBase("application", "octet-stream")
part.set_payload(attachment.read())
encoders.encode_base64(part)
part.add_header(
"Content-Disposition",
f"attachment; filename= 'attachment.txt'",
)
message = MIMEMultipart()
message['Subject'] = subject
message['From'] = sender_email
message['To'] = recipient_email
html_part = MIMEText(body)
message.attach(html_part)
message.attach(part)
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
server.login(sender_email, sender_password)
server.sendmail(sender_email, recipient_email, message.as_string())HTML-E-Mail senden
Genau wie bei einer normalen E-Mail-Nachricht verwenden Sie zum Senden einer HTML-E-Mail über den Gmail-SMTP-Server in Python die Klasse MIMEText aus dem Paket email. Verwenden Sie danach das Objekt html_message anstelle des reinen Textobjekts msg und fügen Sie den HTML-Inhalt in den Körper der E-Mail ein.
Hier ist ein vollständiges Codebeispiel:
import smtplib
from email.mime.text import MIMEText
sender_email = "absender@gmail.com"
sender_password = "passwort"
recipient_email = "empfaenger@gmail.com"
subject = "Hallo von Python"
body = """
<html>
<body>
<p>Dies ist eine <b>HTML</b>-E-Mail, gesendet von Python über den Gmail-SMTP-Server.</p>
</body>
</html>
"""
html_message = MIMEText(body, 'html')
html_message['Subject'] = subject
html_message['From'] = sender_email
html_message['To'] = recipient_email
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
server.login(sender_email, sender_password)
server.sendmail(sender_email, recipient_email, html_message.as_string())Wenn Sie eine E-Mail mit einer HTML-Vorlage senden möchten, anstatt den HTML-Code im Textkörper zu haben, können Sie die Klasse Template aus dem Paket jinja2 verwenden, einer schnellen, ausdrucksstarken und erweiterbaren Template-Engine.
pip install jinja2
Hier ist das Skript für alle erforderlichen Schritte:
import smtplib
from email.mime.text import MIMEText
from jinja2 import Template
sender_email = "absender@gmail.com"
sender_password = "passwort"
recipient_email = "empfaenger@gmail.com"
with open('template.html', 'r') as f:
template = Template(f.read())
context = {
'subject': 'Hallo von Python',
'body': 'Dies ist eine E-Mail, die von Python mit einer HTML-Vorlage und dem Gmail-SMTP-Server gesendet wurde.'
}
html = template.render(context)
html_message = MIMEText(context['body'], 'html')
html_message['Subject'] = context['subject']
html_message['From'] = sender_email
html_message['To'] = recipient_email
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
server.login(sender_email, sender_password)
server.sendmail(sender_email, recipient_email, html_message.as_string())Wenn Sie mehr über das Senden dynamischer Inhalte aus Ihrer Python-Anwendung erfahren möchten, empfehlen wir Ihnen unseren Artikel über Serienbriefe (Mail Merge).
Massen-E-Mails senden
Ich zeige Ihnen, wie Sie Massen-E-Mails über Gmail senden können, aber denken Sie daran, dass dies nur zur Veranschaulichung dient und keine Methode ist, die Sie in der Produktion einsetzen sollten.
Gmail hat ziemlich strenge Richtlinien für das Senden von Massen-E-Mails und Kampagnen, darüber spreche ich in einem späteren Abschnitt (springen Sie dorthin, indem Sie auf den Link klicken). Außerdem könnte Ihre Zustellbarkeit leiden, insbesondere bei einer neuen Domain oder einer relativ niedrigen Domain-Bewertung. Oder wenn Sie einfach versuchen, von einer @gmail.com-Adresse aus zu senden.
Vor diesem Hintergrund ist das folgende Skript auf Szenarien zugeschnitten, in denen jeder Empfänger eine separate, individuelle E-Mail erhalten soll, was bei personalisierten Marketingkampagnen, Benachrichtigungen usw. üblich ist.
Einfach ausgedrückt, dieselbe Nachricht wird an mehrere Personen gesendet, ohne sie in einer einzigen E-Mail zusammenzufassen. Diese Methode vermeidet auch, die Liste der Empfänger untereinander preiszugeben, wodurch die Privatsphäre gewahrt bleibt.
Überprüfen Sie das folgende Skript.
import smtplib
from email.mime.text import MIMEText
# E-Mail-Inhalt
subject = "Betreff der E-Mail"
body = "Dies ist der Textkörper der Nachricht"
sender = "absender@gmail.com"
recipients = ["empfaenger1@gmail.com", "empfaenger2@gmail.com", "empfaenger3@gmail.com"] # Empfängerliste
password = "Passwort"
def send_bulk_emails(subject, body, sender, recipients, password):
# Verbindung zum SMTP-Server von Gmail über SSL herstellen
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp_server:
smtp_server.login(sender, password) # Am Server anmelden
# Jeden Empfänger durchlaufen und ihm eine individuelle E-Mail senden
for recipient in recipients:
msg = MIMEText(body) # MIMEText-Objekt mit dem E-Mail-Text erstellen
msg['Subject'] = subject # Betreff der E-Mail festlegen
msg['From'] = sender # Absender festlegen
msg['To'] = recipient # Aktuellen Empfänger festlegen
smtp_server.sendmail(sender, recipient, msg.as_string()) # Send the email
print(f"Nachricht an {recipient} gesendet!")
# Funktion zum Senden von Massen-E-Mails aufrufen
send_bulk_emails(subject, body, sender, recipients, password)Nun möchte ich Ihnen eine kurze Aufschlüsselung geben, um zu untersuchen, wie das alles funktioniert:
- Bei der Initialisierung definiert das Skript Betreff, Text, E-Mail-Adresse des Absenders, Empfängerliste und Passwort.
- Mit
send_bulk_emailsstellt das Skript eine sichere Verbindung zum SMTP-Server von Gmail auf Port 465 übersmtplib.SMTP_SSLher. Nach dem Herstellen einer Verbindung meldet sich das Skript mit den Gmail-Anmeldeinformationen des Absenders am SMTP-Server an. - Anschließend durchläuft das Skript die Empfänger und führt für jeden Folgendes aus:
- Ein
MIMEText-Objekt wird für den E-Mail-Textkörper erstellt. - Die E-Mail-Header (Betreff, Von, An) werden gesetzt.
Anwird für jeden Empfänger individuell gesetzt, um sicherzustellen, dass jede E-Mail personalisiert ist. - Die E-Mail wird an den aktuellen Empfänger gesendet. Die Methode
Sendmailbenötigt Absender, aktuellen Empfänger und den E-Mail-Inhalt als Argumente.
- Ein
Der Vorteil dieser Methode ist, dass jede Nachricht separat protokolliert oder behandelt wird. Dies hilft, den Erfolg jeder gesendeten E-Mail effizienter zu verfolgen, was für Massenoperationen entscheidend ist.
E-Mail in Python mit der Gmail API senden
Die Gmail API ist eine RESTful API, die es Ihrer Anwendung ermöglicht, E-Mails über die Mailserver von Google zu senden und zu empfangen. Darüber hinaus bietet sie Ihnen die Möglichkeit, Nachrichten abzurufen und zu verwalten sowie Gmail-Funktionen wie Labels, Threads usw. zu nutzen.
Analysieren wir jeden Schritt des Sendens einer E-Mail mit Python über die Gmail API unter Verwendung der OAuth-2.0-Authentifizierung.
- Richten Sie ein Google Cloud Platform-Projekt ein, klicken Sie auf das Hamburger-Menü und wählen Sie „Alle Produkte anzeigen“. Wählen Sie im Verwaltungsbereich „APIs and services“ (APIs und Dienste).
- Wählen Sie als Nächstes „Library“ (Bibliothek), geben Sie „Gmail API“ in die Suchleiste ein und klicken Sie auf die Gmail-API-Karte.
- Wählen Sie schließlich die Schaltfläche zum Aktivieren der Gmail API.
- Nun müssen Sie die Client-Secret-Datei für Ihr Projekt herunterladen. Wählen Sie zunächst „Create Credentials“ (Anmeldedaten erstellen). Wählen Sie in diesem Abschnitt die Gmail API als Ihre bevorzugte API und Benutzerdaten als den Typ der Daten aus, auf die Sie zugreifen möchten.
- Um die OAuth-Client-ID zu erhalten, wählen Sie als Anwendungstyp „Desktop App“, legen Sie den Anwendungsnamen fest und wählen Sie „Erstellen“. Laden Sie anschließend die Anmeldedaten herunter und speichern Sie sie in Ihrem lokalen Dateisystem.
Nach dem Herunterladen der Secret-Datei sollte die Datei dieses Format haben:
{
"installed": {
"client_id": "463220703866-un8ijck75igunsbh4nhclm74edprhj5p.apps.googleusercontent.com",
"project_id": "geocaching-366015",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"token_uri": "https://oauth2.googleapis.com/token",
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"client_secret": "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",
"redirect_uris": [
"http://localhost"
]
}
}Bevor Sie mit dem Code beginnen, müssen Sie die Bibliotheken google-auth, google-auth-oauthlib, google-auth-httplib2 und google-api-python-client mit dem folgenden Befehl installieren:
pip install google-auth google-auth-oauthlib google-auth-httplib2 google-api-python-clientNach erfolgreicher Installation der Bibliotheken erstellen Sie eine Variable namens SCOPES, die eine Liste von Zeichenketten enthält, die die Berechtigungen festlegen, die eine App beim Zugriff auf die Daten eines Benutzers hat.
An dieser Stelle erstellen Sie eine weitere Variable namens flow, die die Klasse InstalledAppFlow verwendet, um einen OAuth-2.0-Flow für eine installierte App zu erstellen, und die OAuth-2.0-Bereiche angibt, die die App in der Variable SCOPES benötigt.
Der Code startet dann den OAuth-2.0-Flow, indem er die Methode run_local_server aufruft und eine Portnummer angibt. Dadurch wird ein lokaler Webserver gestartet, der den Autorisierungsflow abwickelt und die OAuth-2.0-Anmeldeinformationen zurückgibt, wenn der Flow abgeschlossen ist.
Erstellen Sie als Nächstes den Gmail-Dienst, indem Sie die Build-Funktion aus dem Modul googleapiclient.discovery aufrufen, ‘gmail’ als Dienstnamen und ‘v1’ als Version übergeben und die zuvor aufgerufenen Anmeldeinformationen verwenden.
Erstellen Sie nun die E-Mail-Nachricht, indem Sie ein MIMEText-Objekt erstellen und die Felder to und subject auf die gewünschten Werte setzen. Kodieren Sie außerdem die E-Mail-Nachricht als base64-kodierte Zeichenkette.
Schließlich können Sie die E-Mail senden, indem Sie die Methode send der Ressource messages aufrufen und ihr das Wörterbuch create_message als Anforderungstext übergeben.
So sieht der Python-Code aus, wenn all diese Schritte zusammengefügt werden:
import base64
from email.mime.text import MIMEText
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build
from requests import HTTPError
SCOPES = [
"https://www.googleapis.com/auth/gmail.send"
]
flow = InstalledAppFlow.from_client_secrets_file(
'credentials.json', SCOPES)
creds = flow.run_local_server(port=0)
service = build('gmail', 'v1', credentials=creds)
message = MIMEText(''Dies ist der Textkörper der E-Mail')
message['to'] = 'empfaenger@gmail.com'
message['subject'] = 'Betreff der E-Mail'
create_message = {'raw': base64.urlsafe_b64encode(message.as_bytes()).decode()}
try:
message = (service.users().messages().send(userId="me", body=create_message).execute())
print(F'Nachricht gesendet an {message_object}, Nachrichten-ID: {message_object["id"]}') # F-String korrigiert
except HttpError as error:
print(F'Ein Fehler ist aufgetreten: {error}')
message = NoneDas war’s! Mit nur wenigen Codezeilen können Sie Ihrer App eine schnelle E-Mail-Versandfunktion hinzufügen. Und vergessen Sie natürlich nicht, die von Ihren Benutzern gesammelten E-Mail-Adressen zu validieren.
Einschränkungen von Gmail SMTP und API
Die Verwendung der Gmail API oder SMTP ist eine bequeme und zuverlässige Option zur Automatisierung Ihres E-Mail-Versands, hat aber, wie erwähnt, einige Einschränkungen.
- Tägliches Sendelimit und maximale E-Mail-Größenbeschränkung
Um sicherzustellen, dass ein einzelner Benutzer oder eine einzelne Anwendung nicht zu viele Ressourcen verbraucht, begrenzt die API die Anzahl der E-Mails, die Sie täglich senden können, und hat eine maximale E-Mail-Größenbeschränkung. Genaue Zahlen zu diesen Beschränkungen finden Sie in der Dokumentation von Google.
- Eingeschränkte Unterstützung für Funktionen
Die API unterstützt möglicherweise nicht alle Funktionen, die über die Gmail-Weboberfläche verfügbar sind, wie z. B. die Möglichkeit, E-Mails zu einem späteren Zeitpunkt zu senden oder bestimmte Arten von Formatierungen oder Anhängen zu verwenden.
- OAuth scopes control access to user data
Wenn Sie Ihre Anwendung authentifizieren, müssen Sie die entsprechenden OAuth-Bereiche anfordern, um auf die benötigten Daten zugreifen zu können. Der Benutzer muss Ihrer Anwendung dann den Zugriff auf seine Daten gewähren, wobei das Prinzip der geringsten Rechte zu beachten ist und möglicherweise Just-in-Time-Berechtigungen für erhöhte Sicherheit genutzt werden. Ohne die entsprechenden OAuth-Bereiche werden Ihre Anfragen zum Zugriff auf Benutzerdaten abgelehnt und führen zu einem Fehler.
- Kontingent- und Ratenbegrenzungen
Die Gmail API unterliegt einer täglichen Nutzungsbeschränkung, die für alle von Ihrer Anwendung gestellten Anfragen gilt, sowie Ratenbegrenzungen pro Benutzer. Jede Begrenzung wird in Form von Kontingenteinheiten identifiziert, einer abstrakten Maßeinheit, die die Nutzung von Gmail-Ressourcen darstellt.
Beispielsweise verbraucht das Senden einer Nachricht 100 Kontingenteinheiten, während die meisten anderen Aktionen wie das Abrufen einer Nachricht oder das Erstellen eines Entwurfs weitaus weniger Kontingenteinheiten verbrauchen.
- Sendebeschränkungen
Der SMTP-Zugang von Gmail unterliegt strengen Beschränkungen, um Missbrauch zu verhindern und die Dienstverfügbarkeit sicherzustellen. In der Regel sind diese Beschränkungen niedriger als die der Gmail API und schränken Benutzer oft darin ein, weniger E-Mails pro Tag zu senden.
- Anhangsgröße
Wie die API begrenzt auch der SMTP-Dienst die Größe von E-Mail-Anhängen. Die kombinierte E-Mail-Größe (Textkörper und alle Anhänge) darf 25 MB nicht überschreiten.
- Verbindungsdrosselung
Wenn innerhalb kurzer Zeit zu viele Verbindungen oder Authentifizierungsversuche unternommen werden, kann Gmail Ihre Verbindung drosseln und Ihre Fähigkeit, weitere E-Mails zu senden, vorübergehend einschränken. Dies ist Teil der Bemühungen von Gmail, potenziellen Spam oder missbräuchliches Verhalten über SMTP zu erkennen und zu verhindern.
Gibt es eine Alternative zur E-Mail-Infrastruktur von Gmail?
Die kürzere Antwort ist ja.
Es gibt viele Alternativen zur Verwendung des SMTP-Servers von Gmail zum Senden von E-Mails. Sie können jeden anderen E-Mail-Anbieter Ihrer Wahl verwenden. Es ist wichtig sicherzustellen, dass dessen Serverinfrastruktur Ihren Anforderungen und Bedürfnissen entspricht.
Eine weitere Möglichkeit besteht darin, einen externen E-Mail-Dienstanbieter mit einer API zu verwenden, die das Senden von E-Mails von Ihrer eigenen Anwendung über deren Server ermöglicht. Darüber hinaus ist es wichtig, die E-Mail-Versandfunktion in Ihrer App zu testen, bevor Sie sie implementieren.
Hier kommt die E-Mail-Zustellungsplattform von Mailtrap ins Spiel.
Die Plattform bietet den Email API/SMTP-Dienst von Mailtrap, der zur Zustellung von E-Mails verwendet wird und Ihnen mehr Kontrolle über Ihre E-Mail-Infrastruktur gibt, sowie die Email Sandbox von Mailtrap, ein Tool, mit dem diese E-Mails vor dem Versand getestet und debuggt werden können.
Wenn Sie die E-Mail API von Mailtrap mit Ihrer Python-App verwenden möchten, gehen Sie nach der Überprüfung Ihres Domainnamens zum Abschnitt „Sending Domains“ (Sendedomänen) und wählen Sie den Tab „API and SMTP“ (API und SMTP). Wählen Sie im Dropdown-Menü Python aus und kopieren Sie den generierten Code mit Ihren Anmeldeinformationen in Ihr Skript.
Tipp: Sehen Sie sich die offizielle GitHub-Dokumentation zum Python SDK von Mailtrap an.
import requests
url = "https://send.api.mailtrap.io/api/send"
payload = "{\"from\":{\"email\":\"mailtrap@mailtrap.club\",\"name\":\"Mailtrap Test\"},\"to\":[{\"email\":\"empfaenger@beispiel.com\"}],\"subject\":\"Sie sind großartig!\",\"text\":\"Glückwunsch zum Senden der Test-E-Mail mit Mailtrap!\",\"category\":\"Integrationstest\"}"
headers = {
"Authorization": "Bearer 48d3783bde8152*******************",
"Content-Type": "application/json"
}
response = requests.request("POST", url, headers=headers, data=payload)
print(response.text)Sie können auch die SMTP-Methode auswählen und die relevanten Konfigurationen aus der App kopieren. Stellen Sie einfach sicher, dass Sie den richtigen Sende-Stream auswählen – Transaktional oder Massenversand, je nachdem, welche Art von E-Mails Sie senden möchten.
Hier ist ein Beispiel:
import smtplib
from email.mime.text import MIMEText
# Definieren Sie Ihren E-Mail-Inhalt und Ihre Anmeldeinformationen
subject = "Betreff der E-Mail"
body = "Dies ist der Textkörper der E-Mail."
sender_email = "absender@gmail.com"
receiver_email = "empfaenger@gmail.com"
password = "Ihr_Passwort" # Seien Sie vorsichtig mit Passwörtern im Code!
# MIMEText-Objekt erstellen
message = MIMEText(body)
message['Subject'] = subject
message['From'] = sender_email
message['To'] = receiver_email
# Verbindung zum SMTP-Server von Mailtrap herstellen (beachten Sie, dass dies nicht Gmail ist)
with smtplib.SMTP('live.smtp.mailtrap.io', 587) as server: # Beachten Sie die Verwendung von Port 587 für STARTTLS
server.ehlo() # Kann optional aufgerufen werden (wird nach einer Verbindung automatisch aufgerufen)
server.starttls() # Die Verbindung sichern
server.ehlo() # Kann optional aufgerufen werden (identifiziert uns nach STARTTLS erneut beim Server)
server.login(sender_email, password)
server.send_message(message) # Die E-Mail senden
print("E-Mail erfolgreich gesendet!")Hinweise:
- Die Methode
starttls()wird aufgerufen, um das TLS-Upgrade zu initiieren. Nach diesem Aufruf ist die Verbindung verschlüsselt. - Das Beispiel enthält einen einfachen Nachrichtentext; Sie können ihn nach Belieben mit HTML- oder CSS-Stilen erweitern.
E-Mails und E-Mail-Versand im Staging testen
Das Testen der Effektivität Ihrer E-Mails ist entscheidend, um sicherzustellen, dass sie erfolgreich zugestellt und korrekt formatiert werden.
Eine E-Mail-Sandbox bietet eine Reihe von Funktionen, die Ihnen genau dabei helfen. Durch das Erfassen von SMTP-Traffic können Sie E-Mail-Inhalte auf einen Spam-Score analysieren, HTML/CSS validieren, Rohdaten überprüfen und vieles mehr, um sicherzustellen, dass Ihre E-Mails ordnungsgemäß formatiert und erfolgreich zugestellt werden.
Hier verwende ich die Email-Tests von Mailtrap, um Ihnen zu zeigen, wie Sie eine Sandbox über SMTP oder API nutzen können.
SMTP
Die Email-Tests von Mailtrap lassen sich mit nur wenigen Klicks einfach in Ihre Python-App integrieren. Sie müssen lediglich die von der App generierten SMTP-Anmeldeinformationen kopieren und in Ihren Code einfügen.
Wählen Sie dann eines der verfügbaren Python-Codebeispiele unter „Integrations“ (Integrationen) aus und führen Sie es aus, um den Test in Aktion zu sehen. Natürlich kann unser Standard-Codebeispiel an Ihre Bedürfnisse angepasst werden.
API
Wenn Sie QA-Testabläufe automatisieren und mehr Kontrolle über das Testen haben möchten, ist die API für Email-Tests von Mailtrap der richtige Weg.
Hier zeige ich Ihnen, wie Sie alles einrichten, natürlich vorausgesetzt, Sie sind bereits Benutzer. Alle Details finden Sie in unserer offiziellen API-Dokumentation.
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": "base64_encoded_content_here",
"filename": "index.html",
"type": "text/html",
"disposition": "attachment"
}
],
"custom_variables": {"user_id": "45982", "batch_id": "PSJ-12"},
"headers": {"X-Message-Source": "dev.mydomain.com"},
"subject": "Ihre Beispiel-Bestellbestätigung",
"text": "Herzlichen Glückwunsch zu Ihrer Bestellung Nr. 1234",
"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/Posteingangs_ID", json_payload, headers) # Replace 'inbox_id' with your real inbox ID
# Die Antwort erhalten
response = conn.getresponse()
data = response.read()
print(data.decode("utf-8"))
if __name__ == "__main__":
test_send_email()Das obige Skript verbindet sich über http.client.HTTPSConnection mit der API für Email-Tests von Mailtrap. Der E-Mail-Inhalt, einschließlich Betreff, Textinhalt, Empfänger usw., wird als JSON-Payload definiert. Und die POST-Anfrage wird mit dem von Ihnen festgelegten Payload gestellt.
Profi-Tipps:
- Wenn Sie Anhänge hinzufügen möchten, kodieren Sie den Inhalt in Base64 und fügen Sie ihn in das Feld
contentein. - Fügen Sie unter dem Header
Api-TokenIhren tatsächlichen Mailtrap-API-Token ein, den Sie unter Settings > API Tokens (Einstellungen > API-Tokens) finden. - Die POST-Anfrage wird an
/api/send/inbox_idgesendet. Stellen Sie sicher, dass Sieinbox_iddurch Ihre tatsächliche Posteingangs-ID ersetzen, die Sie in der Posteingangs-URL finden.
Zusammenfassung
Wir hoffen, dies hilft Ihnen bei der Entwicklung der E-Mail-Versandfunktionalität in Ihrer App! Denken Sie nur daran, bevor Sie mit dem Erstellen beginnen, recherchieren Sie, welches Python-Framework Sie verwenden möchten, da jedes seine eigenen Funktionen und Vorteile hat:
