· Nacho Coll · Guides  · 8 min läsning

X Alerts API: Programmatiska prenumerationer och notifieringshistorik

Bygg anpassade integrationer ovanpå WALLAWHATS. Lägg till och ta bort X-prenumerationer, dirigera varningar till kanaler, hämta notifieringshistorik — allt via REST.

Bygg anpassade integrationer ovanpå WALLAWHATS. Lägg till och ta bort X-prenumerationer, dirigera varningar till kanaler, hämta notifieringshistorik — allt via REST.

När realtids X (Twitter) varningar blir verksamhetskritiska för ditt företag stöter manuell dashboardhantering på en vägg. Oavsett om du bygger kundintelligensplatformar, automatiserar flöden för varumärkesövervakning eller skapar anpassade notifieringssystem för handelsbord behöver du programmatisk kontroll över dina X-varnprenumerationer.

WALLAWHATS tillhandahåller ett REST API som låter dig skapa, hantera och granska X-varnprenumerationer utan att röra webbgränssnittet. Lägg till eller ta bort övervakade konton, hämta notifieringshistorik med leveransstatus och integrera realtids X-varningar i vilket system som helst som talar HTTP.

API keys management page with create / revoke controls

Varför använda WALLAWHATS API?

Dashboarden fungerar utmärkt för manuella arbetsflöden, men API-åtkomst låser upp automationsscenarier som skalas bortom mänsklig hantering:

Kundintelligensplattformar: Prenumerera automatiskt på nyidentifierade konkurrentchefer, produktledare eller branschanalytiker när de upptäcks genom forskningsverktyg eller CRM-integrationer.

Handels- och finansflöden: Övervaka programmatiskt regleringsmyndigheter, VD-konton eller sektorspecifika journalister baserat på portföljförändringar eller marknadshändelser — utan manuell prenumerationshantering.

Varumärkesövervakning i skala: Lägg till eller ta bort varumärkesnämnsspårning när nya kampanjer lanseras, produkter skickas eller krissituationer utvecklas.

Hyres-SaaS-applikationer med flera klienter: White-label realtids X-övervakning för dina kunder, med programmatisk prenumerationshantering bakom kulisserna.

Compliance- och granskningssystem: Hämta komplett notifieringshistorik med leveransstatus för regleringsrapportering, interna granskningsspår eller SLA-övervakning.

API-autentisering och åtkomst

Varje WALLAWHATS-plan inkluderar API-åtkomst med skalande nyckelkvoter:

  • Free: 1 API-nyckel
  • Pro: 1 API-nyckel
  • Pro+: 2 API-nycklar
  • Business: 5 API-nycklar
  • Enterprise: 20 API-nycklar

Autentisering använder x-api-key-headern (inte Authorization: Bearer). Generera dina nycklar från dashboardens API-sektion och behandla dem som lösenord — de ger fullständiga kontoprivilegier.

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

Huvudsakliga API-endpoints

WALLAWHATS API tillhandahåller fem huvudresursgrupper för att bygga integrationer:

Prenumerationshantering

Skapa en ny prenumeration:

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

{
  "xUsername": "elonmusk"
}

Lista alla prenumerationer:

GET /subscriptions
x-api-key: your_api_key_here

Ta bort en prenumeration:

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

Notera att delete-endpointen tar X-handtaget som en path-parameter — inte ett internt prenumerations-ID.

Notifieringshistorik och granskning

Hämta notifieringshistorik med leveransstatus:

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

Notifications-endpointen returnerar paginerade resultat där varje rad representerar en varning levererad till en kanal. Statusvärden inkluderar:

  • queued: Varning accepterad, väntar på leverans
  • sent: Skickad till kanalleverantören
  • delivered: Bekräftat mottagen av destinationen
  • read: Öppnad av mottagaren (endast WhatsApp, kräver läskvitton aktiverade)
  • failed: Leveransförsöket misslyckades

Kanalhantering

Lista konfigurerade kanaler:

GET /channels
x-api-key: your_api_key_here

Lägg till en ny kanal:

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

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

Ta bort en kanal:

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

Tweet-ögonblicksbilder

Komma åt ögonblicksbild-galleriet:

GET /snapshots
x-api-key: your_api_key_here

