Python Envía Email Gmail: Tutorial con Ejemplos [2025]

En este tutorial, usando ejemplos de código, explicaremos cómo usar diferentes módulos en Python para construir y enviar varios tipos de mensajes de email, revisaremos los métodos de autenticación existentes y más. Como ejemplo, usaremos tanto el servidor SMTP de Gmail como su API.

Si quiere conocer otros métodos para enviar emails en Python, consulte nuestra guía completa.

¿Listo para enviar sus emails?

Pruebe Mailtrap Gratis

Configuración de las bibliotecas smtplib y email de Python

Para enviar un email con Python a través de Gmail SMTP, usted debe usar el módulo smtplib y el módulo email. El módulo smtplib proporciona esencialmente funciones para conectar y enviar emails usando un servidor de Simple Mail Transfer Protocol (SMTP).

En cuanto al módulo email, proporciona clases para construir y analizar mensajes de email (To; From; Subject; etc.) también permite codificar y decodificar emails con el estándar MIME (Multipurpose Internet Mail Extensions).

Analicemos los pasos necesarios. Y, en la siguiente sección, podrá ver el código real.

Importe las bibliotecas necesarias: smtplib y MIMEText del módulo email.
Cree el mensaje de email usando el objeto MIMEText, y establezca los valores deseados en los campos ‘Subject’, ‘Sender’ y ‘Recipients‘.
Establezca la conexión SMTP al servidor de Gmail a través de una conexión SSL segura usando la función SMTP_SSL.
Llame al método sendmail del objeto SMTP, y especifique las direcciones de email del remitente y del destinatario, también el mensaje de email como argumentos.

Con eso listo, está preparado para enviar emails vía Gmail en Python. En las siguientes secciones, cubriré la metodología, ejemplos y otros casos de uso. En caso de que necesite repasar sus habilidades, consulte estos cursos de Python online antes.

Enviar email en Python usando SMTP de Gmail

Basándome en lo que cubrí en la sección anterior, aquí hay un script simple para enviar emails:

import smtplib
from email.mime.text import MIMEText

subject = "Asunto del Email"
body = "Este es el cuerpo del mensaje de texto"
sender = "remitente@gmail.com"
recipients = ["destinatario1@gmail.com", "destinatario2@gmail.com"]
password = "contraseña"


def send_email(subject, body, sender, recipients, password):
    msg = MIMEText(body)
    msg['Subject'] = subject
    msg['From'] = sender
    msg['To'] = ', '.join(recipients)
    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp_server:
       smtp_server.login(sender, password)
       smtp_server.sendmail(sender, recipients, msg.as_string())
    print("¡Mensaje enviado!")


send_email(subject, body, sender, recipients, password)

Notas Importantes:

Antes del 30 de mayo de 2022, era posible conectarse al servidor SMTP de Gmail usando su contraseña regular de Gmail si la “verificación en 2 pasos” estaba activada. Para un estándar de seguridad más alto, Google ahora requiere que use una “Contraseña de Aplicación” (“App Password”).

Esta es una contraseña de 16 dígitos que se genera en su cuenta de Google y permite que aplicaciones o dispositivos menos seguros que no admiten la verificación en 2 pasos inicien sesión en su cuenta de Gmail.

Alternativamente, existe el modo de autenticación OAuth 2.0 de Gmail, pero en este caso, necesitará usar el método de envío de la API de Gmail en su script de Python.

Enviar email a múltiples destinatarios

Para enviar el email a múltiples destinatarios, definiré una lista de direcciones de email para permitir el envío a múltiples destinatarios. Además, el campo ‘To’ establece los destinatarios bajo los encabezados del mensaje. Se convierte de una lista a una string (cadena) separada por comas, que es un formato aceptado por la mayoría de los encabezados de email.

Aquí está el código:

import smtplib
from email.mime.text import MIMEText

# Defina el asunto y cuerpo del email.
subject = "Asunto del Email"
body = "Este es el cuerpo del mensaje de texto"
# Defina la dirección de email del remitente.
sender = "remitente@gmail.com"
# Lista de destinatarios a quienes se les enviará el email.
recipients = ["destinatario1@gmail.com", "destinatario2@gmail.com"]
# Contraseña para la cuenta de email del remitente.
password = "contraseña"

