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-0309-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

Le coût d’une veille automatisée se maîtrise d’abord par le regroupement : une seule requête couvrant dix handles coûte une invocation là où dix requêtes séparées en coûtent dix, pour la même information. La fréquence de scan est le deuxième levier, et elle n’a aucune raison d’être constante — resserrez-la pendant les événements clés (lancement d’un concurrent, crise sectorielle) et relâchez-la en période calme : une veille horaire un dimanche d’août brûle du budget pour rien. Le filtrage côté prompt affine ensuite le signal : demander à Grok de ne remonter que les éléments au-dessus d’un seuil de pertinence vous évite de traiter — et de stocker — du bruit. Enfin, un cache simple ferme la boucle : si le dernier scan date de moins de quelques minutes, resservez son résultat au lieu de relancer la requête, notamment quand plusieurs utilisateurs ou tableaux de bord consomment la même veille.

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

Tarifs relevés le 5 août 2026 — les prix évoluent régulièrement : avant tout calcul de budget, vérifiez la grille en vigueur sur la page officielle des modèles et tarifs xAI.

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