X Alerts API: การสมัครสมาชิกและประวัติการแจ้งเตือนแบบโปรแกรม

เมื่อการแจ้งเตือน X (Twitter) แบบเรียลไทม์กลายเป็นสิ่งสำคัญยิ่งสำหรับธุรกิจของคุณ การจัดการแดชบอร์ดแบบแมนนวลจะมีข้อจำกัด ไม่ว่าคุณจะกำลังสร้างแดชบอร์ดข่าวกรองลูกค้า ทำให้ขั้นตอนการติดตามแบรนด์เป็นไปโดยอัตโนมัติ หรือสร้างระบบแจ้งเตือนแบบกำหนดเองสำหรับโต๊ะเทรดดิง คุณต้องการการควบคุมแบบโปรแกรมเหนือการสมัครสมาชิกการแจ้งเตือน X ของคุณ

WALLAWHATS จัดหา REST API ที่ให้คุณสร้าง จัดการ และตรวจสอบการสมัครสมาชิกการแจ้งเตือน X โดยไม่ต้องแตะส่วนติดต่อเว็บ เพิ่มหรือลบบัญชีที่ติดตาม ดึงประวัติการแจ้งเตือนพร้อมสถานะการส่ง และผสานรวมการแจ้งเตือน X แบบเรียลไทม์เข้ากับระบบใดๆ ที่พูด HTTP ได้

API keys management page with create / revoke controls

ทำไมถึงใช้ WALLAWHATS API?

แดชบอร์ดใช้งานได้ดีสำหรับขั้นตอนการทำงานแบบแมนนวล แต่การเข้าถึง API ปลดล็อกสถานการณ์อัตโนมัติที่ขยายได้เกินการจัดการของมนุษย์:

แพลตฟอร์มข่าวกรองลูกค้า: สมัครสมาชิกผู้บริหารคู่แข่งที่เพิ่งระบุใหม่ หัวหน้าผลิตภัณฑ์ หรือนักวิเคราะห์อุตสาหกรรมโดยอัตโนมัติเมื่อค้นพบผ่านเครื่องมือวิจัยหรือการผสานรวม CRM

ขั้นตอนการเทรดและการเงิน: ติดตามบัญชีกำกับดูแล แฮนเดิล CEO หรือนักข่าวเฉพาะภาคส่วนแบบโปรแกรมตามการเปลี่ยนแปลงพอร์ตโฟลิโอหรือเหตุการณ์ตลาด—โดยไม่ต้องจัดการการสมัครสมาชิกแบบแมนนวล

การติดตามแบรนด์ในระดับใหญ่: เพิ่มหรือลบการติดตามการกล่าวถึงแบรนด์เมื่อแคมเปญใหม่เปิดตัว ผลิตภัณฑ์จัดส่ง หรือสถานการณ์วิกฤตเกิดขึ้น

แอปพลิเคชัน SaaS หลายผู้ใช้งาน: การติดตาม X แบบเรียลไทม์แบบไวท์เลเบลสำหรับลูกค้าของคุณ พร้อมการจัดการการสมัครสมาชิกแบบโปรแกรมเบื้องหลัง

ระบบการปฏิบัติตามและการตรวจสอบ: ดึงประวัติการแจ้งเตือนที่สมบูรณ์พร้อมสถานะการส่งสำหรับรายงานกำกับดูแล เส้นทางการตรวจสอบภายใน หรือการติดตาม SLA

การรับรองความถูกต้องและการเข้าถึง API

ทุกแพลน WALLAWHATS รวมการเข้าถึง API พร้อมโควต้าคีย์ที่ขยายได้:

Free: 1 API key
Pro: 1 API key
Pro+: 2 API keys
Business: 5 API keys
Enterprise: 20 API keys

การรับรองความถูกต้องใช้ header x-api-key (ไม่ใช่ Authorization: Bearer) สร้างคีย์ของคุณจากส่วน API ของแดชบอร์ด และปฏิบัติต่อมันเหมือนรหัสผ่าน—มันมีสิทธิ์เต็มบัญชี

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

Core API Endpoints

WALLAWHATS API จัดหากลุมทรัพยากรหลักห้ากลุ่มสำหรับสร้างการผสานรวม:

การจัดการการสมัครสมาชิก

สร้างการสมัครสมาชิกใหม่:

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

{
  "xUsername": "elonmusk"
}

แสดงรายการการสมัครสมาชิกทั้งหมด:

GET /subscriptions
x-api-key: your_api_key_here

ลบการสมัครสมาชิก:

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

สังเกต endpoint ลบใช้แฮนเดิล X เป็นพารามิเตอร์พาธ—ไม่ใช่ ID การสมัครสมาชิกภายใน

ประวัติและการตรวจสอบการแจ้งเตือน

ดึงประวัติการแจ้งเตือนพร้อมสถานะการส่ง:

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

