· Nacho Coll · Guides  · 8 min lasīšanas

X brīdinājumu API: Programmatiskas abonēšanas un paziņojumu vēsture

Veidojiet pielāgotas integrācijas uz WALLAWHATS pamata. Pievienojiet un noņemiet X abonemntus, novirziet brīdinājumus uz kanāliem, izgūstiet paziņojumu vēsturi — visu ar REST.

Veidojiet pielāgotas integrācijas uz WALLAWHATS pamata. Pievienojiet un noņemiet X abonemntus, novirziet brīdinājumus uz kanāliem, izgūstiet paziņojumu vēsturi — visu ar REST.

Kad reāllaika X (Twitter) brīdinājumi kļūst kritiski svarīgi jūsu uzņēmumam, manuāla paneļa pārvaldība sasniedzas strupceļā. Neatkarīgi no tā, vai veidojat klientu izlūkošanas paneļus, automatizējat zīmola monitoringa darba procesus vai veidojat pielāgotas paziņojumu sistēmas tirdzniecības departamentiem, jums nepieciešama programmatiska kontrole pār saviem X brīdinājumu abonementiem.

WALLAWHATS nodrošina REST API, kas ļauj izveidot, pārvaldīt un auditēt X brīdinājumu abonemntus, nepieskaroties tīmekļa saskarnei. Pievienojiet vai noņemiet uzraugāmos kontus, izgūstiet paziņojumu vēsturi ar piegādes statusu un integrējiet reāllaika X brīdinājumus jebkurā sistēmā, kas saprot HTTP.

API atslēgu pārvaldības lapa ar izveides / atsaukšanas kontrolēm

Kāpēc izmantot WALLAWHATS API?

Panelis lieliski darbojas manuāliem darba procesiem, bet API piekļuve atbloķē automatizācijas scenārijus, kas mērogojami pārāk cilvēciskās pārvaldības robežām:

Klientu izlūkošanas platformas: Automātiski abonējiet jaunatklātos konkurentu izpilddirektorus, produktu vadītājus vai nozares analītiķus, kad tos atklāj, izmantojot pētniecības rīkus vai CRM integrācijas.

Tirdzniecības un finanšu darba procesi: Programatiski uzraugiet regulatīvo kontu, CEO rokturi vai nozarēm specifiskos žurnālistus, pamatojoties uz portfeļa izmaiņām vai tirgus notikumiem — bez manuālas abonementa pārvaldības.

Zīmola monitorings mērogā: Pievienojiet vai noņemiet zīmola pieminējumu izsekošanu, kad sākas jaunas kampaņas, tiek izlaisti produkti vai attīstās krīzes situācijas.

Daudznomnieku SaaS lietojumprogrammas: Baltā etiketa reāllaika X monitorings jūsu klientiem ar programatisku abonementa pārvaldību aizkulisēs.

Atbilstības un audita sistēmas: Izgūstiet pilnu paziņojumu vēsturi ar piegādes statusu regulatīvajiem ziņojumiem, iekšējiem audita ceļiem vai SLA monitoringam.

API autentifikācija un piekļuve

Katrs WALLAWHATS plāns ietver API piekļuvi ar mērogošanas atslēgu kvotām:

  • Free: 1 API atslēga
  • Pro: 1 API atslēga
  • Pro+: 2 API atslēgas
  • Business: 5 API atslēgas
  • Enterprise: 20 API atslēgas

Autentifikācija izmanto x-api-key galveni (ne Authorization: Bearer). Ģenerējiet savas atslēgas no paneļa API sadaļas un rīkojieties ar tām kā parolēm — tās nes pilnas konta privilēģijas.

curl -H "x-api-key: jūsu_api_atslēga_šeit" \
     https://api.wallawhats.com/subscriptions

Galvenie API galapunkti

WALLAWHATS API nodrošina piecas galvenās resursu grupas integrāciju veidošanai:

Abonementa pārvaldība

Izveidot jaunu abonementu:

POST /subscriptions
Content-Type: application/json
x-api-key: jūsu_api_atslēga_šeit

{
  "xUsername": "elonmusk"
}

Uzskaitīt visus abonemntus:

GET /subscriptions
x-api-key: jūsu_api_atslēga_šeit

Noņemt abonementu:

DELETE /subscriptions/elonmusk
x-api-key: jūsu_api_atslēga_šeit

Ievērojiet, ka dzēšanas galapunkts pieņem X rokturi kā ceļa parametru — ne iekšējo abonementa ID.

Paziņojumu vēsture un audits

Izgūt paziņojumu vēsturi ar piegādes statusu:

GET /notifications?from=1704067200000&to=1704153600000
x-api-key: jūsu_api_atslēga_šeit

