· Nacho Coll · Guides  · 8 Min. Lesezeit

X Alerts API: Programmatische Abonnements und Benachrichtigungshistorie

Erstelle benutzerdefinierte Integrationen auf Basis von WALLAWHATS. Füge X-Abonnements hinzu und entferne sie, leite Warnungen an Kanäle weiter, rufe die Benachrichtigungshistorie ab — alles über REST.

Erstelle benutzerdefinierte Integrationen auf Basis von WALLAWHATS. Füge X-Abonnements hinzu und entferne sie, leite Warnungen an Kanäle weiter, rufe die Benachrichtigungshistorie ab — alles über REST.

Wenn Echtzeit-X-(Twitter)-Warnungen für dein Unternehmen geschäftskritisch werden, stößt die manuelle Dashboard-Verwaltung an ihre Grenzen. Egal ob du Kundenintelligenz-Dashboards erstellst, Brand-Monitoring-Workflows automatisierst oder benutzerdefinierte Benachrichtigungssysteme für Handelsabteilungen entwickelst — du brauchst programmatische Kontrolle über deine X-Alert-Abonnements.

WALLAWHATS bietet eine REST API, mit der du X-Alert-Abonnements erstellen, verwalten und überwachen kannst, ohne die Web-Oberfläche zu berühren. Füge überwachte Accounts hinzu oder entferne sie, rufe die Benachrichtigungshistorie mit Lieferstatus ab und integriere Echtzeit-X-Alerts in jedes System, das HTTP spricht.

API keys management page with create / revoke controls

Warum die WALLAWHATS API verwenden?

Das Dashboard funktioniert großartig für manuelle Workflows, aber API-Zugriff ermöglicht Automatisierungsszenarien, die über menschliche Verwaltung hinaus skalieren:

Kundenintelligenz-Plattformen: Abonniere automatisch neu identifizierte Konkurrenz-Führungskräfte, Produktleiter oder Branchenanalysten, sobald sie über Recherche-Tools oder CRM-Integrationen entdeckt werden.

Trading- und Finanz-Workflows: Überwache programmatisch Regulierungsbehörden, CEO-Handles oder branchenspezifische Journalisten basierend auf Portfolio-Änderungen oder Marktereignissen — ohne manuelle Abonnement-Verwaltung.

Brand Monitoring im großen Stil: Füge Brand-Mention-Tracking hinzu oder entferne es, wenn neue Kampagnen starten, Produkte ausgeliefert werden oder sich Krisensituationen entwickeln.

Multi-Tenant-SaaS-Anwendungen: White-Label-Echtzeit-X-Monitoring für deine Kunden mit programmatischer Abonnement-Verwaltung im Hintergrund.

Compliance- und Audit-Systeme: Rufe die komplette Benachrichtigungshistorie mit Lieferstatus für Compliance-Berichte, interne Audit-Trails oder SLA-Monitoring ab.

API-Authentifizierung und Zugang

Jeder WALLAWHATS-Plan enthält API-Zugang mit skalierenden Key-Kontingenten:

  • Free: 1 API-Key
  • Pro: 1 API-Key
  • Pro+: 2 API-Keys
  • Business: 5 API-Keys
  • Enterprise: 20 API-Keys

Die Authentifizierung verwendet den x-api-key-Header (nicht Authorization: Bearer). Generiere deine Keys im API-Bereich des Dashboards und behandle sie wie Passwörter — sie haben volle Account-Berechtigung.

curl -H "x-api-key: your_api_key_here" \
     https://api.wallawhats.com/subscriptions

Zentrale API-Endpunkte

Die WALLAWHATS API bietet fünf Haupt-Ressourcengruppen für den Aufbau von Integrationen:

Abonnement-Verwaltung

Neues Abonnement erstellen:

POST /subscriptions
Content-Type: application/json
x-api-key: your_api_key_here

{
  "xUsername": "elonmusk"
}

Alle Abonnements auflisten:

GET /subscriptions
x-api-key: your_api_key_here

Abonnement entfernen:

DELETE /subscriptions/elonmusk
x-api-key: your_api_key_here

Beachte, dass der Delete-Endpunkt das X-Handle als Pfad-Parameter nimmt — nicht eine interne Abonnement-ID.

Benachrichtigungshistorie und Audit

Benachrichtigungshistorie mit Lieferstatus abrufen:

GET /notifications?from=1704067200000&to=1704153600000
x-api-key: your_api_key_here

