Dev Life
Práticas recomendadas de e-mail transacional para desenvolvedores
Já recebeu um e-mail de notificação instantânea ao comprar algo online? Isso é essencialmente o que é uma mensagem transacional é. As mensagens transacionais são e-mails ou notificações automatizados que você recebe ao se inscrever em um serviço, fazer uma compra ou redefinir uma senha. Elas também incluem alertas de fraude, lembretes de carrinho abandonado e atualizações de entrega e bancárias. Ao contrário dos e-mails de marketing, elas confirmam ações e mantêm você informado, construindo confiança e melhorando o engajamento do usuário.
Neste artigo, você aprenderá a automatizar mensagens transacionais do seu aplicativo usando fluxos de trabalho de API para melhorar a experiência do cliente.
Por que o e-mail transacional é importante para a experiência do cliente?
Em contraste com envios em massa e-mails de marketing, as mensagens transacionais são personalizadas, oportunas e aguardadas, pois são altamente relevantes para a atividade do usuário. Essas mensagens são individuais e contêm informações diretamente relacionadas às atividades do usuário.
Mensagens transacionais oportunas – como confirmações de pedido e alertas de conta – aumentar a satisfação do cliente, aumentam a transparência e fortalecem a confiança ao lidar de forma eficiente com as interações dos clientes e possíveis fraudes. Elas também ajudam os clientes ao oferecer opções de autoatendimento e reduzir a carga sobre o suporte ao cliente.
Ao contrário de e-mails promocionais que costumam passar despercebidos, os e-mails transacionais são muito aguardados e frequentemente abertos instantaneamente; os usuários até fazem uma caça ao tesouro em suas pastas de spam para localizá-los.
Como construir um fluxo de trabalho de API para automatizar e-mails transacionais?
Neste tutorial, você aprenderá a enviar e-mails transacionais do seu aplicativo configurando fluxos de trabalho simples com APIs do Mailgun. O Mailgun é uma plataforma de envio de e-mails que permite enviar e rastrear e-mails. Ele simplifica a automação de e-mail transacional com APIs confiáveis e fáceis de usar. Você usará o Mailgun para automatizar mensagens transacionais com Python nos seguintes cenários:
- Inscrição de conta de usuário
- Duplo opt-in para assinaturas de newsletter
- Redefinição de senha
Antes de começar, certifique-se de ter o seguinte:
- Python 3.9 ou superior
- Uma conta do Mailgun (o teste gratuito de 30 dias é suficiente para este tutorial)
Configure um novo projeto em Python
Para começar, crie um diretório para o seu projeto em Python e adicione um arquivo .env vazio dentro dele.
Antes de prosseguir, é uma boa prática criar e ativar um novo ambiente virtual para isolar seu projeto e evitar conflitos de dependências.
Quando o seu ambiente virtual estiver ativo, instale as bibliotecas necessárias (requests e python-dotenv) executando o seguinte:
```python
pip install requests python-dotenv
```
A biblioteca requests permite fazer chamadas de API, e o python-dotenv ajuda a armazenar sua chave de API com segurança fora do seu código.
Obtenha uma chave de API
Para fazer chamadas de API para o Mailgun, você precisa de uma chave de API da sua conta do Mailgun.
Faça login na sua conta do Mailgun e navegue até a Segurança da API página. Você pode encontrar isso no menu suspenso abaixo do seu nome, no canto superior direito:
Crie uma chave de API e copie-a:
Armazene-a com segurança colando a chave no arquivo .env do seu projeto:
```python
MAILGUN_API_KEY="Your API Key Here"
```
Ao usar o Mailgun, anote os seus domínios de envio na painel:
Se você estiver em um plano gratuito, verá um domínio de sandbox, que usará no endpoint da API e como o endereço de e-mail de remetente (“from”) ao enviar e-mails por meio das APIs do Mailgun. O domínio de sandbox normalmente se parece com isto: .mailgun.org.
Importar módulos e inicializar
Para automatizar e-mails transacionais, comece criando um arquivo main.py no diretório do seu projeto e adicionando o seguinte 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 "
```
A função load_dotenv(), da biblioteca python-dotenv , carrega as variáveis de ambiente do seu arquivo .env para o seu código Python. Essa é uma prática recomendada para armazenar e acessar com segurança informações confidenciais, como credenciais e chaves de API.
A MAILGUN_API_URL define a URL da API para o seu script Python, enquanto FROM_EMAIL_ADDRESS especifica o endereço de e-mail do remetente (ambos devem usar o seu domínio de envio de e-mails ou o domínio de sandbox mencionado anteriormente).
Enviar um e-mail usando a API do Mailgun
O código a seguir mostra como enviar um e-mail para um único endereço usando a API do Mailgun. Você deve adicionar este código ao arquivo main.py criado anteriormente, abaixo da inicialização:
```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}")
```
A função _send_email() recebe três argumentos: to_address, subject e message. to_address é o e-mail do destinatário, enquanto subject e message definem o assunto e o conteúdo do e-mail, respectivamente.
A função lê a chave de API do Mailgun do arquivo .env, que é então usada para autenticar a chamada da API para a MAILGUN_API_URL especificada. Essa chave identifica sua conta de forma exclusiva, permitindo que o Mailgun verifique sua solicitação.
Para garantir que o e-mail seja enviado corretamente, você deve usar a sua chave de API exclusiva; o endereço de e-mail de remetente (“from”) deve estar associado ao seu domínio válido ou ao domínio de sandbox do Mailgun. Caso contrário, a chamada da API falhará e retornará um erro.
Os dados do e-mail são enviados usando o método HTTP POST por meio da chamada requests.post(). Se a chamada da API for bem-sucedida, o e-mail será enfileirado para entrega, e a API retornará o status HTTP 200 OK. Se ocorrer um erro, a API fornece uma mensagem de erro junto com um código de status HTTP apropriado. Ambos os cenários são registrados por essa função para sua referência.
Todas as automações de e-mail transacional nas seções a seguir dependem da função _send_email() para enviar e-mails por meio da API do Mailgun.
Prática recomendada: Automatizar e-mails de registro de conta
O registro de conta de usuário é um dos casos de uso mais importantes para e-mails transacionais, pois serve como o ponto de entrada do usuário no seu sistema. As primeiras impressões são importantes, e essa interação inicial é uma oportunidade para construir confiança e estabelecer uma relação positiva com o usuário. Um e-mail de felicitação oportuno após o registro não apenas confirma o sucesso do processo, mas também tranquiliza o usuário de que sua conta está pronta para uso.
Para conseguir isso, o seu sistema deve enviar imediatamente um e-mail de confirmação automatizado para informar ao usuário que o registro foi bem-sucedido.
Aqui está um exemplo de como implementar isso:
```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)
```
A primeira função, _notify_registration(), é responsável por enviar uma notificação por e-mail a um usuário que acabou de se registrar. Ela recebe dois parâmetros: user_name e user_email. Dentro dessa função, uma mensagem HTML simples é construída usando uma f-string, que permite a inserção fácil do nome do usuário na mensagem. Essa função então chama a função discutida anteriormente, _send_email(), para enviar o e-mail.
A segunda função stub, register_user(), sugere o principal ponto de entrada para o processo de registro de usuário dentro do seu sistema. Ela também recebe user_name e user_email como parâmetros. Na vida real, ela normalmente teria mais parâmetros ou objetos ‘usuário’ com mais detalhes. Essa função é responsável por lidar com o processo de registro. Como mostrado aqui, ela registra o envio do e-mail e chama a função _notify_registration() para iniciar o e-mail de confirmação automatizado após concluir o registro do usuário.
O registro do usuário atua como um evento de gatilho para esse e-mail transacional, e você pode automatizá-lo usando o fluxo de trabalho da API mostrado acima. Também é uma ótima chance de informar os usuários sobre os seus serviços e principais recursos.
Prática recomendada: Automatizar e-mails de confirmação de duplo opt-in
Quando um usuário assina a sua newsletter, em vez de adicioná-lo imediatamente à sua lista de assinantes, você pode enviar um e-mail pedindo que ele confirme a sua assinatura. Esse processo, chamado de confirmação de duplo opt-in, é exigido legalmente em alguns países para conformidade regulatória.
Aqui, a assinatura do usuário atua como o gatilho, e você pode automatizar a confirmação de duplo opt-in com o seguinte 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)
```
A primeira função, _notify_subscription(), é responsável por enviar um e-mail de confirmação de duplo opt-in a um usuário que solicitou assinar uma newsletter. Ela recebe dois parâmetros: user_name e user_email. Dentro dessa função, uma mensagem HTML é construída usando uma f-string, que inclui o nome do usuário e um link de confirmação fictício. Novamente, essa função então chama a função _send_email() para enviar o e-mail.
A segunda função stub, subscribe_user(), é o principal ponto de entrada para o processo de assinatura do usuário. Ela também recebe user_name e user_email como parâmetros. Essa função normalmente lida com o processo inicial de assinatura, provavelmente armazenando as informações do usuário com um status de ‘pendente’. No final, ela registra o envio do e-mail e chama a função _notify_subscription() para criar e enviar o e-mail de confirmação de duplo opt-in.
Prática recomendada: Automatizar e-mails de redefinição de senha
Você já precisou fazer login, mas percebeu que esqueceu a senha e teve que clicar no link ‘esqueci a senha’? Clicar nesse link dispara um e-mail que você está aguardando ansiosamente.
Aqui está um exemplo de código que demonstra como automatizar esse tipo de e-mail transacional:
```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)
```
A função _notify_password_reset() é responsável por criar e enviar um e-mail de redefinição de senha para o usuário. Ela recebe o nome e o endereço de e-mail do usuário como entradas. Dentro da função, uma mensagem HTML é criada usando uma f-string, que inclui o nome do usuário e uma URL exclusiva de redefinição de senha. A função então usa a função _send_email() para entregar essa mensagem à caixa de entrada do usuário.
A função reset_user_password() trabalha em conjunto com ela como o ponto de partida quando um usuário deseja redefinir sua senha. Ela também requer o nome e o e-mail do usuário como entradas. Normalmente, essa função faria algum trabalho nos bastidores para configurar a redefinição de senha (não mostrado neste código). Em seguida, ela registra o envio do e-mail e chama _notify_password_reset() para enviar as instruções de redefinição.
Semelhante aos dois casos de uso anteriores, esse par de funções demonstra uma abordagem modular para lidar com redefinições de senha. Ao manter os processos de notificação e acionamento separados, esse design torna o sistema mais fácil de manter e permite melhorias futuras no fluxo de trabalho de redefinição de senha.
Você pode chamar essas funções da função main para demonstração, desta forma:
```python
# Demo of automated transactional emails
if __name__ == "__main__":
register_user("Kirstin", "Kirstin ")
subscribe_user("Jakkie", "Jakkie ")
reset_user_password("Manish", "Manish ")
```
Esses três exemplos mostram como automatizar e-mails transacionais no seu sistema. Cada um segue um padrão semelhante:
- Uma função específica é criada para um tipo particular de notificação (registro, assinatura ou redefinição de senha), que é acionada pelo evento ou fluxo de trabalho correspondente.
- A função prepara uma mensagem de e-mail relevante.
- Uma função de utilidade separada (usando a API do Mailgun) é chamada para realmente enviar o e-mail.
Essa abordagem garante que e-mails transacionais sejam enviados automaticamente em momentos-chave, como quando um usuário se registra, assina ou solicita uma redefinição de senha.
O que vem a seguir depois de implementar esses fluxos de trabalho?
Neste artigo, detalhamos o poder dos e-mails transacionais na comunicação com o usuário. Ao contrário dos e-mails de marketing, essas mensagens são acionadas por ações específicas — como uma compra ou redefinição de senha — e entregam informações cruciais e sensíveis ao tempo que mantêm os usuários engajados e informados.
Também mostramos como automatizar esses e-mails usando fluxos de trabalho de API, orientando você na configuração de funções para coisas como e-mails de boas-vindas, confirmações de assinatura e redefinições de senha. Essa automação garante que os seus e-mails cheguem às caixas de entrada exatamente quando os seus usuários precisam deles.
Pronto para otimizar os seus e-mails transacionais? Com as APIs robustas e as ferramentas de rastreamento do Mailgun, você pode automatizar mensagens facilmente e aprimorar a experiência do usuário do início ao fim, mas não acredite apenas na nossa palavra, confira você mesmo.
