Lo esencial
En esta lección vas a configurar un sistema de analítica automático: PostHog recolecta los datos, Claude los analiza y cada lunes por la mañana te llega un reporte a tu chat (en el ejemplo, Telegram): qué funciona, qué no y qué hacer después.
Conceptos clave
- PostHog: analítica open source con grabaciones de sesiones, feature flags, API y un servidor MCP para Claude
- Mixpanel: embudos y análisis de cohortes potentes, con funciones de IA (revisa cuáles en su sitio)
- Plausible: analítica que prioriza la privacidad, ideal para empezar sin complicaciones
- DAU/MAU, Retention, Funnel: tres métricas que de verdad hablan de la salud del producto
- Churn prediction: Claude analiza patrones de comportamiento y predice quién se va a ir
- Session replay + IA: Claude lee los registros de las sesiones y encuentra los problemas de los usuarios sin ver cada video
- Pruebas A/B con feature flags: PostHog maneja los experimentos y Claude interpreta los resultados
- Reporte semanal automático: script de Python + Claude API + un bot de chat = analítica en piloto automático
Teoría
Por qué un emprendedor necesita analítica de producto en 2026
La mayoría de los emprendedores que trabajan solos lo hacen a ciegas. Ven el número de registros y creen que todo va bien. Pero las preguntas de verdad son otras: ¿cuántos de los que se registraron volvieron una semana después? ¿En qué paso del onboarding se va la mitad de los usuarios? ¿Qué función se usa todos los días y cuál no toca nadie?
Antes, responder estas preguntas requería un analista de datos. Ahora mucho se puede obtener de un Claude bien configurado, pero igual verifica las conclusiones: el modelo puede equivocarse.
PostHog: analítica open source con cerebro
PostHog es la navaja suiza de la analítica de producto. Open source: puedes instalarlo en tu propio servidor o usar su nube. Cada producto tiene un límite mensual gratuito (los límites vigentes para eventos de analítica y grabaciones de sesiones están en la página de precios de PostHog). PostHog también trae un asistente de IA integrado (PostHog AI) que responde preguntas sobre los datos.
Qué hace PostHog:
- Seguimiento de eventos (clics, navegación, acciones de los usuarios)
- Grabaciones de sesiones: literalmente, videos de lo que hizo el usuario
- Feature flags: activa o desactiva funciones para distintos grupos
- Embudos: dónde abandonan los usuarios un proceso
- Cohortes: grupos de usuarios por comportamiento
- Experimentos (pruebas A/B)
- PostHog MCP: integración directa con Claude Code
PostHog MCP para Claude Code permite que Claude consulte directamente los datos de tu PostHog, arme consultas en HogQL (su lenguaje de consultas) y analice los resultados sin copiar y pegar. Hoy es un servidor MCP remoto de PostHog (dirección https://mcp.posthog.com/mcp; la región de los datos se define al iniciar sesión en la cuenta). Conexión a Claude Code:
claude mcp add --transport http posthog https://mcp.posthog.com/mcpLa forma de autenticarte depende de la versión: sigue las instrucciones de PostHog para Claude Code (documentación de MCP de PostHog). Los ejemplos viejos con el paquete @posthog/mcp-server y la clave en la configuración pueden no funcionar.
Después, en Claude Code puedes preguntar: "Muéstrame los 5 eventos principales de la última semana", y Claude pedirá los datos por su cuenta.
Mixpanel: embudos y cohortes a nivel profesional
Mixpanel se especializa en analítica de comportamiento. Si PostHog es la herramienta universal, Mixpanel es el especialista en la pregunta "por qué los usuarios hacen X".
Puntos fuertes de Mixpanel:
- Embudos con desglose por segmento (de pago vs. gratuitos, móvil vs. web)
- Retention por cohortes: ves qué semanas de usuarios se retienen mejor
- Impact report: cómo afectó el lanzamiento de una función a las métricas clave
- Funciones de IA integradas para hacerle preguntas a los datos (revisa cuáles y sus nombres en el sitio de Mixpanel)
- Flows: visualización de las rutas de los usuarios en la interfaz
API de Mixpanel para automatizar:
import requests
def get_mixpanel_funnel(project_id, funnel_id, api_secret):
url = f"https://mixpanel.com/api/2.0/funnels"
params = {
"funnel_id": funnel_id,
"from_date": "2026-09-01", # ejemplo: pon tus propias fechas
"to_date": "2026-09-30",
}
response = requests.get(
url,
params=params,
auth=(api_secret, "")
)
return response.json()Mixpanel tiene un nivel gratuito con un límite de eventos; las condiciones y los límites cambian, revísalos en su sitio. Para llamar a la API necesitas los datos del proyecto y la clave de una cuenta de servicio: la forma vigente de autenticarte está en la referencia de la API.
Plausible: empezar sin sobrecarga
Para el principio, cuando el producto acaba de lanzarse y hay pocos datos, Plausible Analytics es una opción ideal. Instalación sencilla (un solo script) y prioridad a la privacidad: funciona sin cookies, así que en una configuración típica no necesitas banner de cookies. Es un servicio de pago (con periodo de prueba); los planes están en su sitio.
Plausible es bueno para la analítica de tráfico (de dónde llegan, qué leen), pero para la analítica de producto dentro de la aplicación conviene más PostHog o Mixpanel.
Métricas clave: lo que de verdad importa
La mayoría de los emprendedores siguen demasiadas métricas y no las que hacen falta. Este es el conjunto mínimo:
DAU/MAU (Daily/Monthly Active Users) El porcentaje DAU/MAU muestra qué tan "pegajoso" es el producto. El valor normal depende mucho del tipo de producto: una app de mensajería se usa a diario, un servicio de contabilidad una vez al mes. Compárate contigo mismo a lo largo del tiempo y con productos parecidos. Si el porcentaje está cerca de cero, la gente no vuelve: eso es un problema.
Retention por cohortes El reporte de retention clásico: de los usuarios que se registraron en la semana X, cuántos volvieron a la semana 1, 2 y 4. Lo principal es ver si la curva se aplana: si una parte de los usuarios se queda de forma estable, es buena señal.
Funnel conversion Qué % de usuarios recorre el camino desde el registro hasta el uso activo. En el onboarding normalmente se pierde una parte notable de la gente. Encontrar dónde es tarea del embudo.
Feature adoption Qué funciones se usan con regularidad y cuáles nadie toca después de la primera vez.
Predicción de abandono (churn prediction) con Claude
Esta es una de las cosas más valiosas que Claude puede hacer con tus datos. En lugar de reaccionar cuando el usuario ya se fue, predecir quién se irá la próxima semana e intervenir.
import anthropic
import json
def predict_churn(users_activity_data: list[dict]) -> dict:
"""
users_activity_data: lista de diccionarios con la actividad de cada usuario:
[{"user_id": "u123", "last_login_days_ago": 8, "sessions_last_30d": 2,
"feature_usage": {"core": 5, "advanced": 0}, "plan": "free"}]
"""
client = anthropic.Anthropic()
prompt = f"""
Eres analista de producto. Estos son los datos de actividad de {len(users_activity_data)} usuarios en los últimos 30 días:
{json.dumps(users_activity_data, ensure_ascii=False, indent=2)}
Analiza los patrones y:
1. Identifica a los usuarios HIGH RISK (probablemente se irán en las próximas 2 semanas)
2. Explica las señales con las que determinaste el riesgo
3. Propón una acción concreta para cada grupo de riesgo (correo, llamada, notificación dentro de la app)
Responde en formato JSON:
{{
"high_risk": [lista de user_id],
"medium_risk": [lista de user_id],
"risk_signals": "explicación",
"actions": {{"high_risk": "acción", "medium_risk": "acción"}}
}}
"""
message = client.messages.create(
model="claude-sonnet-5-5", # modelos vigentes: página «Lo vigente»
max_tokens=1024,
messages=[{"role": "user", "content": prompt}]
)
return json.loads("".join(b.text for b in message.content if b.type == "text"))Pruebas A/B: feature flags + Claude como intérprete
Los feature flags de PostHog permiten mostrar distintas versiones de la interfaz a distintos usuarios. Claude ayuda a interpretar los resultados sin conocimientos de estadística.
Escenario: pruebas dos versiones del botón de pago. PostHog muestra: variante A, 4.2% de conversión; variante B, 5.1% de conversión. ¿Es estadísticamente significativo? ¿Cuánto hay que esperar? Claude responde estas preguntas.
def interpret_ab_test(test_data: dict) -> str:
client = anthropic.Anthropic()
message = client.messages.create(
model="claude-sonnet-5-5",
max_tokens=512,
messages=[{
"role": "user",
"content": f"""
Analiza los resultados de la prueba A/B:
{json.dumps(test_data, ensure_ascii=False)}
Responde:
1. ¿Qué variante ganó y con qué grado de certeza?
2. ¿El resultado es estadísticamente significativo (muestra de {test_data.get('total_users', 'N/A')} usuarios)?
3. Recomienda: ¿lanzar la ganadora para todos o esperar más datos?
Responde en español, breve: 3-4 oraciones.
"""
}]
)
return "".join(b.text for b in message.content if b.type == "text")Session replay + Claude: encontrar los problemas sin ver videos
PostHog graba las sesiones de los usuarios. Con 1000 usuarios al día son 1000 videos. Nadie los va a ver. Pero Claude puede leer los metadatos de las sesiones y sacar patrones.
Los metadatos de una sesión incluyen: clics, rage clicks (clics desesperados cuando algo no funciona), dead clicks (clics en elementos que no son clicables), tiempo en la página y elementos con los que se interactuó.
def analyze_session_patterns(sessions_metadata: list[dict]) -> str:
rage_clicks = [s for s in sessions_metadata if s.get("rage_clicks", 0) > 2]
high_exit_pages = {}
for session in sessions_metadata:
exit_page = session.get("exit_page", "")
high_exit_pages[exit_page] = high_exit_pages.get(exit_page, 0) + 1
analysis_data = {
"total_sessions": len(sessions_metadata),
"frustration_sessions": len(rage_clicks),
"top_exit_pages": sorted(
high_exit_pages.items(), key=lambda x: x[1], reverse=True
)[:5],
"avg_session_duration_minutes": sum(
s.get("duration_seconds", 0) for s in sessions_metadata
) / len(sessions_metadata) / 60
}
client = anthropic.Anthropic()
message = client.messages.create(
model="claude-sonnet-5-5",
max_tokens=800,
messages=[{
"role": "user",
"content": f"""
Datos de las sesiones de los usuarios:
{json.dumps(analysis_data, ensure_ascii=False, indent=2)}
Encuentra los principales puntos de dolor de los usuarios. ¿Qué hay que corregir primero?
Respuesta: tres problemas concretos con propuestas para corregirlos.
"""
}]
)
return "".join(b.text for b in message.content if b.type == "text")Reporte semanal automático
Esta es la herramienta principal que vas a configurar en la práctica. Un script de Python se ejecuta cada lunes, toma los datos de PostHog de la semana anterior (con consultas en HogQL), se los pasa a Claude, recibe un reporte en lenguaje humano y lo envía a Telegram. Telegram se usa aquí porque crear un bot es gratis y toma minutos; si prefieres recibirlo por correo o Slack, cambia solo la función send_to_telegram.
import os
import json
import anthropic
import requests
from datetime import datetime, timedelta
from dotenv import load_dotenv
load_dotenv()
# Las claves se toman de .env, no se escriben en el código
POSTHOG_PERSONAL_API_KEY = os.getenv("POSTHOG_PERSONAL_API_KEY") # clave personal (phx_...) para leer datos
POSTHOG_PROJECT_ID = os.getenv("POSTHOG_PROJECT_ID")
POSTHOG_HOST = os.getenv("POSTHOG_HOST", "https://us.posthog.com") # para Europa: https://eu.posthog.com
TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID")
ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
def run_hogql(query: str) -> list:
"""Ejecuta una consulta en HogQL (el lenguaje de consultas de PostHog) mediante la API."""
response = requests.post(
f"{POSTHOG_HOST}/api/projects/{POSTHOG_PROJECT_ID}/query/",
headers={"Authorization": f"Bearer {POSTHOG_PERSONAL_API_KEY}"},
json={"query": {"kind": "HogQLQuery", "query": query}, "name": "weekly report"},
)
return response.json().get("results", []) if response.ok else []
def fetch_posthog_insights() -> dict:
"""Tomamos las métricas clave de la semana anterior"""
end_date = datetime.now()
start_date = end_date - timedelta(days=7)
# Vistas de página por día
pageviews_by_day = run_hogql(
"select toDate(timestamp) as day, count() from events "
"where event = '$pageview' and timestamp >= now() - interval 7 day "
"group by day order by day"
)
# Usuarios activos de la semana
active_users = run_hogql(
"select count(distinct person_id) from events "
"where timestamp >= now() - interval 7 day"
)
# Registros nuevos
signups = run_hogql(
"select count() from events "
"where event = 'signed_up' and timestamp >= now() - interval 7 day"
)
return {
"period": f"{start_date.strftime('%d.%m')} — {end_date.strftime('%d.%m.%Y')}",
"pageviews_by_day": pageviews_by_day,
"active_users": active_users,
"signups": signups,
}
def generate_weekly_report(insights: dict) -> str:
"""Claude genera un reporte en lenguaje humano"""
client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
message = client.messages.create(
model="claude-sonnet-5-5", # modelos vigentes: página «Lo vigente»
max_tokens=1500,
messages=[{
"role": "user",
"content": f"""
Eres analista de producto. Estos son los datos de la semana {insights['period']}:
{json.dumps(insights, ensure_ascii=False, indent=2, default=str)}
Escribe un reporte semanal para el fundador de una startup. Estructura:
📊 SEMANA {insights['period']}
🟢 Lo que va bien (2-3 puntos)
🔴 A qué poner atención (1-2 puntos)
🎯 Prioridad para esta semana (1 acción concreta)
Tono: amigable, concreto, sin relleno. Escribe en español.
Si hay pocos datos, dilo así, no inventes causas.
"""
}]
)
return "".join(b.text for b in message.content if b.type == "text")
def send_to_telegram(text: str):
"""Enviamos el reporte a Telegram"""
requests.post(
f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage",
json={
"chat_id": TELEGRAM_CHAT_ID,
"text": text,
}
)
def run_weekly_report():
print("Recolectando datos de PostHog...")
insights = fetch_posthog_insights()
print("Claude está analizando...")
report = generate_weekly_report(insights)
print("Enviando a Telegram...")
send_to_telegram(report)
print("¡Listo!")
if __name__ == "__main__":
run_weekly_report()Este script se ejecuta con cron cada lunes a las 9:00:
0 9 * * 1 cd /path/to/project && python weekly_report.py
Práctica
Tarea: configurar un sistema de analítica automático en 5 pasos.
Paso 1: Instalar PostHog (15 min)
- Entra a posthog.com y crea una cuenta (tiene un nivel gratuito)
- Crea un proyecto y obtén dos claves. La
Project API Key(empieza conphc_) sirve para enviar eventos desde el producto. Para leer datos con scripts necesitas una clave personal aparte (empieza conphx_: en la configuración de la cuenta, sección Personal API keys) y el ID del proyecto - Agrega el seguimiento a tu producto (el código exacto y la dirección
api_hostde tu región tómalos de la guía dentro de PostHog):
Para una aplicación web (HTML):
<script>
!function(t,e){var o,n,p,r;e.__SV||(window.posthog=e,e._i=[],e.init=function(i,s,a){...}
posthog.init('phc_tu_clave', {api_host: 'https://us.i.posthog.com'}) // para Europa: https://eu.i.posthog.com
</script>Para un backend en Python:
pip install posthogfrom posthog import Posthog
posthog = Posthog('phc_tu_clave', host='https://us.i.posthog.com')
# Los argumentos con nombre funcionan en distintas versiones de la biblioteca
posthog.capture(event='signed_up', distinct_id='user_123', properties={'plan': 'free', 'source': 'google'})- Verifica que lleguen los eventos: entra a PostHog → Activity → Live Events
Paso 2: Configurar los embudos clave (10 min)
En PostHog → Funnels → New Funnel:
- Paso 1:
signed_up(registro) - Paso 2:
onboarding_completed(terminó el onboarding) - Paso 3:
first_core_action(hizo la primera acción clave) - Paso 4:
payment_completed(pagó)
Guarda el embudo. Es tu métrica principal de la salud del producto.
Paso 3: Crear el script de Python del reporte semanal (20 min)
mkdir analytics_bot
cd analytics_bot
pip install anthropic requests python-dotenvCrea el archivo .env (y agrégalo a .gitignore):
POSTHOG_PERSONAL_API_KEY=phx_tu_clave_personal
POSTHOG_PROJECT_ID=tu_id_de_proyecto
POSTHOG_HOST=https://us.posthog.com
ANTHROPIC_API_KEY=sk-ant-tu_clave
TELEGRAM_BOT_TOKEN=tu_token
TELEGRAM_CHAT_ID=tu_chat_idCopia el código de weekly_report.py de la teoría de arriba. Ejecútalo:
python weekly_report.pyVerifica que el reporte llegó a Telegram.
Paso 4: Configurar la predicción de abandono (15 min)
Agrega al proyecto el script churn_detector.py:
from dotenv import load_dotenv
import os
import anthropic
import requests
import json
load_dotenv()
POSTHOG_HOST = os.getenv("POSTHOG_HOST", "https://us.posthog.com")
def get_at_risk_users():
"""Obtenemos a los usuarios que no entran desde hace 7+ días (simplificado: verifica el filtro y los campos en la documentación de PostHog)"""
headers = {"Authorization": f"Bearer {os.getenv('POSTHOG_PERSONAL_API_KEY')}"}
# Consulta simplificada: usuarios con baja actividad
response = requests.get(
f"{POSTHOG_HOST}/api/projects/{os.getenv('POSTHOG_PROJECT_ID')}/persons/",
headers=headers,
params={"properties": '[{"key":"$last_seen","value":"-7d","operator":"is_before_date"}]'}
)
if not response.ok:
return []
persons = response.json().get("results", [])
# Al modelo le enviamos solo IDs internos y contadores, sin nombres ni correos
return [
{
"user_id": p.get("distinct_ids", ["unknown"])[0],
"last_seen": p.get("properties", {}).get("$last_seen"),
"total_sessions": p.get("properties", {}).get("$session_count", 0),
}
for p in persons[:50] # Tomamos los primeros 50
]
def run_churn_check():
users = get_at_risk_users()
if not users:
print("No hay usuarios en zona de riesgo")
return
client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
message = client.messages.create(
model="claude-haiku-4-5", # Haiku basta para esta tarea (verifica que el modelo siga disponible en la API)
max_tokens=500,
messages=[{
"role": "user",
"content": f"""
Estos son usuarios que no entran desde hace tiempo ({len(users)} personas):
{json.dumps(users[:10], ensure_ascii=False)}
¿Qué les escribimos para que vuelvan? Un correo corto (3-4 oraciones) de reactivación.
"""
}]
)
print("Texto recomendado para la reactivación:")
print("".join(b.text for b in message.content if b.type == "text"))
print(f"\nUsuarios en zona de riesgo: {len(users)}")
if __name__ == "__main__":
run_churn_check()Paso 5: Configurar el arranque automático (5 min)
# Abrir crontab
crontab -e
# Agregar las líneas:
# Lunes 9:00: reporte semanal
0 9 * * 1 cd /path/to/analytics_bot && python weekly_report.py
# Viernes 17:00: revisión de abandono
0 17 * * 5 cd /path/to/analytics_bot && python churn_detector.py >> churn_log.txtVerificación del resultado: en una semana debería llegarte a Telegram el primer reporte automático. Si todavía hay pocos datos, es normal: el sistema funciona y va acumulando historial.
Herramientas y recursos
| Herramienta | Precio | Para qué |
|---|---|---|
| PostHog | Límite mensual gratuito en cada producto (límites vigentes en su página de precios) | Analítica de producto principal, session replay, flags |
| Mixpanel | Tiene nivel gratuito, condiciones en su sitio | Embudos, cohortes, cuando necesitas analítica de comportamiento a fondo |
| Plausible | De pago, con periodo de prueba, planes en su sitio | Analítica de tráfico con prioridad en la privacidad, inicio del proyecto |
| Amplitude | Tiene nivel gratuito, condiciones en su sitio | Alternativa a Mixpanel, análisis de retention sólido |
| PostHog MCP | Incluido en PostHog | Consultas directas desde Claude Code a PostHog |
| Claude Haiku | Pago por tokens | Tareas analíticas rutinarias |
| Claude Sonnet | Pago por tokens | Análisis complejo, churn prediction |
Precios y versiones vigentes: Lo vigente.
Enlaces útiles:
- PostHog Docs: documentación oficial
- PostHog MCP: conexión del servidor MCP
- Mixpanel API Reference: documentación de la API
- Amplitude SDK: si eliges Amplitude
Ideas clave
"Datos sin interpretación son ruido. Claude convierte el ruido en decisiones."
"Un reporte semanal automático cuesta centavos en tokens y ahorra horas de resumen manual. Pero vuelve a revisar sus cifras: el modelo relata los datos, no reemplaza a un analista."
"El mejor momento para configurar la analítica es antes del lanzamiento. El segundo mejor momento es ahora mismo."
Siguiente lección
→ Análisis de nichos y tendencias: Exploding Topics, Google Trends API y la búsqueda de oportunidades
La marca se guarda solo en este navegador y no se envía a ningún sitio. Mi progreso