Paziņojumu galapunkts atgriež lapošanas rezultātus, kur katra rinda attēlo vienu brīdinājumu, kas piegādāts vienam kanālam. Statusa vērtības ietver:

  • queued: Brīdinājums pieņemts, gaida piegādi
  • sent: Nosūtīts kanāla pakalpojuma sniedzējam
  • delivered: Apstiprināts saņemts galamērķī
  • read: Atvērts saņēmēja (tikai WhatsApp, nepieciešami iespējoti lasīšanas apstiprinājumi)
  • failed: Piegādes mēģinājums nesekmīgs

Kanālu pārvaldība

Uzskaitīt konfigurētos kanālus:

GET /channels
x-api-key: jūsu_api_atslēga_šeit

Pievienot jaunu kanālu:

POST /channels
Content-Type: application/json
x-api-key: jūsu_api_atslēga_šeit

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

Noņemt kanālu:

DELETE /channels/channel_id_here
x-api-key: jūsu_api_atslēga_šeit

Tvītu momentuzņēmumi

Piekļūt momentuzņēmumu galerijai:

GET /snapshots
x-api-key: jūsu_api_atslēga_šeit

Dzēst konkrētu momentuzņēmumu:

DELETE /snapshots/tweet_id_here
x-api-key: jūsu_api_atslēga_šeit

Integrāciju veidošana: koda piemēri

Node.js integrācija

Šeit ir Node.js piemērs, kas pievieno abonementu un aptauja jaunus paziņojumus:

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(`Neizdevās pievienot abonementu: ${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(`Neizdevās izgūt paziņojumus: ${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(`Neizdevās uzskaitīt abonemntus: ${error.response?.data?.message || error.message}`);
    }
  }
}

// Lietošanas piemērs
async function monitorCompetitor() {
  const client = new WallaWhatsClient('jūsu_api_atslēga_šeit');
  
  // Pievienot jaunu abonementu
  await client.addSubscription('vercel');
  console.log('Tagad uzraugām @vercel');
  
  // Pārbaudīt nesenos paziņojumus
  const oneDayAgo = Date.now() - (24 * 60 * 60 * 1000);
  const notifications = await client.getNotifications(oneDayAgo, Date.now());
  
  console.log(`Atrasti ${notifications.items.length} neseni brīdinājumi`);
  notifications.items.forEach(notification => {
    console.log(`${notification.xUsername}: ${notification.status} plkst. ${notification.timestamp}`);
  });
}

Python integrācija

Python darba procesiem šeit ir klase, kas apstrādā abonementa pārvaldību un paziņojumu aptauju:

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):
        """Pievienot jaunu X kontu uzraugāšanai"""
        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):
        """Noņemt X kontu no uzraugāšanas"""
        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):
        """Izgūt paziņojumu vēsturi ar lapošanu"""
        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):
        """Izgūt visus paziņojumus laika diapazonā, apstrādājot lapošanu"""
        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):
        """Iegūt visus pašreizējos abonemntus"""
        response = requests.get(
            f'{self.base_url}/subscriptions',
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()

# Piemērs: Dienas audita atskaite
def generate_daily_report():
    api = WallaWhatsAPI('jūsu_api_atslēga_šeit')
    
    # Iegūt vakardienas paziņojumus
    end_time = int(time.time() * 1000)
    start_time = end_time - (24 * 60 * 60 * 1000)
    
    notifications = api.get_all_notifications(start_time, end_time)
    
    # Grupēt pēc konta un statusa
    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
    
    # Drukāt kopsavilkumu
    print(f"Dienas brīdinājumu atskaite - {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']} brīdinājumi, {success_rate:.1f}% piegādāti")

Kanālu maršrutēšanas izpratne

WALLAWHATS izmanto globālo kanālu maršrutēšanas modeli — katrs brīdinājums no katra abonementa izplatās uz visiem iespējotajiem un verificētajiem kanāliem. Jūs nevarat maršrutēt konkrētus kontus uz konkrētiem galamērķiem via API (piemēram, „@elonmusk → WhatsApp, @vercel → e-pasts”).

Kanālu izvēle notiek konta līmenī kanālu lapā. Kad pievienojat kanālu via API, tas kļūst pieejams visiem brīdinājumiem pēc verifikācijas. Kad noņemat kanālu, tas pārtrauc saņemt brīdinājumus no visiem abonementiem.

Šis dizains vienkāršo automatizāciju, vienlaikus novēršot brīdinājumu sadrumstalotību. Jūsu integrācijas kodam nav jāizseko per-abonementa maršrutēšanas noteikumi — vienkārši pārvaldiet, kurus kontus uzraudzīt un kurus kanālus iespējot.

Ātruma ierobežojumi un ātruma ierobežojumi

WALLAWHATS īsteno lietotāja līmeņa ātruma ierobežojumus, lai novērstu brīdinājumu spamu augstās aktivitātes periodos:

  • Free: 2 brīdinājumi/stundā
  • Pro: 5 brīdinājumi/stundā
  • Pro+: 15 brīdinājumi/stundā
  • Business: 30 brīdinājumi/stundā
  • Enterprise: 100 brīdinājumi/stundā

Kad ātruma ierobežojumi tiek pārsniegti, papildu tvīti tiek buferizēti kopsavilkuma ziņojumos un piegādāti ik pēc 15 minūtēm. Jūsu API integrācija redzēs tos kā atsevišķus paziņojumu ierakstus — vienu tūlītējam brīdinājumam un vienu katram kopsavilkuma paketam.

Pats API neuzliek atsevišķus ātruma ierobežojumus abonementa pārvaldībai vai paziņojumu vaicājumiem. Tomēr izvairieties no galapunktu bombardēšanas ar nevajadzīgiem pieprasījumiem — lokāli kešojiet abonementa sarakstus un efektīvi grupējiet paziņojumu vaicājumus.

Kļūdu apstrāde un problēmu novēršana

Izplatītie API kļūdu modeļi un to apstrāde:

Autentifikācijas kļūmes (401):

  • Pārliecinieties, ka jūsu API atslēga ir pareiza un nav atsaukta
  • Pārliecinieties, ka izmantojat x-api-key galveni, ne Authorization

Abonementa konflikti (409):

  • Konts jau uzraugāms: Abonements eksistē, uztveriet kā panākumu
  • Konts aizsargāts/privāts: WALLAWHATS tos atsakās pēc dizaina

Ātruma ierobežošana (429):

  • Atkāpieties eksponenciāli pirms atkārtota mēģinājuma
  • Pārbaudiet, vai tuvojaties plāna ierobežojumiem uzraugāmajos kontos

Kanālu verifikācijas problēmas:

  • Jauniem kanāliem nepieciešama OTP verifikācija pirms brīdinājumu saņemšanas
  • Programatiski pievienotie kanāli nedarbosies, kamēr lietotājs nepabeidz verifikāciju

Jūsu integrāciju monitorings un brīdinājumi

Tā kā WALLAWHATS kļūst par kritisku infrastruktūru, kad tiek integrēts biznesa darba procesos, uzraugiet savas integrācijas veselību:

Abonementa novirzes atklāšana:

// Pārbaudīt, vai paredzētie abonemnti joprojām ir aktīvi
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(`Trūkst abonementi: ${missing.join(', ')}`);
  }
  
  return missing;
}

