Automatiza reportes de Google Analytics con IA y mándalos por email cada lunes

Datos y precios verificados al 4 de junio de 2026.

Si estás como la mayoría de los equipos de desarrollo, tienes dashboards de Google Analytics que nadie revisa a menos que haya una emergencia. Alguien decide el viernes por la tarde revisar el tráfico de la semana anterior, exporta una hoja de cálculo manualmente, la pega en Slack, y para el martes siguiente ya nadie recuerda qué decía. El problema no es la falta de datos: es el costo cognitivo de convertirlos en decisiones. Automatizar reportes de Google Analytics con IA resuelve exactamente eso: convierte métricas crudas en análisis ejecutivos legibles y los entrega en el inbox de quien toma decisiones cada lunes a las 8 AM, sin intervención humana.

La solución que vamos a construir usa tres piezas: la Google Analytics Data API v1 (gratuita e incluida con GA4), un modelo de lenguaje económico para el análisis automatizado, y un envío SMTP sin dependencias de plataformas intermediarias. El costo total del pipeline para un equipo pequeño es prácticamente cero: menos de $0.05 anuales en llamadas a APIs de IA si eliges el modelo correcto, como verás más adelante con números concretos. Todo el stack corre en tu infraestructura, sin vendor lock-in y sin dashboards de terceros que aprender a usar.

Antes de entrar en código, un dato de contexto relevante: según la documentación oficial de Google actualizada en abril de 2026, la GA4 Data API v1 tiene una cuota de 200,000 tokens por proyecto por día, más que suficiente para un pipeline semanal que consume en promedio 3-5 llamadas por ejecución. El verdadero cuello de botella no es la API de Google, sino cómo le preguntas a la IA y cuánto le dejas responder. En este artículo atacamos ambos problemas con soluciones concretas.

Por qué los reportes manuales tienen fecha de caducidad

Hay un patrón que cualquier senior developer ha visto repetirse en equipos de producto: el área de marketing pide "un reporte semanal de GA4", alguien lo arma a mano durante 40 minutos cada lunes, y tres semanas después ese proceso muere porque esa persona tiene otras prioridades. El reporte vuelve a ser bajo demanda, intermitente y tardío.

El costo oculto no está solo en el tiempo. Está en la inconsistencia de criterios: cada semana alguien interpreta los números de forma diferente, el rango de fechas cambia dependiendo de quién lo arma, las métricas varían. Con un pipeline de generación de reportes automatizados, el análisis es reproducible, auditable y comparable semana contra semana con exactamente las mismas dimensiones.

Comparemos el escenario manual versus el automatizado con números reales. Un analista que invierte 45 minutos semanales en armar ese reporte, a un costo hourly de $25 USD, genera un gasto de $975 al año contando 52 semanas. El pipeline descrito en este artículo, corriendo sobre una EC2 t3.micro en AWS (a $0.0104/hora, aproximadamente $7.50 mensuales), tiene un costo de API de IA de aproximadamente $0.001 por ejecución usando GPT-4.1 Mini. El servidor es el componente más caro del stack, y todavía es entre diez y veinte veces más barato que el tiempo humano equivalente.

El otro argumento que circula en equipos más conservadores es la complejidad de la configuración inicial. La realidad es que la Google Analytics Data API en Python, con la biblioteca oficial google-analytics-data, está a un pip install de distancia, y la autenticación via Service Account está documentada con claridad en Google Cloud Console. La barrera de entrada es mucho menor de lo que parece.

Arquitectura del pipeline: GA4 → IA → Email

El flujo completo es lineal y tiene tres fases sin estado compartido entre ellas, lo que facilita el debugging y el testing de cada componente de forma independiente.

La fase de extracción consulta la GA4 Data API v1 con un rango de fechas calculado dinámicamente (siempre la semana anterior completa, de lunes a domingo), agregando métricas de sesiones, usuarios activos, tasa de rebote y conversiones por canal de tráfico. La fase de interpretación envía esos datos como texto estructurado a un modelo de lenguaje con un prompt que limita la respuesta a observaciones y recomendaciones concretas, sin introducciones ni párrafos de relleno. La fase de envío transmite el análisis como email HTML via SMTP estándar, compatible con cualquier proveedor.

