· Nacho Coll · Guides · 10 min de lecture
API d'Alertes X : Abonnements Programmatiques et Historique des Notifications
Créez des intégrations personnalisées au-dessus de WALLAWHATS. Ajoutez et supprimez des abonnements X, dirigez les alertes vers des canaux, récupérez l'historique des notifications — tout via REST.
Quand les alertes X (Twitter) en temps réel deviennent critiques pour votre entreprise, la gestion manuelle du tableau de bord atteint ses limites. Que vous construisiez des tableaux de bord d’intelligence client, automatisiez des flux de travail de surveillance de marque, ou créiez des systèmes de notification personnalisés pour des équipes de trading, vous avez besoin d’un contrôle programmatique sur vos abonnements d’alertes X.
WALLAWHATS fournit une API REST qui vous permet de créer, gérer et auditer les abonnements d’alertes X sans toucher à l’interface web. Ajoutez ou supprimez des comptes surveillés, récupérez l’historique des notifications avec le statut de livraison, et intégrez les alertes X en temps réel dans n’importe quel système qui parle HTTP.
Pourquoi Utiliser l’API WALLAWHATS ?
Le tableau de bord fonctionne parfaitement pour les flux de travail manuels, mais l’accès API débloque des scénarios d’automatisation qui s’étendent au-delà de la gestion humaine :
Plateformes d’Intelligence Client : Abonnez-vous automatiquement aux dirigeants concurrents nouvellement identifiés, aux responsables produits, ou aux analystes sectoriels au fur et à mesure qu’ils sont découverts via les outils de recherche ou les intégrations CRM.
Flux de Travail Trading et Financier : Surveillez programmatiquement les comptes réglementaires, les profils de PDG, ou les journalistes spécialisés par secteur basés sur les changements de portefeuille ou les événements de marché — sans gestion manuelle d’abonnement.
Surveillance de Marque à Grande Échelle : Ajoutez ou supprimez le suivi des mentions de marque au fur et à mesure que de nouvelles campagnes se lancent, que les produits sortent, ou que des situations de crise se développent.
Applications SaaS Multi-Tenants : Surveillance X en temps réel en marque blanche pour vos clients, avec gestion programmatique d’abonnement en arrière-plan.
Systèmes de Conformité et d’Audit : Récupérez l’historique complet des notifications avec le statut de livraison pour les rapports réglementaires, les pistes d’audit internes, ou la surveillance des SLA.
Authentification et Accès API
Chaque plan WALLAWHATS inclut l’accès API avec des quotas de clés évolutifs :
- Free : 1 clé API
- Pro : 1 clé API
- Pro+ : 2 clés API
- Business : 5 clés API
- Enterprise : 20 clés API
L’authentification utilise l’en-tête x-api-key (pas Authorization: Bearer). Générez vos clés depuis la section API du tableau de bord, et traitez-les comme des mots de passe — elles portent tous les privilèges du compte.
curl -H "x-api-key: your_api_key_here" \
https://api.wallawhats.com/subscriptionsEndpoints API Principaux
L’API WALLAWHATS fournit cinq groupes de ressources principaux pour construire des intégrations :
Gestion des Abonnements
Créer un nouvel abonnement :
POST /subscriptions
Content-Type: application/json
x-api-key: your_api_key_here
{
"xUsername": "elonmusk"
}Lister tous les abonnements :
GET /subscriptions
x-api-key: your_api_key_hereSupprimer un abonnement :
DELETE /subscriptions/elonmusk
x-api-key: your_api_key_hereNotez que l’endpoint de suppression prend le nom d’utilisateur X comme paramètre de chemin — pas un ID d’abonnement interne.
Historique des Notifications et Audit
Récupérer l’historique des notifications avec le statut de livraison :
GET /notifications?from=1704067200000&to=1704153600000
x-api-key: your_api_key_hereL’endpoint notifications retourne des résultats paginés avec chaque ligne représentant une alerte livrée à un canal. Les valeurs de statut incluent :
queued: Alerte acceptée, en attente de livraisonsent: Expédiée au fournisseur de canaldelivered: Confirmée reçue par la destinationread: Ouverte par le destinataire (WhatsApp uniquement, nécessite l’activation des accusés de lecture)failed: Tentative de livraison échouée
Gestion des Canaux
Lister les canaux configurés :
GET /channels
x-api-key: your_api_key_hereAjouter un nouveau canal :
POST /channels
Content-Type: application/json
x-api-key: your_api_key_here
{
"type": "email",
"destination": "alerts@yourcompany.com"
}Supprimer un canal :
DELETE /channels/channel_id_here
x-api-key: your_api_key_hereCaptures d’Écran de Tweets
Accéder à la galerie de captures :
GET /snapshots
x-api-key: your_api_key_hereSupprimer une capture spécifique :
DELETE /snapshots/tweet_id_here
x-api-key: your_api_key_hereConstruire des Intégrations : Exemples de Code
Intégration Node.js
Voici un exemple Node.js qui ajoute un abonnement et interroge pour de nouvelles notifications :
const axios = require('axios');
class WallaWhatsClient {
constructor(apiKey) {
this.apiKey = apiKey;
this.baseURL = 'https://api.wallawhats.com';
}
async addSubscription(xUsername) {
try {
const response = await axios.post(
`${this.baseURL}/subscriptions`,
{ xUsername },
{ headers: { 'x-api-key': this.apiKey } }
);
return response.data;
} catch (error) {
throw new Error(`Failed to add subscription: ${error.response?.data?.message || error.message}`);
}
}
async getNotifications(from, to, lastKey = null) {
try {
let url = `${this.baseURL}/notifications?from=${from}&to=${to}`;
if (lastKey) url += `&lastKey=${lastKey}`;
const response = await axios.get(url, {
headers: { 'x-api-key': this.apiKey }
});
return response.data;
} catch (error) {
throw new Error(`Failed to fetch notifications: ${error.response?.data?.message || error.message}`);
}
}
async listSubscriptions() {
try {
const response = await axios.get(
`${this.baseURL}/subscriptions`,
{ headers: { 'x-api-key': this.apiKey } }
);
return response.data;
} catch (error) {
throw new Error(`Failed to list subscriptions: ${error.response?.data?.message || error.message}`);
}
}
}
// Exemple d'utilisation
async function monitorCompetitor() {
const client = new WallaWhatsClient('your_api_key_here');
// Ajouter un nouvel abonnement
await client.addSubscription('vercel');
console.log('Surveillance de @vercel maintenant active');
// Vérifier les notifications récentes
const oneDayAgo = Date.now() - (24 * 60 * 60 * 1000);
const notifications = await client.getNotifications(oneDayAgo, Date.now());
console.log(`Trouvé ${notifications.items.length} alertes récentes`);
notifications.items.forEach(notification => {
console.log(`${notification.xUsername}: ${notification.status} à ${notification.timestamp}`);
});
}Intégration Python
Pour les flux de travail Python, voici une classe qui gère la gestion des abonnements et l’interrogation des notifications :
import requests
import time
from datetime import datetime, timedelta
class WallaWhatsAPI:
def __init__(self, api_key):
self.api_key = api_key
self.base_url = 'https://api.wallawhats.com'
self.headers = {'x-api-key': api_key}
def add_subscription(self, x_username):
"""Ajouter un nouveau compte X à surveiller"""
response = requests.post(
f'{self.base_url}/subscriptions',
json={'xUsername': x_username},
headers=self.headers
)
response.raise_for_status()
return response.json()
def remove_subscription(self, x_username):
"""Supprimer un compte X de la surveillance"""
response = requests.delete(
f'{self.base_url}/subscriptions/{x_username}',
headers=self.headers
)
response.raise_for_status()
return response.status_code == 200
def get_notifications(self, from_ms, to_ms, last_key=None):
"""Récupérer l'historique des notifications avec pagination"""
params = {'from': from_ms, 'to': to_ms}
if last_key:
params['lastKey'] = last_key
response = requests.get(
f'{self.base_url}/notifications',
params=params,
headers=self.headers
)
response.raise_for_status()
return response.json()
def get_all_notifications(self, from_ms, to_ms):
"""Récupérer toutes les notifications dans une plage de temps, gérant la pagination"""
all_notifications = []
last_key = None
while True:
batch = self.get_notifications(from_ms, to_ms, last_key)
all_notifications.extend(batch['items'])
if not batch.get('lastKey'):
break
last_key = batch['lastKey']
return all_notifications
def list_subscriptions(self):
"""Obtenir tous les abonnements actuels"""
response = requests.get(
f'{self.base_url}/subscriptions',
headers=self.headers
)
response.raise_for_status()
return response.json()
# Exemple : Rapport d'audit quotidien
def generate_daily_report():
api = WallaWhatsAPI('your_api_key_here')
# Obtenir les notifications d'hier
end_time = int(time.time() * 1000)
start_time = end_time - (24 * 60 * 60 * 1000)
notifications = api.get_all_notifications(start_time, end_time)
# Grouper par compte et statut
report = {}
for notification in notifications:
account = notification['xUsername']
status = notification['status']
if account not in report:
report[account] = {'total': 0, 'delivered': 0, 'failed': 0}
report[account]['total'] += 1
if status in ['delivered', 'read']:
report[account]['delivered'] += 1
elif status == 'failed':
report[account]['failed'] += 1
# Imprimer le résumé
print(f"Rapport d'Alertes Quotidien - {datetime.now().strftime('%Y-%m-%d')}")
print("-" * 50)
for account, stats in report.items():
success_rate = (stats['delivered'] / stats['total']) * 100 if stats['total'] > 0 else 0
print(f"@{account}: {stats['total']} alertes, {success_rate:.1f}% livrées")Comprendre le Routage des Canaux
WALLAWHATS utilise un modèle de routage de canal global — chaque alerte de chaque abonnement se diffuse vers tous les canaux activés et vérifiés. Vous ne pouvez pas router des comptes spécifiques vers des destinations spécifiques via l’API (comme « @elonmusk → WhatsApp, @vercel → email »).
La sélection des canaux se fait au niveau du compte sur la page Canaux. Lorsque vous ajoutez un canal via l’API, il devient disponible pour toutes les alertes une fois vérifié. Lorsque vous supprimez un canal, il arrête de recevoir des alertes de tous les abonnements.
Ce design simplifie l’automatisation tout en empêchant la fragmentation des alertes. Votre code d’intégration n’a pas besoin de suivre les règles de routage par abonnement — gérez simplement quels comptes surveiller et quels canaux activer.
Limites de Taux et Plafonds de Vélocité
WALLAWHATS implémente des plafonds de vélocité au niveau utilisateur pour prévenir le spam d’alertes pendant les périodes de haute activité :
- Free : 2 alertes/heure
- Pro : 5 alertes/heure
- Pro+ : 15 alertes/heure
- Business : 30 alertes/heure
- Enterprise : 100 alertes/heure
Quand les plafonds de vélocité sont dépassés, les tweets supplémentaires sont mis en tampon dans des messages de résumé et livrés toutes les 15 minutes. Votre intégration API verra ceux-ci comme des enregistrements de notification séparés — un pour l’alerte immédiate, et un pour chaque lot de résumé.
L’API elle-même n’impose pas de limites de taux séparées sur la gestion des abonnements ou les requêtes de notifications. Cependant, évitez de marteler les endpoints avec des requêtes inutiles — mettez en cache les listes d’abonnements localement et groupez les requêtes de notifications efficacement.
Gestion des Erreurs et Dépannage
Modèles d’erreurs API courants et comment les gérer :
Échecs d’authentification (401) :
- Vérifiez que votre clé API est correcte et n’a pas été révoquée
- Assurez-vous d’utiliser l’en-tête
x-api-key, pasAuthorization
Conflits d’abonnements (409) :
- Compte déjà surveillé : L’abonnement existe, traitez comme un succès
- Compte protégé/privé : WALLAWHATS les refuse par design
Limitation de taux (429) :
- Reculez exponentiellement avant de réessayer
- Vérifiez si vous approchez des limites de plan sur les comptes surveillés
Problèmes de vérification de canal :
- Les nouveaux canaux nécessitent une vérification OTP avant de recevoir des alertes
- Les canaux ajoutés programmatiquement ne fonctionneront pas jusqu’à ce que l’utilisateur termine la vérification
Surveillance et Alerte de Vos Intégrations
Puisque WALLAWHATS devient une infrastructure critique quand intégré dans les flux de travail d’entreprise, surveillez la santé de votre intégration :
Détection de Dérive d’Abonnement :
// Vérifier si les abonnements attendus sont toujours actifs
async function auditSubscriptions(expectedHandles) {
const current = await client.listSubscriptions();
const currentHandles = current.map(s => s.xUsername);
const missing = expectedHandles.filter(h => !currentHandles.includes(h));
if (missing.length > 0) {
console.warn(`Abonnements manquants : ${missing.join(', ')}`);
}
return missing;
}Surveillance du Taux de Succès de Livraison :
def check_delivery_health():
# Vérifier les dernières 6 heures
end_time = int(time.time() * 1000)
start_time = end_time - (6 * 60 * 60 * 1000)
notifications = api.get_all_notifications(start_time, end_time)
if not notifications:
return None
delivered = sum(1 for n in notifications if n['status'] in ['delivered', 'read'])
total = len(notifications)
success_rate = (delivered / total) * 100
if success_rate < 95:
# Alerter votre équipe ops
print(f"ATTENTION : Le taux de succès de livraison est tombé à {success_rate:.1f}%")
return success_rateModèles d’Intégration et Bonnes Pratiques
Traitement Style Webhook : Bien que WALLAWHATS ne fournisse pas de webhooks directement, vous pouvez interroger l’endpoint notifications pour de nouvelles alertes et les traiter en quasi temps réel :
async function pollForNewAlerts() {
const lastCheck = localStorage.getItem('lastNotificationCheck') || Date.now() - 300000;
const now = Date.now();
const notifications = await client.getNotifications(lastCheck, now);
for (const notification of notifications.items) {
if (notification.status === 'delivered') {
// Traiter l'alerte - envoyer à Slack, mettre à jour la base de données, etc.
await processAlert(notification);
}
}
localStorage.setItem('lastNotificationCheck', now);
}
// Interroger toutes les 30 secondes
setInterval(pollForNewAlerts, 30000);Gestion Conditionnelle d’Abonnement : Ajoutez ou supprimez dynamiquement des abonnements basés sur des déclencheurs externes :
def update_competitor_monitoring(portfolio_companies):
"""Mettre à jour la surveillance X basée sur le portefeuille actuel"""
current_subs = {s['xUsername'] for s in api.list_subscriptions()}
# Comptes que nous devrions surveiller
target_accounts = set()
for company in portfolio_companies:
if company.get('ceo_twitter_handle'):
target_accounts.add(company['ceo_twitter_handle'])
if company.get('company_twitter_handle'):
target_accounts.add(company['company_twitter_handle'])
# Ajouter les abonnements manquants
for account in target_accounts - current_subs:
try:
api.add_subscription(account)
print(f"Surveillance de @{account} commencée")
except Exception as e:
print(f"Échec de l'ajout de @{account} : {e}")
# Supprimer les abonnements obsolètes
for account in current_subs - target_accounts:
api.remove_subscription(account)
print(f"Surveillance de @{account} arrêtée")L’API WALLAWHATS transforme les alertes X en temps réel d’un outil de tableau de bord manuel en un composant d’infrastructure programmable. Que vous construisiez des flux de travail d’intelligence personnalisés, automatisiez la surveillance de marque, ou créiez des services de notification en marque blanche, l’API fournit le contrôle et les capacités d’audit nécessaires pour l’intégration en production.
Vous cherchez à étendre votre surveillance au-delà des concurrents ? Consultez notre guide sur la surveillance de crypto Twitter pour les signaux de marché ou apprenez comment les journalistes utilisent WALLAWHATS pour la surveillance de sources en temps réel.
Ne ratez plus jamais un post important. Créez un compte gratuit — 1 numéro WhatsApp, alertes temps réel, aucune carte de crédit requise.