def send_email(subject, body, sender, recipients, password):
    # Cree un objeto MIMEText con el cuerpo del email.
    msg = MIMEText(body)
    # Establezca el asunto del email.
    msg['Subject'] = subject
    # Establezca el email del remitente.
    msg['From'] = sender
    # Una la lista de destinatarios en una sola string separada por comas.
    msg['To'] = ', '.join(recipients)
   
    # Conecte al servidor SMTP de Gmail usando SSL.
    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp_server:
        # Inicie sesión en el servidor SMTP usando las credenciales del remitente.
        smtp_server.login(sender, password)
        # Envíe el email. La función sendmail requiere el email del remitente, la lista de destinatarios y el mensaje de email como string.
        smtp_server.sendmail(sender, recipients, msg.as_string())
    # Imprima un mensaje en consola después de enviar exitosamente el email.
    print("¡Mensaje enviado!")

# Llame a la función para enviar el email.
send_email(subject, body, sender, recipients, password)

Enviar email con adjuntos

Necesita importar las bibliotecas necesarias. En este caso, también necesitará MIMEBase que permite representar un archivo adjunto y encoders, que son usados para codificar el adjunto en formato base64.

Aquí está el script completo incluyendo comentarios que le ayudarán a entender cómo enviar un email con adjuntos:

import smtplib
from email import encoders
from email.mime.base import MIMEBase
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

sender_email = "remitente@gmail.com"
sender_password = "contraseña"
recipient_email = "destinatario@gmail.com"
subject = "Hola, desde Python"
body = "con adjunto"


with open("attachment.txt", "rb") as attachment:
    # Agregue el adjunto al mensaje
    part = MIMEBase("application", "octet-stream")
    part.set_payload(attachment.read())
encoders.encode_base64(part)
part.add_header(
    "Content-Disposition",
    f"attachment; filename= 'attachment.txt'",
)

message = MIMEMultipart()
message['Subject'] = subject
message['From'] = sender_email
message['To'] = recipient_email
html_part = MIMEText(body)
message.attach(html_part)
message.attach(part)

with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
   server.login(sender_email, sender_password)
   server.sendmail(sender_email, recipient_email, message.as_string())

Enviar email HTML

Al igual que con un mensaje de email regular, para enviar un email HTML usando el servidor SMTP de Gmail en Python, use la clase MIMEText del paquete email. Después, use el objeto html_message en lugar del objeto de texto plano msg y pegue el contenido HTML en el cuerpo del email.

Aquí hay un ejemplo de código completo:

import smtplib
from email.mime.text import MIMEText

sender_email = "remitente@gmail.com"
sender_password = "contraseña"
recipient_email = "destinatario@gmail.com"
subject = "Hola, desde Python"
body = """
<html>
  <body>
    <p>Este es un email <b>HTML</b> enviado desde Python usando el servidor SMTP de Gmail.</p>
  </body>
</html>
"""
html_message = MIMEText(body, 'html')
html_message['Subject'] = subject
html_message['From'] = sender_email
html_message['To'] = recipient_email
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
   server.login(sender_email, sender_password)
   server.sendmail(sender_email, recipient_email, html_message.as_string())

Si usted quisiera enviar un email usando una plantilla HTML en lugar de tener el HTML en el cuerpo, puede usar la clase Template del paquete jinja2, un motor de plantillas rápido, expresivo y extensible.

pip install jinja2

Aquí está el script con todos los pasos necesarios:

import smtplib
from email.mime.text import MIMEText
from jinja2 import Template

sender_email = "remitente@gmail.com"
sender_password = "contraseña"
recipient_email = "destinatario@gmail.com"
with open('plantilla.html', 'r') as f:
    template = Template(f.read())
context = {
    'subject': 'Hola, desde Python',
    'body': 'Este es un email enviado desde Python usando una plantilla HTML y el servidor SMTP de Gmail.'
}
html = template.render(context)
html_message = MIMEText(context['body'], 'html')
html_message['Subject'] = context['subject']
html_message['From'] = sender_email
html_message['To'] = recipient_email
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
   server.login(sender_email, sender_password)
   server.sendmail(sender_email, recipient_email, html_message.as_string())

Si quiere aprender más sobre el envío de contenido dinámico desde su aplicación Python, le recomendamos consultar nuestro artículo sobre Mail Merge.

Enviar emails masivos

Le mostraré cómo enviar emails masivos vía Gmail, pero tenga en cuenta que esto es solo para demostración, no un método que debería usar en producción.

