Alertes Thématiques et Veille Automatisée

De la veille ponctuelle à la veille permanente

Les leçons précédentes vous ont montré comment interroger X ponctuellement. Mais la vraie puissance de la veille marketing réside dans son automatisation : un système qui tourne en continu, filtre le bruit et ne vous alerte que lorsqu’un signal pertinent apparaît.

Cette leçon vous apprend à construire un système d’alertes thématiques complet, depuis la définition des critères jusqu’à la notification.

Définir vos axes de veille

Un système d’alertes efficace commence par une cartographie précise de vos besoins. Organisez vos alertes en quatre axes :

Axe 1 : Marque et réputation

Tout ce qui mentionne votre marque, vos produits, vos dirigeants, directement ou indirectement.

Axe 2 : Concurrence

Les mouvements de vos concurrents directs et indirects (couvert en leçon 2).

Axe 3 : Secteur et réglementation

Les évolutions de votre marché, les nouvelles réglementations, les ruptures technologiques.

Axe 4 : Opportunités

Les demandes non satisfaites, les frustrations exprimées par les consommateurs, les appels d’offres informels.

Architecturer un système d’alertes

Voici l’architecture d’un système de veille automatisé basé sur X Search :

import json
from datetime import datetime, timedelta

class VeilleMarketing:
    def __init__(self, client):
        self.client = client
        self.alertes = []

    def definir_alerte(self, nom, prompt, handles=None,
                       frequence_heures=6, seuil_urgence="moyen"):
        self.alertes.append({
            "nom": nom,
            "prompt": prompt,
            "handles": handles,
            "frequence_heures": frequence_heures,
            "seuil_urgence": seuil_urgence,
            "dernier_scan": None
        })

    def executer_scan(self, alerte):
        tools_config = {"type": "x_search"}
        if alerte["handles"]:
            tools_config["allowed_x_handles"] = alerte["handles"]

        # Fenêtre temporelle depuis le dernier scan
        now = datetime.now()
        depuis = alerte["dernier_scan"] or (
            now - timedelta(hours=alerte["frequence_heures"])
        )

        tools_config["from_date"] = depuis.strftime("%Y-%m-%d")
        tools_config["to_date"] = now.strftime("%Y-%m-%d")

        response = self.client.responses.create(
            model="grok-4.20-reasoning",
            input=f"""{alerte['prompt']}

            Évalue l'urgence de chaque signal détecté :
            - CRITIQUE : nécessite une réaction immédiate
            - IMPORTANT : à traiter dans la journée
            - INFORMATIF : à noter pour le rapport hebdomadaire

            Si aucun signal pertinent, réponds simplement 'RAS'.""",
            tools=[tools_config]
        )

        alerte["dernier_scan"] = now
        return response.output_text

Configurer des alertes concrètes

Voici des exemples d’alertes adaptées à différents contextes marketing :

Alerte réputation

veille = VeilleMarketing(client)

veille.definir_alerte(
    nom="Réputation marque",
    prompt="""Recherche toute mention de [votre marque]
    sur X. Identifie les plaintes, critiques, ou problèmes
    signalés par les utilisateurs. Classe par gravité.""",
    frequence_heures=4,
    seuil_urgence="critique"
)

Alerte lancement concurrent

veille.definir_alerte(
    nom="Lancements concurrents",
    prompt="""Détecte tout signe de lancement de produit
    ou de campagne majeure : teasers, annonces, pages de
    pré-inscription, changements de bio ou de photo de profil.""",
    handles=["@concurrent_a", "@concurrent_b", "@concurrent_c"],
    frequence_heures=12,
    seuil_urgence="important"
)

Alerte opportunité sectorielle

veille.definir_alerte(
    nom="Opportunités secteur",
    prompt="""Identifie les demandes non satisfaites, les
    frustrations ou les recherches de recommandations dans
    le secteur [votre secteur]. Focus sur les posts qui
    expriment un besoin concret auquel notre offre répond.""",
    frequence_heures=8,
    seuil_urgence="moyen"
)

Gérer les notifications et le routage

Les résultats de vos alertes doivent atteindre les bonnes personnes au bon moment. Structurez votre système de notification en fonction du niveau d’urgence :

def router_alerte(nom_alerte, resultat, seuil):
    if resultat.strip() == "RAS":
        return  # Pas de notification

    if seuil == "critique":
        # Notification immédiate (Slack, SMS, email)
        envoyer_notification_urgente(nom_alerte, resultat)
    elif seuil == "important":
        # Ajout au digest quotidien
        ajouter_au_digest(nom_alerte, resultat)
    else:
        # Archivage pour rapport hebdomadaire
        archiver_signal(nom_alerte, resultat)

Bonnes pratiques de notification

• Ne sur-notifiez pas : trop d’alertes non pertinentes conduit à les ignorer toutes
• Contextualisez : chaque alerte doit expliquer pourquoi elle a été déclenchée
• Priorisez : le système doit faire le tri, pas le destinataire
• Historisez : gardez un log de toutes les alertes pour identifier les patterns

Optimiser les coûts de votre veille

À 5 $ pour 1 000 appels X Search, une veille active peut générer des coûts significatifs. Voici comment les maîtriser :

Calcul de budget

Nombre d'alertes × scans/jour × 30 jours = appels mensuels

Exemple :
- 5 alertes × 4 scans/jour × 30 = 600 appels/mois
- Coût : 600 / 1000 × 5 $ = 3 $/mois

Stratégies d’optimisation

• Regroupez les handles : une seule requête avec 10 handles au lieu de 10 requêtes séparées
• Adaptez la fréquence : scannez plus souvent pendant les événements clés, moins en période calme
• Filtrez côté prompt : demandez à Grok de ne remonter que les signaux au-dessus d’un certain seuil
• Cachez les résultats : ne relancez pas un scan si le précédent date de moins de X minutes

Mise en pratique : tableau de bord de veille

Combinez tous vos axes de veille dans un script orchestrateur :

def cycle_veille_complet(veille):
    resultats = {}
    for alerte in veille.alertes:
        now = datetime.now()
        dernier = alerte["dernier_scan"]

        # Vérifier si le scan est dû
        if dernier and (now - dernier).total_seconds() < \
           alerte["frequence_heures"] * 3600:
            continue

        resultat = veille.executer_scan(alerte)
        resultats[alerte["nom"]] = resultat
        router_alerte(alerte["nom"], resultat, alerte["seuil_urgence"])

    return resultats

Points clés à retenir

• Structurez votre veille en quatre axes : réputation, concurrence, secteur et opportunités
• Chaque alerte doit avoir une fréquence et un seuil d’urgence adaptés
• Routez les notifications vers les bonnes personnes selon l’urgence
• À 5 $/1 000 appels, une veille marketing complète coûte quelques dollars par mois
• Regroupez les handles et adaptez la fréquence pour optimiser les coûts