X Alerts API: Programozható feliratkozások és értesítési előzmények

Amikor a valós idejű X (Twitter) értesítések kritikussá válnak a vállalkozásodnak, a manuális dashboard kezelés korlátokba ütközik. Függetlenül attól, hogy ügyfél-intelligencia dashboardokat építesz, brand monitoring workflow-kat automatizálsz, vagy egyedi értesítési rendszereket hozol létre kereskedési asztalokhoz, programozható kontrollt kell gyakorolnod az X értesítési feliratkozásaid felett.

A WALLAWHATS REST API-t biztosít, amely lehetővé teszi X értesítési feliratkozások létrehozását, kezelését és auditálását anélkül, hogy a webes felületet használnád. Adj hozzá vagy távolíts el monitorizált fiókokat, töltsd le az értesítési előzményeket kézbesítési státusszal, és integráld a valós idejű X értesítéseket bármilyen HTTP-t beszélő rendszerbe.

Miért használd a WALLAWHATS API-t?

A dashboard remekül működik manuális workflow-k esetén, de az API hozzáférés automatizálási forgatókönyveket tesz lehetővé, amelyek túlmutatnak az emberi kezelésen:

Ügyfél-intelligencia platformok: Automatikusan iratkozz fel újonnan azonosított versenytárs vezetőkre, termékfelelősökre vagy iparági elemzőkre, ahogy kutatási eszközök vagy CRM integrációk felfedezik őket.

Kereskedési és pénzügyi workflow-k: Programozottan figyelj szabályozási fiókokat, CEO kezelőket vagy szektorspecifikus újságírókat portfólióváltozások vagy piaci események alapján—manuális feliratkozás-kezelés nélkül.

Márkamonitoring nagy volumenben: Adj hozzá vagy távolíts el márkaemlegetési követést új kampányok indításakor, termékszállításkor vagy krízishelyzetek kialakulásakor.

Több bérlős SaaS alkalmazások: White-label valós idejű X monitoring az ügyfeleidnek, programozható feliratkozás-kezeléssel a háttérben.

Megfelelőségi és audit rendszerek: Töltsd le a teljes értesítési előzményeket kézbesítési státusszal szabályozási jelentésekhez, belső audit nyomvonalakhoz vagy SLA monitoringhoz.

API hitelesítés és hozzáférés

Minden WALLAWHATS csomag tartalmaz API hozzáférést skálázódó kulcskvótákkal:

• Free: 1 API kulcs
• Pro: 1 API kulcs
• Pro+: 2 API kulcs
• Business: 5 API kulcs
• Enterprise: 20 API kulcs

A hitelesítés az x-api-key header-t használja (nem Authorization: Bearer). Generáld a kulcsaidat a dashboard API szekciójából, és kezeld őket jelszóként—teljes fiókjogosultságokat hordoznak.

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

Fő API végpontok

A WALLAWHATS API öt fő erőforráscsoportot biztosít integrációk építéséhez:

Feliratkozás-kezelés

Új feliratkozás létrehozása:

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

{
  "xUsername": "elonmusk"
}

Minden feliratkozás listázása:

GET /subscriptions
x-api-key: your_api_key_here

Feliratkozás eltávolítása:

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

Figyeld meg, hogy a törlési végpont az X handle-t veszi path paraméterként—nem belső feliratkozás ID-t.

Értesítési előzmények és audit

Értesítési előzmények lehívása kézbesítési státusszal:

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

A notifications végpont lapozott eredményeket ad vissza, ahol minden sor egy értesítést jelent, amelyet egy csatornára küldtek. A státusz értékek tartalmazzák:

• queued: Értesítés elfogadva, kézbesítésre vár
• sent: Elküldve a csatorna szolgáltatónak
• delivered: Megerősítve, hogy a célpont megkapta
• read: A címzett megnyitotta (csak WhatsApp, read receipts engedélyezve szükséges)
• failed: Kézbesítési kísérlet sikertelen

Csatornakezlés

Konfigurált csatornák listázása:

GET /channels
x-api-key: your_api_key_here

Új csatorna hozzáadása:

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

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