Gmail tiene políticas bastante estrictas sobre el envío de emails masivos y campañas, hablo de ello en una sección posterior (Léalo haciendo clic en el enlace). Además, su entregabilidad podría verse afectada, particularmente con un dominio nuevo o una calificación de dominio relativamente baja. O si simplemente intenta enviar desde una dirección @gmail.com.

Con esto en mente, el script a continuación está diseñado para escenarios donde cada destinatario debe recibir un email separado e individual, lo cual es común en campañas personalizadas de marketing, notificaciones, etc.

Simplemente, el mismo mensaje se envía a múltiples personas sin agruparlas en un solo email. Este método también evita revelar la lista de destinatarios entre sí, preservando la privacidad.

Revise el script a continuación.

import smtplib
from email.mime.text import MIMEText

# Contenido del email
subject = "Asunto del Email"
body = "Este es el cuerpo del mensaje de texto"
sender = "remitente@gmail.com"
recipients = ["destinatario1@gmail.com", "destinatario2@gmail.com", "destinatario3@gmail.com"]  # Lista de destinatarios
password = "contraseña"

def send_bulk_emails(subject, body, sender, recipients, password):
    # Conecte al servidor SMTP de Gmail usando SSL
    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp_server:
        smtp_server.login(sender, password)  # Inicie sesión en el servidor

        # Recorra cada destinatario y envíeles un email individual
        for recipient in recipients:
            msg = MIMEText(body)  # Cree un objeto MIMEText con el cuerpo del email
            msg['Subject'] = subject  # Establezca el asunto del email
            msg['From'] = sender  # Establezca el remitente
            msg['To'] = recipient  # Establezca el destinatario actual

            smtp_server.sendmail(sender, recipient, msg.as_string())  # Envíe el email
            print(f"¡Mensaje enviado a {recipient}!")

# Llame a la función para enviar emails masivos
send_bulk_emails(subject, body, sender, recipients, password)

Ahora, me gustaría darle un desglose rápido para explorar cómo funciona todo:

En la inicialización, el script define el asunto, cuerpo, dirección de email del remitente, lista de destinatarios y contraseña.
Con send_bulk_emails, el script realiza una conexión segura al servidor SMTP de Gmail en el puerto 465 vía smtplib.SMTP_SSL. Después de establecer una conexión, el script inicia sesión en el servidor SMTP usando las credenciales de Gmail del remitente.
Luego, el script recorre los destinatarios, haciendo lo siguiente para cada uno:

Se crea un objeto MIMEText para el cuerpo del email.
Se establecen los encabezados del email (Subject, From, To). To se establece individualmente para cada destinatario, para así asegurar que cada email sea personalizado.
El email se envía al destinatario actual. El método sendmail toma el remitente, el destinatario actual y el contenido del email como argumentos.

La ventaja de este método es que cada mensaje se registra o maneja por separado. Esto ayuda a rastrear el éxito de cada email enviado de una manera más eficiente, lo cual es crucial para operaciones masivas.

Enviar email en Python usando la API de Gmail

La API de Gmail es una API RESTful que permite a su aplicación enviar y recibir emails usando los servidores de correo de Google. Además, le da la capacidad de recuperar y gestionar mensajes, mientras usa características de Gmail como etiquetas, hilos, etc.

Analicemos cada paso para enviar un email con Python vía API de Gmail usando autenticación OAuth2.

Configure un proyecto en la Google Cloud Platform, haga clic en el menú hamburger y seleccione ver todos los productos. Bajo la sección de gestión, seleccione APIs y servicios

A continuación, seleccione Biblioteca y escriba “Gmail API” en la barra de búsqueda, luego haga clic en la tarjeta de Gmail API.

Finalmente, seleccione el botón para habilitar la API de Gmail.

Ahora, necesitará descargar el archivo de secretos del cliente para su proyecto. Comience seleccionando “Crear Credenciales”. En esta sección, seleccione la API de Gmail como su API preferida y datos de usuario como el tipo de datos al que accederá.

Para obtener el ID de cliente OAuth, seleccione su tipo de aplicación como Aplicación de Escritorio (Desktop App), establezca el nombre de la aplicación y seleccione crear. Luego, descargue y almacene las credenciales en su sistema de archivos local.

Después de descargar el archivo secreto, debería tenerlo en este formato:

