· Nacho Coll · Guides  · 8 min lugemist

X hoiatuste API: programmaatilised tellimused ja teavituste ajalugu

Ehita kohandatud integratsioonid WALLAWHATS platvormi peale. Lisa ja eemalda X tellimusi, suuna hoiatused kanalitesse, päri teavituste ajalugu — kõik REST-i kaudu.

Ehita kohandatud integratsioonid WALLAWHATS platvormi peale. Lisa ja eemalda X tellimusi, suuna hoiatused kanalitesse, päri teavituste ajalugu — kõik REST-i kaudu.

Kui reaalajas X (Twitter) hoiatused muutuvad sinu äri jaoks kriitiliseks, jõuab käsitsi juhtpaneeli haldamine piirini. Olenemata sellest, kas ehitad kliendianalüütika juhtpaneele, automatiseerid brändi jälgimise töövoogusid või lood kohandatud teavitussüsteeme kauplemislaudadele, vajad programmaatilist kontrolli oma X hoiatuste tellimuste üle.

WALLAWHATS pakub REST API-d, mis võimaldab luua, hallata ja auditeerida X hoiatuste tellimusi ilma veebiliidest puudutamata. Lisa või eemalda jälgitavaid kontosid, päri teavituste ajalugu koos kohaletoimetamise staatusega ja integreeri reaalajas X hoiatused mis tahes süsteemi, mis räägib HTTP-d.

API võtmete haldamise leht loomise / tühistamise juhtudega

Miks kasutada WALLAWHATS API-d?

Juhtpaneel töötab suurepäraselt käsitsi töövoogude jaoks, kuid API juurdepääs avab automatiseerimisstsenaariume, mis skaleeruvad üle inimese halduse:

Kliendi analüütika platvormid: Automaatselt telli äsja avastatud konkurentide juhtide, tootejuhtide või tööstusanalüütikute tellimusi, kuna neid avastatakse uurimisvahendite või CRM integratsioonide kaudu.

Kauplemise ja finantsvoogu: Programmaatiliselt jälgi regulatiivasutuste kontosid, tegevjuhtide kasutajanimesid või sektoripõhiseid ajakirjanikke vastavalt portfelli muutustele või turusündmustele — ilma käsitsi tellimuste haldamiseta.

Brändi jälgimine suures mahus: Lisa või eemalda brändi mainimise jälgimine, kui uued kampaaniad käivituvad, tooted välja tuleb või kriisiolukorrad arenevad.

Mitme rentniku SaaS rakendused: Valge sildiga reaalajas X jälgimine sinu klientide jaoks, programmaatilise tellimuste haldamisega taustal.

Vastavuse ja auditisüsteemid: Päri täielik teavituste ajalugu koos kohaletoimetamise staatusega regulatiivse aruandluse, sisemiste auditijälgede või SLA jälgimise jaoks.

API autentimine ja juurdepääs

Iga WALLAWHATS plaan sisaldab API juurdepääsu koos skaleeruvate võtmete kvootidega:

  • Free: 1 API võti
  • Pro: 1 API võti
  • Pro+: 2 API võtit
  • Business: 5 API võtit
  • Enterprise: 20 API võtit

Autentimine kasutab x-api-key päist (mitte Authorization: Bearer). Genereeri oma võtmed juhtpaneeli API jaotisest ja käitle neid nagu paroole — need kannavad täielikke konto õigusi.

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

Peamised API lõpp-punktid

WALLAWHATS API pakub viit peamist ressursigruppi integratsioonide ehitamiseks:

Tellimuste haldamine

Uue tellimuse loomine:

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

{
  "xUsername": "elonmusk"
}

Kõikide tellimuste loetlemine:

GET /subscriptions
x-api-key: your_api_key_here

Tellimuse eemaldamine:

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

Pane tähele, et kustutamise lõpp-punkt võtab X kasutajanimega tee parameetrina — mitte sisemise tellimuse ID-ga.

Teavituste ajalugu ja audit

Teavituste ajaloo pärimine koos kohaletoimetamise staatusega:

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

Teavituste lõpp-punkt tagastab lehestatud tulemused, kusjuures iga rida esindab ühte hoiatust, mis on kohale toimetatud ühte kanalisse. Staatuse väärtused sisaldavad:

  • queued: Hoiatus vastu võetud, ootab kohaletoimetamist
  • sent: Saadetud kanali pakkujale
  • delivered: Kinnitatud, et sihtkoht sai kätte
  • read: Adressaadi poolt avatud (ainult WhatsApp, nõuab lugemiskinnituste lubamist)
  • failed: Kohaletoimetamise katse ebaõnnestus

