· Nacho Coll · Guides  · 8 min čítania

X Alerts API: Programové predplatné a história notifikácií

Vytvárajte vlastné integrácie na základe WALLAWHATS. Pridávajte a odoberajte X predplatné, smerujte upozornenia do kanálov, sťahujte históriu notifikácií — všetko cez REST.

Vytvárajte vlastné integrácie na základe WALLAWHATS. Pridávajte a odoberajte X predplatné, smerujte upozornenia do kanálov, sťahujte históriu notifikácií — všetko cez REST.

Keď sa upozornenia z X (Twitter) v reálnom čase stanú pre váš biznis kriticky dôležité, manuálne spravovanie cez dashboard narazí na stenu. Či už vytvárate dashboardy zákazníckej inteligencie, automatizujete procesy monitorovania značky, alebo tvoríte vlastné notifikačné systémy pre obchodné oddelenia, potrebujete programovú kontrolu nad vašimi X upozorneniami.

WALLAWHATS poskytuje REST API, ktoré vám umožňuje vytvárať, spravovať a auditovať X predplatné bez dotýkania sa webového rozhrania. Pridávajte alebo odoberajte monitorované účty, sťahujte históriu notifikácií so stavom doručenia a integrujte upozornenia z X v reálnom čase do akéhokoľvek systému, ktorý vie komunikovať cez HTTP.

API keys management page with create / revoke controls

Prečo používať WALLAWHATS API?

Dashboard funguje skvele pre manuálne procesy, ale API prístup odomyká automatizačné scenáre, ktoré škálujú nad rámec ľudského spravovania:

Platformy zákazníckej inteligencie: Automaticky sa prihláste na odber novo identifikovaných konkurenčných manažérov, vedúcich produktov alebo priemyselných analytikov, akonáhle sú objavení cez výskumné nástroje alebo CRM integrácie.

Obchodné a finančné procesy: Programovo monitorujte regulačné účty, CEO profily alebo sektorovo špecifických novinárov na základe zmien v portfóliu alebo trhových udalostí—bez manuálneho spravovania predplatného.

Monitorovanie značky vo veľkom: Pridávajte alebo odoberajte sledovanie zmienok o značke pri spúšťaní nových kampaní, uvedení produktov alebo rozvoji krízozvých situácií.

Multi-tenant SaaS aplikácie: White-label monitorovanie X v reálnom čase pre vašich zákazníkov s programovým spravovaním predplatného v pozadí.

Compliance a auditné systémy: Sťahujte kompletných históriu notifikácií so stavom doručenia pre regulačné reporty, interné auditné stopy alebo SLA monitoring.

API autentifikácia a prístup

Každý WALLAWHATS plán zahŕňa API prístup s škálovaním kvót kľúčov:

  • Free: 1 API kľúč
  • Pro: 1 API kľúč
  • Pro+: 2 API kľúče
  • Business: 5 API kľúčov
  • Enterprise: 20 API kľúčov

Autentifikácia používa header x-api-key (nie Authorization: Bearer). Vygenerujte si kľúče z API sekcie dashboardu a zaobchádzajte s nimi ako s heslami—majú plné oprávnenia účtu.

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

Hlavné API endpointy

WALLAWHATS API poskytuje päť hlavných skupín zdrojov pre budovanie integrácií:

Spravovanie predplatného

Vytvorenie nového predplatného:

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

{
  "xUsername": "elonmusk"
}

Zoznam všetkých predplatných:

GET /subscriptions
x-api-key: your_api_key_here

Odstránenie predplatného:

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

Všimnite si, že delete endpoint prijíma X handle ako path parameter—nie interné subscription ID.

História notifikácií a audit

Stiahnutie histórie notifikácií so stavom doručenia:

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

Notifications endpoint vracia stránkované výsledky, kde každý riadok predstavuje jedno upozornenie doručené do jedného kanála. Hodnoty stavu zahŕňajú:

  • queued: Upozornenie akceptované, čaká na doručenie
  • sent: Odoslané k poskytovateľovi kanála
  • delivered: Potvrdené doručenie do cieľa
  • read: Otvorené príjemcom (len WhatsApp, vyžaduje povolené potvrdenia o prečítaní)
  • failed: Pokus o doručenie neúspešný