{
    "installed": {
        "client_id": "463220703866-un8ijck75igunsbh4nhclm74edprhj5p.apps.googleusercontent.com",
        "project_id": "geocaching-366015",
        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
        "token_uri": "https://oauth2.googleapis.com/token",
        "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
        "client_secret": "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",
        "redirect_uris": [
            "http://localhost"
        ]
    }
}

Antes de comenzar con el código, necesitará instalar las bibliotecas google-auth, google-auth-oauthlib, google-auth-httplib2 y google-api-python-client usando el comando:

pip install google-auth google-auth-oauthlib google-auth-httplib2 google-api-python-client

Después de instalar correctamente las bibliotecas, creará una variable llamada SCOPES que contendrá una lista de strings que especifica los permisos que tiene una aplicación cuando accede a los datos de un usuario.

En este punto, cree otra variable llamada flow que utilizará la clase InstalledAppFlow para crear un flujo OAuth 2.0 para una aplicación instalada y especifique los ámbitos OAuth 2.0 que la aplicación necesita en la variable SCOPES.

El código luego inicia el flujo OAuth 2.0 llamando al método run_local_server y especificando un número de puerto, lo que inicia un servidor web local para manejar el flujo de autorización y devolver las credenciales OAuth 2.0 cuando se completa el flujo.

A continuación, construya el servicio de Gmail llamando a la función build del módulo googleapiclient.discovery, pasando ‘gmail’ como nombre del servicio y ‘v1’ como argumentos de versión, y tomando las credenciales que llamó anteriormente.

Ahora construya el mensaje de email creando un objeto MIMEText y estableciendo los campos ‘to’ y ‘subject’ con los valores deseados. Además, codifique el mensaje de email como una string base64-encoded.

Finalmente, puede enviar el email llamando al método send del recurso de mensajes y pasándolo en el diccionario create_message como el cuerpo de la solicitud.

Este es el aspecto del código Python cuando se combinan todos estos pasos:

import base64
from email.mime.text import MIMEText
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build
from requests import HTTPError
SCOPES = [
        "https://www.googleapis.com/auth/gmail.send"
    ]
flow = InstalledAppFlow.from_client_secrets_file(
            'credentials.json', SCOPES)
creds = flow.run_local_server(port=0)
service = build('gmail', 'v1', credentials=creds)
message = MIMEText('Este es el cuerpo del email')
message['to'] = 'destinatario@gmail.com'
message['subject'] = 'Asunto del email'
create_message = {'raw': base64.urlsafe_b64encode(message.as_bytes()).decode()}
try:
    message = (service.users().messages().send(userId="me", body=create_message).execute())
    print(F'Mensaje enviado a {message} Id del mensaje: {message["id"]}')
except HTTPError as error:
    print(F'Ocurrió un error: {error}')
    message = None

¡Eso es todo! Así de simple, y con unas pocas líneas de código, puede agregar una funcionalidad rápida de envío de emails a la aplicación que está construyendo y, por supuesto, no olvide validar las direcciones de email de sus usuarios.

Limitaciones de la API y SMTP de Gmail

Usar la API o SMTP de Gmail es una opción conveniente y confiable para la automatización del envío de emails, pero, tal como se mencionó, tiene algunas limitaciones.

Límite de envío diario y límite de tamaño máximo del email

Para garantizar que un solo usuario o aplicación no consuma demasiados recursos, la API limita la cantidad de emails que puede enviar diariamente y tiene un límite de tamaño máximo de email. Para obtener números precisos sobre estas limitaciones, consulte la documentación de Google.

Soporte limitado para características

La API puede no admitir todas las características disponibles a través de la interfaz web de Gmail, como la capacidad de programar emails para enviarlos más tarde o utilizar ciertos tipos de formato y/o archivos adjuntos.

Los scopes OAuth controlan el acceso a los datos del usuario

Cuando autentique su aplicación, debe solicitar los scopes de OAuth adecuados para acceder a los datos que necesita. El usuario debe otorgar a su aplicación el acceso a sus datos, adhiriéndose al principio del menor privilegio y potencialmente utilizando just in time permissions para una mayor seguridad. Sin los scopes de OAuth adecuados, sus solicitudes de acceso a los datos del usuario serán denegadas y resultarán en un error.

Cuotas y límites de tasa

La API de Gmail está sujeta a un límite de uso diario, que se aplica a todas las solicitudes realizadas desde su aplicación, y límites de tasa por usuario. Cada límite se identifica en términos de unidades de cuota, o una unidad abstracta de medida que representa el uso de los recursos de Gmail.