Csatorna eltávolítása:

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

Tweet pillanatképek

Pillanatkép galéria elérése:

GET /snapshots
x-api-key: your_api_key_here

Specifikus pillanatkép törlése:

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

Integrációk építése: kódpéldák

Node.js integráció

Itt egy Node.js példa, amely feliratkozást ad hozzá és új értesítéseket poll-oz:

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

// Használati példa
async function monitorCompetitor() {
  const client = new WallaWhatsClient('your_api_key_here');
  
  // Új feliratkozás hozzáadása
  await client.addSubscription('vercel');
  console.log('Most figyelve: @vercel');
  
  // Legutóbbi értesítések ellenőrzése
  const oneDayAgo = Date.now() - (24 * 60 * 60 * 1000);
  const notifications = await client.getNotifications(oneDayAgo, Date.now());
  
  console.log(`${notifications.items.length} friss értesítést találtam`);
  notifications.items.forEach(notification => {
    console.log(`${notification.xUsername}: ${notification.status} at ${notification.timestamp}`);
  });
}

Python integráció

Python workflow-k esetén itt egy osztály, amely feliratkozás-kezelést és értesítés-poll-ozást kezel:

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):
        """Új X fiók hozzáadása monitoringhoz"""
        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 fiók eltávolítása a monitoringból"""
        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):
        """Értesítési előzmények lekérése lapozással"""
        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):
        """Minden értesítés lekérése egy időtartományból, lapozás kezeléssel"""
        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):
        """Minden jelenlegi feliratkozás lekérése"""
        response = requests.get(
            f'{self.base_url}/subscriptions',
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()

# Példa: Napi audit jelentés
def generate_daily_report():
    api = WallaWhatsAPI('your_api_key_here')
    
    # Tegnapi értesítések lekérése
    end_time = int(time.time() * 1000)
    start_time = end_time - (24 * 60 * 60 * 1000)
    
    notifications = api.get_all_notifications(start_time, end_time)
    
    # Csoportosítás fiók és státusz szerint
    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
    
    # Összefoglaló nyomtatása
    print(f"Napi értesítési jelentés - {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']} értesítés, {success_rate:.1f}% kézbesítve")

A csatorna routing megértése

A WALLAWHATS globális csatorna routing modellt használ—minden értesítés minden feliratkozásból minden engedélyezett és verificált csatornára kiküldésre kerül. Nem tudod specifikus fiókokat specifikus célpontokra irányítani az API-n keresztül (mint “@elonmusk → WhatsApp, @vercel → email”).

A csatorna kiválasztás a fiókszinten történik a Channels oldalon. Amikor API-n keresztül adsz hozzá csatornát, az minden értesítés számára elérhetővé válik verificálás után. Amikor eltávolítasz egy csatornát, az leáll minden feliratkozástól származó értesítés fogadásával.

Ez a design leegyszerűsíti az automatizálást, miközben megakadályozza az értesítések fragmentálódását. Az integráció kódodnak nem kell feliratkozásonkénti routing szabályokat követnie—csak azt kell kezelnie, mely fiókokat kell monitorozni és mely csatornákat kell engedélyezni.

Sebességlimitek és sebességkorlátok

A WALLAWHATS felhasználószintű sebességkorlátokat alkalmaz az értesítés-spam megelőzésére magas aktivitású időszakokban:

• Free: 2 értesítés/óra
• Pro: 5 értesítés/óra
• Pro+: 15 értesítés/óra
• Business: 30 értesítés/óra
• Enterprise: 100 értesítés/óra

Amikor a sebességkorlátok túllépésre kerülnek, a további tweet-ek digest üzenetekbe pufferelődnek és 15 percenként kerülnek kézbesítésre. Az API integrációd ezeket külön értesítési rekordokként fogja látni—egyet az azonnali értesítésért, és egyet minden digest batch-ért.

Maga az API nem alkalmaz külön sebességlimiteket a feliratkozás-kezelésre vagy értesítési lekérdezésekre. Azonban kerüld a végpontok felesleges kérésekkel való bombázását—cache-eld a feliratkozás-listákat lokálisan és batch-eld az értesítési lekérdezéseket hatékonyan.

Hibakezelés és hibaelhárítás

Gyakori API hibaminták és kezelésük:

Hitelesítési hibák (401):

• Ellenőrizd, hogy az API kulcsod helyes és nem lett visszavonva
• Győződj meg róla, hogy az x-api-key header-t használod, nem az Authorization-t

Feliratkozás konfliktusok (409):

• Fiók már monitorozott: A feliratkozás létezik, kezelj sikerként
• Fiók védett/privát: A WALLAWHATS ezeket designból elutasítja

Sebességlimitálás (429):

• Exponenciálisan hátrálj vissza újrapróbálás előtt
• Ellenőrizd, hogy közeledel-e a csomag limitjeihez a monitorozott fiókok számában

Csatorna verificálási problémák:

• Az új csatornák OTP verificálást igényelnek értesítések fogadása előtt
• A programozottan hozzáadott csatornák nem működnek, amíg a felhasználó be nem fejezi a verificálást

Integrációid monitorozása és riasztása

Mivel a WALLAWHATS kritikus infrastruktúrává válik, amikor üzleti workflow-kba integrálódik, monitorozd az integráció egészségét:

Feliratkozás drift észlelése:

// Ellenőrizd, hogy a várt feliratkozások még mindig aktívak-e
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(`Hiányzó feliratkozások: ${missing.join(', ')}`);
  }
  
  return missing;
}

Kézbesítési sikerességi arány monitorozása:

def check_delivery_health():
    # Utóbbi 6 óra ellenőrzése
    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:
        # Riasztás az ops csapatnak
        print(f"FIGYELMEZTETÉS: A kézbesítési sikerességi arány {success_rate:.1f}%-ra csökkent")
    
    return success_rate

Integráció minták és legjobb gyakorlatok

Webhook-stílus feldolgozás: Bár a WALLAWHATS nem biztosít webhook-okat közvetlenül, poll-ozhatod a notifications végpontot új értesítésekért és közel valós időben feldolgozhatod őket:

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') {
      // Értesítés feldolgozása - Slack-re küldés, adatbázis frissítés, stb.
      await processAlert(notification);
    }
  }
  
  localStorage.setItem('lastNotificationCheck', now);
}

// Poll-ozás 30 másodpercenként
setInterval(pollForNewAlerts, 30000);

Feltételes feliratkozás-kezelés: Dinamikusan adj hozzá vagy távolíts el feliratkozásokat külső triggerek alapján:

def update_competitor_monitoring(portfolio_companies):
    """X monitoring frissítése a jelenlegi portfólió alapján"""
    current_subs = {s['xUsername'] for s in api.list_subscriptions()}
    
    # Fiókok, amelyeket monitoroznunk kellene
    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'])
    
    # Hiányzó feliratkozások hozzáadása
    for account in target_accounts - current_subs:
        try:
            api.add_subscription(account)
            print(f"@{account} monitorozásának elindítása")
        except Exception as e:
            print(f"@{account} hozzáadása sikertelen: {e}")
    
    # Elavult feliratkozások eltávolítása
    for account in current_subs - target_accounts:
        api.remove_subscription(account)
        print(f"@{account} monitorozásának leállítása")

A WALLAWHATS API a valós idejű X értesítéseket manuális dashboard eszközből programozható infrastruktúra komponenssé alakítja. Függetlenül attól, hogy egyedi intelligencia workflow-kat építesz, brand monitoring-ot automatizálsz, vagy white-label értesítési szolgáltatásokat hozol létre, az API biztosítja a kontrollt és audit képességeket, amelyek produkciós integrációhoz szükségesek.

Szeretnéd kiterjeszteni a monitoringodat a versenytársakon túlra? Tekintsd meg az útmutatónkat a kripto Twitter monitoring piaci jelzésekhez vagy tudd meg, hogyan használják újságírók a WALLAWHATS-ot valós idejű forrás monitoringra.

Soha többé ne szalassz el egy fontos posztot. Hozz létre egy ingyenes fiókot — 1 WhatsApp szám, valós idejű értesítések, bankkártya nem szükséges.