· Nacho Coll · Guides  · 8 minit bacaan

API Makluman X: Langganan Berprogram dan Sejarah Notifikasi

Bina integrasi tersuai di atas WALLAWHATS. Tambah dan buang langganan X, salur makluman ke saluran, tarik sejarah notifikasi — semua melalui REST.

Bina integrasi tersuai di atas WALLAWHATS. Tambah dan buang langganan X, salur makluman ke saluran, tarik sejarah notifikasi — semua melalui REST.

Apabila makluman X (Twitter) masa nyata menjadi penting untuk perniagaan anda, pengurusan papan pemuka manual mencapai had. Sama ada anda membina papan pemuka risikan pelanggan, mengautomatik alir kerja pemantauan jenama, atau mencipta sistem notifikasi tersuai untuk meja dagangan, anda memerlukan kawalan berprogram ke atas langganan makluman X anda.

WALLAWHATS menyediakan REST API yang membolehkan anda cipta, urus, dan audit langganan makluman X tanpa menyentuh antara muka web. Tambah atau buang akaun yang dipantau, tarik sejarah notifikasi dengan status penghantaran, dan integrasikan makluman X masa nyata ke dalam mana-mana sistem yang memahami HTTP.

API keys management page with create / revoke controls

Mengapa Gunakan API WALLAWHATS?

Papan pemuka berfungsi dengan baik untuk alir kerja manual, tetapi akses API membuka kunci senario automasi yang berkembang melebihi pengurusan manusia:

Platform Risikan Pelanggan: Secara automatik langgan kepada eksekutif pesaing yang baru dikenal pasti, ketua produk, atau penganalisis industri semasa mereka ditemui melalui alat penyelidikan atau integrasi CRM.

Alir Kerja Dagangan dan Kewangan: Pantau secara berprogram akaun kawal selia, pegangan CEO, atau wartawan khusus sektor berdasarkan perubahan portfolio atau peristiwa pasaran—tanpa pengurusan langganan manual.

Pemantauan Jenama Berskala: Tambah atau buang penjejakan sebutan jenama semasa kempen baharu dilancarkan, produk dihantar, atau situasi krisis berkembang.

Aplikasi SaaS Berbilang Penyewa: Pemantauan X masa nyata label putih untuk pelanggan anda, dengan pengurusan langganan berprogram di belakang tabir.

Sistem Pematuhan dan Audit: Tarik sejarah notifikasi lengkap dengan status penghantaran untuk pelaporan kawal selia, jejak audit dalaman, atau pemantauan SLA.

Pengesahan API dan Akses

Setiap pelan WALLAWHATS termasuk akses API dengan kuota kunci berskala:

  • Free: 1 kunci API
  • Pro: 1 kunci API
  • Pro+: 2 kunci API
  • Business: 5 kunci API
  • Enterprise: 20 kunci API

Pengesahan menggunakan header x-api-key (bukan Authorization: Bearer). Jana kunci anda dari bahagian API papan pemuka, dan layani mereka seperti kata laluan—mereka membawa keistimewaan akaun penuh.

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

Titik Akhir API Teras

API WALLAWHATS menyediakan lima kumpulan sumber utama untuk membina integrasi:

Pengurusan Langganan

Cipta langganan baharu:

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

{
  "xUsername": "elonmusk"
}

Senarai semua langganan:

GET /subscriptions
x-api-key: your_api_key_here

Buang langganan:

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

Perhatikan titik akhir padam mengambil handle X sebagai parameter laluan—bukan ID langganan dalaman.

Sejarah Notifikasi dan Audit

Tarik sejarah notifikasi dengan status penghantaran:

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

Titik akhir notifikasi mengembalikan keputusan berpagina dengan setiap baris mewakili satu makluman yang dihantar ke satu saluran. Nilai status termasuk:

  • queued: Makluman diterima, menunggu penghantaran
  • sent: Dihantar kepada pembekal saluran
  • delivered: Disahkan diterima oleh destinasi
  • read: Dibuka oleh penerima (WhatsApp sahaja, memerlukan resit baca dibolehkan)
  • failed: Percubaan penghantaran tidak berjaya

Pengurusan Saluran

Senarai saluran yang dikonfigur:

GET /channels
x-api-key: your_api_key_here

Tambah saluran baharu:

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

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

Buang saluran:

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

Tangkapan Skrin Tweet

Akses galeri tangkapan skrin:

GET /snapshots
x-api-key: your_api_key_here

Padam tangkapan skrin tertentu:

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

Membina Integrasi: Contoh Kod

Integrasi Node.js

Berikut adalah contoh Node.js yang menambah langganan dan menyoal untuk notifikasi baharu:

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