Spravovanie kanálov

Zoznam nakonfigurovaných kanálov:

GET /channels
x-api-key: your_api_key_here

Pridanie nového kanála:

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

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

Odstránenie kanála:

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

Snímky tweetov

Prístup ku galérii snímok:

GET /snapshots
x-api-key: your_api_key_here

Vymazanie konkrétnej snímky:

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

Budovanie integrácií: Príklady kódu

Node.js integrácia

Tu je Node.js príklad, ktorý pridá predplatné a dotazuje sa na nové notifikácie:

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

// Príklad použitia
async function monitorCompetitor() {
  const client = new WallaWhatsClient('your_api_key_here');
  
  // Pridanie nového predplatného
  await client.addSubscription('vercel');
  console.log('Teraz monitorujeme @vercel');
  
  // Kontrola posledných notifikácií
  const oneDayAgo = Date.now() - (24 * 60 * 60 * 1000);
  const notifications = await client.getNotifications(oneDayAgo, Date.now());
  
  console.log(`Našli sme ${notifications.items.length} posledných upozornení`);
  notifications.items.forEach(notification => {
    console.log(`${notification.xUsername}: ${notification.status} at ${notification.timestamp}`);
  });
}

Python integrácia

Pre Python procesy tu je trieda, ktorá spravuje predplatné a dotazovanie notifikácií:

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):
        """Pridanie nového X účtu na monitorovanie"""
        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):
        """Odstránenie X účtu z monitorovania"""
        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):
        """Načítanie histórie notifikácií s stránkovaním"""
        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):
        """Načítanie všetkých notifikácií v časovom rozsahu s riešením stránkovania"""
        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):
        """Získanie všetkých aktuálnych predplatných"""
        response = requests.get(
            f'{self.base_url}/subscriptions',
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()

# Príklad: Denný audit report
def generate_daily_report():
    api = WallaWhatsAPI('your_api_key_here')
    
    # Získanie včerajších notifikácií
    end_time = int(time.time() * 1000)
    start_time = end_time - (24 * 60 * 60 * 1000)
    
    notifications = api.get_all_notifications(start_time, end_time)
    
    # Zoskupenie podľa účtu a stavu
    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
    
    # Výpis súhrnu
    print(f"Denný report upozornení - {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']} upozornení, {success_rate:.1f}% doručených")

Porozumenie smerovaniu kanálov

WALLAWHATS používa globálny model smerovania kanálov—každé upozornenie z každého predplatného sa rozošle do všetkých povolených a overených kanálov. Nemôžete smerovať konkrétne účty do konkrétnych cieľov cez API (ako „@elonmusk → WhatsApp, @vercel → email”).

Výber kanála sa deje na úrovni účtu na stránke Kanály. Keď pridáte kanál cez API, stane sa dostupným pre všetky upozornenia po overení. Keď kanál odstránite, prestane dostávať upozornenia zo všetkých predplatných.

Tento dizajn zjednodušuje automatizáciu a zároveň zabraňuje fragmentácii upozornení. Váš integračný kód nepotrebuje sledovať pravidlá smerovania na úrovni predplatného—len spravujte, ktoré účty monitorovať a ktoré kanály povoliť.

Rýchlostné limity a rýchlostné obmedzenia

WALLAWHATS implementuje rýchlostné obmedzenia na úrovni užívateľa na prevenciu spamu upozornení počas období vysokej aktivity:

  • Free: 2 upozornenia/hodinu
  • Pro: 5 upozornení/hodinu
  • Pro+: 15 upozornení/hodinu
  • Business: 30 upozornení/hodinu
  • Enterprise: 100 upozornení/hodinu

Keď sú rýchlostné limity prekročené, ďalšie tweety sa zhlukujú do súhrnných správ a doručujú každých 15 minút. Vaša API integrácia ich uvidí ako samostatné záznamy notifikácií—jeden pre okamžité upozornenie a jeden pre každý súhrnný balík.

Samotné API neukladá samostatné rýchlostné limity na spravovanie predplatného alebo dotazy na notifikácie. Avšak, vyhýbajte sa bombardovaniu endpointov zbytočnými požiadavkami—cachujte zoznamy predplatných lokálne a efektívne zoskupujte dotazy na notifikácie.

Spracovanie chýb a riešenie problémov

Bežné vzory chýb API a ako ich riešiť:

Zlyhanie autentifikácie (401):

  • Overte si, že váš API kľúč je správny a nebol zrušený
  • Ubezpečte sa, že používate header x-api-key, nie Authorization

Konflikty predplatného (409):

  • Účet už monitorovaný: Predplatné existuje, považujte za úspech
  • Chránený/súkromný účet: WALLAWHATS ich odmieta z principu

Rýchlostné obmedzenie (429):

  • Exponenciálne spomalte pred opätovným pokusom
  • Skontrolujte, či sa nepriblížujete k plánowym limitom na monitorované účty

Problémy s overením kanála:

  • Nové kanály vyžadujú OTP overenie pred prijímaním upozornení
  • Programovo pridané kanály nebudú fungovať, kým užívateľ nedokončí overenie

Monitorovanie a upozorňovanie vašich integrácií

Keďže sa WALLAWHATS stane kritickou infraštruktúrou pri integrácii do biznes procesov, monitorujte zdravie vašej integrácie:

Detekcia odchýlky predplatného:

// Kontrola, či očakávané predplatné sú stále aktívne
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(`Chýbajúce predplatné: ${missing.join(', ')}`);
  }
  
  return missing;
}