Lo que necesitas antes de escribir código

Para que el pipeline funcione en producción necesitas cuatro elementos configurados:

Un Google Cloud Project con la GA4 Data API habilitada y una Service Account con rol "Viewer" en tu propiedad de GA4. Esa cuenta de servicio debe estar añadida como usuario en la configuración de GA4 (Administración → Acceso a la cuenta). El archivo JSON de credenciales va en el servidor referenciado por la variable de entorno GOOGLE_APPLICATION_CREDENTIALS.

Una clave de API de IA: GPT-4.1 Mini de OpenAI es la opción más económica para análisis rutinarios en junio 2026, a $0.40 por millón de tokens de entrada y $1.60 por millón de salida. Si prefieres mantenerte en el ecosistema de Google, Gemini 2.5 Flash tiene una capa gratuita generosa que cubre sobradamente un análisis semanal.

Un servidor SMTP: Gmail funciona con contraseñas de aplicación (no la contraseña normal de la cuenta) y permite hasta 500 emails por día de forma gratuita. Brevo ofrece 300 emails por día de forma permanente y sin tarjeta de crédito, lo que lo convierte en la alternativa más práctica si no quieres depender de Gmail. Nota: desde mayo de 2025, SendGrid ya no tiene plan gratuito permanente; su trial es de 60 días y luego el plan Essentials parte desde $19.95/mes.

Un entorno Python 3.10+ con las siguientes dependencias: google-analytics-data, openai, schedule, y python-dotenv.

El script completo explicado línea por línea

El siguiente script implementa el pipeline completo en un solo archivo. Está diseñado para ser legible, extensible y con un costo de tokens optimizado por construcción, no como un ajuste posterior.

python
 Copiar
# Instalar dependencias:
# pip install google-analytics-data openai schedule python-dotenv

import os
import schedule
import time
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from datetime import datetime, timedelta
from dotenv import load_dotenv
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import (
    DateRange, Dimension, Metric, RunReportRequest
)
from openai import OpenAI

# Cargar variables de entorno desde un archivo .env (no subir al repositorio)
load_dotenv()

# --- Configuración global: todo desde variables de entorno, sin hardcodear ---
PROPERTY_ID  = os.getenv("GA4_PROPERTY_ID")    # Solo el número, ej: "123456789"
OPENAI_KEY   = os.getenv("OPENAI_API_KEY")
SMTP_HOST    = os.getenv("SMTP_HOST", "smtp.gmail.com")
SMTP_PORT    = int(os.getenv("SMTP_PORT", "587"))
SMTP_USER    = os.getenv("SMTP_USER")           # Dirección de Gmail o Brevo
SMTP_PASS    = os.getenv("SMTP_PASS")           # Contraseña de aplicación (no la normal)
DESTINATARIO = os.getenv("RECIPIENT_EMAIL")

# Inicializar el cliente de OpenAI con la clave del entorno
cliente_ai = OpenAI(api_key=OPENAI_KEY)


