Conectar un Formulario de Contacto con Gmail en Django + React
Este artículo técnico explica cómo conectar un formulario de contacto creado con React a Gmail utilizando Django. Se detalla la configuración de Django para enviar correos electrónicos a través de SMTP de Gmail, incluyendo la creación de una App Password para mayor seguridad. Aprenderás a configurar las variables de entorno necesarias, a implementar una vista en Django que envíe el correo electrónico al recibir un nuevo mensaje del formulario y a manejar errores en caso de que la configuración sea incorrecta. El flujo es sincrónico, ideal para sitios de bajo tráfico.

Arquitectura
Visitante llena formulario (React)
↓
POST /api/contact/messages/
↓
Django guarda en PostgreSQL (ContactMessage)
↓
Django envía email via SMTP → smtp.gmail.com:587
↓
Email llega a tu bandeja de Gmail
El flujo es sincrónico: el email se envía dentro de la misma request HTTP. Para un sitio de bajo tráfico como un portafolio personal esto es perfectamente aceptable. Si el volumen fuera alto, habría que mover el envío a una cola asíncrona (Celery, Cloud Tasks), pero eso es sobreingeniería para este caso.
Paso 1: Crear un App Password en Google
Gmail no permite usar tu contraseña normal para SMTP desde aplicaciones de terceros. Desde mayo de 2022, Google requiere una App Password — una contraseña de 16 caracteres generada específicamente para una aplicación.
Prerequisito: Verificación en 2 pasos
Las App Passwords solo están disponibles si tienes activada la verificación en 2 pasos (2FA) en tu cuenta de Google. Si no la tienes:
- Ve a myaccount.google.com/security
- En la sección "Cómo accedes a Google", activa Verificación en 2 pasos
- Sigue el wizard (necesitas un teléfono para recibir códigos)
Generar la App Password
- Ve a myaccount.google.com/apppasswords
- En "Selecciona la app", elige Otra (nombre personalizado)
- Escribe un nombre descriptivo:
Blog Contacto(o lo que quieras) - Haz clic en Generar
- Google muestra una contraseña de 16 caracteres tipo:
abcd efgh ijkl mnop
Copia esa contraseña inmediatamente. Google no la muestra de nuevo. Si la pierdes, tienes que revocarla y generar una nueva.
⚠️ Importante: Esta NO es tu contraseña de Gmail. Es una credencial independiente con permisos limitados a envío SMTP. Si alguien la obtiene, puede enviar emails en tu nombre pero no acceder a tu cuenta completa. Aun así, trátala como un secreto.
Paso 2: Configurar Django para SMTP
Django tiene soporte nativo para envío de email. Solo hay que configurar las variables en settings.py.
Las variables de entorno
En el archivo .env del backend:
# Email — Gmail SMTP
EMAIL_BACKEND=django.core.mail.backends.smtp.EmailBackend
EMAIL_HOST=smtp.gmail.com
EMAIL_PORT=587
EMAIL_USE_TLS=True
EMAIL_HOST_USER=maria.rodriguez@gmail.com
EMAIL_HOST_PASSWORD=abcd efgh ijkl mnop
DEFAULT_FROM_EMAIL=maria.rodriguez@gmail.com
CONTACT_NOTIFICATION_EMAIL=maria.rodriguez@gmail.com
Donde:
- EMAIL_HOST_USER: Tu dirección de Gmail
- EMAIL_HOST_PASSWORD: La App Password generada (con o sin espacios, Django los ignora)
- DEFAULT_FROM_EMAIL: El remitente que aparece en los emails enviados
- CONTACT_NOTIFICATION_EMAIL: A quién llegan las notificaciones (puede ser distinto)
En settings.py
# Email Configuration — Gmail SMTP via App Password
EMAIL_BACKEND = os.getenv(
'EMAIL_BACKEND',
'django.core.mail.backends.console.EmailBackend'
)
EMAIL_HOST = os.getenv('EMAIL_HOST', 'smtp.gmail.com')
EMAIL_PORT = int(os.getenv('EMAIL_PORT', '587'))
EMAIL_USE_TLS = os.getenv('EMAIL_USE_TLS', 'True') == 'True'
EMAIL_HOST_USER = os.getenv('EMAIL_HOST_USER')
EMAIL_HOST_PASSWORD = os.getenv('EMAIL_HOST_PASSWORD')
DEFAULT_FROM_EMAIL = os.getenv(
'DEFAULT_FROM_EMAIL',
EMAIL_HOST_USER or 'webmaster@localhost'
)
CONTACT_NOTIFICATION_EMAIL = os.getenv(
'CONTACT_NOTIFICATION_EMAIL',
EMAIL_HOST_USER
)
El patrón clave es el fallback a console backend: cuando EMAIL_BACKEND no está definida (desarrollo local), Django imprime los emails en la terminal en lugar de enviarlos. Así puedes desarrollar y testear sin enviar correos reales.
Paso 3: La Vista que Envía el Email
El formulario ya guardaba mensajes en la base de datos a través de un ModelViewSet. Lo que falta es el hook perform_create que dispara el envío del email después de guardar.
import logging
from django.conf import settings
from django.core.mail import send_mail
from django.template.loader import render_to_string
from django.utils.html import strip_tags
from rest_framework import permissions, viewsets
from .models import ContactMessage
from .serializers import ContactMessageSerializer
logger = logging.getLogger(__name__)
class ContactMessageViewSet(viewsets.ModelViewSet):
queryset = ContactMessage.objects.all()
serializer_class = ContactMessageSerializer
def get_permissions(self):
if self.action in ('create',):
return [permissions.AllowAny()]
return [permissions.IsAdminUser()]
def perform_create(self, serializer):
instance = serializer.save()
self._send_notification_email(instance)
def _send_notification_email(self, message):
recipient = getattr(settings, 'CONTACT_NOTIFICATION_EMAIL', None)
if not recipient:
logger.warning(
"CONTACT_NOTIFICATION_EMAIL no configurado. "
"Mensaje de %s guardado sin notificación.",
message.email,
)
return
subject = f"[Mi Sitio] Nuevo mensaje de {message.name}"
if message.subject:
subject += f": {message.subject}"
html_message = render_to_string(
'contact/email_notification.html',
{
'name': message.name,
'email': message.email,
'subject': message.subject or '(sin asunto)',
'message': message.message,
'created_at': message.created_at,
}
)
plain_message = strip_tags(html_message)
try:
send_mail(
subject=subject,
message=plain_message,
from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=[recipient],
html_message=html_message,
fail_silently=False,
)
logger.info("Notificación enviada a %s", recipient)
except Exception:
logger.exception(
"Error enviando notificación para mensaje id=%s",
message.pk,
)
Decisiones de diseño
-
El email no bloquea la respuesta al usuario. Si
send_mailfalla, el mensaje ya está guardado en la base de datos. Elexceptregistra el error en logs pero la respuesta HTTP al visitante sigue siendo 201 Created. No vamos a decirle al visitante "tu mensaje falló" cuando en realidad sí se guardó. -
HTML + plaintext dual. Se envía
html_messagepara clientes que lo soportan (Gmail, Outlook) ymessagecomo fallback en texto plano. Django maneja automáticamente el multipart/alternative. -
Template HTML separado. El contenido del email está en un template Django (
templates/contact/email_notification.html), no hardcodeado en la vista. Esto permite modificar el diseño sin tocar lógica.
Paso 4: El Template del Email
Los emails HTML son un mundo aparte del CSS moderno. No hay flexbox, no hay grid, el soporte de estilos varía por cliente. La regla es: inline styles, tablas para layout, y asumir lo peor.
Para este caso, un diseño simple funciona:
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8">
<style>
body {
font-family: -apple-system, BlinkMacSystemFont, sans-serif;
color: #1a1a1a;
line-height: 1.6;
}
.container {
max-width: 600px;
margin: 24px auto;
background: #ffffff;
border-radius: 8px;
overflow: hidden;
}
.header {
background: #1565c0;
color: #ffffff;
padding: 20px 24px;
}
.body { padding: 24px; }
.field-label {
font-size: 12px;
text-transform: uppercase;
color: #666;
}
.message-box {
background: #f8f9fa;
border-left: 3px solid #1565c0;
padding: 16px;
white-space: pre-wrap;
}
</style>
</head>
<body>
<div class="container">
<div class="header">
<h1>Nuevo mensaje de contacto</h1>
</div>
<div class="body">
<div class="field-label">Nombre</div>
<div>{{ name }}</div>
<div class="field-label">Email</div>
<div><a href="mailto:{{ email }}">{{ email }}</a></div>
<div class="field-label">Asunto</div>
<div>{{ subject }}</div>
<div class="field-label">Mensaje</div>
<div class="message-box">{{ message }}</div>
</div>
<div style="padding: 16px 24px; font-size: 12px; color: #999;">
Recibido el {{ created_at|date:"d/m/Y H:i" }} UTC
</div>
</div>
</body>
</html>
Paso 5: Verificar en Desarrollo
Antes de desplegar a producción, verifica que todo funciona con el console backend:
# Sin variables de email en .env (usa console backend por defecto)
python manage.py runserver
Envía un mensaje desde el formulario. En la terminal del servidor deberías ver algo como:
Content-Type: multipart/alternative;
boundary="===============1234567890123456789=="
MIME-Version: 1.0
Subject: [Mi Sitio] Nuevo mensaje de Juan Pérez: Consulta sobre servicios
From: webmaster@localhost
To: None
Date: Fri, 21 Feb 2026 15:30:00 -0000
--===============1234567890123456789==
Content-Type: text/plain; charset="utf-8"
Nombre: Juan Pérez
Email: juan@example.com
...
Si ves eso, la lógica funciona. Solo falta configurar las variables de producción para que use SMTP real.
Test rápido con SMTP real
Para verificar el envío real sin desplegar:
# Temporalmente en .env local:
EMAIL_BACKEND=django.core.mail.backends.smtp.EmailBackend
EMAIL_HOST=smtp.gmail.com
EMAIL_PORT=587
EMAIL_USE_TLS=True
EMAIL_HOST_USER=maria.rodriguez@gmail.com
EMAIL_HOST_PASSWORD=abcd efgh ijkl mnop
CONTACT_NOTIFICATION_EMAIL=maria.rodriguez@gmail.com
Reinicia el servidor, envía un mensaje desde el formulario, y revisa tu bandeja de Gmail. El email debería llegar en menos de 10 segundos.
Recuerda quitar las credenciales del
.envlocal después de la prueba. En desarrollo normalmente quieres el console backend.
Paso 6: Configuración en Producción (Cloud Run)
En Cloud Run las variables de entorno se configuran como secretos:
# Crear los secretos en Secret Manager
echo -n "django.core.mail.backends.smtp.EmailBackend" | \
gcloud secrets create EMAIL_BACKEND --data-file=- --project=mi-proyecto
echo -n "smtp.gmail.com" | \
gcloud secrets create EMAIL_HOST --data-file=- --project=mi-proyecto
echo -n "maria.rodriguez@gmail.com" | \
gcloud secrets create EMAIL_HOST_USER --data-file=- --project=mi-proyecto
echo -n "abcd efgh ijkl mnop" | \
gcloud secrets create EMAIL_HOST_PASSWORD --data-file=- --project=mi-proyecto
Luego, al desplegar el servicio de Cloud Run, montar los secretos como variables de entorno:
gcloud run deploy mi-backend \
--image=REGION-docker.pkg.dev/mi-proyecto/repo/backend:latest \
--set-secrets="EMAIL_BACKEND=EMAIL_BACKEND:latest,EMAIL_HOST=EMAIL_HOST:latest,EMAIL_HOST_USER=EMAIL_HOST_USER:latest,EMAIL_HOST_PASSWORD=EMAIL_HOST_PASSWORD:latest" \
--region=us-central1 \
--project=mi-proyecto
Consideraciones de Seguridad
Límites de Gmail SMTP
Gmail impone límites que hay que conocer:
| Límite | Valor |
|---|---|
| Emails por día (cuenta personal) | 500 |
| Emails por día (Google Workspace) | 2,000 |
| Destinatarios por mensaje | 500 |
| Tamaño máximo del email | 25 MB |
Para un portafolio personal, 500 emails/día es más que suficiente. Si alguna vez recibieras más de 500 mensajes de contacto en un día, tienes un problema diferente (probablemente spam).
Rate limiting en el endpoint
El formulario está abierto al público (AllowAny). Sin protección adicional, un bot podría enviar cientos de requests y generarte cientos de emails. Opciones de mitigación:
- Throttling de DRF: Limitar a N requests por IP por hora
- reCAPTCHA: Agregar verificación en el frontend
- Honeypot: Campo hidden que los bots llenan pero los humanos no
La más simple y efectiva para empezar es el throttling:
# settings.py
REST_FRAMEWORK = {
# ...existente...
'DEFAULT_THROTTLE_CLASSES': [
'rest_framework.throttling.AnonRateThrottle',
],
'DEFAULT_THROTTLE_RATES': {
'anon': '10/hour',
},
}
Esto limita a cualquier usuario anónimo a 10 requests por hora por IP. Más que suficiente para uso legítimo.
No exponer credenciales
Las variables EMAIL_HOST_PASSWORD y EMAIL_HOST_USER nunca deben estar en el código fuente ni en el repositorio. Siempre via variables de entorno o Secret Manager. El .env local debe estar en .gitignore.
El Frontend No Necesita Cambios
Un detalle importante: el frontend no se modificó. El formulario React ya enviaba un POST a /api/contact/messages/ y mostraba un mensaje de éxito/error. Todo el cambio fue en el backend.
Esta es la ventaja de una arquitectura desacoplada: el contrato de la API (request body, response status) no cambió. Solo se agregó un efecto secundario invisible para el cliente — el envío del email.
Resultado
El flujo completo ahora es:
- Un visitante llena el formulario y envía
- React hace POST a la API → recibe 201 Created → muestra "Gracias por tu mensaje"
- Django guarda el mensaje en PostgreSQL
- Django envía un email HTML a mi Gmail
- Recibo la notificación en mi teléfono en menos de 10 segundos
La inversión de tiempo fue mínima: ~30 minutos de código, ~15 minutos configurando la App Password en Google. El resultado es que ahora el formulario de contacto es un canal de comunicación real.
Anterior: Dominio Propio en Cloud Run: hectorgarrido.cl Paso a Paso
Siguiente: Por Qué Implementé Tests Automáticos en Mi Portafolio (Django + React)
Este artículo es parte de la serie "Construyendo un Blog con IA". El código fuente completo está en GitHub.