· Nacho Coll · Guides  · 7 min lukuaika

X-hälytykset API: Ohjelmallinen tilaukset ja ilmoitushistoria

Rakenna mukautettuja integraatioita WALLAWHATS:in päälle. Lisää ja poista X-tilauksia, reitittää hälytykset kanaviin, hae ilmoitushistoriaa — kaikki REST:n kautta.

Rakenna mukautettuja integraatioita WALLAWHATS:in päälle. Lisää ja poista X-tilauksia, reitittää hälytykset kanaviin, hae ilmoitushistoriaa — kaikki REST:n kautta.

Kun reaaliaikaiset X (Twitter) -hälytykset muuttuvat liiketoiminnallesi kriittisiksi, manuaalinen hallintapaneelin hallinta törmää seinään. Rakennatpa asiakastietoälykkyydashboardeja, automatisoit brändin seuranta -työnkulkuja tai luot mukautettuja ilmoitusjärjestelmiä kaupankäyntipöydille, tarvitset ohjelmallist kontrollia X-hälytysten tilauksistasi.

WALLAWHATS tarjoaa REST API:n, jolla voit luoda, hallita ja auditoida X-hälytysten tilauksia koskematta web-käyttöliittymään. Lisää tai poista seurattavia tilejä, hae ilmoitushistoriaa toimitustiloineen ja integroi reaaliaikaiset X-hälytykset mihin tahansa järjestelmään, joka puhuu HTTP:tä.

API-avainten hallintasivu, jossa on luo/peruuta -kontrollit

Miksi käyttää WALLAWHATS API:a?

Dashboard toimii loistavasti manuaalisiin työnkulkuihin, mutta API-käyttöoikeus avaa automatisointiskenaarioita, jotka skaalautuvat ihmishallinnan ulkopuolelle:

Asiakastietoälykkyyden alustat: Automaattisesti tilaa äskettäin tunnistetut kilpailijan johtajat, tuotepäälliköt tai toimiala-analyytikot sitä mukaa, kun heidät löydetään tutkimustyökalujen tai CRM-integraatioiden kautta.

Kaupankäynti ja rahoituksen työnkulut: Ohjelmallisesti seuraa sääntelyviranomaisten tilejä, toimitusjohtajien kahvoja tai sektorikohtaisia toimittajia perustuen salkun muutoksiin tai markkinatapahtumiin — ilman manuaalista tilaustenhallintaa.

Brändin seuranta laajassa mittakaavassa: Lisää tai poista brändin mainintojen seuranta uusien kampanjoiden käynnistyessä, tuotteiden lanseerauksissa tai kriisitilanteiden kehittyessä.

Monivuokraalaiset SaaS-sovellukset: White-label reaaliaikaista X-seurantaa asiakkaillesi ohjelmallisella tilauksenhallinnalla kulissien takana.

Compliance- ja auditointijärjestelmät: Hae täydellinen ilmoitushistoria toimitustatuksineen sääntelyraportteihin, sisäisiin auditointijälkiin tai SLA-seurantaan.

API-todennus ja käyttöoikeus

Jokaiseen WALLAWHATS-pakettiin sisältyy API-käyttöoikeus skaalautuvilla avainkiintiöillä:

  • Free: 1 API-avain
  • Pro: 1 API-avain
  • Pro+: 2 API-avainta
  • Business: 5 API-avainta
  • Enterprise: 20 API-avainta

Todennus käyttää x-api-key-headeria (ei Authorization: Bearer). Luo avaimesi hallintapaneelin API-osiosta ja kohtele niitä salasanoina — ne kantavat täydet tilin käyttöoikeudet.

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

Tärkeimmät API-päätepisteet

WALLAWHATS API tarjoaa viisi pääresurssiryhmää integraatioiden rakentamiseen:

Tilausten hallinta

Luo uusi tilaus:

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

{
  "xUsername": "elonmusk"
}

Listaa kaikki tilaukset:

GET /subscriptions
x-api-key: your_api_key_here

Poista tilaus:

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

Huomaa, että poisto-päätepiste ottaa X-kahvan polkuparametrina — ei sisäistä tilaus-ID:tä.

Ilmoitushistoria ja auditointi

Hae ilmoitushistoria toimitustatuksineen:

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

Ilmoitusten päätepiste palauttaa sivutettuja tuloksia, joissa jokainen rivi edustaa yhtä hälytystä, joka on toimitettu yhteen kanavaan. Tilat sisältävät:

  • queued: Hälytys hyväksytty, odottaa toimitusta
  • sent: Lähetetty kanavan tarjoajalle
  • delivered: Vahvistettu vastaanotetuksi kohteessa
  • read: Avattu vastaanottajan toimesta (vain WhatsApp, vaatii lukukuittausten olevan käytössä)
  • failed: Toimitusyritys epäonnistunut