def extraer_datos_ga4():
    """
    Consulta la GA4 Data API v1 para obtener métricas de la semana anterior.
    Rango dinámico: siempre lunes a domingo de la semana pasada.
    La API es gratuita dentro de la cuota de 200,000 tokens/proyecto/día.
    """
    hoy = datetime.today()

    # weekday() retorna 0 para lunes; sumar 7 nos lleva al lunes de la semana pasada
    lunes_pasado   = hoy - timedelta(days=hoy.weekday() + 7)
    domingo_pasado = lunes_pasado + timedelta(days=6)

    fecha_inicio = lunes_pasado.strftime("%Y-%m-%d")    # Formato requerido por la API
    fecha_fin    = domingo_pasado.strftime("%Y-%m-%d")

    # El cliente usa GOOGLE_APPLICATION_CREDENTIALS del entorno automáticamente
    cliente_ga4 = BetaAnalyticsDataClient()

    solicitud = RunReportRequest(
        property=f"properties/{PROPERTY_ID}",
        dimensions=[
            # sessionDefaultChannelGroup agrupa por canal (Organic, Paid, Direct, etc.)
            Dimension(name="sessionDefaultChannelGroup"),
        ],
        metrics=[
            Metric(name="sessions"),       # Total de sesiones en el período
            Metric(name="activeUsers"),    # Usuarios únicos activos
            Metric(name="bounceRate"),     # Tasa de rebote (valor entre 0.0 y 1.0)
            Metric(name="conversions"),    # Eventos marcados como conversión en GA4
        ],
        date_ranges=[DateRange(start_date=fecha_inicio, end_date=fecha_fin)],
    )

    # Ejecutar la consulta contra la API
    respuesta = cliente_ga4.run_report(solicitud)

    # Transformar la respuesta en una lista de diccionarios legibles
    datos = []
    for fila in respuesta.rows:
        datos.append({
            "canal":        fila.dimension_values[0].value,
            "sesiones":     int(fila.metric_values[0].value),
            "usuarios":     int(fila.metric_values[1].value),
            # Multiplicar por 100 para convertir de decimal a porcentaje
            "tasa_rebote":  round(float(fila.metric_values[2].value) * 100, 1),
            "conversiones": int(fila.metric_values[3].value),
        })

    return datos, fecha_inicio, fecha_fin


def analizar_con_ia(datos, fecha_inicio, fecha_fin):
    """
    Genera un análisis ejecutivo usando GPT-4.1 Mini.
    Costo estimado por ejecución: ~$0.001 USD (entrada + salida combinadas).
    El prompt está estructurado para minimizar tokens sin sacrificar calidad.
    """
    # Serializar los datos como texto compacto: reduce tokens de entrada ~40%
    resumen = "\n".join([
        f"- {d['canal']}: {d['sesiones']} sesiones | "
        f"{d['usuarios']} usuarios | {d['tasa_rebote']}% rebote | "
        f"{d['conversiones']} conversiones"
        for d in datos
    ])

    # Prompt con instrucciones explícitas de formato y longitud máxima
    prompt = f"""Analiza estos datos de Google Analytics del {fecha_inicio} al {fecha_fin}:

{resumen}

Entrega exactamente:
1. Tres observaciones clave (máx. 2 líneas por observación)
2. Dos recomendaciones accionables concretas
3. Canal con mejor rendimiento y justificación breve

Sin introducción, sin resumen al final. Directo al análisis."""

    respuesta = cliente_ai.chat.completions.create(
        model="gpt-4.1-mini",   # Balance óptimo costo/calidad para análisis rutinarios
        messages=[{"role": "user", "content": prompt}],
        max_tokens=450,          # Límite explícito: controla el costo de tokens de salida
        temperature=0.2,         # Temperatura baja: resultados más deterministas y concisos
    )

    # Extraer solo el texto de la respuesta del modelo
    return respuesta.choices[0].message.content


def enviar_email(analisis, fecha_inicio, fecha_fin):
    """
    Construye y envía el reporte como email HTML via SMTP con TLS.
    Compatible con Gmail (contraseña de aplicación), Brevo, o cualquier SMTP estándar.
    """
    # Template HTML minimalista: máxima compatibilidad con clientes de correo
    cuerpo_html = f"""
    <html>
    <body style="font-family:Arial,sans-serif; max-width:600px; margin:0 auto;">
      <h2 style="color:#1a73e8;">Reporte Semanal GA4</h2>
      <p style="color:#555;">
        Período: <strong>{fecha_inicio}</strong> al <strong>{fecha_fin}</strong>
      </p>
      <hr style="border:1px solid #eee;">
      <div style="background:#f9f9f9; padding:16px; border-radius:8px;">
        <pre style="white-space:pre-wrap; font-size:14px; color:#333;">{analisis}</pre>
      </div>
      <hr style="border:1px solid #eee;">
      <small style="color:#999;">
        Generado automáticamente · {datetime.today().strftime("%d/%m/%Y %H:%M")}
      </small>
    </body>
    </html>"""

    # Construir el mensaje MIME con soporte HTML
    msg = MIMEMultipart("alternative")
    msg["Subject"] = f"Reporte GA4 | Semana del {fecha_inicio}"
    msg["From"]    = SMTP_USER
    msg["To"]      = DESTINATARIO
    msg.attach(MIMEText(cuerpo_html, "html"))  # Adjuntar cuerpo HTML

    # Conectar al servidor SMTP, iniciar cifrado TLS, autenticar y enviar
    with smtplib.SMTP(SMTP_HOST, SMTP_PORT) as servidor:
        servidor.ehlo()           # Presentarse al servidor SMTP
        servidor.starttls()       # Iniciar cifrado TLS (requerido por Gmail)
        servidor.login(SMTP_USER, SMTP_PASS)
        servidor.sendmail(SMTP_USER, DESTINATARIO, msg.as_string())

    print(f"✓ Email enviado a {DESTINATARIO} | {datetime.now().strftime('%H:%M')}")