Endpoint การแจ้งเตือนคืนค่าผลลัพธ์แบบแบ่งหน้าโดยแต่ละแถวแสดงการแจ้งเตือนหนึ่งครั้งที่ส่งไปยังช่องทางหนึ่ง ค่าสถานะรวม:

queued: การแจ้งเตือนได้รับ รอการส่ง
sent: จัดส่งไปยังผู้ให้บริการช่องทางแล้ว
delivered: ยืนยันได้รับแล้วจากปลายทาง
read: เปิดโดยผู้รับ (WhatsApp เท่านั้น ต้องเปิดการแจ้งการอ่าน)
failed: ความพยายามส่งไม่สำเร็จ

การจัดการช่องทาง

แสดงรายการช่องทางที่กำหนดค่า:

GET /channels
x-api-key: your_api_key_here

เพิ่มช่องทางใหม่:

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

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

ลบช่องทาง:

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

สแนปชอตทวีต

เข้าถึงแกลเลอรีสแนปชอต:

GET /snapshots
x-api-key: your_api_key_here

ลบสแนปชอตที่ระบุ:

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

การสร้างการผสานรวม: ตัวอย่างโค้ด

การผสานรวม Node.js

นี่คือตัวอย่าง Node.js ที่เพิ่มการสมัครสมาชิกและโพลล์สำหรับการแจ้งเตือนใหม่:

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