Kanavien hallinta

Listaa konfiguroidut kanavat:

GET /channels
x-api-key: your_api_key_here

Lisää uusi kanava:

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

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

Poista kanava:

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

Tweet-tilannekuvat

Käytä tilannekuvagalleriaa:

GET /snapshots
x-api-key: your_api_key_here

Poista tietty tilannekuva:

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

Integraatioiden rakentaminen: Koodiesimerkit

Node.js integraatio

Tässä on Node.js-esimerkki, joka lisää tilauksen ja pollaa uusia ilmoituksia:

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

// Käyttöesimerkki
async function monitorCompetitor() {
  const client = new WallaWhatsClient('your_api_key_here');
  
  // Lisää uusi tilaus
  await client.addSubscription('vercel');
  console.log('Nyt seurataan @vercel');
  
  // Tarkista viimeaikaiset ilmoitukset
  const oneDayAgo = Date.now() - (24 * 60 * 60 * 1000);
  const notifications = await client.getNotifications(oneDayAgo, Date.now());
  
  console.log(`Löytyi ${notifications.items.length} viimeaikaista hälytystä`);
  notifications.items.forEach(notification => {
    console.log(`${notification.xUsername}: ${notification.status} klo ${notification.timestamp}`);
  });
}

Python integraatio

Python-työnkulkuille, tässä on luokka, joka hoitaa tilausten hallinnan ja ilmoitusten pollauksen:

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):
        """Lisää uusi X-tili seurattavaksi"""
        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):
        """Poista X-tili seurannasta"""
        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):
        """Hae ilmoitushistoria sivutuksella"""
        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):
        """Hae kaikki ilmoitukset aikaväliltä, sivutus käsiteltynä"""
        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):
        """Hae kaikki nykyiset tilaukset"""
        response = requests.get(
            f'{self.base_url}/subscriptions',
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()

# Esimerkki: Päivittäinen auditointiraportti
def generate_daily_report():
    api = WallaWhatsAPI('your_api_key_here')
    
    # Hae eilisen ilmoitukset
    end_time = int(time.time() * 1000)
    start_time = end_time - (24 * 60 * 60 * 1000)
    
    notifications = api.get_all_notifications(start_time, end_time)
    
    # Ryhmittele tilin ja tilan mukaan
    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
    
    # Tulosta yhteenveto
    print(f"Päivittäinen hälytysten raportti - {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']} hälytystä, {success_rate:.1f}% toimitettu")

Kanavien reitityksen ymmärtäminen

WALLAWHATS käyttää globaalia kanavan reititysmallia — jokainen hälytys jokaisesta tilauksesta haarautuu kaikkiin käytössä oleviin ja vahvistettuihin kanaviin. Et voi reitittää tiettyjä tilejä tiettyihin kohteisiin API:n kautta (kuten “@elonmusk → WhatsApp, @vercel → sähköposti”).

Kanavien valinta tapahtuu tilin tasolla Kanavat-sivulla. Kun lisäät kanavan API:n kautta, se tulee saataville kaikille hälytyksille vahvistuksen jälkeen. Kun poistat kanavan, se lopettaa hälytysten vastaanottamisen kaikista tilauksista.

Tämä suunnittelu yksinkertaistaa automatisointia ja estää hälytysten pirstoutumisen. Sinun integraatiokoodisi ei tarvitse seurata tilauskohtaisia reitityshääntöjä — hallitse vain mitä tilejä seurata ja mitkä kanavat ottaa käyttöön.

Nopeusrajat ja kiintiöt

WALLAWHATS toteuttaa käyttäjätason nopeusmitat estääkseen hälytysroskan korkean aktiivisuuden jaksojen aikana:

  • Free: 2 hälytystä/tunti
  • Pro: 5 hälytystä/tunti
  • Pro+: 15 hälytystä/tunti
  • Business: 30 hälytystä/tunti
  • Enterprise: 100 hälytystä/tunti

Kun kiintiöt ylittyvät, ylimääräiset tweetit puskuroidaan tiivisteviesteihin ja toimitetaan 15 minuutin välein. API-integraatiosi näkee nämä erillisinä ilmoitustietueina — yhden välittömälle hälytykselle ja yhden jokaiselle tiivisteerälle.

API itsessään ei aseta erillisiä nopeusrajoja tilausten hallinnalle tai ilmoituskyselyille. Vältä kuitenkin päätepisteiden hakkausta tarpeettomilla pyynnöillä — välimuistita tilauslistat paikallisesti ja eräkäsittele ilmoituskyselyt tehokkaasti.

Virheiden käsittely ja vianmääritys

Yleisiä API-virhemalleja ja kuinka käsitellä niitä:

Todennusvirheet (401):

  • Tarkista, että API-avaimesi on oikea eikä ole peruutettu
  • Varmista, että käytät x-api-key-headeria, ei Authorization

Tilauskonfliktit (409):

  • Tili jo seurannassa: Tilaus on olemassa, käsittele onnistumisena
  • Tili suojattu/yksityinen: WALLAWHATS kieltäytyy näistä suunnittelun mukaan

Nopeusrajat (429):

  • Keskeytä eksponentiaalisesti ennen uudelleenyritystä
  • Tarkista lähestytkö pakettirajoja seurattavissa tileissä

Kanavan vahvistusongelmat:

  • Uudet kanavat vaativat OTP-vahvistuksen ennen hälytysten vastaanottoa
  • Ohjelmallisesti lisätyt kanavat eivät toimi ennen kuin käyttäjä suorittaa vahvistuksen

Integraatioidesi seuranta ja hälyttäminen

Koska WALLAWHATS muuttuu kriittiseksi infrastruktuuriksi liiketoiminnan työnkulkuihin integroituna, seuraa integraatiosi terveyttä:

Tilaussiirtymien tunnistus:

// Tarkista, että odotetut tilaukset ovat edelleen aktiivisia
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(`Puuttuvat tilaukset: ${missing.join(', ')}`);
  }
  
  return missing;
}