def ejecutar_pipeline():
    """
    Orquestador principal: encadena extracción → análisis → envío.
    Cada función es independiente y puede testearse por separado.
    """
    print(f"[{datetime.now()}] Iniciando pipeline semanal de GA4...")
    datos, inicio, fin = extraer_datos_ga4()     # Paso 1: obtener datos
    analisis = analizar_con_ia(datos, inicio, fin)  # Paso 2: analizar con IA
    enviar_email(analisis, inicio, fin)          # Paso 3: enviar email
    print(f"[{datetime.now()}] Pipeline completado exitosamente.")


# --- Scheduler: ejecutar automáticamente cada lunes a las 08:00 AM ---
schedule.every().monday.at("08:00").do(ejecutar_pipeline)

if __name__ == "__main__":
    print("Scheduler activo. Próxima ejecución: lunes 08:00 AM.")

    # Ejecutar una vez inmediatamente al arrancar (útil para testing y primera validación)
    ejecutar_pipeline()

    while True:
        schedule.run_pending()   # Revisar si hay tareas pendientes según el schedule
        time.sleep(60)           # Esperar 60 segundos antes de la próxima revisión

Hay tres decisiones de diseño que vale la pena destacar. El rango de fechas dinámico calculado con timedelta garantiza que siempre se analice la semana anterior completa sin depender de valores hardcodeados, lo que hace el script correcto independientemente del día en que se ejecute por primera vez. El parámetro max_tokens=450 en la llamada a la IA no es arbitrario: con prompts bien estructurados, 450 tokens de salida son suficientes para tres observaciones y dos recomendaciones concretas, y reducen el costo de salida aproximadamente un 60% respecto a dejar el límite por defecto. Y el uso de python-dotenv mantiene todas las credenciales fuera del código fuente, haciendo el script seguro para llevar a un repositorio privado o deployar via CI/CD.

Automatizando la ejecución cada lunes con cron del sistema

La librería schedule de Python es perfecta durante el desarrollo, pero en producción es mejor delegar el trigger al cron del sistema operativo. Esto simplifica la arquitectura: el script se ejecuta, hace su trabajo y termina. No hay proceso persistente consumiendo RAM ni riesgo de que el loop muera silenciosamente.

Para el despliegue con cron, elimina el bloque while True al final del script y llama a ejecutar_pipeline() directamente en el if __name__ == "__main__". Luego agrega la siguiente entrada en tu crontab con crontab -e:

bash
 Copiar
# Ejecutar el pipeline GA4 todos los lunes a las 08:00 AM (hora UTC del servidor)
# La variable GOOGLE_APPLICATION_CREDENTIALS debe estar definida explícitamente en el crontab
GOOGLE_APPLICATION_CREDENTIALS=/opt/pipelines/credenciales-ga4.json
0 8 * * 1 /usr/bin/python3 /opt/pipelines/ga4_report.py >> /var/log/ga4_pipeline.log 2>&1

