· Nacho Coll · Guides  · 8 min skaitymo

X įspėjimų API: programinės prenumeratos ir pranešimų istorija

Kurkite individualius integracijas ant WALLAWHATS platformos. Pridėkite ir šalinkite X prenumeratas, nukreipkite įspėjimus į kanalus, gaukite pranešimų istoriją — visa tai per REST.

Kurkite individualius integracijas ant WALLAWHATS platformos. Pridėkite ir šalinkite X prenumeratas, nukreipkite įspėjimus į kanalus, gaukite pranešimų istoriją — visa tai per REST.

Kai realaus laiko X (Twitter) įspėjimai tampa kritiškai svarbūs jūsų verslui, rankinis valdymo skydelio naudojimas pasiekia ribą. Nesvarbu, ar kuriate klientų žvalgybos skydelius, automatizuojate prekės ženklo stebėjimo darbo eigas, ar kuriate individualias pranešimų sistemas prekybos biurui — jums reikia programinio X įspėjimų prenumeratų valdymo.

WALLAWHATS teikia REST API, kuris leidžia kurti, valdyti ir audituoti X įspėjimų prenumeratas nepaliesdami žiniatinklio sąsajos. Pridėkite ar šalinkite stebimas paskyras, gaukite pranešimų istoriją su pristatymo būsena ir integruokite realaus laiko X įspėjimus į bet kurią sistemą, kuri kalba HTTP.

API raktų valdymo puslapis su kūrimo / atšaukimo valdikliais

Kodėl naudoti WALLAWHATS API?

Valdymo skydas puikiai tinka rankiniams darbo procesams, bet API prieiga atveria automatizacijos scenarijus, kurie plečiasi už žmogiškojo valdymo ribų:

Klientų žvalgybos platformos: automatiškai prenumeruokite naujai identifikuotus konkurentų vadovus, produktų lyderius ar sektorių analitikus, kai jie aptinkami tyrimų įrankių ar CRM integracijų pagalba.

Prekybos ir finansų darbo eigos: programiškai stebėkite reguliavimo institucijų paskyras, CEO rankinius ar sektorių žurnalistus pagal portfelio pokyčius ar rinkos įvykius — be rankinio prenumeratų valdymo.

Prekės ženklo stebėjimas plataus masto: pridėkite ar šalinkite prekės ženklo paminėjimų sekimą, kai paleidžiamos naujos kampanijos, išleidžiami produktai ar atsiranda krizės situacijos.

Daugiatenant SaaS programos: baltos etiketės realaus laiko X stebėjimas jūsų klientams, su programiniu prenumeratų valdymu užkulisiuose.

Atitikties ir audito sistemos: gaukite visą pranešimų istoriją su pristatymo būsena reguliavimo ataskaitoms, vidaus audito pėdsakams ar SLA stebėjimui.

API autentifikacija ir prieiga

Kiekvienas WALLAWHATS planas apima API prieigą su kintančiomis raktų kvotomis:

  • Free: 1 API raktas
  • Pro: 1 API raktas
  • Pro+: 2 API raktai
  • Business: 5 API raktai
  • Enterprise: 20 API raktų

Autentifikacija naudoja x-api-key antraštę (ne Authorization: Bearer). Generuokite savo raktus iš valdymo skydelio API skyriaus ir elkitės su jais kaip su slaptažodžiais — jie turi pilnas paskyros privilegijas.

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

Pagrindiniai API galutiniai taškai

WALLAWHATS API teikia penkias pagrindines išteklių grupes integracijoms kurti:

Prenumeratų valdymas

Sukurti naują prenumeratą:

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

{
  "xUsername": "elonmusk"
}

Išvardinti visas prenumeratas:

GET /subscriptions
x-api-key: your_api_key_here

Pašalinti prenumeratą:

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

Atkreipkite dėmesį, kad šalinimo galutinis taškas priima X rankinį kaip kelio parametrą — ne vidinį prenumeratos ID.

Pranešimų istorija ir auditas

Gauti pranešimų istoriją su pristatymo būsena:

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

Pranešimų galutinis taškas grąžina suskaidytus rezultatus, kur kiekviena eilutė atstovauja vienam įspėjimui, pristatytam į vieną kanalą. Būsenos vertės apima:

  • queued: įspėjimas priimtas, laukia pristatymo
  • sent: išsiųstas kanalo teikėjui
  • delivered: patvirtintas gautas paskirties vietoje
  • read: atidarė gavėjas (tik WhatsApp, reikia įjungti skaitymų kvitų)
  • failed: pristatymo bandymas nesėkmingas

Kanalų valdymas

