· Nacho Coll · Guides  · 8 min læsning

X Alerts API: Programmatiske abonnementer og notifikationshistorik

Byg brugerdefinerede integrationer oven på WALLAWHATS. Tilføj og fjern X-abonnementer, dirigér alerts til kanaler, hent notifikationshistorik — alt via REST.

Byg brugerdefinerede integrationer oven på WALLAWHATS. Tilføj og fjern X-abonnementer, dirigér alerts til kanaler, hent notifikationshistorik — alt via REST.

Når real-time X (Twitter) alerts bliver kritiske for din virksomhed, rammer manuel dashboard-styring en mur. Uanset om du bygger kunde-intelligence dashboards, automatiserer brand monitoring workflows eller skaber brugerdefinerede notifikationssystemer til trading desks, har du brug for programmatisk kontrol over dine X alert-abonnementer.

WALLAWHATS tilbyder en REST API, der lader dig oprette, administrere og auditere X alert-abonnementer uden at røre web-interfacet. Tilføj eller fjern overvågede konti, hent notifikationshistorik med leveringsstatus, og integrér real-time X alerts i ethvert system, der taler HTTP.

API keys management page with create / revoke controls

Hvorfor bruge WALLAWHATS API?

Dashboardet fungerer fantastisk til manuelle workflows, men API-adgang låser op for automatiseringsscenarier, der skalerer ud over menneskelig styring:

Kunde-Intelligence Platforme: Abonnér automatisk på nyidentificerede konkurrent-executives, produktledere eller brancheanalytikere, som de opdages gennem forskningsværktøjer eller CRM-integrationer.

Trading og Finansielle Workflows: Overvåg programmatisk regulatoriske konti, CEO-handles eller sektorspecifikke journalister baseret på porteføljeændringer eller markedsbegivenheder—uden manuel abonnementsstyring.

Brand Monitoring i stor skala: Tilføj eller fjern brand mention-tracking, når nye kampagner lanceres, produkter shippes eller krisesituationer udvikles.

Multi-Tenant SaaS Applikationer: White-label real-time X monitoring for dine kunder, med programmatisk abonnementsstyring bag kulisserne.

Compliance og Audit Systemer: Hent komplet notifikationshistorik med leveringsstatus til regulatorisk rapportering, interne audit trails eller SLA-overvågning.

API Autentifikation og Adgang

Alle WALLAWHATS planer inkluderer API-adgang med skalerende nøglekvoter:

  • Free: 1 API nøgle
  • Pro: 1 API nøgle
  • Pro+: 2 API nøgler
  • Business: 5 API nøgler
  • Enterprise: 20 API nøgler

Autentifikation bruger x-api-key header (ikke Authorization: Bearer). Generér dine nøgler fra dashboardets API-sektion, og behandl dem som adgangskoder—de har fulde kontoprivilegier.

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

Centrale API Endpoints

WALLAWHATS API tilbyder fem hovedressourcegrupper til at bygge integrationer:

Abonnementsstyring

Opret et nyt abonnement:

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

{
  "xUsername": "elonmusk"
}

List alle abonnementer:

GET /subscriptions
x-api-key: your_api_key_here

Fjern et abonnement:

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

Bemærk at delete-endpointet tager X-handlet som path parameter—ikke et internt abonnements-ID.

Notifikationshistorik og Audit

Hent notifikationshistorik med leveringsstatus:

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

Notifications-endpointet returnerer paginerede resultater med hver række repræsenterende én alert leveret til én kanal. Statusværdier inkluderer:

  • queued: Alert accepteret, venter på levering
  • sent: Afsendt til kanal-provideren
  • delivered: Bekræftet modtaget på destinationen
  • read: Åbnet af modtageren (kun WhatsApp, kræver læsekvitteringer aktiveret)
  • failed: Leveringsforsøg mislykkedes

Kanalstyring

List konfigurerede kanaler:

GET /channels
x-api-key: your_api_key_here

Tilføj en ny kanal:

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

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

Fjern en kanal:

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

Tweet Snapshots

Få adgang til snapshot-galleriet:

GET /snapshots
x-api-key: your_api_key_here

Slet et specifikt snapshot:

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

Bygge Integrationer: Kode Eksempler

Node.js Integration

Her er et Node.js eksempel, der tilføjer et abonnement og poller for nye notifikationer:

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

