· Nacho Coll · Guides  · 8 min lesing

X Alerts API: Programmatiske abonnementer og varslingshistorikk

Bygg tilpassede integrasjoner på toppen av WALLAWHATS. Legg til og fjern X-abonnementer, rut varsler til kanaler, hent varslingshistorikk — alt via REST.

Bygg tilpassede integrasjoner på toppen av WALLAWHATS. Legg til og fjern X-abonnementer, rut varsler til kanaler, hent varslingshistorikk — alt via REST.

Når sanntids X (Twitter) varsler blir virksomhetskritiske for din bedrift, når manuell dashboard-styring en vegg. Enten du bygger kundeintelligens-dashboards, automatiserer merkevareovervåking-arbeidsflyter, eller lager tilpassede varslingssystemer for handelsbord, trenger du programmatisk kontroll over dine X-varsel-abonnementer.

WALLAWHATS tilbyr en REST API som lar deg opprette, administrere og revidere X-varsel-abonnementer uten å røre nettgrensesnittet. Legg til eller fjern overvåkede kontoer, hent varslingshistorikk med leveringsstatus, og integrer sanntids X-varsler i ethvert system som snakker HTTP.

API keys management page with create / revoke controls

Hvorfor bruke WALLAWHATS API?

Dashboard-et fungerer flott for manuelle arbeidsflyter, men API-tilgang låser opp automatiseringsscenarier som skalerer utover menneskelig administrasjon:

Kundeintelligens-plattformer: Automatisk abonner på nylig identifiserte konkurrent-ledere, produktsjefer eller bransjeindustrianalytikere når de oppdages gjennom forskningsverktøy eller CRM-integrasjoner.

Handels- og finansielle arbeidsflyter: Programmatisk overvåk regulatoriske kontoer, administrerende direktør-håndtak, eller sektorspesifikke journalister basert på porteføljeendringer eller markedshendelser—uten manuell abonnementsstyring.

Merkevareovervåking i stor skala: Legg til eller fjern merkevareomtalesporing når nye kampanjer lanseres, produkter sendes, eller krisesituasjoner utvikler seg.

Multi-tenant SaaS-applikasjoner: Hvitmerk sanntids X-overvåking for dine kunder, med programmatisk abonnementsstyring bak kulissene.

Compliance- og revisjonssystemer: Hent komplett varslingshistorikk med leveringsstatus for regulatorisk rapportering, interne revisjonsspor, eller SLA-overvåking.

API-autentisering og tilgang

Hver WALLAWHATS-plan inkluderer API-tilgang med skalerende nøkkelkvoter:

  • Free: 1 API-nøkkel
  • Pro: 1 API-nøkkel
  • Pro+: 2 API-nøkler
  • Business: 5 API-nøkler
  • Enterprise: 20 API-nøkler

Autentisering bruker x-api-key-headeren (ikke Authorization: Bearer). Generer nøklene dine fra dashboard-ets API-seksjon, og behandle dem som passord—de bærer fulle kontoprivilegier.

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

Kjerne-API-endepunkter

WALLAWHATS API tilbyr fem hovedressursgrupper for å bygge integrasjoner:

Abonnementsstyring

Opprett et nytt 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

Merk at slette-endepunktet tar X-håndtaket som en bane-parameter—ikke en intern abonnement-ID.

Varslingshistorikk og revisjon

Hent varslingshistorikk med leveringsstatus:

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

Varslings-endepunktet returnerer paginerte resultater med hver rad som representerer ett varsel levert til én kanal. Statusverdier inkluderer:

  • queued: Varsel akseptert, venter på levering
  • sent: Sendt til kanalleverandøren
  • delivered: Bekreftet mottatt av destinasjonen
  • read: Åpnet av mottakeren (kun WhatsApp, krever lesekvitteringer aktivert)
  • failed: Leveringsforsøk mislyktes

Kanalstyring

List konfigurerte kanaler:

GET /channels
x-api-key: your_api_key_here

Legg til 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-øyeblikksbilder

Tilgang til øyeblikksbildegalleri:

GET /snapshots
x-api-key: your_api_key_here

Slett et spesifikt øyeblikksbilde:

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