Išvardinti sukonfigūruotus kanalus:

GET /channels
x-api-key: your_api_key_here

Pridėti naują kanalą:

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

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

Pašalinti kanalą:

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

Tweet’ų momentinės nuotraukos

Pasiekti momentinių nuotraukų galeriją:

GET /snapshots
x-api-key: your_api_key_here

Ištrinti konkretų snapshot’ą:

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

Integracijų kūrimas: kodo pavyzdžiai

Node.js integracija

Čia Node.js pavyzdys, kuris prideda prenumeratą ir apklausia naujiems pranešimams:

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(`Nepavyko pridėti prenumeratos: ${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(`Nepavyko gauti pranešimų: ${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(`Nepavyko išvardinti prenumeratų: ${error.response?.data?.message || error.message}`);
    }
  }
}

// Naudojimo pavyzdys
async function monitorCompetitor() {
  const client = new WallaWhatsClient('your_api_key_here');
  
  // Pridėti naują prenumeratą
  await client.addSubscription('vercel');
  console.log('Dabar stebime @vercel');
  
  // Patikrinti paskutinius pranešimus
  const oneDayAgo = Date.now() - (24 * 60 * 60 * 1000);
  const notifications = await client.getNotifications(oneDayAgo, Date.now());
  
  console.log(`Rasta ${notifications.items.length} paskutinių įspėjimų`);
  notifications.items.forEach(notification => {
    console.log(`${notification.xUsername}: ${notification.status} ties ${notification.timestamp}`);
  });
}

Python integracija

