Outlook ya no envía mis correos desde Access, no reconoce la contraseña

El problema que describe se debe a que Microsoft ha actualizado sus políticas de seguridad para aplicaciones que utilizan autenticación básica (usuario y contraseña). Outlook 2016 utiliza este método por defecto, y con la adopción de OAuth (un sistema de autenticación más seguro), las aplicaciones que no lo soportan pueden enfrentar problemas de acceso.

Opciones para resolver el problema

1. Actualizar Office a una versión compatible con OAuth

Outlook 2016 no soporta OAuth de forma nativa, pero puede actualizar a una versión más reciente de Microsoft Office (como Microsoft 365 o Office 2019) que soporte OAuth. Esto permitirá integrar el flujo de autenticación moderno con su cuenta.

2. Habilitar la autenticación de aplicaciones no seguras

Si está utilizando una cuenta de correo personal (como Outlook.com), esta opción ha sido deshabilitada por Microsoft en la mayoría de los casos y no es recomendable debido a los riesgos de seguridad.

Para cuentas de Microsoft 365, podría habilitar contraseñas de aplicación desde el portal de administración (si tu cuenta lo permite), aunque este método también está siendo eliminado.

3. Usar la biblioteca Microsoft Graph API

Este método es más moderno y seguro. Requiere implementar autenticación OAuth 2.0 en su proyecto de Access VBA y enviar correos mediante Microsoft Graph.

Pasos básicos:

Registrar una aplicación en el portal de Azure para tu cuenta.

Configurar permisos de acceso al correo (Mail. Send).

Modificarsu código para usar una biblioteca HTTP que gestione OAuth y realice las solicitudes a la API de Microsoft Graph.

4. Configurar SMTP con OAuth

Configure su aplicación VBA para enviar correos directamente a través de SMTP usando OAuth.
Outlook.com y Microsoft 365 usan el servidor SMTP smtp. Office365.com con el puerto 587.

Para no lidiar con Microsfot yo utilizo CDO y Gmail. Debe configurar su cuenta de Gmail creando una contraseña de apliicación, es decir, NO es su contraseña de Gmail, esto cambió hace un tiempo.

Hay un ejemplo de JJJT donde utiliiza una clase y un modulo para seleccionar el archivo adjunto el cual he editado para adaptarlo a Access de 64 bits. Hoy lo hago con Python.

Si quiere el ejemplo lo puede solcitar a [email protected]. Aunque no es de este foro le dejo como lo hago en Python con Gmail.

From email. Message import EmailMessage
Import smtplib
from tkinter import *
From tkinter import messagebox, filedialog
From PIL import ImageTk, Image
class EmailSender:
    """Clase para manejar el envío de correos electrónicos."""
    def __init__(self, remitente, password):
        self.remitente = remitente
        self.password = password
        self.archivos_adjuntos = []
    def agregar_archivo_adjunto(self, archivo):
        """Agrega un archivo adjunto a la lista de adjuntos."""
        self.archivos_adjuntos.append(archivo)
    def limpiar_adjuntos(self):
        """Limpia la lista de archivos adjuntos."""
        self.archivos_adjuntos.clear()
    def enviar_email(self, destinatarios, asunto, mensaje):
        """Envia un correo electrónico a los destinatarios especificados."""
        email = EmailMessage()
        email["From"] = self.remitente
        email["To"] = ", ".join(destinatarios)  # Convertir lista en cadena separada por comas
        email["Subject"] = asunto
        email.set_content(mensaje)
        # Adjuntar archivos si hay seleccionados
        if self.archivos_adjuntos:
            for archivo in self.archivos_adjuntos:
                try:
                    with open(archivo, "rb") as file:
                        nombre_archivo = archivo.split("/")[-1]
                        email.add_attachment(file.read(), maintype="application", subtype="octet-stream", filename=nombre_archivo)
                except Exception as e:
                    raise Exception(f"No se pudo adjuntar el archivo {nombre_archivo}: {e}")
        # Envío de email
        try:
            smtp = smtplib.SMTP_SSL("smtp.gmail.com",465)
            smtp.login(self.remitente, self.password)
            smtp.sendmail(self.remitente, destinatarios, email.as_string())
            smtp.quit()
        except Exception as e:
            raise Exception(f"No se pudo enviar el correo: {e}")
