LinkedIn
Instagram
WhatsApp
Telegrama
Calendario de Google
Únase a la comunidad SlackAPI IMAP en Python: imaplib, IMAPClient y Guía de OAuth XOAUTH2
Una guía completa para construir clientes de correo electrónico IMAP en Python en 2026: desde los conceptos básicos de la biblioteca estándar `imaplib` hasta los patrones de producción de `IMAPClient`, autenticación OAuth XOAUTH2 para Gmail y Outlook, y cuándo una API de correo electrónico unificada te salva de la complejidad por completo.
import imaplib, email
from encabezado.email import decodificar_cabecera
#: Conexión mediante OAuth XOAUTH2
correo = imaplib.IMAP4_SSL('imap.gmail.com')
auth_str = build_xoauth2(usuario, token)
correo.autenticar('XOAUTH2', lambda x: auth_str)
# Recuperar mensajes no leídos
correo.elegir('BANDEJA DE ENTRADA')
_, identificadores = correo.busque en(Ninguno, 'INESPERADO')
para uid en identificadores0].separar():
_, datos = correo.fetch(uid, '(RFC822)')
msj = correo electrónico.mensaje_de_bytes(datos[0][1])¿Qué es un cliente Python IMAP?
En API IMAP de Python un cliente es cualquier programa de Python que se comunica con un servidor de correo utilizando el protocolo IMAP4 (RFC 3501) para leer, buscar, organizar y sincronizar mensajes de correo electrónico. A diferencia de SMTP, que solo envía correo, IMAP da a su aplicación acceso bidireccional a un buzón de correo remoto: puede recuperar encabezados, leer cuerpos, establecer indicadores, mover mensajes entre carpetas y escuchar las nuevas llegadas en tiempo real utilizando IMAP IDLE.
IMAP (Protocolo de Acceso a Mensajes de Internet) es un protocolo estándar que permite a los clientes recuperar y administrar correos electrónicos almacenados en un servidor remoto. Un cliente IMAP de Python se conecta a través del puerto TLS 993, se autentica (Basic u OAuth XOAUTH2) y luego emite comandos IMAP para buscar, marcar y organizar mensajes. Python ofrece tres niveles de abstracción: la biblioteca estándar imaplib, el nivel superior ClienteIMAP envoltorio, y opciones totalmente asíncronas como aioimaplib. Para una visión completa de la arquitectura y los casos de uso de IMAP, consulte nuestra Guía del desarrollador de la API IMAP.
Sincroniza las bandejas de entrada de los usuarios en tu CRM, ATS o helpdesk. Python IMAP te permite consultar o enviar (IDLE) mensajes nuevos a tu base de datos sin administrar un servidor de correo completo.
Extrae, clasifica y enruta correos electrónicos entrantes usando Python. Tu cliente IMAP alimenta una cola de procesamiento: análisis de facturas, creación deTickets, puntuación de clientes potenciales o resumen con LLM.
Prueba entregas de correo electrónico, crea herramientas de inbox zero o audita la entregabilidad. Python IMAP te da acceso programático al mismo buzón que ven tus usuarios. Mira nuestro guía de API de correo electrónico para el ecosistema completo.
Las 3 opciones de pila IMAP de Python
Elegir la biblioteca IMAP de Python adecuada depende de tu caso de uso: un script rápido, un servicio de producción o un pipeline asíncrono. Aquí se comparan las principales opciones antes de sumergirnos en ejemplos de código para cada una.
| Biblioteca | Tipo | Soporte OAuth | Asincrónico | Ayudas de Análisis | Lo mejor para |
|---|---|---|---|---|---|
| imaplib | Stdlib (sin dependencias) | Manual | No | Mínimo | Scripts sencillos, sin dependencias externas |
| ClienteIMAP | Envoltorio de terceros | Manual | No | Bien | Producción IMAP sin asíncrono |
| aioimaplib | Biblioteca asíncrona | Manual | Sí | Limitado | Pipelines y espera (IDLE) asíncronas a escala |
| API de UnipileMejor | REST/SDK Unificado | Incorporado | Sí | Completo | Producción multientreprise a escala |
Omitir la complejidad de IMAP. Unipile abstrae imaplib, OAuth y la lógica multidominio en una única API REST. Una integración para Gmail, Outlook y cualquier servidor IMAP.
Empezar a construir gratisInicio rápido: Conexión a IMAP con imaplib
La biblioteca estándar de Python incluye imaplib - no se necesita instalación. Aquí hay una guía completa desde la conexión hasta la obtención del cuerpo, con comentarios honestos sobre cuáles son los puntos débiles.
Utilice imaplib.IMAP4_SSL en el puerto 993 para una conexión cifrada. Para Gmail y Outlook, consulta las direcciones del servidor en nuestra Guía de conexión a servidor IMAP. La autenticación básica (contraseña) funciona para los servidores IMAP que aún lo permiten, pero Gmail y Outlook ahora requieren OAuth XOAUTH2 (cubierto en la Sección 5).
import imaplib
#: Conexión a Gmail mediante IMAP (puerto TLS 993)
correo = imaplib.IMAP4_SSL('imap.gmail.com', 993)
# Autenticación básica (solo contraseña de aplicación; se recomienda OAuth)
correo.ingresar('user@gmail.com', 'contraseña de aplicación')
#: Mostrar todas las bandejas de entrada
estado, buzones = correo.list()
para caja en buzones
print(caja.descifrar('utf-8'))
correo.cerrar sesión()En seleccionar() call abre un buzón y devuelve el número de mensajes. buscar() devuelve una cadena de bytes separada por espacios de ID de mensaje, no UIDs. Necesitas decodificar y dividir manualmente.
# Selecciona la bandeja de entrada (o cualquier carpeta)
estado, cantidad = correo.elegir('BANDEJA DE ENTRADA')
print(Mensajes: {count[0].decode()}')
#: Buscar mensajes NO VISUALIZADOS
estado, ids_mensajes = correo.busque en(Ninguno, 'INESPERADO')
identificadores = msg_ids[0].separar()
print(Unread count: {len(ids)}')
#: Búsqueda por remitente
_, de_ids = correo.busque en(Ninguno, 'DE', 'boss@company.com')
#: Búsqueda por intervalo de fechas
reciente = correo.busque en(Ninguno, 'DESDE', '01-ene-2026')Aquí es donde imaplib se ensucia. La respuesta sin procesar es una lista de tuplas que contienen bytes. Debes indexar datos[0][1] para llegar al mensaje sin procesar, luego pásalo al email módulo para analizar. Las cabeceras están codificadas según RFC 2047 y requieren decodificar_encabezado().
import email
from encabezado.email import decodificar_cabecera
def decodificar_cadena(valor):
"Decodificar el valor de cabecera codificado RFC 2047."
partes = decodificar_cabecera(valor)
descifrado = []
para parte, codificar en partes
si isinstanceparte, bytes):
descifrado.añadirparticipio.descifrarcifrar o 'utf-8', errores='reemplazar'))
si no:
descifrado.añadir(parte)
return ' '.unir(decodificado)
para uid en ids[-5:]: #: los últimos 5 mensajes
_, datos = correo.fetch(uid, '(RFC822)')
crudo = datos[0][1] El calvario del desempaquetado de tuplas #
msj = correo electrónico.mensaje_de_bytescrudo
tema = decodificar_cadena(msg['Asunto'] o '')
remitente = decodificar_cadena(msg['De'] o '')
#: Componentes MIME para el cuerpo de texto sin formato
si msj.es_multipart():
para parte en msj.caminar():
si parte.obtener_tipo_de_contenido() == 'text/plain':
cuerpo = parte.obtener_cargadescifrar=Verdadero).descifrar('utf-8', errores='reemplazar')
print(De: {sender} | Asunto: {subject}')Los puntos débiles de imaplib: las respuestas de bytes crudos requieren una indexación cuidadosa de tuplas (datos[0][1]), las cabeceras están codificadas con RFC 2047 y necesitan decodificar_encabezado(), los cuerpos MIME multipartes requieren un completo caminar(), y no hay asistentes integrados para UID frente a números de secuencia. Para cargas de trabajo de producción, considere IMAPClient (Sección 4) o un API IMAP unificada en su lugar.
Profundizando: IMAPClient para Producción
Una vez que llegas a producción con imaplib, rápidamente notas su frágil análisis de respuestas, el manejo inconsistente de UID y la ausencia de ayudantes para tareas comunes. IMAPClient es un wrapper "Pythónico" que suaviza estos bordes ásperos mientras se mantiene fiel a la especificación IMAP.
datos[0][1]uid() envoltorio manualusar_uid=Verdadero)buscar(), fetch(), mover(), copiar() APIinactividad() / comprobacion_inactividad()from imapclient import ClienteIMAP
import imprimir bonito
#: Conexión con IMAPClient (use_uid=True por defecto)
servidor = ClienteIMAP('imap.gmail.com', ssl=Verdadero, uid_de_uso=Verdadero)
servidor.ingresar('user@gmail.com', 'contraseña de aplicación')
# Seleccionar y buscar
servidor.seleccionar_carpeta('BANDEJA DE ENTRADA')
messages = servidor.busque en(['INESPERADO'])
print({len(messages)} mensajes sin leer')
# Fetch: devuelve un diccionario estructurado, no bytes sin procesar
response = servidor.fetch(mensajes[:10], ['SOBRE', 'CUERPO[]', 'BANDERAS'])
para uid, datos en respuesta.artículos():
sobre = datos[SOBRE']
print(UID {uid}: {envelope.subject}')
# Mover mensajes a la carpeta
servidor.mover(mensajes[:5], 'Archivo')
# EN ESPERA: espera a que lleguen nuevos mensajes (hasta 29 minutos en Gmail)
servidor.inactivo()
respuestas = servidor.verificación inactiva(tiempo de espera=60)
print('Respuesta de inactividad:', respuestas)
servidor.idle_done()
servidor.cerrar sesión()Incluso IMAPClient requiere la gestión manual del token OAuth y el manejo de múltiples proveedores. Unipile abstrae todo esto (refrescos de OAuth, particularidades del proveedor, reconexiones de IDLE) tras una única API REST. Vea nuestro completo guía de API de correo electrónico.
Constrúyelo con UnipileOAuth XOAUTH2 en Python: Gmail y Microsoft 365
La autenticación básica de contraseñas está muerta para los principales proveedores. Gmail la bloqueó para cuentas estándar desde mayo de 2022. Microsoft 365 eliminó la autenticación básica para IMAP en septiembre de 2024. XOAUTH2 (un mecanismo SASL de OAuth 2.0) es ahora la única forma apta para producción de autenticar un cliente IMAP de Python. Para obtener una explicación completa del flujo de OAuth, consulte nuestro Guía de la API de correo electrónico de OAuth.
XOAUTH2 es un mecanismo de autenticación SASL que codifica un token de portador de OAuth en una cadena base64 con el formato: usuario={email}\x01autenticación=Bearer {token}\x01\x01. Esta cadena se pasa a imaplib.IMAP4_SSL.authenticate('XOAUTH2', callback). El callback devuelve la cadena codificada en base64. Usted es responsable de obtener y refrescar el token de acceso OAuth a través de los puntos finales de identidad de Google o Microsoft antes de realizar la conexión IMAP. Para los alcances de Gmail requeridos, consulte nuestro Guía de ámbitos de la API de Gmail.
Gmail
Microsoft 365
import imaplib, base64, json
from google.oauth2.credenciales import Credenciales
from google.auth.transport.requests import Solicitud
def construir_cadena_xoauth2(correo_electronico_usuario, token_de_acceso):
"""Generar cadena SASL XOAUTH2 para autenticación IMAP."""
cadena_autenticación = f'usuario={user_email}\x01autenticación=Bearer {access_token}\x01\x01'
return base64.b64encode(cadena_autenticacion.codificar('ascii'))
def obtener_token_valido(diccionario_credenciales):
"Actualizar token si ha expirado usando la biblioteca google-auth."
acreditaciones = Credenciales.de\_info\_usuario\_autorizado(diccionario_credenciales)
si créditos.caducado y creds.refresh_token:
créditos.actualizar(Solicitud())
return credenciales.token
#: Ámbito IMAP de Gmail requerido: https://mail.google.com/
correo_electronico_del_usuario = 'user@gmail.com'
token_de_acceso = obtener_token_valido(diccionario_credenciales)
correo = imaplib.IMAP4_SSL('imap.gmail.com')
cadena_autenticación = construir_cadena_xoauth2(correo_electronico_usuario, token_de_acceso)
correo.autenticar('XOAUTH2', lambda x: cadena_autenticación)
# Ahora úsalo como de costumbre
correo.elegir('BANDEJA DE ENTRADA')
_, identificadores = correo.busque en(Ninguno, 'TODOS')
print(Total de mensajes: {len(ids[0].split())}')https://mail.google.com/ alcance (no gmail.lectura solo - ese alcance no otorga acceso IMAP). Ver nuestra Guía de ámbitos de la API de Gmail para un desglose completo. También necesitas habilitar IMAP en la configuración de Gmail y usar un ID de cliente OAuth 2.0 de Google Cloud con la URI de redirección correcta.
import imaplib, base64
import msal
def construir_cadena_xoauth2(correo_electronico_usuario, token_de_acceso):
cadena_autenticación = f'usuario={user_email}\x01autenticación=Bearer {access_token}\x01\x01'
return base64.b64encode(cadena_autenticacion.codificar('ascii'))
# MSAL - Biblioteca de autenticación de Microsoft para Python
ID_CLIENTE = 'su-id-de-cliente-de-aplicación-azure'
ID_DEL_ARRENDATARIO = 'tu-id-de-inquilino'
Ámbito de aplicación de # para el acceso IMAP (Outlook / Microsoft 365)
ALCANCE = ['https://outlook.office365.com/IMAP.AccessAsUser.All']
aplicación = msal.AplicaciónClientePública(CLIENT_ID, autoridad=https://login.microsoftonline.com/{TENANT_ID}')
# Obtener token (de forma interactiva o mediante un token de actualización)
resultado = aplicación.adquirir_token_por_codigo_de_autorizacion(código, alcances=SCOPE, uri_redireccionamiento=redirect_uri)
token_de_acceso = resultado ['token_de_acceso']
#: Conexión a Outlook IMAP con XOAUTH2
correo_electronico_del_usuario = 'user@outlook.com'
correo = imaplib.IMAP4_SSL('outlook.office365.com')
cadena_autenticación = construir_cadena_xoauth2(correo_electronico_usuario, token_de_acceso)
correo.autenticar('XOAUTH2', lambda x: cadena_autenticación)
correo.elegir('BANDEJA DE ENTRADA')OAuth XOAUTH2 tiene más de 50 líneas por proveedor. Unipile se encarga de la actualización de tokens, el intercambio XOAUTH2 y las particularidades específicas del proveedor para que su código Python se centre en la lógica de negocio, no en las complicadas gestiones de autenticación.
Construye tu flujo OAuthChequeo de realidad multi-proveedor
Cada proveedor tiene sus propias peculiaridades de autenticación, direcciones de servidor y límites de velocidad. Aquí se detalla lo que su cliente IMAP de Python necesita manejar para cada uno. Para los nombres de host del servidor y los detalles del puerto TLS, consulte nuestra sección dedicada Guía de conexión a servidor IMAP.
https://mail.google.com/
IMAP.AccesoComoUsuario.Todos
Soportar múltiples proveedores significa mantener flujos de autenticación, configuraciones de servidor y soluciones alternativas específicas por separado. Unipile normaliza Gmail, Outlook y cualquier servidor IMAP en una única API. Lea nuestro comparación de proveedores de API de correo electrónico para contexto.
Construir correo electrónico multiproveedorCuándo omitir IMAP por completo: enfoque de API unificada
Tras repasar imaplib, IMAPClient y XOAUTH2, una verdad se hace evidente: IMAP puro en Python requiere cientos de líneas de código repetitivo para cada proveedor que soportes. Unipile es un API IMAP unificada que abstrae todo esto en una única interfaz REST. Vinculas cuentas de usuario (Gmail, Outlook o cualquier servidor IMAP) con OAuth, y Unipile se encarga de todos los detalles del protocolo en tu nombre.
# 1. Obtener el token OAuth (más de 50 líneas)
# 2. Generar la cadena XOAUTH2
# 3. Conectar + autenticar
# 4. Seleccionar carpeta
# 5. Buscar mensajes
# 6. Obtener bytes sin procesar
# 7. Analizar los datos de la tupla [0][1]
# 8. Descodificar encabezados RFC 2047
# 9. Recorrido por las partes del MIME
# 10. Accesorios para asas
# 11. Gestionar los tiempos de espera por inactividad
# 12. Volver a conectarse en caso de error
# 13. Repite el proceso para Outlook...
# 14. Repite el proceso para los servidores IMAP...import solicita
#: Recuperar correos electrónicos de cualquier cuenta vinculada
r = solicitudes.consiga(
'https://api6.unipile.com/api/v1/correos',
encabezados={'X-API-KEY': clave_api},
params={'id_cuenta': id_cuenta}
)
correos electrónicos = r.json()['artículos']
# funciona con Gmail, Outlook y cualquier cliente IMAPUnipile administra la adquisición, renovación y expiración de tokens XOAUTH2 para Gmail y Outlook. No se necesita configuración de MSAL o google-auth en tu código.
Sin bytes crudos, sin desempaquetado de tuplas, sin decodificación RFC 2047. Cada correo electrónico se devuelve como JSON estructurado limpio con encabezados, cuerpo y archivos adjuntos analizados.
En lugar de administrar sesiones inactivas y reconexiones, Unipile envía nuevos eventos de correo electrónico a tu endpoint de webhook. Sin sondeos, sin gestión de sockets.
Un punto final de API sirve para Gmail, Outlook y cualquier servidor IMAP. Agregue nuevos proveedores vinculando cuentas, sin necesidad de cambios de código de su parte.
Unipile cubre el ciclo de vida completo del correo electrónico. Leer, buscar, mover, marcar y enviar, todo desde la misma API. Vea nuestro Guía para enviar correos electrónicos en Python para el lado del remitente.
Cada uno de tus usuarios vincula su propia cuenta a través de OAuth. Unipile actúa como un intermediario técnico independiente en nombre de cada usuario autenticado, no como un repositorio compartido de credenciales.
Obstáculos comunes en producción
Tras hacer funcionar un cliente IMAP de Python localmente, la producción revela casos extremos que pueden provocar pérdida silenciosa de datos, caídas de conexión o codificación de caracteres rota. Estos son los problemas más comunes y cómo solucionarlos.
Microsoft completó la eliminación de la autenticación básica para IMAP en todos los inquilinos de Microsoft 365 en Septiembre 2024. Cualquier código Python que utiliza mail.login(usuario, contraseña) contra outlook.office365.com recibirá ahora AUTENTICACIÓN fallida. La migración a XOAUTH2 (Sección 5) es obligatoria para todas las integraciones de Microsoft 365 / Outlook IMAP. Las implementaciones locales de Exchange aún pueden admitir autenticación básica dependiendo de la configuración del servidor.
Gmail termina silenciosamente las conexiones IDLE después de aproximadamente 29 minutos. Si tu código no renueva la sesión IDLE, los nuevos mensajes dejan de llegar sin que se genere ninguna excepción.
idle_done() cada 25 minutos, luego llama inmediatamente inactividad() otra vez. Usar seleccionar_carpeta('INBOX', readonly=False) para volver a comprobar el recuento de mensajes en la reconexión.Los encabezados de correo electrónico como Subject y From usan codificación RFC 2047 (Tú eres un motor de traducción. Traduce el texto del usuario al español. Devuelve sólo el texto traducido. No añadas comentarios ni ningún otro texto. No añadas comillas adicionales alrededor de la traducción. Tu salida DEBE estar en español.) Llamando str(msg['Asunto']) directamente en un valor de bytes devuelve basura o genera UnicodeDecodeError.
email.header.decode_header() y maneja la codificación de cada parte explícitamente. Pasa errores='reemplazar' a .decodificar() para evitar fallos en cabeceras mal formadas.Los archivos adjuntos viven en partes MIME anidadas. Llamando get_payload() en un mensaje multipartes devuelve una lista de partes, no el contenido. Las imágenes en línea son Content-Disposition: inline y tener un ID de contenido.
msg.caminar(), comprobar get_content_disposition() para adjunto, y llamar get_payload(decode=True) en partes adjuntas para obtener bytes decodificados.imaplib.IMAP4_SSL Las instancias NO son seguras para subprocesos. Usar una conexión en múltiples subprocesos causa respuestas erróneas. Crear una nueva conexión por solicitud es costoso y está limitado en tasa.
aioimaplib. Siempre implementa reintentos aleatorios exponenciales después de IMAP4.abortar excepciones.Gmail limita las conexiones IMAP a 15 conexiones concurrentes por cuenta y aplica cuotas de ancho de banda (2.500 MB/día a través de IMAP). La obtención de cuerpos completos de RFC822 a escala alcanzará estos límites rápidamente.
RFC822.ENCABEZADO), luego recupere los cuerpos selectivamente. Utilice BODY.PEEK[] en vez de RFC822 para evitar que se marque automáticamente como leído. Implementa retroceso exponencial en [SOBRECUOTA] respuestas.Las tokens de acceso de Google y Microsoft expiran después de 3.600 segundos (1 hora). Si su sesión IMAP todavía está abierta cuando la token expira, el próximo comando después de la expiración fallará silenciosamente o devolverá NO.
expira_en marca de tiempo. Antes de cada operación por lotes, compruebe si el token está a menos de 5 minutos de su vencimiento y renueve de forma proactiva. Almacene los tokens de actualización de forma segura. Esto es exactamente lo que Unipile maneja automáticamente.Evitar las 6 trampas requiere una infraestructura considerable. Unipile maneja reconexiones de inactividad, refresco de tokens, limitación de tarifas y normalización de múltiples proveedores, para que puedas concentrarte en la lógica de tu producto. Parte de nuestro completo guía de API de correo electrónico.
Construye sin las trampasPreguntas frecuentes
Preguntas comunes sobre clientes IMAP de Python, imaplib, IMAPClient, autenticación XOAUTH2 y cuándo usar una API de correo unificada en su lugar.
imap.gmail.com en el puerto 993 usando imaplib.IMAP4_SSL. Sin embargo, Gmail ya no acepta el inicio de sesión con nombre de usuario/contraseña simple para aplicaciones de terceros. Debes usar OAuth XOAUTH2 autenticación con un token de acceso obtenido de Google utilizando el https://mail.google.com/ alcance. Ver nuestra Guía de ámbitos de la API de Gmail Para el desglose completo del alcance. Las contraseñas de aplicaciones todavía funcionan para cuentas personales con verificación en dos pasos habilitada, pero se requiere OAuth para las aplicaciones.usuario={email}\x01autenticación=Bearer {token}\x01\x01 en base64, luego pásalo a imaplib.IMAP4_SSL.authenticate('XOAUTH2', callback). Esto reemplaza la autenticación básica obsoleta para Gmail y Microsoft 365. Los ejemplos completos de implementación se encuentran en la Sección 5 de esta guía. Ver también nuestro Guía de la API de correo electrónico de OAuth.base64(f'usuario={email}\x01auth=Bearer {token}\x01\x01'). 3) Llamar mail.authenticate('XOAUTH2', lambda x: auth_string). Para Gmail, usa el google-autenticacion biblioteca para administrar la renovación de tokens. Para Outlook/Microsoft 365, use la msal Biblioteca de Python. Ambas requieren registrar una aplicación OAuth en Google Cloud Console o Azure AD. El código completo de imap python oauth se encuentra en la Sección 5 anterior.buscar()/fetch()/mover() métodos e incluye soporte integrado para IDLE. Ambos requieren que usted gestione la administración de tokens OAuth. Ninguno es asíncrono; para pipelines basados en asyncio, considere aioimaplib. Instalar IMAPClient con pip install imapclient.outlook.office365.com en el puerto 993 usando imaplib.IMAP4_SSL. Desde septiembre de 2024, la autenticación básica está deshabilitada para Microsoft 365; debes usar XOAUTH2. Registra una aplicación de Azure AD, solicita la IMAP.AccesoComoUsuario.Todos permiso, obtener un token de acceso utilizando el msal Biblioteca de Python, luego autenticarse con mail.authenticate('XOAUTH2', ...). Para cuentas personales de Outlook.com, se aplica el mismo flujo OAuth. Para obtener detalles del servidor y la configuración TLS, consulta nuestra Guía de conexión a servidor IMAP.outlook.office365.com:993. Sin embargo, desde septiembre de 2024, Microsoft ha deshabilitado completamente la autenticación básica para IMAP en los inquilinos de Microsoft 365. Debes usar OAuth 2.0 con el mecanismo SASL XOAUTH2. Es posible que tu administrador de Azure AD también deba habilitar el acceso IMAP en el centro de administración de Exchange. Una alternativa es usar el API Graph de Microsoft (REST) que evita IMAP por completo y proporciona metadatos más ricos.servidor.inactivo() para entrar en modo IDLE, luego server.idle_check(timeout=60) esperar eventos. Gmail se desconecta silenciosamente después de ~29 minutos, así que debes renovar: llamar server.idle_done() cada 25 minutos, luego servidor.inactivo() De nuevo. Con imaplib "crudo", IDLE requiere gestión manual a nivel de socket, considerablemente más complejo. Para correo electrónico en tiempo real en producción, un enfoque basado en webhooks (como el que proporciona Unipile) es más fiable que mantener sesiones IDLE.aioimaplib la biblioteca proporciona un cliente IMAP4 compatible con asyncio para Python. Admite comandos IMAP estándar y IDLE en un contexto asíncrono, lo que la hace adecuada para canalizaciones de alta concurrencia donde se administran muchos buzones de correo simultáneamente. Sin embargo, aioimaplib tiene una comunidad más pequeña que imaplib o IMAPClient, y el soporte de OAuth aún requiere una implementación manual de XOAUTH2. Para equipos que priorizan la velocidad del desarrollador sobre el control detallado, una API unificada basada en REST ofrece correo electrónico en tiempo real a través de webhooks sin gestión de sockets asíncronos.
ES 
EN 
FR 
DE 
IT 
BR 
NL 
PL 
TR