Python darbo eigoms — klasė, kuri tvarko prenumeratų valdymą ir pranešimų apklausą:

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):
        """Pridėti naują X paskyrą stebėjimui"""
        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):
        """Pašalinti X paskyrą iš stebėjimo"""
        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):
        """Gauti pranešimų istoriją su puslapiavimu"""
        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):
        """Gauti visus pranešimus laiko intervale, tvarkant puslapiavimą"""
        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):
        """Gauti visas dabartines prenumeratas"""
        response = requests.get(
            f'{self.base_url}/subscriptions',
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()

# Pavyzdys: kasdienė audito ataskaita
def generate_daily_report():
    api = WallaWhatsAPI('your_api_key_here')
    
    # Gauti vakarykščius pranešimus
    end_time = int(time.time() * 1000)
    start_time = end_time - (24 * 60 * 60 * 1000)
    
    notifications = api.get_all_notifications(start_time, end_time)
    
    # Grupuoti pagal paskyrą ir būseną
    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
    
    # Spausdinti santrauką
    print(f"Kasdienė įspėjimų ataskaita - {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']} įspėjimų, {success_rate:.1f}% pristatyta")

Kanalų maršrutizavimo supratimas

WALLAWHATS naudoja globalų kanalų maršrutizavimo modelį — kiekvienas įspėjimas iš kiekvienos prenumeratos pasiskleidžia į visus įjungtus ir patikrintus kanalus. Negalite maršrutuoti konkrečių paskyrų į konkrečius paskirties taškus per API (pavyzdžiui, „@elonmusk → WhatsApp, @vercel → email”).

Kanalo pasirinkimas vyksta paskyros lygiu Kanalų puslapyje. Kai pridėdate kanalą per API, jis tampa prieinamas visiems įspėjimams, kai tik patvirtinamas. Kai pašalinate kanalą, jis nustoja gauti įspėjimus iš visų prenumeratų.

Šis dizainas supaprastina automatizaciją, tuo pačiu užkertant kelią įspėjimų fragmentacijai. Jūsų integracijos kodui nereikia sekti kiekvienai prenumeratai skirtų maršrutizavimo taisyklių — tiesiog valdykite, kurias paskyras stebėti ir kuriuos kanalus įjungti.

Dažnio apribojimai ir greičio limitai

WALLAWHATS įgyvendina naudotojo lygio greičio apribojimus, kad apsaugotų nuo įspėjimų šlamšto didelio aktyvumo laikotarpiais:

  • Free: 2 įspėjimai/val
  • Pro: 5 įspėjimai/val
  • Pro+: 15 įspėjimų/val
  • Business: 30 įspėjimų/val
  • Enterprise: 100 įspėjimų/val

Kai greičio limitai viršijami, papildomi tweet’ai buferizuojami į santraukos pranešimus ir pristatomi kas 15 minučių. Jūsų API integracija matys juos kaip atskirus pranešimo įrašus — vieną tiesioginiam įspėjimui ir po vieną kiekvienam santraukos paketui.

Pats API neuždeda atskirų dažnio apribojimų prenumeratų valdymui ar pranešimų užklausoms. Tačiau vengkite smūgiuoti galinius taškus nereikalingais užklausimais — cache’uokite prenumeratų sąrašus vietoje ir efektyviai grupuokite pranešimų užklausas.

Klaidų tvarkymas ir trikčių šalinimas

Dažni API klaidų šablonai ir kaip su jais elgtis:

Autentifikacijos nesėkmės (401):

  • Patikrinkite, ar jūsų API raktas teisingas ir nebuvo atšauktas
  • Įsitikinkite, kad naudojate x-api-key antraštę, ne Authorization

Prenumeratos konfliktai (409):

  • Paskyra jau stebima: prenumerata egzistuoja, laikykite sėkme
  • Paskyra apsaugota/privati: WALLAWHATS sąmoningai jas atsisako

Dažnio apribojimas (429):

  • Eksponentiškai sumažinkite tempą prieš bandant dar kartą
  • Patikrinkite, ar artėjate prie plano limitų stebimų paskyrų skaičiui

Kanalo patvirtinimo problemos:

  • Nauji kanalai reikalauja OTP patvirtinimo prieš gaunant įspėjimus
  • Programiškai pridėti kanalai neveiks, kol naudotojas užbaigs patvirtinimą

Jūsų integracijų stebėjimas ir įspėjimai

Kadangi WALLAWHATS tampa kritine infrastruktūra, kai integruojama į verslo darbo eigas, stebėkite savo integracijos sveikatą:

Prenumeratos nuokrypio aptikimas:

// Patikrinti, ar tikėtinos prenumeratos vis dar aktyvios
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ūkstamos prenumeratos: ${missing.join(', ')}`);
  }
  
  return missing;
}

Pristatymo sėkmės rodiklio stebėjimas:

def check_delivery_health():
    # Patikrinti paskutines 6 valandas
    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:
        # Įspėti jūsų operacijų komandą
        print(f"ĮSPĖJIMAS: pristatymo sėkmės rodiklis nukrito iki {success_rate:.1f}%")
    
    return success_rate

Integracijų šablonai ir geriausi praktikos

Webhook stiliaus apdorojimas: nors WALLAWHATS tiesiogiai neteikia webhook’ų, galite apklausti pranešimų galutinį tašką naujiem įspėjimams ir apdoroti juos beveik realiu laiku:

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') {
      // Apdoroti įspėjimą - siųsti į Slack, atnaujinti duomenų bazę ir t.t.
      await processAlert(notification);
    }
  }
  
  localStorage.setItem('lastNotificationCheck', now);
}

// Apklausinėti kas 30 sekundžių
setInterval(pollForNewAlerts, 30000);

Sąlyginis prenumeratų valdymas: dinamiškai pridėkite ar pašalinkite prenumeratas pagal išorinius trigerius:

def update_competitor_monitoring(portfolio_companies):
    """Atnaujinti X stebėjimą pagal dabartinį portfelį"""
    current_subs = {s['xUsername'] for s in api.list_subscriptions()}
    
    # Paskyros, kurias turėtume stebėti
    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'])
    
    # Pridėti trūkstamas prenumeratas
    for account in target_accounts - current_subs:
        try:
            api.add_subscription(account)
            print(f"Pradėjome stebėti @{account}")
        except Exception as e:
            print(f"Nepavyko pridėti @{account}: {e}")
    
    # Pašalinti pasenusias prenumeratas
    for account in current_subs - target_accounts:
        api.remove_subscription(account)
        print(f"Nustojome stebėti @{account}")

WALLAWHATS API transformuoja realaus laiko X įspėjimus iš rankinio valdymo skydelio įrankio į programuojamą infrastruktūros komponentą. Nesvarbu, ar kuriate individualias žvalgybos darbo eigas, automatizuojate prekės ženklo stebėjimą, ar kuriate baltos etiketės pranešimų tarnybas, API teikia reikiamą kontrolę ir audito galimybes produkcijos integracijai.

Norite išplėsti stebėjimą už konkurentų ribų? Peržiūrėkite mūsų vadovą apie kriptovaliutos Twitter stebėjimą rinkos signalams arba sužinokite, kaip žurnalistai naudoja WALLAWHATS realaus laiko šaltinių stebėjimui.

Daugiau niekada nepraleiskite svarbaus įrašo. Sukurkite nemokamą paskyrą — 1 WhatsApp numeris, realaus laiko įspėjimai, mokėjimo kortelės nereikia.

Share:
Grįžti į Tinklaraštį

Susiję straipsniai

Peržiūrėti visus straipsnius »