Toimituksen onnistumisasteen seuranta:

def check_delivery_health():
    # Tarkista viimeiset 6 tuntia
    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:
        # Hälytä ops-tiimillesi
        print(f"VAROITUS: Toimituksen onnistumisaste putosi {success_rate:.1f}%:iin")
    
    return success_rate

Integraatiomalleja ja parhaita käytäntöjä

Webhook-tyylinen käsittely: Vaikka WALLAWHATS ei tarjoa webhookkeja suoraan, voit pollaata ilmoitusten päätepistettä uusien hälytysten hakemiseksi ja käsitellä niitä lähes reaaliajassa:

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') {
      // Käsittele hälytys - lähetä Slackiin, päivitä tietokanta, jne.
      await processAlert(notification);
    }
  }
  
  localStorage.setItem('lastNotificationCheck', now);
}

// Pollaa 30 sekunnin välein
setInterval(pollForNewAlerts, 30000);

Ehdollinen tilausten hallinta: Lisää tai poista tilauksia dynaamisesti ulkoisten laukaisimien perusteella:

def update_competitor_monitoring(portfolio_companies):
    """Päivitä X-seuranta nykyisen salkun perusteella"""
    current_subs = {s['xUsername'] for s in api.list_subscriptions()}
    
    # Tilit, joita meidän tulisi seurata
    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'])
    
    # Lisää puuttuvat tilaukset
    for account in target_accounts - current_subs:
        try:
            api.add_subscription(account)
            print(f"Aloitettu @{account} seuranta")
        except Exception as e:
            print(f"@{account} lisääminen epäonnistui: {e}")
    
    # Poista vanhentuneet tilaukset
    for account in current_subs - target_accounts:
        api.remove_subscription(account)
        print(f"Lopetettu @{account} seuranta")

WALLAWHATS API muuttaa reaaliaikaiset X-hälytykset manuaalisesta dashboard-työkalusta ohjelmoitavaksi infrastruktuurikomponentiksi. Rakennatpa mukautettuja tietotyönkulkuja, automatisoit brändin seurantaa tai luot white-label -ilmoituspalveluita, API tarjoaa tuotantointegraatioon tarvittavan kontrollin ja auditointikyvyt.

Haluatko laajentaa seurantaasi kilpailijoiden ulkopuolelle? Tutustu oppaaseemme crypto Twitter -seurantaan markkinasignaaleille tai opi kuinka toimittajat käyttävät WALLAWHATS:ia reaaliaikaiseen lähteiden seurantaan.

Älä koskaan jää paitsi tärkeästä julkaisusta. Luo ilmainen tili — 1 WhatsApp-numero, reaaliaikaiset hälytykset, luottokortia ei tarvita.

Share:
Takaisin Blogiin

Aiheeseen liittyvät artikkelit

Näytä kaikki artikkelit »