Por ejemplo, enviar un mensaje consume 100 unidades de cuota, mientras que la mayoría de las otras acciones, como obtener un mensaje o crear un borrador, consumen muchas menos unidades de cuota.

Límites de envío

El acceso SMTP de Gmail tiene límites estrictos para evitar abusos y garantizar la disponibilidad del servicio. Por lo general, estos límites son más bajos que los de la API de Gmail, a menudo restringiendo a los usuarios a enviar menos emails por día.

Tamaño de los archivos adjuntos

Al igual que la API, el servicio SMTP limita el tamaño de los archivos adjuntos del email. El tamaño combinado del email (cuerpo y archivos adjuntos totales) no debe exceder los 25 MB.

Limitación de conexiones

Si se realizan demasiadas conexiones o intentos de autenticación en un corto período de tiempo, Gmail puede limitar su conexión, lo que limita temporalmente su capacidad para enviar más emails. Esto es parte del esfuerzo de Gmail para identificar y evitar posibles comportamientos abusivos o de spam a través de SMTP.

¿Existe una alternativa a la infraestructura de email de Gmail?

La respuesta corta es sí.

Hay muchas alternativas al uso del servidor SMTP de Gmail para enviar emails. puede utilizar cualquier otro proveedor de email de su elección. Es importante asegurarse de que la infraestructura de su servidor cumpla con sus requisitos y necesidades.

Otra opción es utilizar un proveedor de servicios de email de terceros con una API que permita enviar emails desde su propia aplicación utilizando sus servidores. Además, antes de implementar la funcionalidad de envío de emails en su aplicación, es importante probarla.

Aquí es donde la Plataforma de Email Delivery de Mailtrap resulta útil.

La plataforma ofrece Servicio de API/SMTP de Email, que se utiliza para enviar emails mientras le brinda más control sobre su infraestructura de email, y Sandbox de Email, una herramienta que le permite probar y depurar esos emails antes de enviarlos.

Si desea utilizar la API de Email de Mailtrap con su aplicación Python, después de verificar su nombre de dominio, vaya a la sección de Sending Domains y seleccione la pestaña API and SMTP. En el menú desplegable, seleccione Python, copie y pegue el código generado con sus credenciales en su script.

Consejo: Consulte la documentación oficial de GitHub sobre el SDK Python de Mailtrap

import requests

url = "https://send.api.mailtrap.io/api/send"

