LinkedIn
Instagram
WhatsApp
Telegramm
Google Kalender
Slack-Gemeinschaft beitretenIMAP-API in Pythonimaplib, IMAPClient & OAuth XOAUTH2 Leitfaden
Ein umfassender Leitfaden zum Erstellen von Python-IMAP-E-Mail-Clients im Jahr 2026: von den Grundlagen der Standardbibliothek imaplib bis hin zu IMAPClient-Produktionsmustern, OAuth XOAUTH2-Authentifizierung für Gmail und Outlook und wann eine einheitliche E-Mail-API Sie gänzlich vor Komplexität bewahrt.
import imaplib, email
from E-Mail-Kopf import decode_header
# Verbindung mit OAuth XOAUTH2
E-Mail = imaplib.IMAP4_SSL('imap.gmail.com')
Authentifizierungsstring = build_xoauth2(Benutzer, Token)
Post.authentifizieren('XOAUTH2', Lambda x: auth_str)
# Ungelesene Nachrichten abrufen
Post.Auswählen('POSTeingang')
_, ids = Post.Suche(Nichts, 'UNGESEHEN')
für UID in ids[0].trennen():
_, Daten = Post.fetch(uid, '(RFC822)')
Nachricht = E-Mail.Nachricht_von_Bytes(Daten[0][1])Was ist ein IMAP Python Client?
Eine IMAP API Python Ein Client ist jedes Python-Programm, das über das IMAP4-Protokoll (RFC 3501) mit einem Mailserver kommuniziert, um E-Mail-Nachrichten zu lesen, zu durchsuchen, zu organisieren und zu synchronisieren. Im Gegensatz zu SMTP, das nur E-Mails sendet, ermöglicht IMAP Ihrer Anwendung einen bidirektionalen Zugriff auf ein Remote-Postfach: Sie können Header abrufen, Körper lesen, Flags setzen, Nachrichten zwischen Ordnern verschieben und in Echtzeit auf neue Ankünfte lauschen, indem Sie IMAP IDLE verwenden.
IMAP (Internet Message Access Protocol) ist ein Standardprotokoll, mit dem Clients E-Mails auf einem Remote-Server abrufen und verwalten können. Ein Python IMAP-Client stellt eine Verbindung über TLS-Port 993 her, authentifiziert sich (Basic oder OAuth XOAUTH2) und sendet dann IMAP-Befehle, um Nachrichten abzurufen, zu suchen, zu kennzeichnen und zu organisieren. Python bietet drei Abstraktionsebenen: die Standardbibliothek imaplib, die übergeordnete IMAP-Client Wrapper und vollständig asynchrone Optionen wie aioimaplib. Für einen vollständigen Überblick über die IMAP-Architektur und Anwendungsfälle siehe unser IMAP API Entwicklerhandbuch.
Synchronisieren Sie Benutzereingangsordner in Ihr CRM, ATS oder Helpdesk. Python IMAP ermöglicht es Ihnen, neue Nachrichten in Ihre Datenbank abzurufen oder zu pushen (IDLE), ohne einen vollständigen Mailserver verwalten zu müssen.
Extrahieren, klassifizieren und weiterleiten von eingehenden E-Mails mit Python. Ihr IMAP-Client speist eine Verarbeitungswarteschlange: Rechnungsparcing, Ticketerstellung, Lead-Scoring oder LLM-Zusammenfassung.
Testen Sie E-Mail-Zustellungen, erstellen Sie Inbox-Zero-Tools oder überprüfen Sie die Zustellbarkeit. Python IMAP bietet Ihnen programmatischen Zugriff auf dasselbe Postfach, das Ihre Benutzer sehen. Schauen Sie sich unsere an E-Mail-API-Leitfaden für das gesamte Ökosystem.
Die 3 Python IMAP Stack-Optionen
Die Wahl der richtigen Python IMAP-Bibliothek hängt von Ihrem Anwendungsfall ab: einem schnellen Skript, einem Produktionsdienst oder einer asynchronen Pipeline. Hier ist ein Vergleich der Hauptoptionen, bevor wir uns mit Codebeispielen für jede einzelne befassen.
| Bibliothek | Typ | OAuth-Unterstützung | Asynchron | Hilfsfunktionen für die Syntaxanalyse | Am besten für |
|---|---|---|---|---|---|
| imaplib | Stdlib (keine Abhängigkeiten) | Handbuch | Nein | Minimal | Einfache Skripte, keine externen Abhängigkeiten |
| IMAP-Client | Drittanbieter-Wrapper | Handbuch | Nein | Gut | IMAP in der Produktion ohne Asynchronität |
| aioimaplib | Async-Bibliothek | Handbuch | Ja | Begrenzt | asyncio-Pipelines & IDLE in großem Maßstab |
| Unipile APIAm besten | Einheitliches REST/SDK | Eingebaut | Ja | Voll | Groß angelegte Produktion mit mehreren Anbietern |
Vermeiden Sie die IMAP-Komplexität. Unipile abstrahiert imaplib, OAuth und Multi-Provider-Logik in eine einzige REST-API. Eine Integration für Gmail, Outlook und jeden IMAP-Server.
Kostenlos startenSchnellstart: Verbindung zu IMAP mit imaplib
Die Python-Standardbibliothek wird ausgeliefert mit imaplib - keine Installation nötig. Hier ist eine vollständige Anleitung von der Verbindung bis zum Abrufen des Körpers, mit ehrlicher Kommentierung der Schwachstellen.
Verwenden Sie imaplib.IMAP4_SSL auf Port 993 für eine verschlüsselte Verbindung. Für Gmail und Outlook siehe die Serveradressen in unseren IMAP-Server-Verbindungsanleitung. Basic Auth (Passwort) funktioniert für IMAP-Server, die es noch zulassen – aber Gmail und Outlook erfordern jetzt OAuth XOAUTH2 (behandelt in Abschnitt 5).
import imaplib
# Verbindung zu Gmail IMAP (TLS-Port 993)
E-Mail = imaplib.IMAP4_SSL('imap.gmail.com', 993)
# Basisauthentifizierung (nur App-Passwort – OAuth wird bevorzugt)
Post.Anmelden('user@gmail.com', 'App-Passwort')
# Alle Postfächer auflisten
Status, Postfächer = Post.list()
für Kasten in Briefkästen
print(Kasten.dekodieren('utf-8'))
Post.abmelden()Die auswählen() Aufruf öffnet eine Mailbox und gibt die Anzahl der Nachrichten zurück. suchen() liefert einen durch Leerzeichen getrennten Byte-String von Nachrichten-IDs – nicht von UIDs. Sie müssen manuell dekodieren und aufteilen.
# Wähle „Posteingang“ (oder einen beliebigen Ordner)
Status, Anzahl = Post.Auswählen('POSTeingang')
print(Nachrichten: {count[0].decode()}')
# Suche nach ungelesenen Nachrichten
Status, Nachrichten-IDs = Post.Suche(Nichts, 'UNGESEHEN')
IDS = msg_ids[0].trennen()
print(Ungelesene Anzahl: {len(ids)}')
# Suche nach Absender
_, aus_ids = Post.Suche(Nichts, 'VON', 'boss@company.com')
# Suche nach Datumsbereich
kürzlich = Post.Suche(Nichts, 'seit', '01. Januar 2026')Dies ist der Ort, an dem imaplib wird unübersichtlich. Die rohe Antwort ist eine Liste von Tupeln, die Bytes enthalten. Sie müssen indizieren daten[0][1] um die Rohnachricht zu erreichen, dann gib sie an die E-Mail Modul zum Parsen. Header sind RFC 2047-kodiert und erfordern decode_header().
import E-Mail
from E-Mail-Kopf import decode_header
def decode_str(Wert):
"""RFC 2047 kodierte Kopfzeilenwerte dekodieren."""
Teile = decode_header(Wert)
dekodiert = []
für Teil, verschlüsseln in Teile:
wenn isinstanceTeil, Bytes):
dekodiert.anhängenTeil.dekodierenVerschlüsselt oder 'utf-8', Fehler='ersetzen'))
sonst:
dekodiert.anhängenTeil
return ' '.beitretendekodiert
für UID in ids[-5:]: # – die letzten 5 Nachrichten
_, Daten = Post.fetch(uid, '(RFC822)')
roh = Daten[0][1] Die Qualen beim Entpacken von #-Tupeln
Nachricht = E-Mail.Nachricht_von_Bytes(roh)
Thema = decode_str(Nachricht['Betreff'] oder '')
Absender = decode_str(Nachricht['Von'] oder '')
# Walk MIME-Teile für den Klartext-Body
wenn Nachricht.ist_multipart():
für Teil in Nachricht.gehen():
wenn Teil.get_content_type() == 'text/plain':
Körper = Teil.Nutzlast_abrufen(dekodieren=Wahr).dekodieren('utf-8', Fehler='ersetzen')
print(Von: {sender} | Betreff: {subject}')Die Schmerzpunkte von imaplib: rohe Byte-Antworten erfordern sorgfältige Tupelindizes (daten[0][1]), Header sind RFC 2047-kodiert und benötigen decode_header(), mehrteilige MIME-Nachrichten erfordern eine vollständige laufen(), und es gibt keine integrierten Hilfen für UIDs im Vergleich zu Sequenznummern. Für Produktions-Workloads sollten Sie IMAPClient (Abschnitt 4) oder eine einheitliche IMAP-API stattdessen.
Weiterführende Informationen: IMAPClient für den produktiven Einsatz
Sobald Sie mit imaplib in die Produktion gehen, werden Sie schnell dessen fragile Antwortanalyse, inkonsistente UID-Verwaltung und das Fehlen von Hilfsfunktionen für gängige Aufgaben feststellen. IMAPClient ist ein Python-kompatibler Wrapper, der diese Schwachstellen ausbessert, während er eng an der IMAP-Spezifikation bleibt.
daten[0][1]uid() Wrapper manuelluse_uid=True)suchen(), holen(), beweg dich, Kopie() APIleer() / idle_check()from imapclient import IMAP-Client
import schön drucken
# Verbindung mit IMAPClient herstellen (standardmäßig use_uid=True)
Server = IMAP-Client('imap.gmail.com', ssl=Wahr, Benutzer-ID verwenden=Wahr)
Server.Anmelden('user@gmail.com', 'App-Passwort')
# Auswählen und suchen
Server.Ordner auswählen('POSTeingang')
messages = Server.Suche(['UNGESEHEN'])
print({len(messages)} ungelesene Nachrichten')
# Fetch – gibt ein strukturiertes Wörterbuch zurück, keine rohen Bytes
response = Server.fetch(Nachrichten[:10], ['Umschlag', 'BODY[]', 'FLAGGEN'])
für uid, Daten in Antwort.Artikel():
Umschlag = Daten[ENVELOPE']
print(UID {uid}: {envelope.Betreff}')
# Nachrichten in Ordner verschieben
Server.bewegen(Nachrichten[:5], 'Archiv')
# IDLE – auf neue Nachrichten warten (bis zu 29 Minuten bei Gmail)
Server.Leerlauf()
Antworten = Server.Leerlaufprüfung(timeout=60)
print('IDLE-Antwort:', Antworten)
Server.idle_done()
Server.abmelden()Selbst IMAPClient erfordert manuelles OAuth-Token-Management und die Handhabung mehrerer Anbieter. Unipile abstrahiert all dies – OAuth-Aktualisierungen, Anbieter-Eigenheiten, IDLE-Wiederverbindungen – hinter einer einzigen REST-API. Sehen Sie sich unsere vollständige E-Mail-API-Leitfaden.
Bauen Sie es mit UnipileOAuth XOAUTH2 in Python: Gmail und Microsoft 365
Die grundlegende Passwortauthentifizierung ist für große Anbieter tot. Gmail hat sie für Standardkonten seit Mai 2022 blockiert. Microsoft 365 hat die Basisauthentifizierung für IMAP im September 2024 eingestellt. XOAUTH2 (ein OAuth 2.0 SASL-Mechanismus) ist nun der einzig produktionsreife Weg, um einen Python IMAP-Client zu authentifizieren. Eine vollständige Erklärung des OAuth-Flows finden Sie in unserem OAuth E-Mail-API-Leitfaden.
XOAUTH2 ist ein SASL-Authentifizierungsmechanismus, der ein OAuth-Bearer-Token in einen Base64-String mit dem Format enkodiert: Benutzer={email}\x01auth=Bearer {token}\x01\x01. Dieser String wird an imaplib.IMAP4_SSL.authenticate('XOAUTH2', callback). Der Callback gibt den Base64-codierten String zurück. Sie sind dafür verantwortlich, das OAuth-Zugangstoken über die Google- oder Microsoft-Identitätsendpunkte zu erhalten und zu aktualisieren, bevor Sie die IMAP-Verbindung herstellen. Die erforderlichen Gmail-Scopes finden Sie in unseren Leitfaden zu Gmail API-Umfängen.
Google Mail
Microsoft 365
import imaplib, base64, json
from google.oauth2.anmeldeinformationen import Berechtigungsnachweise
from google.auth.transport.requests import Anfrage
def build_xoauth2_string(benutzer_email, zugriffstoken)
"Erstellen Sie eine XOAUTH2 SASL-Zeichenfolge für die IMAP-Authentifizierung."
auth_string = f'user={user_email}\x01auth=Bearer {access_token}\x01\x01'
return Base64.b64encode(auth_string.kodieren('ASCII'))
def get_valid_token(creds_dict):
"Aktualisieren Sie das Token, falls es mit der google-auth-Bibliothek abgelaufen ist."
Referenzen = Zugangsdaten.vom_autorisierten_benutzer_info(creds_dict)
wenn Guthaben.abgelaufen und creds.aktualisierungstoken:
Guthaben.auffrischen(Anfrage())
return credits.token
# Erforderlicher IMAP-Bereich für Gmail: https://mail.google.com/
Benutzer-E-Mail = 'user@gmail.com'
Zugriffstoken = get_valid_token(creds_dict)
E-Mail = imaplib.IMAP4_SSL('imap.gmail.com')
auth_string = build_xoauth2_string(benutzer_email, zugriffstoken)
Post.authentifizieren('XOAUTH2', Lambda x: auth_string)
# Jetzt wie gewohnt verwenden
Post.Auswählen('POSTeingang')
_, ids = Post.Suche(Nichts, 'ALLE')
print(Gesamtzahl der Nachrichten: {len(ids[0].split())}')https://mail.google.com/ Umfang (nicht gmail.readonly allein – dieser Geltungsbereich gewährt keinen IMAP-Zugriff). Siehe unsere Leitfaden zu Gmail API-Umfängen für eine vollständige Aufschlüsselung. Sie müssen außerdem IMAP in den Gmail-Einstellungen aktivieren und eine Google Cloud OAuth 2.0 Client-ID mit der korrekten Weiterleitungs-URI verwenden.
import imaplib, base64
import msal
def build_xoauth2_string(benutzer_email, zugriffstoken)
auth_string = f'user={user_email}\x01auth=Bearer {access_token}\x01\x01'
return Base64.b64encode(auth_string.kodieren('ASCII'))
# MSAL – Microsoft-Authentifizierungsbibliothek für Python
CLIENT_ID = 'ihre-azure-app-client-id'
Mieter-ID = 'deine-mandanten-id'
#-Scope für den IMAP-Zugriff (Outlook / Microsoft 365)
Umfang = ['https://outlook.office365.com/IMAP.AccessAsUser.All']
app = msal.ÖffentlicheClientAnwendung(CLIENT_ID, Autorität=https://login.microsoftonline.com/{TENANT_ID}')
# Token abrufen (interaktiv oder über ein Refresh-Token)
Ergebnis = App.acquire_token_by_authorization_code(code, scopes=SCOPE, redirect_uri=redirect_uri)
Zugriffstoken = Ergebnis['Zugriffstoken']
# Verbindung zu Outlook IMAP über XOAUTH2 herstellen
Benutzer-E-Mail = 'user@outlook.com'
E-Mail = imaplib.IMAP4_SSL('outlook.office365.com')
auth_string = build_xoauth2_string(benutzer_email, zugriffstoken)
Post.authentifizieren('XOAUTH2', Lambda x: auth_string)
Post.Auswählen('POSTeingang')OAuth XOAUTH2 ist 50+ Zeilen pro Anbieter. Unipile kümmert sich um Token-Aktualisierung, XOAUTH2-Handshake und anbieterspezifische Eigenarten, damit sich Ihr Python-Code auf die Geschäftslogik konzentrieren kann – nicht auf die Authentifizierungs-Infrastruktur.
Erstellen Sie Ihren OAuth-FlowMulti-Anbieter-Realitätsprüfung
Jeder Anbieter hat seine eigenen Besonderheiten bei der Authentifizierung, Serveradressen und Ratenbegrenzungen. Hier ist, was Ihr Python IMAP-Client für jeden einzeln behandeln muss. Server-Hostnamen und TLS-Portdetails finden Sie in unserem separaten IMAP-Server-Verbindungsanleitung.
https://mail.google.com/
IMAP.ZugriffAlsBenutzer.Alle
Die Unterstützung mehrerer Anbieter bedeutet, separate Authentifizierungsabläufe, Serverkonfigurationen und Workarounds für Eigenheiten zu pflegen. Unipile normalisiert Gmail, Outlook und jeden IMAP-Server zu einer einzigen API. Lesen Sie unsere Vergleich von E-Mail-API-Anbietern zum Kontext.
Multi-Provider-E-Mail erstellenWann Sie IMAP komplett überspringen sollten: Unifizierter API-Ansatz
Nachdem man sich mit imaplib, IMAPClient und XOAUTH2 auseinandergesetzt hat, wird eine einzige Wahrheit deutlich: Natives IMAP in Python erfordert Hunderte von Boilerplate-Codezeilen für jeden unterstützten Anbieter. Unipile ist ein einheitliche IMAP-API das all dies in eine einzige REST-Schnittstelle abstrahiert. Sie verknüpfen Benutzerkonten (Gmail, Outlook oder jeden IMAP-Server) mit OAuth, und Unipile kümmert sich im Hintergrund um jedes Protokolldetail.
# 1. OAuth-Token abrufen (über 50 Zeilen)
# 2. XOAUTH2-Zeichenkette erstellen
# 3. Verbinden + Authentifizieren
# 4. Ordner auswählen
# 5. Nachrichten suchen
# 6. Rohdaten abrufen
# 7. Tupel-Daten[0][1] analysieren
# 8. RFC-2047-Header dekodieren
# 9. MIME-Teile durchgehen
# 10. Halterungen
# 11. Zeitüberschreitungen bei Inaktivität verwalten
# 12. Bei einem Fehler erneut verbinden
# 13. Für Outlook wiederholen...
# 14. Für IMAP-Server wiederholen...import Anfragen
# E-Mails von jedem verknüpften Konto abrufen
r = Anfragen.bekommen.(
'https://api6.unipile.com/api/v1/emails',
Kopfzeilen={'X-API-KEY': api_key},
params={'Konto-ID': konto_id}
)
Emails = r.json()['Artikel']
# funktioniert mit Gmail, Outlook und jedem IMAP-ClientUnipile verwaltet die XOAUTH2-Tokenbeschaffung, -aktualisierung und -ablauf für Gmail und Outlook. Keine MSAL- oder google-auth-Einrichtung in Ihrem Code erforderlich.
Keine Rohdaten, keine Tupel-Entpackung, keine RFC 2047-Dekodierung. Jede E-Mail kommt als sauberes, strukturiertes JSON mit geparsten Headern, Body und Anhängen zurück.
Anstatt IDLE-Sitzungen und Wiederverbindungen zu verwalten, sendet Unipile neue E-Mail-Ereignisse an Ihren Webhook-Endpunkt. Kein Polling, keine Socket-Verwaltung.
Ein API-Endpunkt bedient Gmail, Outlook und jeden IMAP-Server. Fügen Sie neue Anbieter hinzu, indem Sie Konten verknüpfen – keine Codeänderungen auf Ihrer Seite erforderlich.
Unipile deckt den gesamten Lebenszyklus von E-Mails ab. Lesen, suchen, verschieben, markieren und senden – alles von derselben API. Sehen Sie unsere Python E-Mail senden Anleitung für die sendende Seite.
Jeder Ihrer Benutzer verknüpft sein eigenes Konto über OAuth. Unipile fungiert als unabhängiger technischer Vermittler im Namen jedes authentifizierten Benutzers – nicht als gemeinsam genutzter Anmeldedatenpool.
Häufige Fehler in der Produktion
Nachdem ein lokaler Python IMAP-Client funktioniert, deckt die Produktion Randfälle auf, die zu stillem Datenverlust, Verbindungsabbrüchen oder beschädigter Zeichenkodierung führen können. Hier sind die häufigsten Probleme und wie man sie behebt.
Microsoft hat die Entfernung der Basissicherheit für IMAP bei allen Microsoft 365-Clients abgeschlossen am September 2024. Jegliche Python-Code-Verwendung mail.login(user, password) gegen outlook.office365.com erhält nun Authentifizierung fehlgeschlagen. Die Migration zu XOAUTH2 (Abschnitt 5) ist für alle Microsoft 365 / Outlook IMAP-Integrationen obligatorisch. Exchange-On-Premises-Bereitstellungen können je nach Serverkonfiguration weiterhin Basic Auth unterstützen.
Gmail beendet IDLE-Verbindungen nach etwa 29 Minuten stillschweigend. Wenn Ihr Code die IDLE-Sitzung nicht erneuert, stoppt der Empfang neuer Nachrichten, ohne dass eine Ausnahme ausgelöst wird.
idle_done() alle 25 Minuten, dann sofort anrufen leer() noch einmal. Benutzen select_folder('INBOX', readonly=False) Nachrichtenzahl bei Wiederverbindung erneut prüfen.E-Mail-Header wie Betreff und Von verwenden die RFC 2047-CodierungDas ist ein Base64-kodierter String, der wahrscheinlich Teil eines E-Mail-Headers ist. Ohne den vollständigen kodierten String kann ich ihn nicht dekodieren und ins Deutsche übersetzen.). Rufen str(msg['Betreff']) direkt auf einem Byte-Wert gibt Müll zurück oder löst aus UnicodeDecodeError.
email.header.decode_header() und behandeln Sie die Kodierung jedes Teils explizit. Übergeben Sie Fehler='ersetzen' zu .decode() um Abstürze bei fehlerhaften Headern zu vermeiden.Anhänge befinden sich in verschachtelten MIME-Teilen. Aufrufen get_payload() Auf einer Mehrteilenachricht wird eine Liste von Teilen zurückgegeben, nicht der Inhalt. Inline-Bilder sind Content-Disposition: inline und habe eine Content-ID.
msg.gehen(), prüfen get_content_disposition() für Anhang, und rufen get_payload(decode=True) an Anhangsteilen, um decodierte Bytes zu erhalten.imaplib.IMAP4_SSL Instanzen sind NICHT threadsicher. Die gemeinsame Nutzung einer Verbindung über mehrere Threads hinweg führt zu fehlerhaften Antworten. Das Erstellen einer neuen Verbindung pro Anfrage ist teuer und limitiert.
aioimaplib. Implementieren Sie immer exponentielles Backoff für Wiederverbindungsversuche nach IMAP4.abbruch Ausnahmen.Gmail begrenzt IMAP-Verbindungen auf 15 gleichzeitige Verbindungen pro Konto und erzwingt Bandbreitenkontingente (2.500 MB/Tag über IMAP). Das Abrufen ganzer RFC822-Nachrichten in großem Maßstab wird diese Limits schnell erreichen.
RFC822.HEADER), dann rufe Körper selektiv ab. Verwende BODY.PEEK[] anstatt RFC822 um als gelesen markiert zu werden, zu vermeiden. Implementiere exponentiellen Backoff auf [Über Kontingent] Antworten.Zugriffstoken von Google und Microsoft laufen nach 3.600 Sekunden (1 Stunde) ab. Wenn Ihre IMAP-Sitzung nach Ablauf des Tokens noch geöffnet ist, schlägt der nächste Befehl nach Ablauf lautlos fehl oder gibt einen Fehler zurück NEIN.
abläuft_am Zeitstempel. Vor jeder Stapelverarbeitung prüfen, ob das Token innerhalb von 5 Minuten abläuft und proaktiv aktualisieren. Aktualisierungstoken sicher speichern. Das ist genau das, was Unipile handhabt automatisch.Die Vermeidung aller sechs Fallstricke erfordert eine beträchtliche Infrastruktur. Unipile übernimmt IDLE-Wiederverbindungen, Token-Aktualisierungen, Ratenbegrenzungen und die Normalisierung mehrerer Anbieter – damit Sie sich auf Ihre Produktlogik konzentrieren können. Teil unseres vollständigen E-Mail-API-Leitfaden.
Bauen ohne FallstrickeHäufig gestellte Fragen
Häufig gestellte Fragen zu Python IMAP-Clients, imaplib, IMAPClient, XOAUTH2-Authentifizierung und wann stattdessen eine einheitliche E-Mail-API verwendet werden sollte.
imap.gmail.com auf Port 993 mit imaplib.IMAP4_SSL. Allerdings akzeptiert Gmail keine Anmeldungen mehr mit Benutzername/Passwort für Drittanbieter-Apps. Sie müssen OAuth XOAUTH2 Authentifizierung mit einem Zugriffstoken, das von Google erhalten wurde, unter Verwendung der https://mail.google.com/ Umfang. Siehe unsere Leitfaden zu Gmail API-Umfängen Für die vollständige Umfangsaufschlüsselung. App-Passwörter funktionieren weiterhin für persönliche Konten mit aktivierter Zwei-Faktor-Authentifizierung, aber OAuth ist für Anwendungen erforderlich.Benutzer={email}\x01auth=Bearer {token}\x01\x01 in Base64, dann übergeben an imaplib.IMAP4_SSL.authenticate('XOAUTH2', callback). Dies ersetzt die veraltete Basic Auth-Anmeldung für Gmail und Microsoft 365. Vollständige Implementierungsbeispiele finden Sie in Abschnitt 5 dieser Anleitung. Siehe auch unser OAuth E-Mail-API-Leitfaden.base64(f'Benutzer={email}\x01auth=Bearer {token}\x01\x01'). 3) Rufen mail.authenticate('XOAUTH2', lambda x: auth_string). Für Gmail, verwenden Sie die google-auth Bibliothek zur Verwaltung von Token-Aktualisierungen. Für Outlook/Microsoft 365, verwenden Sie die msal Python-Bibliothek. Beide erfordern die Registrierung einer OAuth-Anwendung in der Google Cloud Console oder Azure AD. Der vollständige Python-OAuth-Code für IMAP befindet sich in Abschnitt 5 oben.suchen()/holen()/beweg dich Methoden und enthält integrierte IDLE-Unterstützung. Beide erfordern, dass Sie die OAuth-Tokenverwaltung selbst übernehmen. Keiner ist asynchron – für auf asyncio basierende Pipelines ziehen Sie aioimaplib. Installiere IMAPClient mit pip install imapclient.outlook.office365.com auf Port 993 mit imaplib.IMAP4_SSL. Seit September 2024 ist die Basisauthentifizierung für Microsoft 365 deaktiviert – Sie müssen XOAUTH2 verwenden. Registrieren Sie eine Azure AD-Anwendung, fordern Sie die IMAP.ZugriffAlsBenutzer.Alle Berechtigung, ein Zugriffstoken zu erhalten, der msal Python-Bibliothek, dann authentifizieren mit mail.authentifizieren('XOAUTH2', ...). Für persönliche Outlook.com-Konten gilt der gleiche OAuth-Flow. Details zu Servern und TLS-Konfiguration finden Sie in unserem IMAP-Server-Verbindungsanleitung.outlook.office365.com:993. Seit September 2024 hat Microsoft die Basisauthentifizierung für IMAP auf Microsoft 365-Mandanten jedoch vollständig deaktiviert. Sie müssen OAuth 2.0 mit dem XOAUTH2 SASL-Mechanismus verwenden. Ihr Azure AD-Administrator muss möglicherweise auch den IMAP-Zugriff im Exchange Admin Center aktivieren. Eine Alternative ist die Verwendung der Microsoft Graph-API (REST) das IMAP vollständig vermeidet und reichhaltigere Metadaten bietet.server.idle() um in den IDLE-Modus zu wechseln, dann server.idle_check(timeout=60) auf Ereignisse warten. Gmail trennt nach ca. 29 Minuten stillschweigend die Verbindung, also müssen Sie erneuern: anrufen server.idle_done() alle 25 Minuten, dann server.idle() Mit rohem imaplib erfordert IDLE ein manuelles Socket-Management – was erheblich komplexer ist. Für die Produktionsechtzeit-E-Mail ist ein webhook-basierter Ansatz (wie Unipile ihn bietet) zuverlässiger als die Aufrechterhaltung von IDLE-Sitzungen.aioimaplib Die Bibliothek bietet einen asyncio-kompatiblen IMAP4-Client für Python. Sie unterstützt Standard-IMAP-Befehle und IDLE in einem asynchronen Kontext, was sie für Hochdurchsatz-Pipelines geeignet macht, bei denen viele Mailboxen gleichzeitig verwaltet werden. Allerdings, aioimaplib hat eine kleinere Community als imaplib oder IMAPClient, und die OAuth-Unterstützung erfordert immer noch eine manuelle XOAUTH2-Implementierung. Für Teams, die Entwicklergeschwindigkeit über eine fein granulierte Kontrolle stellen, liefert eine REST-basierte einheitliche API E-Mails in Echtzeit über Webhooks ohne asynchrones Socket-Management.
DE 
EN 
FR 
ES 
IT 
BR 
NL 
PL 
TR