Ir al contenido principal
Español— Elegir un idioma
Menú

Informes competitivos automatizados

Lección 10 de 12 Actualizado el 30 de julio de 2026 Intermedio
En esta página
  1. Automatiza la inteligencia competitiva
  2. Arquitectura de un informe competitivo completo
  3. Construye el sistema de informes
  4. Estructura el informe en JSON utilizable
  5. Compara periodos para detectar cambios
  6. Programa la ejecución recurrente
  7. Mejores prácticas para informes útiles
  8. Puntos clave

Automatiza la inteligencia competitiva

Un informe competitivo puntual queda obsoleto en cuestión de días. El verdadero valor reside en la automatización: informes generados regularmente, con una estructura idéntica, que te permiten comparar periodos y rastrear los cambios estratégicos de tus competidores.

Esta lección te muestra cómo construir un sistema de informes competitivos automatizado que combine datos de X y datos web.

Arquitectura de un informe competitivo completo

Un informe de inteligencia competitiva de marketing eficaz abarca cinco ejes, y su valor proviene de cómo se intersecan: un lanzamiento de producto (eje 3) también se refleja en el volumen de publicaciones (eje 1) y en el sentimiento público (eje 4). Esta triangulación es lo que distingue la inteligencia de la mera recopilación: una señal confirmada por dos ejes merece atención; una señal aislada requiere, sobre todo, verificación:

1. Actividad en redes sociales

Volumen de publicaciones, formatos utilizados, interacción, crecimiento de la audiencia.

2. Estrategia de contenidos

Temas tratados, tono, posicionamiento, calendario editorial observado.

3. Lanzamientos y anuncios

Nuevos productos, funcionalidades, asociaciones, eventos.

4. Percepción pública

Sentimiento, quejas, elogios, comparaciones espontáneas con otras marcas.

5. Posicionamiento de precios y oferta

Cambios de precios, promociones, embalaje, ofertas especiales.

Construye el sistema de informes

Clase del informe competitivo

from datetime import datetime, timedelta
import json

class RapportConcurrentiel:
    def __init__(self, client, marque_propre, concurrents):
        self.client = client
        self.marque = marque_propre
        self.concurrents = concurrents

    def collecter_donnees_x(self, handles, start, end):
        response = self.client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=f"""Recopila y analiza las publicaciones
            de estas cuentas desde {start} hasta {end}.

            Proporciona para cada cuenta:
            - Número estimado de publicaciones
            - Tipos de contenido (texto, imagen, vídeo, hilo)
            - Publicaciones con mayor interacción
            - Principales temas tratados
            - Tono y posicionamiento observados
            - Anuncios o lanzamientos detectados""",
            tools=[{
                "type": "x_search",
                "allowed_x_handles": handles,
                "from_date": start,
                "to_date": end,
                "enable_image_understanding": True
            }]
        )
        return response.output_text

    def collecter_donnees_web(self, concurrent, start, end):
        response = self.client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=f"""Busca noticias recientes sobre
            {concurrent} entre {start} y {end}.

            Céntrate en:
            - Notas de prensa y artículos de noticias
            - Actualizaciones de productos o servicios
            - Cambios en el equipo directivo
            - Recaudación de fondos o resultados financieros
            - Asociaciones estratégicas""",
            tools=[{
                "type": "web_search",
                "allowed_domains": [
                    "techcrunch.com", "lesechos.fr",
                    "usine-digitale.fr"
                ]
            }]
        )
        return response.output_text

Genera el informe consolidado

    def generer_rapport(self, periode_jours=30):
        end = datetime.now().strftime("%Y-%m-%d")
        start = (datetime.now() - timedelta(
            days=periode_jours)).strftime("%Y-%m-%d")

        sections = {}

        # Recopila datos para cada competidor
        for concurrent in self.concurrents:
            handles = concurrent.get("handles", [])
            nom = concurrent["nom"]

            donnees_x = self.collecter_donnees_x(
                handles, start, end
            ) if handles else "No X data"

            donnees_web = self.collecter_donnees_web(
                nom, start, end
            )

            sections[nom] = {
                "x": donnees_x,
                "web": donnees_web
            }

        # Resumen comparativo
        rapport_final = self.client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=f"""Compila este informe competitivo mensual.

            Nuestra marca: {self.marque}
            Periodo: {start} a {end}

            DATOS POR COMPETIDOR:
            {json.dumps(sections, ensure_ascii=False, indent=2)}

            Estructura del informe:
            1. RESUMEN EJECUTIVO (máximo 5 puntos clave)
            2. TABLA COMPARATIVA (actividad, sentimiento, innovación)
            3. ANÁLISIS POR COMPETIDOR (fortalezas, debilidades, movimientos)
            4. AMENAZAS IDENTIFICADAS (ordenadas por urgencia)
            5. OPORTUNIDADES PARA {self.marque}
            6. RECOMENDACIONES ESTRATÉGICAS (3-5 acciones prioritarias)"""
        ).output_text

        return rapport_final