Kanalite haldamine

Konfigureeritud kanalite loetlemine:

GET /channels
x-api-key: your_api_key_here

Uue kanali lisamine:

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

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

Kanali eemaldamine:

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

Tviitide hetktõmmised

Hetktõmmiste galerii juurdepääs:

GET /snapshots
x-api-key: your_api_key_here

Konkreetse hetktõmmise kustutamine:

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

Integratsioonide ehitamine: koodinäited

Node.js integratsioon

Siin on Node.js näide, mis lisab tellimuse ja küsitleb uusi teavitusi:

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

// Kasutamise näide
async function monitorCompetitor() {
  const client = new WallaWhatsClient('your_api_key_here');
  
  // Lisa uus tellimus
  await client.addSubscription('vercel');
  console.log('Nüüd jälgin @vercel');
  
  // Kontrolli hiljutisi teavitusi
  const oneDayAgo = Date.now() - (24 * 60 * 60 * 1000);
  const notifications = await client.getNotifications(oneDayAgo, Date.now());
  
  console.log(`Leidsin ${notifications.items.length} hiljutist hoiatust`);
  notifications.items.forEach(notification => {
    console.log(`${notification.xUsername}: ${notification.status} ajahetkel ${notification.timestamp}`);
  });
}

Python integratsioon

Python töövoogude jaoks on siin klass, mis käsitleb tellimuste haldamist ja teavituste küsitlemist:

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):
        """Lisa uus X konto jälgimiseks"""
        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):
        """Eemalda X konto jälgimisest"""
        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):
        """Hangi teavituste ajalugu lehestamisega"""
        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):
        """Hangi kõik teavitused ajavahemikus, käsitledes lehestamist"""
        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):
        """Hangi kõik praegused tellimused"""
        response = requests.get(
            f'{self.base_url}/subscriptions',
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()

# Näide: igapäevane audit aruanne
def generate_daily_report():
    api = WallaWhatsAPI('your_api_key_here')
    
    # Hangi eilsed teavitused
    end_time = int(time.time() * 1000)
    start_time = end_time - (24 * 60 * 60 * 1000)
    
    notifications = api.get_all_notifications(start_time, end_time)
    
    # Grupeeri konto ja staatuse järgi
    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
    
    # Trüki kokkuvõte
    print(f"Päevane hoiatuste aruanne - {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']} hoiatust, {success_rate:.1f}% kohale toimetatud")

Kanalite marsruutimise mõistmine

WALLAWHATS kasutab globaalset kanalite marsruutimise mudelit — iga hoiatus igast tellimusest laieneb kõikidele lubatud ja kinnitatud kanalitele. Sa ei saa API kaudu suunata konkreetseid kontosid konkreetsetesse sihtkohtadesse (nagu “@elonmusk → WhatsApp, @vercel → e-post”).

Kanalite valik toimub konto tasemel kanalite lehel. Kui sa lisad kanali API kaudu, muutub see kõikide hoiatuste jaoks saadavaks pärast kinnitamist. Kui sa eemaldad kanali, lõpetab see kõikide tellimuste hoiatuste saamise.

See disain lihtsustab automatiseerimist, välditakse hoiatuste killustumist. Sinu integratsiooni kood ei pea jälgima tellimuspõhiseid marsruutimisreegleid — lihtsalt halda, milliseid kontosid jälgida ja milliseid kanaleid lubada.

Kiiruspiirangud ja kiiruse ülempiirid

WALLAWHATS rakendab kasutaja-tasemel kiiruse ülempiire, et vältida hoiatuste rämpspost kõrge aktiivsuse perioodidel:

  • Free: 2 hoiatust/tund
  • Pro: 5 hoiatust/tund
  • Pro+: 15 hoiatust/tund
  • Business: 30 hoiatust/tund
  • Enterprise: 100 hoiatust/tund

Kui kiiruse ülempiirid on ületatud, puhverdatakse lisatviidid koondteadetesse ja toimetatakse iga 15 minuti järel kohale. Sinu API integratsioon näeb neid eraldi teavituste kirjetena — üks kohese hoiatuse jaoks ja üks iga koondpartii jaoks.

API ise ei kehtesta eraldi kiiruspiiranguid tellimuste haldamisele või teavituste päringutele. Siiski väldi lõpp-punktide pommitamist mittevajalike päringutega — salvesta tellimuste loendid kohalikult vahemällu ja partiid teavituste päringuid tõhusalt.

Vigade käsitlemine ja tõrkeotsing

Tavalised API vigade mustrid ja kuidas neid käsitleda:

Autentimise tõrked (401):

  • Kontrolli, et sinu API võti on õige ja pole tühistatud
  • Veendu, et kasutad x-api-key päist, mitte Authorization

Tellimuste konfliktid (409):

  • Konto juba jälgitav: Tellimus eksisteerib, käitle kui edu
  • Konto kaitstud/privaatne: WALLAWHATS keeldub neist disaini kohaselt

Kiiruse piiramine (429):

  • Tee eksponentsiaalset taganemist enne uuesti proovimist
  • Kontrolli, kas lähenete plaani piiridele jälgitavate kontode osas

Kanalite kinnitamise probleemid:

  • Uued kanalid nõuavad OTP kinnitamist enne hoiatuste saamist
  • Programmaatiliselt lisatud kanalid ei tööta, kuni kasutaja lõpetab kinnitamise

Sinu integratsioonide jälgimine ja hoiatamine

Kuna WALLAWHATS muutub äri töövoogudesse integreerituna kriitiliseks infrastruktuuriks, jälgi oma integratsiooni tervist:

Tellimuste triivi avastamine:

// Kontrolli, kas oodatud tellimused on endiselt aktiivsed
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(`Puuduvad tellimused: ${missing.join(', ')}`);
  }
  
  return missing;
}

