· Nacho Coll · Guides  · 8 min čitanja

X Alerts API: Programmatske pretplate i povijest obavijesti

Izgradite prilagođene integracije na temelju WALLAWHATS-a. Dodajte i uklanjajte X pretplate, usmjeravajte upozorenja na kanale, dohvaćajte povijest obavijesti — sve putem REST-a.

Izgradite prilagođene integracije na temelju WALLAWHATS-a. Dodajte i uklanjajte X pretplate, usmjeravajte upozorenja na kanale, dohvaćajte povijest obavijesti — sve putem REST-a.

Kada upozorenja s X-a (Twitter) u stvarnom vremenu postanu ključna za vaš posao, ručno upravljanje putem nadzorne ploče dostiže svoje granice. Bilo da gradite nadzorne ploče za poslovnu inteligenciju, automatizirate tijekove rada za praćenje brenda, ili stvarate prilagođene sustave obavijesti za trgovinske stolove, potrebna vam je programatska kontrola nad vašim X pretplatama za upozorenja.

WALLAWHATS pruža REST API koji vam omogućava stvaranje, upravljanje i praćenje X pretplata za upozorenja bez korištenja web sučelja. Dodajte ili uklonite praćene račune, dohvaćajte povijest obavijesti sa statusom isporuke, i integrirajte upozorenja s X-a u stvarnom vremenu u bilo koji sustav koji govori HTTP.

Stranica za upravljanje API ključevima s kontrolama za stvaranje / opoziv

Zašto koristiti WALLAWHATS API?

Nadzorna ploča odlično funkcionira za ručne tijekove rada, ali API pristup otvara scenarije automatizacije koji se skaliraju iznad ljudskog upravljanja:

Platforme za poslovnu inteligenciju: Automatski se pretplatite na nova identificirana natjecateljska rukovodstva, voditelje proizvoda ili industrijske analitičare kako ih otkrivaju istraživačke alatke ili CRM integracije.

Trgovinski i financijski tijekovi rada: Programatski pratite regulatorne račune, CEO handle-ove ili novinare specifične za sektor na temelju promjena portfelja ili tržišnih događaja—bez ručnog upravljanja pretplatama.

Praćenje brenda na velikoj skali: Dodajte ili uklonite praćenje spomena brenda kako se nove kampanje pokretaju, proizvodi isporučuju ili razvijaju krizne situacije.

Multi-tenant SaaS aplikacije: White-label praćenje X-a u stvarnom vremenu za vaše korisnike, s programatskim upravljanjem pretplatama iza scene.

Sustavi za usklađenost i reviziju: Dohvaćajte potpunu povijest obavijesti sa statusom isporuke za regulatorno izvještavanje, interne revizije ili SLA praćenje.

API autentifikacija i pristup

Svaki WALLAWHATS plan uključuje API pristup s kvotama ključeva koji se skaliraju:

  • Free: 1 API ključ
  • Pro: 1 API ključ
  • Pro+: 2 API ključa
  • Business: 5 API ključeva
  • Enterprise: 20 API ključeva

Autentifikacija koristi x-api-key zaglavlje (ne Authorization: Bearer). Generirajte svoje ključeve iz API odjeljka nadzorne ploče i tretirajte ih kao lozinke—nose pune privilegije računa.

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

Glavni API endpoint-ovi

WALLAWHATS API pruža pet glavnih grupa resursa za izgradnju integracija:

Upravljanje pretplatama

Stvorite novu pretplatu:

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

{
  "xUsername": "elonmusk"
}

Popis svih pretplata:

GET /subscriptions
x-api-key: your_api_key_here

Uklonite pretplatu:

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

Primijetite da endpoint za brisanje uzima X handle kao parametar puta—ne interni ID pretplate.

Povijest obavijesti i revizija

Dohvaćanje povijesti obavijesti sa statusom isporuke:

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

Endpoint za obavijesti vraća paginirane rezultate gdje svaki red predstavlja jedno upozorenje isporučeno na jedan kanal. Vrijednosti statusa uključuju:

  • queued: Upozorenje prihvaćeno, čeka isporuku
  • sent: Poslano pružatelju kanala
  • delivered: Potvrđeno primljeno od odredišta
  • read: Otvoreno od primatelja (samo WhatsApp, zahtijeva omogućene potvrde čitanja)
  • failed: Pokušaj isporuke neuspješan

Upravljanje kanalima

Popis konfiguriranih kanala:

GET /channels
x-api-key: your_api_key_here

Dodajte novi kanal:

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

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

Uklonite kanal:

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

Tweet snapshot-ovi

Pristupite galeriji snapshot-ova:

GET /snapshots
x-api-key: your_api_key_here

Obrišite određeni snapshot:

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

Izgradnja integracija: Primjeri koda

Node.js integracija

Evo Node.js primjera koji dodaje pretplatu i provjerava nove obavijesti:

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

