LinkedIn
Instagram
WhatsApp
Telegram
Google Agenda
Rejoindre la communauté SlackAPI IMAP Python: imaplib, IMAPClient & Guide OAuth XOAUTH2
Un guide complet pour construire des clients d'e-mails IMAP en Python en 2026 : des bases d'imaplib de la bibliothèque standard aux modèles de production IMAPClient, l'authentification OAuth XOAUTH2 pour Gmail et Outlook, et quand une API d'e-mail unifiée vous épargne entièrement la complexité.
import imaplib, email
from email.en-tête import décoder_en_tête
# Connexion via OAuth XOAUTH2
courriel = imaplib.IMAP4_SSL('imap.gmail.com')
auth_str = construire_xoauth2(utilisateur, jeton)
courriel.authentifier('XOAUTH2', lambda x : auth_str)
# Récupérer les messages non lus
courriel.sélectionner('BOÎTE DE RÉCEPTION')
_, identifiants = courriel.recherche(Aucun, 'INVISIBLES')
pour identifiant d'utilisateur en id[0].divisé():
_, données = courriel.fetch(uid, '(RFC822)')
message = courriel.message_des_octets(données[0][1])Qu'est-ce qu'un client Python IMAP ?
Un API IMAP Python Un client est tout programme Python qui communique avec un serveur de messagerie en utilisant le protocole IMAP4 (RFC 3501) pour lire, rechercher, organiser et synchroniser les messages électroniques. Contrairement à SMTP qui n'envoie que des courriels, IMAP donne à votre application un accès bidirectionnel à une boîte aux lettres distante : vous pouvez récupérer les en-têtes, lire les corps, définir des drapeaux, déplacer des messages entre les dossiers et écouter les nouvelles arrivées en temps réel en utilisant IMAP IDLE.
IMAP (Protocole d'accès aux messages Internet) est un protocole standard qui permet aux clients de récupérer et de gérer les courriels stockés sur un serveur distant. Un client IMAP Python se connecte via le port TLS 993, s'authentifie (Basic ou OAuth XOAUTH2), puis émet des commandes IMAP pour récupérer, rechercher, marquer et organiser les messages. Python fournit trois niveaux d'abstraction : la bibliothèque standard imaplib, le plus haut niveau IMAPClient wrapper, et des options entièrement asynchrones comme aioimaplib. Pour une présentation complète de l'architecture IMAP et des cas d'utilisation, consultez notre Guide du développeur de l'API IMAP.
Synchronisez les boîtes de réception des utilisateurs dans votre CRM, ATS ou helpdesk. Python IMAP vous permet d'interroger ou de pousser (IDLE) les nouveaux messages dans votre base de données sans gérer un serveur de messagerie complet.
Extraire, classifier et acheminer les e-mails entrants à l'aide de Python. Votre client IMAP alimente une file d'attente de traitement : analyse de factures, création de tickets, notation de prospects ou résumé par LLM.
Testez la délivrabilité des e-mails, créez des outils pour atteindre la boîte de réception zéro ou auditez la délivrabilité. Python IMAP vous donne un accès programmatique à la même boîte aux lettres que celle que vos utilisateurs voient. Consultez notre Guide API d'envoi d'e-mails pour l'écosystème complet.
Les 3 options de pile IMAP en Python
Choisir la bonne bibliothèque Python IMAP dépend de votre cas d'utilisation : un script rapide, un service de production ou un pipeline asynchrone. Voici comment les principales options se comparent avant de nous plonger dans des exemples de code pour chacune.
| Bibliothèque | Type | Support OAuth | Asynchrone | Aides d'Analyse | Meilleur pour |
|---|---|---|---|---|---|
| imaplib | Stdlib (sans dépendances) | Manuelle | Non | Minime | Scripts simples, aucune dépendance externe |
| IMAPClient | Enveloppe tierce partie | Manuelle | Non | Bien | Production IMAP sans asynchrone |
| aioimaplib | Bibliothèque asynchrone | Manuelle | Oui, | Limitée | Pipelines et IDLE asyncio à grande échelle |
| Unipile APILe meilleur | REST/SDK unifié | Intégré | Oui, | Plein | Production multi-fournisseurs à grande échelle |
Évitez la complexité de l'IMAP. Unipile abstrait imaplib, OAuth, et la logique multi-fournisseurs en une seule API REST. Une intégration pour Gmail, Outlook et n'importe quel serveur IMAP.
Commencez à construire gratuitementDémarrage rapide : Connexion à l'IMAP avec imaplib
La bibliothèque standard Python comprend imaplib - aucune installation requise. Voici un guide complet, de la connexion à la récupération du corps, avec des commentaires honnêtes sur les points faibles.
Utilisez imaplib.IMAP4_SSL sur le port 993 pour une connexion cryptée. Pour Gmail et Outlook, voir les adresses de serveur dans notre Guide de connexion au serveur IMAP. L'authentification de base (mot de passe) fonctionne pour les serveurs IMAP qui l'autorisent encore – mais Gmail et Outlook exigent maintenant OAuth XOAUTH2 (couvert dans la section 5).
import imaplib
# : Connexion à Gmail via IMAP (port TLS 993)
courriel = imaplib.IMAP4_SSL('imap.gmail.com', 993)
# Authentification de base (mot de passe d'application uniquement – OAuth recommandé)
courriel.Se connecter('user@gmail.com', 'mot de passe d'application')
# Répertorier toutes les boîtes aux lettres
statut, boîtes aux lettres = courriel.list()
pour boîte en boîtes aux lettres :
print(boîte).décoder('utf-8'))
courriel.déconnexion()Le select() l'appel ouvre une boîte aux lettres et renvoie le nombre de messages. rechercher() renvoie une chaîne d'octets séparée par des espaces des identifiants de message, pas des identifiants uniques. Vous devez décoder et diviser manuellement.
# Sélectionnez la Boîte de réception (ou n'importe quel dossier)
statut, nombre = courriel.sélectionner('BOÎTE DE RÉCEPTION')
print(Messages : {count[0].decode()}')
# : Rechercher les messages non lus
statut, ids_messages = courriel.recherche(Aucun, 'INVISIBLES')
ïdes = msg_ids[0].divisé()
print(Nombre d'éléments non lus : {len(ids)}')
# Recherche par expéditeur
_, from_ids = courriel.recherche(Aucun, 'DE', 'boss@company.com')
# Recherche par plage de dates
récent = courriel.recherche(Aucun, 'DEPUIS', '01-janv.-2026')C'est ici que imaplib devient désordonné. La réponse brute est une liste de tuples contenant des octets. Vous devez indexer données[0][1] pour accéder au message brut, puis le passer au l'email module pour l'analyse. Les en-têtes sont encodés selon la RFC 2047 et nécessitent décodage_en_tête().
import l'email
from email.en-tête import décoder_en_tête
déf déchiffrer_chaine(valeur) :
"Décodage de la valeur d'en-tête encodée RFC 2047."
pièces = décoder_en_tête(valeur)
décodé = []
pour part, encl en pièces
si isinstancepart, octets):
décodé.ajouterpart.décoder(enclos ou 'utf-8', erreurs='remplacer'))
sinon:
décodé.ajouterpartie
return ' '.rejoindre(décodé)
pour identifiant d'utilisateur en ids[-5:]: # : les 5 derniers messages
_, données = courriel.fetch(uid, '(RFC822)')
cru = données[0][1] Les difficultés liées au déballage des tuples #
message = courriel.message_des_octetscru
sujet = déchiffrer_chaine(msg['Sujet'] ou '')
expéditeur = déchiffrer_chaine(msg['De'] ou '')
# : analyse MIME des éléments pour un corps de texte brut
si message.est_multipart():
pour part en message.marche():
si en partie.obtenir_type_de_contenu() == 'text/plain':
corps = en partie.get_payload(décoder=Vrai).décoder('utf-8', erreurs='remplacer')
print(De : {sender} | Sujet : {subject}')Les points douloureux d'imaplib : les réponses brutes en octets nécessitent un indexation tuple soigneuse (données[0][1]), les en-têtes sont encodés en RFC 2047 et doivent décodage_en_tête(), les corps MIME multiparts nécessitent une analyse complète marcher(), et il n’y a pas de fonctions d’aide intégrées pour les identifiants uniques (UID) par rapport aux numéros de séquence. Pour les charges de travail de production, envisagez IMAPClient (Section 4) ou un API IMAP unifiée au lieu de cela.
Aller plus loin : IMAPClient pour la production
Une fois que vous passez en production avec imaplib, vous remarquez rapidement son analyse de réponse fragile, sa gestion incohérente des UID et l'absence d'aides pour les tâches courantes. IMAPClient est un wrapper pythonique qui lisse ces aspérités tout en restant proche de la spécification IMAP.
données[0][1]uid() (enveloppe manuellement)use_uid=True)rechercher(), chercher(), bouger(), copier() APIinactif() / idle_check()from imapclient import IMAPClient
import imprimer joliment
# Connexion via IMAPClient (use_uid=True par défaut)
serveur = IMAPClient('imap.gmail.com', ssl=Vrai, use_uid=Vrai)
serveur.Se connecter('user@gmail.com', 'mot de passe d'application')
# Sélectionner et rechercher
serveur.sélectionner_dossier('BOÎTE DE RÉCEPTION')
messages = serveur.recherche(['INVISIBLES'])
print({len(messages)} messages non lus')
# Fetch - renvoie un dictionnaire structuré, et non des octets bruts
response = serveur.fetch(messages[:10], ['ENVELOPPE', 'CORPS[]', 'DRAPEAUX'])
pour uid, données en réponse.articles():
enveloppe = données[ENVELOPPE']
print(UID {uid} : {envelope.subject}')
# Déplacer les messages vers un dossier
serveur.bouger(messages[:5], 'Archives')
# EN ATTENTE - attend les nouveaux messages (jusqu'à 29 minutes sur Gmail)
serveur.inactif()
réponses = serveur.vérification_inactivité(délai d'attente=60)
print('Réponse IDLE :', réponses)
serveur.idle_done()
serveur.déconnexion()Même IMAPClient nécessite une gestion manuelle des jetons OAuth et une gestion multi-fournisseurs. Unipile abstrait tout cela - rafraîchissement OAuth, bizarreries du fournisseur, reconnexions IDLE - derrière une seule API REST. Voir notre version complète Guide API d'envoi d'e-mails.
Construisez-le avec UnipileOAuth XOAUTH2 en Python : Gmail et Microsoft 365
L'authentification par mot de passe de base est morte pour les grands fournisseurs. Gmail l'a bloquée pour les comptes standards depuis mai 2022. Microsoft 365 a déprécié l'authentification de base pour IMAP en septembre 2024. XOAUTH2 (un mécanisme SASL OAuth 2.0) est désormais la seule façon de niveau production d'authentifier un client IMAP Python. Pour une explication complète du flux OAuth, consultez notre Guide API email OAuth.
XOAUTH2 est un mécanisme d'authentification SASL qui encode un jeton OAuth Bearer dans une chaîne base64 avec le format : email={email}\x01auth=Bearer {token}\x01\x01. Cette chaîne est transmise à imaplib.IMAP4_SSL.authenticate('XOAUTH2', callback). Le rappel renvoie la chaîne encodée en base64. Il vous incombe d'obtenir et de renouveler le jeton d'accès OAuth via les points de terminaison d'identité de Google ou de Microsoft avant d'établir la connexion IMAP. Pour les étendues Gmail requises, consultez notre Guide des étendues de l'API Gmail.
Gmail
Microsoft 365
import imaplib, base64, json
from google.oauth2.credentials import Indentifications
from google.auth.transport.requests import Requête
déf construire_chaîne_xoauth2(adresse_electronique_utilisateur, jeton_acces)
"Générer la chaîne SASL XOAUTH2 pour l'authentification IMAP."
chaine_auth = f'utilisateur={user_email}\x01authentification=Bearer {access_token}\x01\x01'
return base64.b64encode(chaîne_authentification.encoder('ascii'))
déf obtenir_jeton_valide(dictionnaire_identifiants)
"Rafraîchir le token si expiré en utilisant la librairie google-auth."
identifiants = Identifiants.informations_utilisateur_autorisé(dico_identifiants)
si identifiants.expiré et credss.jeton_rafraîchissement :
identifiants.Actualiser(Requête())
return identifiants.jeton
# - Paramètres IMAP requis pour Gmail : https://mail.google.com/
email_utilisateur = 'user@gmail.com'
access_token = obtenir_jeton_valide(dico_identifiants)
courriel = imaplib.IMAP4_SSL('imap.gmail.com')
chaine_auth = construire_chaîne_xoauth2(adresse_courriel_utilisateur, jeton_d_accès)
courriel.authentifier('XOAUTH2', lambda x: chaîne_authentification)
# Utilisez-le désormais comme d'habitude
courriel.sélectionner('BOÎTE DE RÉCEPTION')
_, identifiants = courriel.recherche(Aucun, 'TOUT')
print(Total des messages : {len(ids[0].split())}')https://mail.google.com/ portée (pas gmail.lecture seule seul - cette portée n'accorde pas l'accès IMAP). Voir notre Guide des étendues de l'API Gmail pour une analyse complète. Vous devez également activer l'IMAP dans les paramètres de Gmail et utiliser un ID client Google Cloud OAuth 2.0 avec l'URI de redirection correcte.
import imaplib, base64
import msal
déf construire_chaîne_xoauth2(adresse_electronique_utilisateur, jeton_acces)
chaine_auth = f'utilisateur={user_email}\x01authentification=Bearer {access_token}\x01\x01'
return base64.b64encode(chaîne_authentification.encoder('ascii'))
# MSAL - Bibliothèque d'authentification Microsoft pour Python
CLIENT_ID = 'votre-identifiant-client-azure-app'
ID_LOCATAIRE = 'votre-identifiant-locataire'
Portée de # pour l'accès IMAP (Outlook / Microsoft 365)
PORTEE = ['https://outlook.office365.com/IMAP.AccessAsUser.All']
application = msal.ApplicationClientPublic(CLIENT_ID, autorité=https://login.microsoftonline.com/{TENANT_ID}')
# Obtenir un jeton (de manière interactive ou via un jeton de rafraîchissement)
résultat = application.acquérir_jeton_par_code_autorisation(code, périmètre=SCOPE, redirect_uri=redirect_uri)
access_token = résultat['jeton_d'accès']
# : Connexion à Outlook via IMAP avec XOAUTH2
email_utilisateur = 'user@outlook.com'
courriel = imaplib.IMAP4_SSL('outlook.office365.com')
chaine_auth = construire_chaîne_xoauth2(adresse_courriel_utilisateur, jeton_d_accès)
courriel.authentifier('XOAUTH2', lambda x: chaîne_authentification)
courriel.sélectionner('BOÎTE DE RÉCEPTION')OAuth XOAUTH2 fait plus de 50 lignes par fournisseur. Unipile gère les rafraîchissements de jetons, les échanges XOAUTH2 et les particularités spécifiques aux fournisseurs afin que votre code Python se concentre sur la logique métier, et non sur la mécanique d'authentification.
Créez votre flux OAuthRéalité Multipartenaire
Chaque fournisseur a ses propres particularités d'authentification, adresses de serveur et limites de débit. Voici ce que votre client IMAP Python doit gérer pour chacun d'eux. Pour les noms d'hôte de serveur et les détails des ports TLS, consultez notre section dédiée Guide de connexion au serveur IMAP.
https://mail.google.com/
IMAP.AccéderEnTantQuUtilisateur.Tout
Prendre en charge plusieurs fournisseurs signifie maintenir des flux d'authentification, des configurations de serveur et des solutions de contournement spécifiques séparément. Unipile normalise Gmail, Outlook et n'importe quel serveur IMAP en une API unique. Lisez notre Comparaison des fournisseurs d'API d'e-mail pour le contexte.
Construire un courriel multi-fournisseursQuand ignorer IMAP complètement : approche par API unifiée
Après avoir parcouru imaplib, IMAPClient et XOAUTH2, une vérité devient évidente : l'IMAP brut en Python nécessite des centaines de lignes de code répétitif pour chaque fournisseur que vous supportez. Unipile est un API IMAP unifiée qui abstrait tout cela dans une seule interface REST. Vous liez les comptes utilisateur (Gmail, Outlook ou tout serveur IMAP) avec OAuth, et Unipile gère tous les détails du protocole pour vous.
# 1. Obtenir un jeton OAuth (plus de 50 lignes)
# 2. Créer une chaîne XOAUTH2
# 3. Se connecter et s'authentifier
# 4. Sélectionner un dossier
# 5. Rechercher des messages
# 6. Récupérer les octets bruts
# 7. Analyser les données du tuple [0][1]
# 8. Décodage des en-têtes RFC 2047
# 9. Parcours des éléments MIME
# 10. Fixations de poignées
# 11. Gérer les délais d'inactivité
# 12. Se reconnecter en cas d'erreur
# 13. Répétez l'opération pour Outlook...
# 14. Répétez l'opération pour les serveurs IMAP...import demandes
# Récupérer les e-mails de n'importe quel compte associé
r = requêtes.obtenir(
'https://api6.unipile.com/api/v1/emails',
en-têtes={'X-API-KEY': clé_api},
params={'identifiant_de_compte': id_compte}
)
courriels = r.json()['articles']
# fonctionne avec Gmail, Outlook et tout autre client IMAPUnipile gère l'acquisition, le rafraîchissement et l'expiration des jetons XOAUTH2 pour Gmail et Outlook. Aucune configuration MSAL ou google-auth n'est nécessaire dans votre code.
Aucun octet brut, aucun déballage de tuple, aucun décodage RFC 2047. Chaque e-mail revient sous forme de JSON structuré propre avec les en-têtes, le corps et les pièces jointes analysés.
Au lieu de gérer les sessions inactives (IDLE) et les reconnexions, Unipile pousse les nouveaux événements d'e-mail vers votre point de terminaison webhook. Pas de sondage, pas de gestion de socket.
Un point de terminaison API dessert Gmail, Outlook et tout serveur IMAP. Ajoutez de nouveaux fournisseurs en liant des comptes - aucune modification de code requise de votre côté.
Unipile couvre le cycle de vie complet des e-mails. Lire, rechercher, déplacer, marquer et envoyer – le tout depuis la même API. Voir notre Guide pour envoyer des e-mails en Python côté expéditeur.
Chacun de vos utilisateurs lie son propre compte via OAuth. Unipile agit en tant qu'intermédiaire technique indépendant pour le compte de chaque utilisateur authentifié – et non comme un pool d'identifiants partagés.
Les pièges courants en production
Après avoir mis en place un client IMAP Python localement, la production révèle des cas limites qui peuvent entraîner une perte de données silencieuse, une interruption de connexion ou un encodage de caractères incorrect. Voici les problèmes les plus courants et comment les résoudre.
Microsoft a finalisé la suppression de l'authentification de base pour IMAP sur tous les locataires Microsoft 365 en Septembre 2024. Tout code Python utilisant mail.connexion(utilisateur, mot_de_passe) contre outlook.office365.com recevra désormais ÉCHEC D'AUTHENTIFICATION. La migration vers XOAUTH2 (section 5) est obligatoire pour toutes les intégrations IMAP Microsoft 365 / Outlook. Les déploiements Exchange locaux peuvent encore prendre en charge l'authentification de base en fonction de la configuration du serveur.
Gmail met fin silencieusement aux connexions IDLE après environ 29 minutes. Si votre code ne renouvelle pas la session IDLE, de nouveaux messages cessent d'arriver sans qu'aucune exception ne soit levée.
idle_done() toutes les 25 minutes, puis appelez immédiatement inactif() encore. Utilise select_folder('BOÎTE DE RÉCEPTION', readonly=False) pour vérifier à nouveau le nombre de messages lors de la reconnexion.Les en-têtes d'e-mail comme Sujet et De utilisent l'encodage RFC 2047 (Ceci est un exemple de texte encodé en Base64.). Appeler str(msg['Objet']) directement sur une valeur d'octets renvoie des données corrompues ou provoque une erreur Erreur de décodage Unicode.
email.header.decode_header() et gérer explicitement le codage de chaque partie. Passer erreurs='remplacer' à .décoder() pour éviter les plantages sur des en-têtes malformés.Les pièces jointes vivent dans des parties MIME imbriquées. Appelons get_payload() sur un message multipartie renvoie une liste de parties, et non le contenu. Les images en ligne sont Content-Disposition : inline et avoir un ID de contenu.
msg.marcher(), Vérifier get_content_disposition() pour pièce jointe, et appelez get_payload(decode=True) sur des pièces jointes pour obtenir des octets décodés.imaplib.IMAP4_SSL les instances ne sont PAS thread-safe. L'utilisation d'une seule connexion sur plusieurs threads entraîne des réponses brouillées. La création d'une nouvelle connexion par requête est coûteuse et limitée en débit.
aioimaplib. Toujours implémenter un rétro-agissement exponentiel pour les tentatives de reconnexion après IMAP4.abandon exceptions.Gmail limite les connexions IMAP à 15 connexions simultanées par compte et applique des quotas de bande passante (2 500 Mo/jour via IMAP). La récupération de corps RFC822 entiers à grande échelle atteindra rapidement ces limites.
RFC822.EN-TÊTE), puis récupérez les corps sélectivement. Utiliser BODY.PEEK[] au lieu de RFC822 pour éviter de marquer automatiquement comme lu. Implémenter une décroissance exponentielle sur [DÉPASSEMENT DE QUOTA] réponses.Les jetons d'accès de Google et Microsoft expirent après 3 600 secondes (1 heure). Si votre session IMAP est toujours ouverte lorsque le jeton expire, la prochaine commande après l'expiration échouera silencieusement ou renverra NON.
expire à timestamp. Avant chaque opération par lots, vérifiez si le jeton expire dans moins de 5 minutes et actualisez-le de manière proactive. Stockez les jetons d'actualisation en toute sécurité. C'est exactement ce que Unipile gère automatiquement.Éviter les 6 pièges demande des infrastructures considérables. Unipile gère les reconnects IDLE, l'actualisation des jetons, la limitation de débit et la normalisation multi-fournisseurs - afin que vous puissiez vous concentrer sur la logique de votre produit. Fait partie de notre solution complète Guide API d'envoi d'e-mails.
Construire sans les écueilsQuestions fréquemment posées
Questions courantes sur les clients IMAP Python, imaplib, IMAPClient, l'authentification XOAUTH2, et quand utiliser une API de messagerie unifiée à la place.
imap.gmail.com sur le port 993 en utilisant imaplib.IMAP4_SSL. Cependant, Gmail n'accepte plus la connexion par nom d'utilisateur/mot de passe simple pour les applications tierces. Vous devez utiliser OAuth XOAUTH2 authentification avec un jeton d'accès obtenu de Google en utilisant https://mail.google.com/ champ. Voir notre Guide des étendues de l'API Gmail Pour la ventilation complète de la portée. Les mots de passe d'application fonctionnent toujours pour les comptes personnels avec la vérification en deux étapes activée, mais OAuth est requis pour les applications.email={email}\x01auth=Bearer {token}\x01\x01 en base64, puis le passer à imaplib.IMAP4_SSL.authenticate('XOAUTH2', callback). Ceci remplace l'authentification de base obsolète pour Gmail et Microsoft 365. Des exemples d'implémentation complets se trouvent dans la section 5 de ce guide. Voir aussi notre Guide API email OAuth.base64(f'utilisateur={email}\x01auth=Bearer {token}\x01\x01'). 3) Appel mail.authentifier('XOAUTH2', lambda x: auth_string). Pour Gmail, utilisez le authentification Google Bibliothèque pour gérer le rafraîchissement des jetons. Pour Outlook/Microsoft 365, utilisez le msal Bibliothèque Python. Les deux nécessitent l'enregistrement d'une application OAuth dans la console Google Cloud ou Azure AD. Le code complet imap python oauth se trouve dans la section 5 ci-dessus.rechercher()/chercher()/bouger() méthodes, et comprend un support IDLE intégré. Les deux nécessitent que vous gériez vous-même la gestion des jetons OAuth. Aucun n'est asynchrone - pour les pipelines basés sur asyncio, envisagez aioimaplib. Installer IMAPClient avec pip install imapclient.outlook.office365.com sur le port 993 en utilisant imaplib.IMAP4_SSL. Depuis septembre 2024, l'authentification de base est désactivée pour Microsoft 365 - vous devez utiliser XOAUTH2. Enregistrez une application Azure AD, demandez le IMAP.AccéderEnTantQuUtilisateur.Tout la permission, obtenir un jeton d'accès en utilisant le msal Bibliothèque Python, puis authentifiez-vous avec mail.authentifier('XOAUTH2', ...). Pour les comptes Outlook.com personnels, le même flux OAuth s'applique. Pour les détails du serveur et la configuration TLS, consultez notre Guide de connexion au serveur IMAP.outlook.office365.com:993. Cependant, depuis septembre 2024, Microsoft a complètement désactivé l'authentification de base pour IMAP sur les locataires Microsoft 365. Vous devez utiliser OAuth 2.0 avec le mécanisme SASL XOAUTH2. Votre administrateur Azure AD peut également avoir besoin d'activer l'accès IMAP dans le centre d'administration Exchange. Une alternative consiste à utiliser le Microsoft Graph API (REST) qui évite complètement IMAP et fournit des métadonnées plus riches.server.idle() pour entrer en mode IDLE, puis server.idle_check(timeout=60) attendre des événements. Gmail se déconnecte silencieusement après environ 29 minutes, vous devez donc renouveler : appelez server.idle_done() toutes les 25 minutes, puis server.idle() Encore. Avec imaplib brut, IDLE nécessite une gestion manuelle au niveau du socket – considérablement plus complexe. Pour les e-mails en temps réel en production, une approche basée sur les webhooks (comme celle qu'offre Unipile) est plus fiable que le maintien de sessions IDLE.aioimaplib La bibliothèque fournit un client IMAP4 compatible asyncio pour Python. Elle prend en charge les commandes IMAP standard et IDLE dans un contexte asynchrone, ce qui la rend adaptée aux pipelines à haute concurrence où vous gérez de nombreuses boîtes aux lettres simultanément. Cependant, aioimaplib a une communauté plus petite qu'imaplib ou IMAPClient, et le support OAuth nécessite toujours une implémentation manuelle de XOAUTH2. Pour les équipes qui privilégient la rapidité de développement par rapport à un contrôle granulaire, une API unifiée basée sur REST offre des e-mails en temps réel via des webhooks sans gestion de socket asynchrone.
FR 
EN 
ES 
DE 
IT 
BR 
NL 
PL 
TR