La sintaxis 0 8 * * 1 se lee como: minuto 0, hora 8, cualquier día del mes, cualquier mes, día de la semana 1 (lunes). La redirección >> /var/log/ga4_pipeline.log 2>&1 captura tanto stdout como stderr en un log persistente para auditoría. Esto es importante: el cron no tiene acceso al terminal, y cualquier error silencioso que no se capture en un log es un error que nunca verás.

Dos puntos críticos antes de dejar el cron corriendo en producción. Primero, la zona horaria del servidor: un servidor en UTC con un equipo en UTC-6 entregará el reporte a las 2 AM local en lugar de las 8 AM. Puedes forzar la zona horaria a nivel de crontab con TZ=America/Mexico_City antes de la línea del cron. Segundo, si prefieres evitar administrar infraestructura, GitHub Actions ofrece una alternativa sin servidor propio: un workflow con on: schedule: - cron: '0 8 * * 1' ejecuta el script en los runners de GitHub (en UTC), con 2,000 minutos gratuitos por mes en repositorios privados. El pipeline completo tarda menos de 30 segundos por ejecución, lo que equivale a usar apenas 26 minutos al año del límite gratuito.

Optimizando los costos de la API de IA en pipelines automatizados

El costo real de este pipeline es tan bajo que resulta difícil justificar una optimización seria. Pero si escalarás este patrón a decenas de propiedades, o implementarás análisis diarios en lugar de semanales, las decisiones de modelo y prompting se vuelven relevantes.

Con los precios actuales de junio 2026, una ejecución del pipeline consume aproximadamente 500 tokens de entrada (datos de GA4 + instrucciones) y 400 tokens de salida (el análisis). Usando GPT-4.1 Mini a $0.40/M de entrada y $1.60/M de salida, el costo por ejecución es de $0.00084 USD, o $0.044 al año. Escala a 50 propiedades con análisis semanal y son $2.18 anuales en IA. Los números no mienten: el servidor donde corre el cron es el componente más caro del stack, no la API de inteligencia artificial.

Lo que sí puede generar sorpresas a mayor escala es el prompt caching. OpenAI ofrece 90% de descuento en tokens de entrada cacheados; Anthropic cobra el 10% del precio base en cache hits. Si el system prompt es fijo (las instrucciones al modelo), separarlo del contenido de datos en la llamada a la API permite que el modelo cachee la parte estática y cobre solo el 10% de esos tokens en ejecuciones posteriores. En un pipeline con 50 propiedades que comparten el mismo prompt de instrucciones, el ahorro en tokens de entrada puede superar el 80%.

Una estrategia práctica para equipos que crecen es el routing por complejidad: usa un modelo económico (GPT-4.1 Nano a $0.10/M, o Gemini 2.5 Flash con capa gratuita) para el análisis semanal estándar, y reserva un modelo más capaz para análisis de anomalías o reportes ejecutivos de fin de mes. Esta arquitectura reduce el costo promedio por token entre 60% y 80% comparado con enrutar todo al mismo modelo de gama alta.

Conclusión: de proceso manual a pipeline autónomo en menos de 150 líneas

El pipeline que acabas de ver demuestra un principio importante que a veces se pierde entre el hype de plataformas de analytics y BI: la automatización de análisis con IA no requiere contratos enterprise, dashboards de terceros, ni presupuestos significativos. Tres componentes gratuitos o casi gratuitos, menos de 150 líneas de Python, y un cron job son suficientes para transformar el proceso de reportes semanales de un cuello de botella humano a un sistema que funciona solo, cada lunes, sin falta.

Los pasos naturales desde aquí son agregar comparación semana-a-semana (pasar los datos de la semana anterior al prompt para identificar tendencias), enviar el reporte a múltiples destinatarios con niveles de detalle distintos según su rol, e integrar otras fuentes como Google Search Console o datos del CRM para reportes más completos. Cada extensión sigue el mismo patrón: extrae, estructura, analiza con IA, entrega.

Implementa este pipeline esta semana. El tiempo de setup inicial es de 30 a 45 minutos. El retorno sobre ese tiempo, medido en horas ahorradas y decisiones mejor informadas, empieza el primer lunes siguiente.