Monitorovanie miery úspechu doručenia:

def check_delivery_health():
    # Kontrola posledných 6 hodín
    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:
        # Upozornite váš ops tím
        print(f"VAROVANIE: Miera úspechu doručenia klesla na {success_rate:.1f}%")
    
    return success_rate

Integračné vzory a najlepšie praktiky

Spracovanie v štýle webhook-ov: Hoci WALLAWHATS neposkytuje webhooky priamo, môžete dotazovať notifications endpoint na nové upozornenia a spracovávať ich takmer v reálnom čase:

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') {
      // Spracujte upozornenie - pošlite do Slack, aktualizujte databázu, atď.
      await processAlert(notification);
    }
  }
  
  localStorage.setItem('lastNotificationCheck', now);
}

// Dotazovanie každých 30 sekúnd
setInterval(pollForNewAlerts, 30000);

Podmienečné spravovanie predplatného: Dynamicky pridávajte alebo odoberajte predplatné na základe externých spúšťačov:

def update_competitor_monitoring(portfolio_companies):
    """Aktualizácia X monitorovania na základe aktuálneho portfólia"""
    current_subs = {s['xUsername'] for s in api.list_subscriptions()}
    
    # Účty, ktoré by sme mali monitorovať
    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'])
    
    # Pridanie chýbajúcich predplatných
    for account in target_accounts - current_subs:
        try:
            api.add_subscription(account)
            print(f"Začali sme monitorovať @{account}")
        except Exception as e:
            print(f"Zlyhalo pridanie @{account}: {e}")
    
    # Odstránenie zastaraných predplatných
    for account in current_subs - target_accounts:
        api.remove_subscription(account)
        print(f"Prestali sme monitorovať @{account}")

WALLAWHATS API transformuje upozornenia z X v reálnom čase z manuálneho dashboard nástroja na programovateľnú infraštruktúrnu komponentu. Či už vytvárate vlastné intelligence workflow, automatizujete monitorovanie značky, alebo tvoríte white-label notifikačné služby, API poskytuje kontrolu a auditné schopnosti potrebné pre produkčnú integráciu.

Chcete rozšíriť vaše monitorovanie nad rámec konkurentov? Pozrite si našu príručku o monitorovaní crypto Twitter pre trhové signály alebo sa dozviete, ako novinári používajú WALLAWHATS pre monitorovanie zdrojov v reálnom čase.

Nikdy nezmeškajte dôležitý príspevok. Vytvorte si bezplatný účet — 1 WhatsApp číslo, upozornenia v reálnom čase, kreditná karta nie je potrebná.

Share:
Späť na Blog

Súvisiace články

Zobraziť všetky články »