// Usage example
async function monitorCompetitor() {
  const client = new WallaWhatsClient('your_api_key_here');
  
  // Add a new subscription
  await client.addSubscription('vercel');
  console.log('Now monitoring @vercel');
  
  // Check recent notifications
  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

For Python workflows, her er en klasse, der håndterer abonnementsstyring og notifikationspolling:

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):
        """Add a new X account to monitor"""
        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):
        """Remove an X account from monitoring"""
        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):
        """Fetch notification history with 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):
        """Fetch all notifications in a time range, handling 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):
        """Get all current subscriptions"""
        response = requests.get(
            f'{self.base_url}/subscriptions',
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()

# Example: Daily audit report
def generate_daily_report():
    api = WallaWhatsAPI('your_api_key_here')
    
    # Get yesterday's notifications
    end_time = int(time.time() * 1000)
    start_time = end_time - (24 * 60 * 60 * 1000)
    
    notifications = api.get_all_notifications(start_time, end_time)
    
    # Group by account and status
    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
    
    # Print summary
    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")

Forståelse af Kanal Routing

WALLAWHATS bruger en global kanal routing-model—alle alerts fra alle abonnementer faner ud til alle aktiverede og verificerede kanaler. Du kan ikke dirigere specifikke konti til specifikke destinationer via API’et (som „@elonmusk → WhatsApp, @vercel → email”).

Kanalvalg sker på kontoniveau på Kanaler-siden. Når du tilføjer en kanal via API, bliver den tilgængelig for alle alerts, når den er verificeret. Når du fjerner en kanal, stopper den med at modtage alerts fra alle abonnementer.

Dette design forenkler automatisering, mens det forhindrer alert-fragmentering. Din integrationskode behøver ikke spore per-abonnement routing-regler—bare administrér hvilke konti der skal overvåges og hvilke kanaler der skal aktiveres.

Rate Limits og Velocity Caps

WALLAWHATS implementerer bruger-niveau velocity caps for at forhindre alert-spam under perioder med høj aktivitet:

  • Free: 2 alerts/time
  • Pro: 5 alerts/time
  • Pro+: 15 alerts/time
  • Business: 30 alerts/time
  • Enterprise: 100 alerts/time

Når velocity caps overskrides, bufferes yderligere tweets til digest-beskeder og leveres hver 15. minut. Din API-integration vil se disse som separate notifikationsposter—én for den øjeblikkelige alert og én for hver digest-batch.

API’et selv pålægger ikke separate rate limits på abonnementsstyring eller notifikationsforespørgsler. Undgå dog at hamre endpoints med unødvendige anmodninger—cach abonnementslister lokalt og batch notifikationsforespørgsler effektivt.

Fejlhåndtering og Problemløsning

Almindelige API fejlmønstre og hvordan man håndterer dem:

Autentifikationsfejl (401):

  • Verificér at din API-nøgle er korrekt og ikke er blevet tilbagekaldt
  • Sørg for at du bruger x-api-key header, ikke Authorization

Abonnementskonflikter (409):

  • Konto allerede overvåget: Abonnementet eksisterer, behandl som succes
  • Konto beskyttet/privat: WALLAWHATS afviser disse by design

Rate limiting (429):

  • Back off eksponentielt før retry
  • Tjek om du nærmer dig plangrænser på overvågede konti

Kanalverifikationsproblemer:

  • Nye kanaler kræver OTP-verifikation før de modtager alerts
  • Programmatisk tilføjede kanaler virker ikke, før brugeren fuldfører verifikation

Overvågning og Alerting af Dine Integrationer

Da WALLAWHATS bliver kritisk infrastruktur, når den integreres i business workflows, overvåg din integrations-sundhed:

Abonnements Drift Detection:

// Check if expected subscriptions are still active
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;
}

Leveringssuccesrate Overvågning:

def check_delivery_health():
    # Check last 6 hours
    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:
        # Alert your ops team
        print(f"WARNING: Delivery success rate dropped to {success_rate:.1f}%")
    
    return success_rate

Integrationsmønstre og Best Practices

Webhook-Style Processing: Selvom WALLAWHATS ikke tilbyder webhooks direkte, kan du polle notifications-endpointet for nye alerts og processere dem i næsten real-time:

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') {
      // Process the alert - send to Slack, update database, etc.
      await processAlert(notification);
    }
  }
  
  localStorage.setItem('lastNotificationCheck', now);
}

// Poll every 30 seconds
setInterval(pollForNewAlerts, 30000);

Betinget Abonnementsstyring: Tilføj eller fjern dynamisk abonnementer baseret på eksterne triggere:

def update_competitor_monitoring(portfolio_companies):
    """Update X monitoring based on current portfolio"""
    current_subs = {s['xUsername'] for s in api.list_subscriptions()}
    
    # Accounts we should be monitoring
    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'])
    
    # Add missing subscriptions
    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}")
    
    # Remove outdated subscriptions
    for account in current_subs - target_accounts:
        api.remove_subscription(account)
        print(f"Stopped monitoring @{account}")

WALLAWHATS API transformerer real-time X alerts fra et manuelt dashboard-værktøj til en programmerbar infrastrukturkomponent. Uanset om du bygger brugerdefinerede intelligence workflows, automatiserer brand monitoring eller skaber white-label notifikationstjenester, giver API’et den kontrol og audit-kapacitet, der er nødvendig for produktionsintegration.

Ønsker du at udvide din overvågning ud over konkurrenter? Tjek vores guide om overvågning af crypto Twitter for markedssignaler eller lær hvordan journalister bruger WALLAWHATS til real-time kildeovervågning.

Gå aldrig glip af et vigtigt opslag igen. Opret en gratis konto — 1 WhatsApp nummer, real-time alerts, intet kreditkort påkrævet.

Share:
Tilbage til Bloggen

Relaterede artikler

Se alle artikler »