// Usage example
async function monitorCompetitor() {
  const client = new WallaWhatsClient('your_api_key_here');
  
  // Add a new subscription
  await client.addSubscription('vercel');
  console.log('Now monitoring @vercel');
  
  // Check recent notifications
  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}`);
  });
}

Integrasi Python

Untuk alir kerja Python, berikut adalah kelas yang mengendalikan pengurusan langganan dan soalan notifikasi:

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):
        """Add a new X account to monitor"""
        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):
        """Remove an X account from monitoring"""
        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):
        """Fetch notification history with pagination"""
        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):
        """Fetch all notifications in a time range, handling pagination"""
        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):
        """Get all current subscriptions"""
        response = requests.get(
            f'{self.base_url}/subscriptions',
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()

# Example: Daily audit report
def generate_daily_report():
    api = WallaWhatsAPI('your_api_key_here')
    
    # Get yesterday's notifications
    end_time = int(time.time() * 1000)
    start_time = end_time - (24 * 60 * 60 * 1000)
    
    notifications = api.get_all_notifications(start_time, end_time)
    
    # Group by account and status
    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
    
    # Print summary
    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")

Memahami Penghalaan Saluran

WALLAWHATS menggunakan model penghalaan saluran global—setiap makluman dari setiap langganan menyebar ke semua saluran yang dibolehkan dan disahkan. Anda tidak boleh halakan akaun tertentu ke destinasi tertentu melalui API (seperti “@elonmusk → WhatsApp, @vercel → emel”).

Pemilihan saluran berlaku di peringkat akaun pada halaman Saluran. Apabila anda menambah saluran melalui API, ia tersedia untuk semua makluman setelah disahkan. Apabila anda membuang saluran, ia berhenti menerima makluman dari semua langganan.

Reka bentuk ini memudahkan automasi sambil menghalang pemecahan makluman. Kod integrasi anda tidak perlu menjejak peraturan penghalaan setiap langganan—hanya urus akaun mana yang perlu dipantau dan saluran mana yang perlu dibolehkan.

Had Kadar dan Had Kelajuan

WALLAWHATS melaksanakan had kelajuan peringkat pengguna untuk menghalang spam makluman semasa tempoh aktiviti tinggi:

  • Free: 2 makluman/jam
  • Pro: 5 makluman/jam
  • Pro+: 15 makluman/jam
  • Business: 30 makluman/jam
  • Enterprise: 100 makluman/jam

Apabila had kelajuan dilampaui, tweet tambahan ditimbal ke dalam mesej ringkasan dan dihantar setiap 15 minit. Integrasi API anda akan melihat ini sebagai rekod notifikasi berasingan—satu untuk makluman segera, dan satu untuk setiap kelompok ringkasan.

API itu sendiri tidak mengenakan had kadar berasingan pada pengurusan langganan atau pertanyaan notifikasi. Walau bagaimanapun, elakkan membombardir titik akhir dengan permintaan yang tidak perlu—cache senarai langganan secara tempatan dan kelompokkan pertanyaan notifikasi dengan cekap.

Pengendalian Ralat dan Penyelesaian Masalah

Corak ralat API biasa dan cara mengendalikannya:

Kegagalan pengesahan (401):

  • Sahkan kunci API anda betul dan belum dibatalkan
  • Pastikan anda menggunakan header x-api-key, bukan Authorization

Konflik langganan (409):

  • Akaun sudah dipantau: Langganan wujud, anggap sebagai berjaya
  • Akaun dilindungi/peribadi: WALLAWHATS menolak ini mengikut reka bentuk

Had kadar (429):

  • Berundur secara eksponen sebelum mencuba semula
  • Periksa sama ada anda menghampiri had pelan pada akaun yang dipantau

Isu pengesahan saluran:

  • Saluran baharu memerlukan pengesahan OTP sebelum menerima makluman
  • Saluran yang ditambah secara berprogram tidak akan berfungsi sehingga pengguna melengkapkan pengesahan

Memantau dan Memberi Makluman untuk Integrasi Anda

Memandangkan WALLAWHATS menjadi infrastruktur kritikal apabila diintegrasikan ke dalam alir kerja perniagaan, pantau kesihatan integrasi anda:

Pengesanan Hanyutan Langganan:

// Check if expected subscriptions are still active
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;
}

Pemantauan Kadar Kejayaan Penghantaran:

def check_delivery_health():
    # Check last 6 hours
    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:
        # Alert your ops team
        print(f"WARNING: Delivery success rate dropped to {success_rate:.1f}%")
    
    return success_rate

Corak Integrasi dan Amalan Terbaik

Pemprosesan Gaya Webhook: Walaupun WALLAWHATS tidak menyediakan webhook secara langsung, anda boleh menyoal titik akhir notifikasi untuk makluman baharu dan memprosesnya dalam masa nyata hampir:

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') {
      // Process the alert - send to Slack, update database, etc.
      await processAlert(notification);
    }
  }
  
  localStorage.setItem('lastNotificationCheck', now);
}

// Poll every 30 seconds
setInterval(pollForNewAlerts, 30000);

Pengurusan Langganan Bersyarat: Secara dinamik tambah atau buang langganan berdasarkan pencetus luaran:

def update_competitor_monitoring(portfolio_companies):
    """Update X monitoring based on current portfolio"""
    current_subs = {s['xUsername'] for s in api.list_subscriptions()}
    
    # Accounts we should be monitoring
    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'])
    
    # Add missing subscriptions
    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}")
    
    # Remove outdated subscriptions
    for account in current_subs - target_accounts:
        api.remove_subscription(account)
        print(f"Stopped monitoring @{account}")

API WALLAWHATS mengubah makluman X masa nyata dari alat papan pemuka manual kepada komponen infrastruktur yang boleh diprogram. Sama ada anda membina alir kerja risikan tersuai, mengautomatik pemantauan jenama, atau mencipta perkhidmatan notifikasi label putih, API menyediakan kawalan dan keupayaan audit yang diperlukan untuk integrasi produksi.

Ingin mengembangkan pemantauan anda melebihi pesaing? Lihat panduan kami mengenai memantau crypto Twitter untuk isyarat pasaran atau pelajari bagaimana wartawan menggunakan WALLAWHATS untuk pemantauan sumber masa nyata.

Jangan pernah terlepas pos penting lagi. Cipta akaun percuma — 1 nombor WhatsApp, makluman masa nyata, tiada kad kredit diperlukan.

Share:
Kembali ke Blog

Artikel Berkaitan

Lihat Semua Artikel »