Website-Icon Mailtrap

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

Beatriz Campos
How to Send an Email in Python

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.

Sind Sie bereit, Ihre E-Mails zuzustellen?
Mailtrap kostenlos testen

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:

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

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:

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:

E-Mails kostenlos mit Mailtrap senden

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:

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:

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:

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:

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:

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:

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:

E-Mails kostenlos mit Mailtrap senden

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:

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:

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
  1. 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.
  1. 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:

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.

{
    "smtp_server": "live.smtp.mailtrap.io",
    "smtp_port": 587,
    "login": "ihr_login",
    "password": "ihr_password"
}
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.

E-Mails kostenlos mit Mailtrap testen

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:

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!

Die mobile Version verlassen