Kohaletoimetamise edumäära jälgimine:

def check_delivery_health():
    # Kontrolli viimased 6 tundi
    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:
        # Hoiata oma ops meeskonda
        print(f"HOIATUS: Kohaletoimetamise edumäär kukkus {success_rate:.1f}%-le")
    
    return success_rate

Integratsioonide mustrid ja parimad praktikad

Webhookide stiilis töötlemine: Kuigi WALLAWHATS ei paku otse webhookke, saad küsitleda teavituste lõpp-punkti uute hoiatuste jaoks ja töödelda neid peaaegu-reaalajas:

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') {
      // Töötle hoiatus - saada Slack'i, uuenda andmebaasi jne.
      await processAlert(notification);
    }
  }
  
  localStorage.setItem('lastNotificationCheck', now);
}

// Küsitle iga 30 sekundi järel
setInterval(pollForNewAlerts, 30000);

Tingimuslik tellimuste haldamine: Dünaamiliselt lisa või eemalda tellimused väliste päästike põhjal:

def update_competitor_monitoring(portfolio_companies):
    """Uuenda X jälgimist praeguse portfelli põhjal"""
    current_subs = {s['xUsername'] for s in api.list_subscriptions()}
    
    # Kontod, mida peaksime jälgima
    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'])
    
    # Lisa puuduvad tellimused
    for account in target_accounts - current_subs:
        try:
            api.add_subscription(account)
            print(f"Alustasin @{account} jälgimist")
        except Exception as e:
            print(f"Ebaõnnestus @{account} lisamine: {e}")
    
    # Eemalda aegunud tellimused
    for account in current_subs - target_accounts:
        api.remove_subscription(account)
        print(f"Lõpetasin @{account} jälgimise")

WALLAWHATS API muudab reaalajas X hoiatused käsitsi juhtpaneeli tööriistast programmeeritavaks infrastruktuuri komponendiks. Olenemata sellest, kas ehitad kohandatud analüütika töövoogusid, automatiseerid brändi jälgimist või lood valge sildiga teavituseteenuseid, pakub API tootmisintegratsiooni jaoks vajalikku kontrolli ja auditi võimekust.

Soovid laiendada oma jälgimist kaugemale konkurentidest? Vaata meie juhendit krüpto Twitter jälgimiseks turusingnaalide jaoks või õpi, kuidas ajakirjanikud kasutavad WALLAWHATS reaalajas allika jälgimiseks.

Ära kunagi jäta enam tähtsat postitust vahele. Loo tasuta konto — 1 WhatsAppi number, reaalajas hoiatused, krediitkaart pole vajalik.

Share:
Tagasi Blogisse

Seotud artiklid

Vaata kõiki artikleid »