Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Rapports concurrentiels automatisés

Lezione 10 di 12 Aggiornata il 30 luglio 2026 Intermedio
In questa pagina
  1. Automatise la veille concurrentielle
  2. Architecture d’un rapport concurrentiel complet
  3. Construire le système de reporting
  4. Structurer le rapport en JSON exploitable
  5. Comparer les périodes pour détecter les changements
  6. Planifier l’exécution récurrente
  7. Bonnes pratiques pour des rapports exploitables
  8. Punti chiave

Automatise la veille concurrentielle

Un rapport concurrentiel ponctuel devient obsolète en quelques jours. La vraie valeur réside dans l’automatisation : des rapports générés régulièrement, structurés de manière identique, te permettant de comparer les périodes et de suivre les virages stratégiques de tes concurrents.

Cette leçon t’apprend à construire un système de reporting concurrentiel automatisé combinant les données X et les données web.

Architecture d’un rapport concurrentiel complet

Un rapport de veille marketing efficace couvre cinq axes, dont la valeur provient de leur intersection : un lancement de produit (axe 3) se reflète également dans le volume de publications (axe 1) et le sentiment public (axe 4). Ce recoupement distingue l’intelligence de la simple collecte : un signal confirmé par deux axes mérite attention, un signal isolé nécessite surtout vérification :

1. Activité sur les réseaux sociaux

Volume de publications, formats utilisés, engagement, croissance de l’audience.

2. Stratégie de contenu

Sujets abordés, ton, positionnement, calendrier éditorial observé.

3. Lancements et annonces

Nouveaux produits, fonctionnalités, partenariats, événements.

4. Perception publique

Sentiment, plaintes, éloges, comparaisons spontanées avec d’autres marques.

5. Prix et positionnement de l’offre

Changements de prix, promotions, packaging, offres spéciales.

Construire le système de reporting

Classe de rapport concurrentiel

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"""Collect and analyze posts
            from these accounts from {start} to {end}.

            Provide for each account:
            - Estimated number of posts
            - Content types (text, image, video, thread)
            - Most engaging posts
            - Main themes covered
            - Observed tone and positioning
            - Detected announcements or launches""",
            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"""Search for recent news regarding
            {concurrent} between {start} and {end}.

            Focus on:
            - Press releases and news articles
            - Product or service updates
            - Leadership team changes
            - Fundraising or financial results
            - Strategic partnerships""",
            tools=[{
                "type": "web_search",
                "allowed_domains": [
                    "techcrunch.com", "lesechos.fr",
                    "usine-digitale.fr"
                ]
            }]
        )
        return response.output_text

Générer le rapport compilé

    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 = {}

        # Collect data for each competitor
        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
            }

        # Comparative summary
        rapport_final = self.client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=f"""Compile this monthly competitive report.

            Our brand: {self.marque}
            Period: {start} to {end}

            DATA PER COMPETITOR:
            {json.dumps(sections, ensure_ascii=False, indent=2)}

            Report structure:
            1. EXECUTIVE SUMMARY (5 bullet points max)
            2. COMPARATIVE TABLE (activity, sentiment, innovation)
            3. ANALYSIS PER COMPETITOR (strengths, weaknesses, moves)
            4. IDENTIFIED THREATS (ranked by urgency)
            5. OPPORTUNITIES FOR {self.marque}
            6. STRATEGIC RECOMMENDATIONS (3-5 priority actions)"""
        ).output_text

        return rapport_final

Structurer le rapport en JSON exploitable

Pour alimenter un tableau de bord ou une base de données, demande un format structuré :

    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"""Generate a competitive report in JSON.

            Competitors: {json.dumps([c['nom'] for c in self.concurrents])}
            Period: {start} to {end}

            Expected format:
            {{
              "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

Comparer les périodes pour détecter les changements

La valeur d’un système automatisé réside dans la comparaison temporelle :

def comparer_rapports(rapport_actuel, rapport_precedent):
    response = client.responses.create(
        model="grok-4.20-0309-reasoning",
        input=f"""Compare these two consecutive
        competitive reports and identify significant changes:

        PREVIOUS REPORT: {rapport_precedent}
        CURRENT REPORT: {rapport_actuel}

        Analysis:
        1. Which competitors changed strategy?
        2. What new threats appeared?
        3. What opportunities opened or closed?
        4. What trends are confirmed or reversing?
        5. Recommended immediate actions."""
    )
    return response.output_text

Planifier l’exécution récurrente

Intègre ton rapport dans une tâche cron ou un planificateur Python :

# Weekly execution
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"]
        }
    ]
)

# Weekly report
resultat = rapport.generer_rapport(periode_jours=7)

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

Bonnes pratiques pour des rapports exploitables

  • Cohérence : utilise toujours la même structure pour faciliter la comparaison.
  • Priorisation : classe les insights par impact business, et non par volume.
  • Actionnabilité : chaque section doit mener à une recommandation.
  • Distribution : adapte le format au destinataire (direction = synthèse, opérationnel = détail).
  • Archivage : conserve tous les rapports pour l’analyse des tendances à long terme.

Punti chiave

  • Un rapport concurrentiel automatisé couvre 5 axes : social, contenu, lancements, perception, prix.
  • Combine X Search et Web Search pour une vue complète de chaque concurrent.
  • Structure les résultats en JSON pour alimenter tes tableaux de bord.
  • La comparaison entre les périodes révèle les changements stratégiques.
  • Chaque insight doit mener à une recommandation actionnable.
  • Archive systématiquement tes rapports pour un suivi à long terme.