class EmailApp:
    """Clase para la interfaz gráfica del envío de correos electrónicos usando Tkinter."""
    def __init__(self, root):
        self.root = root
        self.root.title("APLICACIÓN DE MENSAJERÍA")
        self.root.geometry("400x670")
        self.root.resizable(0, 0)
        self.root.config(bd=10)
        # Centrando la ventana en la pantalla
        ancho_pantalla = root.winfo_screenwidth()
        alto_pantalla = root.winfo_screenheight()
        pos_x = int((ancho_pantalla - 400) / 2)
        pos_y = int((alto_pantalla - 670) / 2)
        self.root.geometry(f"400x670+{pos_x}+{pos_y}")
        # Inicializar la clase EmailSender
        self.email_sender = EmailSender("[email protected]", "mipass_gmail)
        # Variables
        self.asunto = StringVar()
        self.archivos_adjuntos = []
        # Crear la interfaz
        self.crear_interfaz()
    def crear_interfaz(self):
        """Crea la interfaz gráfica con los widgets de Tkinter."""
        Label(self.root, text="ENVIAR CORREO VIA GMAIL", fg="black", font=("Arial", 15, "bold"), padx=5, pady=5).grid(row=0, column=0, columnspan=2)
        # Imagen GMAIL
        imagen_gmail = Image.open("D:/EnviarEmailPython/logo_gmail.png")
        nueva_imagen = imagen_gmail.resize((125, 84))
        render = ImageTk.PhotoImage(nueva_imagen)
        label_imagen = Label(self.root, image=render)
        label_imagen.image = render
        label_imagen.grid(row=1, column=0, columnspan=2)
        Label(self.root, text="Mi correo: [email protected]", fg="white", bg="blue", font=("Arial", 10, "bold"), padx=5, pady=5).grid(row=2, column=0, columnspan=2, pady=5)
        # Textbox para ingresar múltiples destinatarios
        Label(self.root, text="Destinatarios (uno por línea):", fg="black", font=("Arial", 10, "bold"), padx=5, pady=5).grid(row=3, column=0, columnspan=2)
        self.destinatarios_text = Text(self.root, height=5, width=42)
        self.destinatarios_text.grid(row=4, column=0, columnspan=2)
        Label(self.root, text="Asunto:", fg="black", font=("Arial", 10, "bold"), padx=5, pady=5).grid(row=5, column=0)
        Entry(self.root, textvariable=self.asunto, width=34).grid(row=5, column=1)
        Label(self.root, text="Mensaje:", fg="black", font=("Arial", 10, "bold"), padx=5, pady=5).grid(row=6, column=0)
        self.mensaje = Text(self.root, height=5, width=28, padx=5, pady=5)
        self.mensaje.grid(row=6, column=1)
        self.mensaje.config(font=("Arial", 9), padx=5, pady=5)
        # Listbox para mostrar archivos adjuntos
        Label(self.root, text="Archivos adjuntos:", fg="black", font=("Arial", 10, "bold"), padx=5, pady=5).grid(row=7, column=0, sticky="w")
        self.lista_adjuntos = Listbox(self.root, width=34, height=5)
        self.lista_adjuntos.grid(row=7, column=1)
        # Botones
        Button(self.root, text="Adjuntar archivos", command=self.adjuntar_archivos, height=2, width=15, bg="gray", fg="white", font=("Arial", 10, "bold")).grid(row=8, column=0, columnspan=2, padx=(50, 5), pady=20)
        Button(self.root, text="Enviar", command=self.enviar_email, height=2, width=10, bg="black", fg="white", font=("Arial", 10, "bold")).grid(row=9, column=0, columnspan=2, padx=(50, 5), pady=10)
    def adjuntar_archivos(self):
        """Función para seleccionar múltiples archivos adjuntos."""
        archivos = filedialog.askopenfilenames(title="Seleccione archivos para adjuntar")
        if archivos:
            self.email_sender.archivos_adjuntos.extend(archivos)
            # Limpiar la lista antes de mostrar los nuevos archivos seleccionados
            self.lista_adjuntos.delete(0, END)
            # Mostrar archivos seleccionados en el Listbox
            for archivo in self.email_sender.archivos_adjuntos:
                self.lista_adjuntos.insert(END, archivo.split("/")[-1])
    def enviar_email(self):
        """Función para enviar el correo electrónico usando la clase EmailSender."""
        # Obtener los destinatarios como una lista
        destinatarios = self.destinatarios_text.get(1.0, 'end').strip().split("\n")
        destinatarios = [email.strip() for email in destinatarios if email.strip()]
        # Validar que los campos no estén vacíos
        if not destinatarios:
            messagebox.showwarning("Advertencia", "El campo 'Destinatarios' no puede estar vacío.")
            return
        if not self.asunto.get().strip():
            messagebox.showwarning("Advertencia", "El campo 'Asunto' no puede estar vacío.")
            return
        if not self.mensaje.get(1.0, 'end').strip():
            messagebox.showwarning("Advertencia", "El campo 'Mensaje' no puede estar vacío.")
            return
        try:
            self.email_sender.enviar_email(destinatarios, self.asunto.get(), self.mensaje.get(1.0, 'end'))
            messagebox.showinfo("MENSAJERIA", "Mensaje enviado correctamente")
        except Exception as e:
            messagebox.showerror("Error", str(e))
if __name__ == "__main__":
    root = Tk()
    app = EmailApp(root)
    Root. Mainloop()

Este pequeño aplicativo le permite enviar varios correos y múltiples archivos adjuntos.

Cambie [email protected] por su correo y mipass_gmail por la contraseña de aplicación que le da Google.

¡Gracias! Me ayuda mucho está información, voy a utilizar este método, si puedo lograrlo te platico cómo me fue.

Gracias, oye quiere decir que puedo omitir el uso de Azure usnado CDO con Gmail?