// Primjer korištenja
async function monitorCompetitor() {
  const client = new WallaWhatsClient('your_api_key_here');
  
  // Dodajte novu pretplatu
  await client.addSubscription('vercel');
  console.log('Now monitoring @vercel');
  
  // Proverite nedavne obavijesti
  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 integracija

Za Python tijekove rada, evo klase koja upravlja pretplatama i provjerkom obavijesti:

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):
        """Dodaje novi X račun za praćenje"""
        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):
        """Uklanja X račun iz praćenja"""
        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):
        """Dohvaća povijest obavijesti s paginacijom"""
        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):
        """Dohvaća sve obavijesti u vremenskom rasponu, upravljajući paginacijom"""
        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):
        """Dohvaća sve trenutne pretplate"""
        response = requests.get(
            f'{self.base_url}/subscriptions',
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()

# Primjer: Dnevno izvješće o reviziji
def generate_daily_report():
    api = WallaWhatsAPI('your_api_key_here')
    
    # Dohvaćanje jučerašnjih obavijesti
    end_time = int(time.time() * 1000)
    start_time = end_time - (24 * 60 * 60 * 1000)
    
    notifications = api.get_all_notifications(start_time, end_time)
    
    # Grupiranje po računu i statusu
    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
    
    # Ispišite sažetak
    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")

Razumijevanje usmjeravanja kanala

WALLAWHATS koristi globalni model usmjeravanja kanala—svako upozorenje iz svake pretplate šalje se na sve omogućene i provjerene kanale. Ne možete usmjeriti određene račune na određena odredišta putem API-ja (kao “@elonmusk → WhatsApp, @vercel → email”).

Izbor kanala događa se na razini računa na stranici Kanali. Kada dodajte kanal putem API-ja, postaje dostupan za sva upozorenja nakon provjere. Kada uklonite kanal, prestaje primati upozorenja iz svih pretplata.

Ovaj dizajn pojednostavljuje automatizaciju while sprječava fragmentaciju upozorenja. Vaš kod integracije ne treba pratiti pravila usmjeravanja po pretplati—samo upravljajte kojima računima pratiti i koji kanali omogućiti.

Ograničenja brzine i brzinski kapovi

WALLAWHATS implementira brzinske kapove na korisničkoj razini za sprječavanje spama upozorenja tijekom visoke aktivnosti:

  • Free: 2 upozorenja/sat
  • Pro: 5 upozorenja/sat
  • Pro+: 15 upozorenja/sat
  • Business: 30 upozorenja/sat
  • Enterprise: 100 upozorenja/sat

Kada se prekorače brzinski kapovi, dodatni tweet-ovi se spremaju u digest poruke i isporučuju svakih 15 minuta. Vaša API integracija će ih vidjeti kao zasebne zapise obavijesti—jedan za neposredno upozorenje, i jedan za svaki digest batch.

Sam API ne nameće zasebna ograničenja brzine na upravljanje pretplatama ili upite za obavijesti. Međutim, izbjegavajte bombardiranje endpoint-ova nepotrebnim zahtjevima—keširajte popise pretplata lokalno i grupirajte upite za obavijesti učinkovito.

Rukovanje greškama i rješavanje problema

Uobičajeni uzorci grešaka API-ja i kako ih riješiti:

Neuspjesi autentifikacije (401):

  • Provjerite da li je vaš API ključ točan i nije opozvan
  • Provjerite da koristite x-api-key zaglavlje, ne Authorization

Konflikti pretplata (409):

  • Račun već praćen: Pretplata postoji, tretiraj kao uspjeh
  • Račun zaštićen/privatan: WALLAWHATS ih odbacuje by design

Ograničavanje brzine (429):

  • Eksponencijalno se povucite prije ponovnog pokušaja
  • Provjerite približavate li se ograničenjima plana na praćene račune

Problemi s proverom kanala:

  • Novi kanali zahtijevaju OTP provjeru prije primanja upozorenja
  • Programatski dodani kanali neće raditi dok korisnik ne završi provjeru

Praćenje i upozoravanje vaših integracija

Budući da WALLAWHATS postaje kritična infrastruktura kada se integrira u poslovne tijekove rada, pratite zdravlje vaše integracije:

Otkrivanje drifta pretplata:

// Provjerite da li su očekivane pretplate još uvijek aktivne
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;
}

Praćenje stope uspjeha isporuke:

def check_delivery_health():
    # Provjerite zadnjih 6 sati
    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:
        # Upozorite vaš ops tim
        print(f"WARNING: Delivery success rate dropped to {success_rate:.1f}%")
    
    return success_rate

Uzorci integracije i najbolje prakse

Webhook-stil obrade: Dok WALLAWHATS ne pruža webhook-ove direktno, možete provjeriti endpoint za obavijesti za nova upozorenja i obrađivati ih u skoro stvarnom vremenu:

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') {
      // Obradite upozorenje - pošaljite na Slack, ažurirajte bazu podataka, itd.
      await processAlert(notification);
    }
  }
  
  localStorage.setItem('lastNotificationCheck', now);
}

// Provjeravajte svakih 30 sekundi
setInterval(pollForNewAlerts, 30000);

Uvjetno upravljanje pretplatama: Dinamički dodajte ili uklonite pretplate na temelju vanjskih okidača:

def update_competitor_monitoring(portfolio_companies):
    """Ažuriraj X praćenje na temelju trenutnog portfelja"""
    current_subs = {s['xUsername'] for s in api.list_subscriptions()}
    
    # Računi koje bismo trebali pratiti
    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'])
    
    # Dodaj nedostajuće pretplate
    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}")
    
    # Ukloni zastarjele pretplate
    for account in current_subs - target_accounts:
        api.remove_subscription(account)
        print(f"Stopped monitoring @{account}")

WALLAWHATS API transformira upozorenja s X-a u stvarnom vremenu iz ručne alatke nadzorne ploče u programabilnu komponentu infrastrukture. Bilo da gradite prilagođene tijekove rada za inteligenciju, automatizirate praćenje brenda, ili stvarate white-label usluge obavijesti, API pruža kontrolu i mogućnosti revizije potrebne za produkcijsku integraciju.

Želite proširiti svoje praćenje izvan natjecatelja? Pogledajte naš vodič o praćenju crypto Twitter-a za tržišne signale ili saznajte kako novinari koriste WALLAWHATS za praćenje izvora u stvarnom vremenu.

Nikad više ne propustite važnu objavu. Stvorite besplatni račun — 1 WhatsApp broj, upozorenja u stvarnom vremenu, ne treba kreditna kartica.

Share:
Natrag na Blog

Povezani članci

Pogledaj sve članke »