Dev Life
Mejores prácticas de email transaccional para desarrolladores
¿Has recibido un email de notificación instantánea cuando compraste algo en línea? Eso es esencialmente lo que es un mensaje transaccional es. Los mensajes transaccionales son emails o notificaciones automatizados que recibes cuando te registras en un servicio, haces una compra o restableces una contraseña. También incluyen alertas de fraude, recordatorios de carrito abandonado y actualizaciones bancarias y de entrega. A diferencia de los emails de marketing, estos confirman acciones y te mantienen informado, lo que genera confianza y mejora la interacción del usuario.
En este artículo, aprenderás a automatizar mensajes transaccionales desde tu aplicación mediante flujos de trabajo de API para mejorar la experiencia del cliente.
¿Por qué el email transaccional es importante para la experiencia del cliente?
A diferencia de los envíos masivos emails de marketing, los mensajes transaccionales son personalizados, oportunos y esperados porque son muy relevantes para la actividad del usuario. Estos mensajes son individuales y contienen información directamente relacionada con las actividades del usuario.
Los mensajes transaccionales oportunos – como las confirmaciones de pedido y las alertas de cuenta – aumenta la satisfacción del cliente, mejoran la transparencia y fortalecen la confianza al abordar de manera eficiente las interacciones de los clientes y posibles fraudes. También ayudan a los clientes al ofrecer opciones de autoservicio y reducir la carga de trabajo de la asistencia al cliente.
A diferencia de los emails promocionales que a menudo pasan desapercibidos, los emails transaccionales se esperan con impaciencia y a menudo se abren al instante; los usuarios incluso emprenden la búsqueda del tesoro en sus carpetas de spam para encontrarlos.
¿Cómo se crea un flujo de trabajo de API para automatizar el email transaccional?
En este tutorial, aprenderás a enviar emails transaccionales desde tu aplicación mediante la configuración de flujos de trabajo sencillos con las API de Mailgun. Mailgun es una plataforma de envío de emails que te permite enviar y hacer un seguimiento de los emails. Simplifica la automatización de emails transaccionales con API fiables y fáciles de usar. Usarás Mailgun para automatizar mensajes transaccionales con Python en los siguientes escenarios:
- Registro de cuenta de usuario
- Opt in doble para suscripciones a la newsletter
- Restablecer contraseña
Antes de empezar, asegúrate de tener lo siguiente:
- Python 3.9 o superior
- Una cuenta de Mailgun (la prueba gratuita de 30 días es suficiente para este tutorial)
Configurar un nuevo proyecto de Python
Para empezar, crea un directorio para tu proyecto de Python y añade un archivo .env vacío en él.
Antes de continuar, es una buena práctica crear y activar un nuevo entorno virtual para aislar tu proyecto y evitar conflictos de dependencias.
Una vez que tu entorno virtual esté activo, instala las bibliotecas necesarias (requests y python-dotenv) ejecutando lo siguiente:
```python
pip install requests python-dotenv
```
La biblioteca requests te permite hacer llamadas a la API, y python-dotenv te ayuda a almacenar de forma segura tu clave de API fuera de tu código.
Obtener una clave de API
Para hacer llamadas a la API de Mailgun, necesitas una clave de API de tu cuenta de Mailgun.
Inicia sesión en tu cuenta de Mailgun y ve a la página de Seguridad de la API . Puedes encontrar esto en el menú desplegable bajo tu nombre en la esquina superior derecha:
Crea una clave de API y luego cópiala:
Guárdala de forma segura pegando la clave en el archivo .env de tu proyecto:
```python
MAILGUN_API_KEY="Your API Key Here"
```
Cuando uses Mailgun, toma nota de tus dominios de envío en el panel de control:
Si estás en un plan gratuito, verás un dominio sandbox, que usarás en el punto de conexión de la API y como dirección de email de «remitente» (from) al enviar emails a través de las API de Mailgun. El dominio sandbox suele verse así: .mailgun.org.
Importar módulos e inicializar
Para automatizar los emails transaccionales, empieza creando un archivo main.py en el directorio de tu proyecto y añadiendo el siguiente código:
```python
import requests
import logging
import os
from dotenv import load_dotenv
logging.basicConfig(level=logging.INFO) # Set log level
load_dotenv() # For reading the API key from the `.env` file
# Sandbox API URL format: https://api.mailgun.net/v3/sandbox.mailgun.org/messages
MAILGUN_API_URL = "https://api.mailgun.net/v3/YOUR_DOMAIN_NAME/messages"
FROM_EMAIL_ADDRESS = "Sender Name "
```
La función load_dotenv(), de la biblioteca python-dotenv , carga las variables de entorno de tu archivo .env en tu código Python. Esta es una de las mejores prácticas para almacenar y acceder de forma segura a información sensible como credenciales y claves de API.
MAILGUN_API_URL establece la URL de la API para tu script de Python, mientras que FROM_EMAIL_ADDRESS especifica la dirección de email del remitente (ambas deben usar tu dominio de envío de emails o el dominio sandbox mencionado anteriormente).
Enviar un email usando la API de Mailgun
El siguiente código te muestra cómo enviar un email a una sola dirección usando la API de Mailgun. Deberías añadir este código al archivo main.py que creaste antes, debajo de la inicialización:
```python
def _send_email(to_address: str, subject: str, message: str):
"""
Send single email to the given email address using Mailgun API.
:param to_address:
:param subject:
:param message:
"""
try:
api_key = os.getenv("MAILGUN_API_KEY") # Get API key from the `.env` file
resp = requests.post(MAILGUN_API_URL, auth=("api", api_key),
data={"from": FROM_EMAIL_ADDRESS,
"to": to_address, "subject": subject, "html": message})
if resp.status_code == 200: # Success
logging.info(f"Successfully sent an email to '{to_address}' via Mailgun API.")
else: # Error
logging.error(f"Could not send the email, reason: {resp.text}")
except Exception as ex:
logging.exception(f"Mailgun error: {ex}")
```
La función _send_email() toma tres argumentos: to_address, subject y message. to_address es el email del destinatario, mientras que subject y message definen el asunto y el contenido del email, respectivamente.
La función lee la clave de API de Mailgun desde el archivo .env, que luego se usa para autenticar la llamada a la API a la MAILGUN_API_URL especificada. Esta clave identifica tu cuenta de forma exclusiva, lo que permite a Mailgun verificar tu solicitud.
Para asegurarte de que el email se envía correctamente, debes usar tu clave de API única; la dirección de email de «remitente» (from) debe estar asociada a tu dominio válido o al dominio sandbox de Mailgun. De lo contrario, la llamada a la API fallará y devolverá un error.
Los datos del email se envían usando el método HTTP POST a través de la llamada requests.post(). Si la llamada a la API es exitosa, el email se pone en cola para su entrega y la API devuelve un estado HTTP 200 OK. Si se produce un error, la API proporciona un mensaje de error junto con un código de estado HTTP adecuado. Ambos escenarios son registrados por esta función para tu referencia.
Todas las automatizaciones de emails transaccionales de las siguientes secciones se basan en la función _send_email() para enviar emails a través de la API de Mailgun.
Mejores prácticas: Automatizar emails de registro de cuenta
El registro de cuenta de usuario es uno de los casos de uso más importantes para los emails transaccionales, ya que sirve como punto de entrada del usuario en tu sistema. Las primeras impresiones importan, y esta interacción inicial es una oportunidad para generar confianza y establecer una relación positiva con el usuario. Un email de felicitación oportuno en el momento del registro no solo confirma el éxito del proceso, sino que también le asegura al usuario que su cuenta está lista para usarse.
Para lograr esto, tu sistema debería enviar inmediatamente un email de confirmación automatizado para que el usuario sepa que su registro fue exitoso.
Aquí tienes un ejemplo de cómo implementar esto:
```python
def _notify_registration(user_name: str, user_email: str):
"""
Notify user on successful registration using `_send_email`
:param user_name:
:param user_email:
"""
# Use your own formatted HTML message here, with an appropriate link
registration_msg = f'Dear {user_name},<br /><br /> You have successfully registered on our site.'
_send_email(user_email, "Registration successful", registration_msg)
def register_user(user_name: str, user_email: str):
"""
Register the user and notify the user on successful registration.
:param user_name:
:param user_email:
"""
# Actual code to register the user
logging.info(f"Sending registration email to the user: {user_name}...")
_notify_registration(user_name, user_email)
```
La primera función, _notify_registration(), es responsable de enviar una notificación por email a un usuario que acaba de registrarse. Toma dos parámetros: user_name y user_email. Dentro de esta función, se construye un mensaje HTML sencillo usando una f-string, lo que permite una fácil inserción del nombre del usuario en el mensaje. Luego, esta función llama a la función previamente comentada _send_email() para enviar el email.
La segunda función stub, register_user(), sugiere el punto de entrada principal para el proceso de registro de usuario dentro de tu sistema. También toma user_name y user_email como parámetros. En la vida real, normalmente tendría más parámetros u objetos ‘usuario’ con más detalles. Esta función se encarga de gestionar el proceso de registro. Como se muestra aquí, registra el envío del email y llama a la función _notify_registration() para iniciar el email de confirmación automatizado tras completar el registro de usuario.
El registro de usuario actúa como un evento disparador para este email transaccional, y puedes automatizarlo usando el flujo de trabajo de API que se muestra arriba. También es una gran oportunidad para informar a los usuarios sobre tus servicios y características clave.
Mejores prácticas: Automatizar emails de confirmación de opt in doble
Cuando un usuario se suscribe a tu newsletter, en lugar de añadirlo inmediatamente a tu lista de suscriptores, puedes enviar un email pidiéndole que confirme su suscripción. Este proceso, llamado confirmación de opt in doble, es un requisito legal en algunos países para el cumplimiento normativo.
Aquí, la suscripción del usuario actúa como disparador, y puedes automatizar la confirmación de opt in doble con el siguiente código:
```python
def _notify_subscription(user_name: str, user_email: str):
"""
Double opt-in confirmation for user subscription.
:param user_name:
:param user_email:
"""
# Use your own formatted HTML message here, with an appropriate link
subscription_msg = f'Dear {user_name},<br /><br /> Please confirm your subscription to our newsletter by clicking ' \
f'this link: <a href="https://example.com/confirm-subscription?id=abcdef1234567xyz">' \
f'https://example.com/confirm-subscription?id=abcdef1234567xyz</a>'
_send_email(user_email, "Confirm subscription", subscription_msg)
def subscribe_user(user_name: str, user_email: str):
"""
Subscribe user and send opt-in confirmation message.
:param user_name:
:param user_email:
"""
# Code to subscribe user with pending confirmation
logging.info(f"Sending subscription confirmation email to the user: {user_name}...")
_notify_subscription(user_name, user_email)
```
La primera función, _notify_subscription(), es responsable de enviar un email de confirmación de opt in doble a un usuario que ha solicitado suscribirse a una newsletter. Toma dos parámetros: user_name y user_email. Dentro de esta función, se construye un mensaje HTML usando una f-string, que incluye el nombre del usuario y un enlace de confirmación falso. De nuevo, esta función llama a la función _send_email() para enviar el email.
La segunda función stub, subscribe_user(), es el punto de entrada principal para el proceso de suscripción del usuario. También toma user_name y user_email como parámetros. Esta función normalmente gestiona el proceso de suscripción inicial, probablemente almacenando la información del usuario con un estado ‘pendiente’. Al final, registra el envío del email y luego llama a la función _notify_subscription() para crear y enviar el email de confirmación de opt in doble.
Mejores prácticas: Automatizar emails para restablecer la contraseña
¿Alguna vez has necesitado iniciar sesión, solo para darte cuenta de que habías olvidado tu contraseña y tener que hacer clic en el enlace «olvidé mi contraseña»? Hacer clic en ese enlace actúa como disparador de un email que esperas con impaciencia.
Aquí tienes un código de ejemplo que demuestra cómo automatizar este tipo de email transaccional:
```python
def _notify_password_reset(user_name: str, user_email: str):
"""
Send password reset email to the user
:param user_name:
:param user_email:
"""
# Use your own formatted HTML message here
registration_msg = f'Dear {user_name},<br /><br /> Please use the following link to reset your password: ' \
f'<a href="https://example.com/password-reset?token=lmnopqr7654321abc">' \
f'https://example.com/password-reset?token=lmnopqr7654321abc</a>'
_send_email(user_email, "Reset password", registration_msg)
def reset_user_password(user_name: str, user_email: str):
"""
Initiate password-reset and notify user
:param user_name:
:param user_email:
"""
# Password reset code for the user
logging.info(f"Sending password reset email to the user: {user_name}...")
_notify_password_reset(user_name, user_email)
```
La función _notify_password_reset() se encarga de crear y enviar al usuario un email para restablecer la contraseña. Toma el nombre del usuario y la dirección de email como entradas. Dentro de la función, se crea un mensaje HTML usando una f-string, que incluye el nombre del usuario y una URL única para restablecer la contraseña. La función luego usa la función _send_email() para entregar este mensaje a la bandeja de entrada del usuario.
La función reset_user_password() trabaja junto a ella como punto de partida cuando un usuario quiere restablecer su contraseña. También requiere el nombre del usuario y su email como entradas. Esta función normalmente haría algo de trabajo en segundo plano para configurar el restablecimiento de contraseña (no se muestra en este código). A continuación, registra el envío del email y llama a _notify_password_reset() para enviar las instrucciones para restablecer.
De forma similar a los dos casos de uso anteriores, este par de funciones demuestra un enfoque modular para gestionar el restablecimiento de contraseñas. Al mantener separados los procesos de notificación y del disparador, este diseño hace que el sistema sea más fácil de mantener y permite futuras mejoras en el flujo de trabajo para restablecer la contraseña.
Puedes llamar a estas funciones desde la función principal como demostración, así:
```python
# Demo of automated transactional emails
if __name__ == "__main__":
register_user("Kirstin", "Kirstin ")
subscribe_user("Jakkie", "Jakkie ")
reset_user_password("Manish", "Manish ")
```
Estos tres ejemplos muestran cómo automatizar los emails transaccionales dentro de tu sistema. Cada uno sigue un patrón similar:
- Se crea una función específica para un tipo particular de notificación (registro, suscripción o restablecer contraseña), cuyo disparador es el evento o flujo de trabajo correspondiente.
- La función prepara un mensaje de email relevante.
- Se llama a una función de utilidad separada (usando la API de Mailgun) para enviar realmente el email.
Este enfoque garantiza que los emails transaccionales se envíen automáticamente en momentos clave, como cuando un usuario se registra, se suscribe o solicita restablecer su contraseña.
¿Qué sigue después de implementar estos flujos de trabajo?
En este artículo, desglosamos el poder de los emails transaccionales en la comunicación con el usuario. A diferencia de los emails de marketing, estos mensajes tienen como disparador acciones específicas (como una compra o restablecer la contraseña) y ofrecen información crucial y oportuna que mantiene a los usuarios interactuando e informados.
También cubrimos cómo automatizar estos emails usando flujos de trabajo de API, guiándote a través de la configuración de funciones para cosas como emails de bienvenida, confirmaciones de suscripción y restablecer contraseñas. Esta automatización garantiza que tus emails lleguen a las bandejas de entrada justo cuando tus usuarios los necesitan.
¿Listo para optimizar tus emails transaccionales? Con las sólidas API y las herramientas de seguimiento de Mailgun, puedes automatizar mensajes y mejorar la experiencia del usuario fácilmente de principio a fin, pero no confíes solo en nuestra palabra, compruébalo tú mismo.