Estructura el informe en JSON utilizable

Para alimentar un panel de control o una base de datos, solicita un formato estructurado:

    def rapport_json(self, periode_jours=30):
        end = datetime.now().strftime("%Y-%m-%d")
        start = (datetime.now() - timedelta(
            days=periode_jours)).strftime("%Y-%m-%d")

        response = self.client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=f"""Genera un informe competitivo en JSON.

            Competidores: {json.dumps([c['nom'] for c in self.concurrents])}
            Periodo: {start} a {end}

            Formato esperado:
            {{
              "period": "{start} - {end}",
              "competitors": [
                {{
                  "name": "Competitor A",
                  "social_activity": {{
                    "post_volume": 45,
                    "average_engagement": "high",
                    "dominant_formats": ["image", "thread"]
                  }},
                  "public_sentiment": 3.8,
                  "innovations": ["description"],
                  "threats": ["description"],
                  "main_strength": "description",
                  "main_weakness": "description"
                }}
              ],
              "recommendations": ["action 1", "action 2"]
            }}""",
            tools=[
                {"type": "x_search", "from_date": start, "to_date": end},
                {"type": "web_search"}
            ]
        )
        return response.output_text

Compara periodos para detectar cambios

El valor de un sistema automatizado reside en la comparación temporal:

def comparer_rapports(rapport_actuel, rapport_precedent):
    response = client.responses.create(
        model="grok-4.20-0309-reasoning",
        input=f"""Compara estos dos informes competitivos consecutivos
        e identifica los cambios significativos:

        INFORME ANTERIOR: {rapport_precedent}
        INFORME ACTUAL: {rapport_actuel}

        Análisis:
        1. ¿Qué competidores han cambiado de estrategia?
        2. ¿Qué nuevas amenazas han surgido?
        3. ¿Qué oportunidades se han abierto o cerrado?
        4. ¿Qué tendencias se confirman o se invierten?
        5. Acciones inmediatas recomendadas."""
    )
    return response.output_text

Programa la ejecución recurrente

Integra tu informe en una tarea cron o un planificador de Python:

# Ejecución semanal
rapport = RapportConcurrentiel(
    client=client,
    marque_propre="Your Brand",
    concurrents=[
        {
            "nom": "Competitor A",
            "handles": ["competitor_a", "competitor_a_fr"]
        },
        {
            "nom": "Competitor B",
            "handles": ["competitor_b"]
        },
        {
            "nom": "Competitor C",
            "handles": ["competitor_c"]
        }
    ]
)

# Informe semanal
resultat = rapport.generer_rapport(periode_jours=7)

# Archiva el informe
with open(f"reports/competitor_{datetime.now().strftime('%Y-%m-%d')}.md",
          "w") as f:
    f.write(resultat)

Mejores prácticas para informes útiles

  • Consistencia: utiliza siempre la misma estructura para facilitar la comparación.
  • Priorización: ordena los hallazgos por impacto empresarial, no por volumen.
  • Acción: cada sección debe conducir a una recomendación.
  • Distribución: adapta el formato al destinatario (ejecutivo = resumen, operativo = detalle).
  • Archivado: conserva todos los informes para el análisis de tendencias a largo plazo.

Puntos clave

  • Un informe competitivo automatizado cubre 5 ejes: social, contenidos, lanzamientos, percepción y precios.
  • Combina X Search y Web Search para obtener una visión completa de cada competidor.
  • Estructura los resultados en JSON para alimentar tus paneles de control.
  • La comparación entre periodos revela cambios estratégicos.
  • Todo hallazgo debe conducir a una recomendación accionable.
  • Archiva sistemáticamente tus informes para el seguimiento a largo plazo.