Der Notifications-Endpunkt gibt paginierte Ergebnisse zurück, wobei jede Zeile eine Warnung darstellt, die an einen Kanal geliefert wurde. Statuswerte umfassen:

  • queued: Warnung akzeptiert, wartet auf Lieferung
  • sent: An den Kanal-Provider gesendet
  • delivered: Empfang durch das Ziel bestätigt
  • read: Vom Empfänger geöffnet (nur WhatsApp, erfordert aktivierte Lesebestätigungen)
  • failed: Lieferversuch erfolglos

Kanal-Verwaltung

Konfigurierte Kanäle auflisten:

GET /channels
x-api-key: your_api_key_here

Neuen Kanal hinzufügen:

POST /channels
Content-Type: application/json
x-api-key: your_api_key_here

{
  "type": "email",
  "destination": "alerts@yourcompany.com"
}

Kanal entfernen:

DELETE /channels/channel_id_here
x-api-key: your_api_key_here

Tweet-Snapshots

Auf die Snapshot-Galerie zugreifen:

GET /snapshots
x-api-key: your_api_key_here

Bestimmten Snapshot löschen:

DELETE /snapshots/tweet_id_here
x-api-key: your_api_key_here

Integrationen erstellen: Code-Beispiele

Node.js-Integration

Hier ist ein Node.js-Beispiel, das ein Abonnement hinzufügt und nach neuen Benachrichtigungen abfragt:

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}`);
    }
  }
}

// Verwendungsbeispiel
async function monitorCompetitor() {
  const client = new WallaWhatsClient('your_api_key_here');
  
  // Neues Abonnement hinzufügen
  await client.addSubscription('vercel');
  console.log('Now monitoring @vercel');
  
  // Aktuelle Benachrichtigungen prüfen
  const oneDayAgo = Date.now() - (24 * 60 * 60 * 1000);
  const notifications = await client.getNotifications(oneDayAgo, Date.now());
  
  console.log(`Found ${notifications.items.length} recent alerts`);
  notifications.items.forEach(notification => {
    console.log(`${notification.xUsername}: ${notification.status} at ${notification.timestamp}`);
  });
}

Python-Integration

Für Python-Workflows ist hier eine Klasse, die Abonnement-Verwaltung und Benachrichtigungs-Abfragen übernimmt:

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):
        """Neuen X-Account zur Überwachung hinzufügen"""
        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):
        """X-Account aus der Überwachung entfernen"""
        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):
        """Benachrichtigungshistorie mit Paginierung abrufen"""
        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):
        """Alle Benachrichtigungen in einem Zeitraum abrufen, Paginierung handhaben"""
        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):
        """Alle aktuellen Abonnements abrufen"""
        response = requests.get(
            f'{self.base_url}/subscriptions',
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()

# Beispiel: Täglicher Audit-Bericht
def generate_daily_report():
    api = WallaWhatsAPI('your_api_key_here')
    
    # Gestrige Benachrichtigungen abrufen
    end_time = int(time.time() * 1000)
    start_time = end_time - (24 * 60 * 60 * 1000)
    
    notifications = api.get_all_notifications(start_time, end_time)
    
    # Nach Account und Status gruppieren
    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
    
    # Zusammenfassung ausgeben
    print(f"Daily Alert Report - {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']} alerts, {success_rate:.1f}% delivered")

Kanal-Routing verstehen

WALLAWHATS verwendet ein globales Kanal-Routing-Modell — jede Warnung von jedem Abonnement wird an alle aktivierten und verifizierten Kanäle gesendet. Du kannst nicht spezifische Accounts an spezifische Ziele über die API routen (wie „@elonmusk → WhatsApp, @vercel → E-Mail”).

Die Kanal-Auswahl geschieht auf Account-Ebene auf der Kanäle-Seite. Wenn du einen Kanal über die API hinzufügst, wird er für alle Warnungen verfügbar, sobald er verifiziert ist. Wenn du einen Kanal entfernst, erhält er keine Warnungen mehr von allen Abonnements.

Dieses Design vereinfacht die Automatisierung und verhindert Alert-Fragmentierung. Dein Integrationscode muss keine per-Abonnement-Routing-Regeln verfolgen — verwalte einfach, welche Accounts überwacht werden sollen und welche Kanäle aktiviert werden sollen.

Rate Limits und Velocity Caps

WALLAWHATS implementiert benutzerspezifische Velocity Caps, um Alert-Spam während hochaktiver Perioden zu verhindern:

  • Free: 2 Warnungen/Stunde
  • Pro: 5 Warnungen/Stunde
  • Pro+: 15 Warnungen/Stunde
  • Business: 30 Warnungen/Stunde
  • Enterprise: 100 Warnungen/Stunde

Wenn Velocity Caps überschritten werden, werden zusätzliche Tweets in Digest-Nachrichten gepuffert und alle 15 Minuten geliefert. Deine API-Integration wird diese als separate Benachrichtigungsdatensätze sehen — einen für die sofortige Warnung und einen für jeden Digest-Batch.

Die API selbst setzt keine separaten Rate Limits auf Abonnement-Verwaltung oder Benachrichtigungsabfragen. Bombardiere jedoch die Endpunkte nicht mit unnötigen Anfragen — cache Abonnementlisten lokal und batch Benachrichtigungsabfragen effizient.

Fehlerbehandlung und Troubleshooting

Häufige API-Fehlermuster und wie man sie behandelt:

Authentifizierungsfehler (401):

  • Überprüfe, ob dein API-Key korrekt ist und nicht widerrufen wurde
  • Stelle sicher, dass du den x-api-key-Header verwendest, nicht Authorization

Abonnement-Konflikte (409):

  • Account bereits überwacht: Das Abonnement existiert, behandle es als Erfolg
  • Account geschützt/privat: WALLAWHATS lehnt diese bewusst ab

Rate Limiting (429):

  • Warte exponentiell ab, bevor du es erneut versuchst
  • Prüfe, ob du dich den Plan-Limits für überwachte Accounts näherst

Kanal-Verifizierungsprobleme:

  • Neue Kanäle benötigen OTP-Verifizierung, bevor sie Warnungen erhalten
  • Programmatisch hinzugefügte Kanäle funktionieren nicht, bis der Benutzer die Verifizierung abgeschlossen hat

Monitoring und Alerting deiner Integrationen

Da WALLAWHATS zu kritischer Infrastruktur wird, wenn es in Geschäfts-Workflows integriert ist, überwache die Gesundheit deiner Integration:

Subscription Drift Detection:

// Prüfe, ob erwartete Abonnements noch aktiv sind
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(`Missing subscriptions: ${missing.join(', ')}`);
  }
  
  return missing;
}

Delivery Success Rate Monitoring:

def check_delivery_health():
    # Letzte 6 Stunden prüfen
    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:
        # Dein Ops-Team alarmieren
        print(f"WARNING: Delivery success rate dropped to {success_rate:.1f}%")
    
    return success_rate

Integrationsmuster und Best Practices

Webhook-artige Verarbeitung: Während WALLAWHATS keine Webhooks direkt bereitstellt, kannst du den Notifications-Endpunkt für neue Warnungen abfragen und sie in Near-Real-Time verarbeiten:

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') {
      // Warnung verarbeiten - an Slack senden, Datenbank aktualisieren, etc.
      await processAlert(notification);
    }
  }
  
  localStorage.setItem('lastNotificationCheck', now);
}

// Alle 30 Sekunden abfragen
setInterval(pollForNewAlerts, 30000);

Bedingte Abonnement-Verwaltung: Abonnements dynamisch hinzufügen oder entfernen basierend auf externen Auslösern:

def update_competitor_monitoring(portfolio_companies):
    """X-Monitoring basierend auf aktuellem Portfolio aktualisieren"""
    current_subs = {s['xUsername'] for s in api.list_subscriptions()}
    
    # Accounts, die wir überwachen sollten
    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'])
    
    # Fehlende Abonnements hinzufügen
    for account in target_accounts - current_subs:
        try:
            api.add_subscription(account)
            print(f"Started monitoring @{account}")
        except Exception as e:
            print(f"Failed to add @{account}: {e}")
    
    # Veraltete Abonnements entfernen
    for account in current_subs - target_accounts:
        api.remove_subscription(account)
        print(f"Stopped monitoring @{account}")

Die WALLAWHATS API verwandelt Echtzeit-X-Alerts von einem manuellen Dashboard-Tool in eine programmierbare Infrastruktur-Komponente. Egal ob du benutzerdefinierte Intelligence-Workflows erstellst, Brand Monitoring automatisierst oder White-Label-Benachrichtigungsservices entwickelst — die API bietet die Kontrolle und Audit-Fähigkeiten, die für Produktions-Integrationen benötigt werden.

Möchtest du dein Monitoring über Konkurrenten hinaus erweitern? Schau dir unseren Leitfaden zu Crypto Twitter für Marktsignale überwachen an oder erfahre, wie Journalisten WALLAWHATS für Echtzeit-Quellenüberwachung nutzen.

Verpasse nie wieder einen wichtigen Post. Erstelle ein kostenloses Konto — 1 WhatsApp-Nummer, Echtzeit-Warnungen, keine Kreditkarte erforderlich.

Share:
Zurück zum Blog

Verwandte Artikel

Alle Artikel anzeigen »