Bygge integrasjoner: Kodeeksempler

Node.js-integrasjon

Her er et Node.js-eksempel som legger til et abonnement og poller for nye varsler:

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

For Python-arbeidsflyter, her er en klasse som håndterer abonnementsstyring og varslingspoling:

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å kanalruting

WALLAWHATS bruker en global kanalrutingsmodell—hvert varsel fra hvert abonnement vifte ut til alle aktiverte og verifiserte kanaler. Du kan ikke rute spesifikke kontoer til spesifikke destinasjoner via API-et (som “@elonmusk → WhatsApp, @vercel → e-post”).

Kanalvalg skjer på kontonivå på Kanaler-siden. Når du legger til en kanal via API, blir den tilgjengelig for alle varsler når den er verifisert. Når du fjerner en kanal, stopper den å motta varsler fra alle abonnementer.

Denne designen forenkler automatisering samtidig som den forhindrer varselfragmentering. Din integrasjonskode trenger ikke å spore per-abonnement-rutingregler—bare administrer hvilke kontoer som skal overvåkes og hvilke kanaler som skal aktiveres.

Hastighetsgrenser og hastighetsbegrensninger

WALLAWHATS implementerer hastighetsbegrensninger på brukernivå for å forhindre varselspam under høyaktivitetsperioder:

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

Når hastighetsbegrensninger overskrides, bufferes ekstra tweets til sammendragsmeldinger og leveres hver 15. minutt. Din API-integrasjon vil se disse som separate varslingsposter—en for det umiddelbare varselet, og en for hver sammendragsbatch.

API-et selv pålegger ikke separate hastighetsgrenser på abonnementsstyring eller varslingsforespørsler. Likevel, unngå å hamre endepunktene med unødvendige forespørsler—cache abonnementslister lokalt og batch varslingsforespørsler effektivt.

Feilhåndtering og feilsøking

Vanlige API-feilmønstre og hvordan håndtere dem:

Autentiseringsfeil (401):

  • Verifiser at API-nøkkelen din er riktig og ikke har blitt tilbakekalt
  • Sørg for at du bruker x-api-key-headeren, ikke Authorization

Abonnementskonflikter (409):

  • Konto allerede overvåket: Abonnementet eksisterer, behandle som vellykket
  • Konto beskyttet/privat: WALLAWHATS avslår disse av design

Hastighetsbegrensning (429):

  • Back off eksponentielt før du prøver igjen
  • Sjekk om du nærmer deg plangrenser på overvåkede kontoer

Kanalverifikasjonsproblemer:

  • Nye kanaler krever OTP-verifikasjon før de mottar varsler
  • Programmatisk tillagte kanaler vil ikke fungere før brukeren fullfører verifikasjon

Overvåke og varsle dine integrasjoner

Siden WALLAWHATS blir kritisk infrastruktur når den er integrert i forretningsarbeidsflyter, overvåk din integrasjonshelse:

Deteksjon av abonnementsdrift:

// 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;
}

Overvåking av leveringssuksessrate:

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

Integrasjonsmønstre og beste praksis

Webhook-lignende prosessering: Selv om WALLAWHATS ikke tilbyr webhooks direkte, kan du polle varslings-endepunktet for nye varsler og behandle dem i nesten sanntid:

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: Dynamisk legg til eller fjern abonnementer basert på eksterne utløsere:

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 sanntids X-varsler fra et manuelt dashboard-verktøy til en programmerbar infrastrukturkomponent. Enten du bygger tilpassede intelligensarbeidsflyter, automatiserer merkevareovervåking, eller lager hvitmerke-varseltjenester, gir API-et kontrollen og revisjonsfunksjonene som trengs for produksjonsintegrasjon.

Ser du etter å utvide overvåkingen utover konkurrenter? Sjekk vår guide om overvåking av krypto Twitter for markedssignaler eller lær hvordan journalister bruker WALLAWHATS for sanntids kildeovervåking.

Aldri gå glipp av et viktig innlegg igjen. Opprett en gratis konto — 1 WhatsApp-nummer, sanntidsvarsler, ingen kredittkort påkrevd.

Share:
Tilbake til Bloggen

Relaterte artikler

Se alle artikler »