payload = "{\"from\":{\"email\":\"mailtrap@mailtrap.club\",\"name\":\"Prueba Mailtrap\"},\"to\":[{\"email\":\"ejemplo@railsware.com\"}],\"subject\":\"¡Eres increíble!\",\"text\":\"¡Felicidades por enviar un email de prueba con Mailtrap!\",\"category\":\"Integration Test\"}"
headers = {
  "Authorization": "Bearer 48d3783bde8152*******************",
  "Content-Type": "application/json"
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

También puede seleccionar el método SMTP y copiar las configuraciones relevantes de la aplicación. Solo asegúrese de elegir el flujo de envío correcto: Transaccional o Masivo (Bulk), según el tipo de emails que desee enviar.

Aquí tiene un ejemplo:

import smtplib
from email.mime.text import MIMEText

# Defina el contenido y las credenciales de su email
subject = "Asunto del email"
body = "Este es el cuerpo del email."
sender_email = "remitente@gmail.com"
receiver_email = "destinatario@gmail.com"
password = "su_contraseña"  # ¡Tenga cuidado con las contraseñas en el código!

# Cree el objeto MIMEText
message = MIMEText(body)
message['Subject'] = subject
message['From'] = sender_email
message['To'] = receiver_email

# Conéctese al servidor SMTP de Gmail
with smtplib.SMTP('live.smtp.mailtrap.io', 587) as server:  # Note el uso del puerto 587 para STARTTLS
    server.ehlo()  # Se puede llamar opcionalmente (se llama automáticamente después de una conexión)
    server.starttls()  # Asegure la conexión
    server.ehlo()  # Se puede llamar opcionalmente (nos vuelve a identificar en el servidor después de STARTTLS)
    server.login(sender_email, password)
    server.send_message(message)  # Envíe el email

    print("¡Email enviado con éxito!")

Notas:

El método starttls() se llama para iniciar la actualización TLS. Después de esta llamada, la conexión está encriptada.
El ejemplo presenta un cuerpo de mensaje simple, puede mejorarlo con estilos HTML o CSS según lo que usted considere apropiado.

Envíe emails gratis con Mailtrap

Probar emails y envío de emails en staging

Probar la efectividad de sus emails es crucial para asegurarse de que se entreguen con éxito y estén formateados adecuadamente.

El sandbox de email ofrece una variedad de características para ayudarle a hacer precisamente eso. Al capturar el tráfico SMTP, le permite analizar el contenido del email para obtener una puntuación de spam, validar HTML/CSS, revisar datos sin procesar y mucho más, asegurando así que sus emails estén formateados correctamente y sean entregados con éxito.

Aquí usaré Email Testing de Mailtrap para mostrarle cómo aprovechar un sandbox a través de SMTP o API.

Panel de verificación HTML de Email Testing de Mailtrap

SMTP

Email Testing de Mailtrap se puede integrar fácilmente con su aplicación Python en solo unos pocos clics. Todo lo que tiene que hacer es copiar las credenciales SMTP generadas por la aplicación y pegarlas en su código.

Luego elija una de las muestras de código Python disponibles en Integraciones y ejecútela para ver la prueba en acción. Por supuesto, nuestro ejemplo de código predeterminado se puede adaptar a sus necesidades.

Ejemplo de integración de Email Testing de Mailtrap

Pruebe emails gratis con Mailtrap

API

Si usted desea automatizar los flujos de pruebas de control de calidad y tener más control sobre las pruebas, la API de Email Testing de Mailtrap es el camino a seguir.

Aquí, le mostraré cómo configurar todo, por supuesto, asumiendo que ya es un usuario. Y puede consultar todos los detalles en nuestra documentación oficial de la API.

import http.client
import json

def test_send_email():
    conn = http.client.HTTPSConnection("sandbox.api.mailtrap.io")
   
    payload = {
        "to": [{"email": "john_doe@ejemplo.com", "name": "John Doe"}],
        "cc": [{"email": "jane_doe@ejemplo.com", "name": "Jane Doe"}],
        "bcc": [{"email": "james_doe@ejemplo.com", "name": "Jim Doe"}],
        "from": {"email": "ventas@ejemplo.com", "name": "Equipo de ventas de ejemplo"},
        "attachments": [
            {
                "content": "base64_encoded_content_here",
                "filename": "index.html",
                "type": "text/html",
                "disposition": "attachment"
            }
        ],
        "custom_variables": {"user_id": "45982", "batch_id": "PSJ-12"},
        "headers": {"X-Message-Source": "dev.mydomain.com"},
        "subject": "Confirmación de su pedido de ejemplo",
        "text": "Felicidades por su pedido no. 1234",
        "category": "API Test"
    }

    headers = {
        'Content-Type': "application/json",
        'Accept': "application/json",
        'Api-Token': "su_token_api_aqui"  # Reemplace con su token de API real
    }

    # Convierta el payload en una string JSON
    json_payload = json.dumps(payload)

    # Realice la solicitud POST
    conn.request("POST", "/api/send/inbox_id", json_payload, headers)  # Reemplace 'inbox_id' con su ID de bandeja de entrada real

    # Obtenga la respuesta
    response = conn.getresponse()
    data = response.read()

    print(data.decode("utf-8"))

if __name__ == "__main__":
    test_send_email()

El script anterior se conecta a la API de Email Testing de Mailtrap a través de http.client.HTTPSConnection. El contenido del email, incluyendo asunto, contenido de texto, destinatarios, etc., se define como una payload JSON. Y la solicitud POST se realiza con la payload que usted establece.

Consejos profesionales:

Si desea agregar archivos adjuntos, codifique el contenido en Base64 e inclúyalo en el campo content.
En el encabezado Api-Token, incluya su token de API real de Mailtrap, que se puede encontrar en Settings > API Tokens.
La solicitud POST se realiza a /api/send/inbox_id. Asegúrese de reemplazar inbox_id con su ID de bandeja real, que puede ser encontrado en la URL de la bandeja de entrada.

Conclusión

¡Esperamos que esto le ayude a desarrollar la funcionalidad de envío de emails en su aplicación! Solo recuerde asegurarse de investigar qué framework de Python utilizar, antes de comenzar a construirla, ya que cada uno tiene su propio conjunto de características y beneficios:

Cómo Enviar Emails en Python con SMTP y API de Gmail