Ta bort en specifik ögonblicksbild:

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

Bygga integrationer: Kodexempel

Node.js-integration

Här är ett Node.js-exempel som lägger till en prenumeration och kollar efter nya notifieringar:

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

För Python-arbetsflöden finns här en klass som hanterar prenumerationshantering och notifieringskoll:

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")

Förstå kanalroutning

WALLAWHATS använder en global kanalroutningsmodell — varje varning från varje prenumeration spreds till alla aktiverade och verifierade kanaler. Du kan inte dirigera specifika konton till specifika destinationer via API:et (som “@elonmusk → WhatsApp, @vercel → e-post”).

Kanalval sker på kontonivå på Kanaler-sidan. När du lägger till en kanal via API blir den tillgänglig för alla varningar när den väl verifierats. När du tar bort en kanal slutar den att ta emot varningar från alla prenumerationer.

Denna design förenklar automatisering samtidigt som den förhindrar varningsfragmentering. Din integrationskod behöver inte spåra per-prenumerations-routningsregler — bara hantera vilka konton som ska övervakas och vilka kanaler som ska aktiveras.

Hastighetsgränser och hastighetstak

WALLAWHATS implementerar hastighetsgränser på användarnivå för att förhindra varningsspam under perioder med hög aktivitet:

  • Free: 2 varningar/timme
  • Pro: 5 varningar/timme
  • Pro+: 15 varningar/timme
  • Business: 30 varningar/timme
  • Enterprise: 100 varningar/timme

När hastighetsgränserna överskrids buffras ytterligare tweets i sammandragsmeddelanden som levereras var 15:e minut. Din API-integration kommer att se dessa som separata notifieringsposter — en för den omedelbara varningen och en för varje sammandragsbatch.

API:et självt tillämpar inga separata hastighetsgränser på prenumerationshantering eller notifieringsfrågor. Undvik dock att bombardera endpoints med onödiga förfrågningar — cacha prenumerationslistor lokalt och batcha notifieringsfrågor effektivt.

Felhantering och felsökning

Vanliga API-felmönster och hur du hanterar dem:

Autentiseringsfel (401):

  • Kontrollera att din API-nyckel är korrekt och inte har återkallats
  • Se till att du använder x-api-key-headern, inte Authorization

Prenumerationskonflikter (409):

  • Konto redan övervakat: Prenumerationen existerar, behandla som framgång
  • Konto skyddat/privat: WALLAWHATS avvisar dessa designmässigt

Hastighetsbegränsning (429):

  • Backa exponentiellt innan du försöker igen
  • Kontrollera om du närmar dig plangränser för övervakade konton

Kanalverifieringsproblem:

  • Nya kanaler kräver OTP-verifiering innan de får varningar
  • Programmatiskt tillagda kanaler fungerar inte förrän användaren slutför verifieringen

Övervaka och varna dina integrationer

Eftersom WALLAWHATS blir kritisk infrastruktur när den integreras i affärsarbetsflöden, övervaka din integrations hälsa:

Upptäckt av prenumerationsdrift:

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

Övervakning av leveransframgång:

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önster och bästa praxis

Webhook-liknande behandling: Även om WALLAWHATS inte tillhandahåller webhooks direkt kan du kolla notifications-endpointen för nya varningar och bearbeta dem i nästan realtid:

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

Villkorlig prenumerationshantering: Lägg dynamiskt till eller ta bort prenumerationer baserat på externa triggers:

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 transformerar realtids X-varningar från ett manuellt dashboardverktyg till en programmerbar infrastrukturkomponent. Oavsett om du bygger anpassade intelligensarbetsflöden, automatiserar varumärkesövervakning eller skapar white-label notifieringstjänster ger API:et den kontroll och granskningsförmåga som behövs för produktionsintegration.

Vill du utöka din övervakning bortom konkurrenter? Kolla vår guide om att övervaka krypto-Twitter för marknadssignaler eller lär dig hur journalister använder WALLAWHATS för realtidsövervakning av källor.

Missa aldrig ett viktigt inlägg igen. Skapa ett gratis konto — 1 WhatsApp-nummer, realtidsvarningar, inget kreditkort krävs.

Share:
Tillbaka till Bloggen

Relaterade artiklar

Visa alla artiklar »