// ตัวอย่างการใช้งาน
async function monitorCompetitor() {
  const client = new WallaWhatsClient('your_api_key_here');
  
  // เพิ่มการสมัครสมาชิกใหม่
  await client.addSubscription('vercel');
  console.log('Now monitoring @vercel');
  
  // ตรวจสอบการแจ้งเตือนล่าสุด
  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}`);
  });
}

การผสานรวม Python

สำหรับขั้นตอนการทำงาน Python นี่คือคลาสที่จัดการการจัดการการสมัครสมาชิกและการโพลล์การแจ้งเตือน:

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):
        """เพิ่มบัญชี X ใหม่เพื่อติดตาม"""
        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):
        """ลบบัญชี X จากการติดตาม"""
        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):
        """ดึงประวัติการแจ้งเตือนพร้อมการแบ่งหน้า"""
        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):
        """ดึงการแจ้งเตือนทั้งหมดในช่วงเวลา จัดการการแบ่งหน้า"""
        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):
        """รับการสมัครสมาชิกปัจจุบันทั้งหมด"""
        response = requests.get(
            f'{self.base_url}/subscriptions',
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()

# ตัวอย่าง: รายงานตรวจสอบรายวัน
def generate_daily_report():
    api = WallaWhatsAPI('your_api_key_here')
    
    # รับการแจ้งเตือนของเมื่อวาน
    end_time = int(time.time() * 1000)
    start_time = end_time - (24 * 60 * 60 * 1000)
    
    notifications = api.get_all_notifications(start_time, end_time)
    
    # จัดกลุ่มตามบัญชีและสถานะ
    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(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")

การทำความเข้าใจการกำหนดเส้นทางช่องทาง

WALLAWHATS ใช้โมเดลการกำหนดเส้นทางช่องทางทั่วโลก—ทุกการแจ้งเตือนจากทุกการสมัครสมาชิกแผ่กระจายไปยังช่องทางที่เปิดใช้และตรวจสอบแล้วทั้งหมด คุณไม่สามารถกำหนดเส้นทางบัญชีเฉพาะไปยังปลายทางเฉพาะผ่าน API (เช่น “@elonmusk → WhatsApp, @vercel → email”)

การเลือกช่องทางเกิดขึ้นที่ระดับบัญชีในหน้า Channels เมื่อคุณเพิ่มช่องทางผ่าน API มันจะพร้อมใช้งานสำหรับการแจ้งเตือนทั้งหมดเมื่อตรวจสอบแล้ว เมื่อคุณลบช่องทาง มันจะหยุดรับการแจ้งเตือนจากการสมัครสมาชิกทั้งหมด

การออกแบบนี้ทำให้การอัตโนมัติง่ายขึ้นในขณะที่ป้องกันการกระจุกกระจายของการแจ้งเตือน โค้ดการผสานรวมของคุณไม่จำเป็นต้องติดตามกฎการกำหนดเส้นทางต่อการสมัครสมาชิก—เพียงจัดการบัญชีที่จะติดตามและช่องทางที่จะเปิดใช้

ขดจำกัดอัตราและขีดจำกัดความเร็ว

WALLAWHATS ใช้ขีดจำกัดความเร็วระดับผู้ใช้เพื่อป้องกันสแปมการแจ้งเตือนในช่วงกิจกรรมสูง:

Free: 2 การแจ้งเตือน/ชั่วโมง
Pro: 5 การแจ้งเตือน/ชั่วโมง
Pro+: 15 การแจ้งเตือน/ชั่วโมง
Business: 30 การแจ้งเตือน/ชั่วโมง
Enterprise: 100 การแจ้งเตือน/ชั่วโมง

เมื่อขีดจำกัดความเร็วเกิน ทวีตเพิ่มเติมจะถูกบัฟเฟอร์เป็นข้อความสรุปและส่งทุก 15 นาที การผสานรวม API ของคุณจะเห็นสิ่งเหล่านี้เป็นเรกคอร์ดการแจ้งเตือนแยก—หนึ่งสำหรับการแจ้งเตือนทันที และหนึ่งสำหรับแต่ละแบทช์สรุป

API เองไม่กำหนดขีดจำกัดอัตราแยกต่างหากในการจัดการการสมัครสมาชิกหรือการสอบถามการแจ้งเตือน อย่างไรก็ตาม หลีกเลี่ยงการทุบตี endpoints ด้วยคำขอที่ไม่จำเป็น—แคชรายการการสมัครสมาชิกในเครื่องและการสอบถามการแจ้งเตือนแบทช์ได้อย่างมีประสิทธิภาพ

การจัดการข้อผิดพลาดและการแก้ไขปัญหา

รูปแบบข้อผิดพลาด API ทั่วไปและวิธีจัดการ:

ความล้มเหลวในการรับรองความถูกต้อง (401):

ตรวจสอบ API key ของคุณถูกต้องและยังไม่ถูกเพิกถอน
ตรวจสอบให้แน่ใจว่าคุณใช้ header x-api-key ไม่ใช่ Authorization

การขัดแย้งการสมัครสมาชิก (409):

บัญชีติดตามแล้ว: การสมัครสมาชิกมีอยู่ ปฏิบัติเป็นสำเร็จ
บัญชีได้รับการปกป้อง/ส่วนตัว: WALLAWHATS ปฏิเสธสิ่งเหล่านี้โดยการออกแบบ

การจำกัดอัตรา (429):

ถอยหลังแบบเอกซ์โพเนนเชียลก่อนลองใหม่
ตรวจสอบว่าคุณใกล้ขีดจำกัดแพลนในบัญชีที่ติดตาม

ปัญหาการตรวจสอบช่องทาง:

ช่องทางใหม่ต้องการการตรวจสอบ OTP ก่อนรับการแจ้งเตือน
ช่องทางที่เพิ่มแบบโปรแกรมจะไม่ทำงานจนกว่าผู้ใช้จะทำการตรวจสอบให้เสร็จ

การติดตามและการแจ้งเตือนการผสานรวมของคุณ

เนื่องจาก WALLAWHATS กลายเป็นโครงสร้างพื้นฐานที่สำคัญเมื่อผสานรวมเข้ากับขั้นตอนการทำงานทางธุรกิจ ติดตามความสุขภาพการผสานรวมของคุณ:

การตรวจจับการเบี่ยงเบนการสมัครสมาชิก:

// ตรวจสอบว่าการสมัครสมาชิกที่คาดหวังยังคงใช้งานอยู่
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;
}

การติดตามอัตราความสำเร็จการส่ง:

def check_delivery_health():
    # ตรวจสอบ 6 ชั่วโมงที่ผ่านมา
    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:
        # แจ้งเตือนทีมปฏิบัติการของคุณ
        print(f"WARNING: Delivery success rate dropped to {success_rate:.1f}%")
    
    return success_rate

รูปแบบการผสานรวมและแนวทางปฏิบัติที่ดีที่สุด

การประมวลผลแบบ Webhook: ในขณะที่ WALLAWHATS ไม่ให้ webhooks โดยตรง คุณสามารถโพลล์ endpoint การแจ้งเตือนสำหรับการแจ้งเตือนใหม่และประมวลผลแบบเรียลไทม์ใกล้เคียง:

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') {
      // ประมวลผลการแจ้งเตือน - ส่งไป Slack อัปเดตฐานข้อมูล ฯลฯ
      await processAlert(notification);
    }
  }
  
  localStorage.setItem('lastNotificationCheck', now);
}

// โพลล์ทุก 30 วินาที
setInterval(pollForNewAlerts, 30000);

การจัดการการสมัครสมาชิกตามเงื่อนไข: เพิ่มหรือลบการสมัครสมาชิกอย่างไดนามิกตามทริกเกอร์ภายนอก:

def update_competitor_monitoring(portfolio_companies):
    """อัปเดตการติดตาม X ตามพอร์ตโฟลิโอปัจจุบัน"""
    current_subs = {s['xUsername'] for s in api.list_subscriptions()}
    
    # บัญชีที่เราควรติดตาม
    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'])
    
    # เพิ่มการสมัครสมาชิกที่ขาด
    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}")
    
    # ลบการสมัครสมาชิกที่ล้าสมัย
    for account in current_subs - target_accounts:
        api.remove_subscription(account)
        print(f"Stopped monitoring @{account}")

WALLAWHATS API เปลี่ยนการแจ้งเตือน X แบบเรียลไทม์จากเครื่องมือแดชบอร์ดแบบแมนนวลเป็นส่วน