Piegādes panākumu rādītāja monitorings:

def check_delivery_health():
    # Pārbaudīt pēdējās 6 stundas
    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:
        # Brīdināt jūsu operāciju komandu
        print(f"BRĪDINĀJUMS: Piegādes panākumu rādītājs nokrita uz {success_rate:.1f}%")
    
    return success_rate

Integrācijas modeļi un labākās prakses

Webhook-style apstrāde: Lai gan WALLAWHATS tieši nesniedz webhook’us, varat aptaujāt paziņojumu galapunktu jauniem brīdinājumiem un tos apstrādāt gandrīz reāllaikā:

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') {
      // Apstrādāt brīdinājumu - sūtīt uz Slack, atjaunināt datubāzi, utt.
      await processAlert(notification);
    }
  }
  
  localStorage.setItem('lastNotificationCheck', now);
}

// Aptaujāt ik pēc 30 sekundēm
setInterval(pollForNewAlerts, 30000);

Nosacījumu abonementa pārvaldība: Dinamiski pievienojiet vai noņemiet abonemntus, pamatojoties uz ārējiem triggeriem:

def update_competitor_monitoring(portfolio_companies):
    """Atjaunināt X monitoringu, pamatojoties uz pašreizējo portfeli"""
    current_subs = {s['xUsername'] for s in api.list_subscriptions()}
    
    # Konti, kurus mums vajadzētu uzraudzīt
    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'])
    
    # Pievienot trūkstošos abonemntus
    for account in target_accounts - current_subs:
        try:
            api.add_subscription(account)
            print(f"Sākta @{account} uzraudzība")
        except Exception as e:
            print(f"Neizdevās pievienot @{account}: {e}")
    
    # Noņemt novecojušos abonemntus
    for account in current_subs - target_accounts:
        api.remove_subscription(account)
        print(f"Pārtraukta @{account} uzraudzība")

WALLAWHATS API pārveido reāllaika X brīdinājumus no manuāla paneļa rīka uz programmējamu infrastruktūras komponentu. Neatkarīgi no tā, vai veidojat pielāgotus izlūkošanas darba procesus, automatizējat zīmola monitoringu vai veidojat baltā etiketa paziņojumu pakalpojumus, API nodrošina kontroli un audita iespējas, kas nepieciešamas ražošanas integrācijai.

Vēlaties paplašināt savu monitoringu pāri konkurentiem? Apskatiet mūsu ceļvedi par kripto Twitter monitoringu tirgus signāliem vai uzziniet, kā žurnālisti izmanto WALLAWHATS reāllaika avotu monitoringam.

Nekad vairs nenokavējiet svarīgu ierakstu. Izveidojiet bezmaksas kontu — 1 WhatsApp numurs, reāllaika brīdinājumi, kredītkarte nav vajadzīga.

Share:
Atpakaļ uz Blogu

Saistītie raksti

Skatīt visus rakstus »