· Nacho Coll · Guides · 9 min de citit
API pentru Alerte X: Abonamente Programatice și Istoric de Notificări
Construiește integrări personalizate pe baza WALLAWHATS. Adaugă și elimină abonamente X, direcționează alerte către canale, extrage istoricul notificărilor — totul prin REST.
Când alertele X (Twitter) în timp real devin critice pentru business-ul tău, managementul manual prin dashboard întâmpină obstacole. Fie că construiești dashboard-uri de inteligență clienți, automatizezi fluxuri de monitorizare brand sau creezi sisteme personalizate de notificări pentru desk-uri de tranzacționare, ai nevoie de control programatic asupra abonamentelor de alerte X.
WALLAWHATS oferă un API REST care îți permite să creezi, să gestionezi și să auditezi abonamentele de alerte X fără să atingi interfața web. Adaugă sau elimină conturi monitorizate, extrage istoricul notificărilor cu statutul de livrare și integrează alerte X în timp real în orice sistem care vorbește HTTP.
De Ce să Folosești API-ul WALLAWHATS?
Dashboard-ul funcționează excelent pentru fluxuri manuale, dar accesul API deblochează scenarii de automatizare care se scalează dincolo de managementul uman:
Platforme de Inteligență Clienți: Abonează-te automat la executivi concurenți nou identificați, lideri de produs sau analiști din industrie pe măsură ce sunt descoperiți prin instrumente de cercetare sau integrări CRM.
Fluxuri de Tranzacționare și Financiare: Monitorizează programatic conturi de reglementare, handle-uri de CEO sau jurnaliști specifici pe sectoare bazat pe schimbări de portofoliu sau evenimente de piață — fără management manual al abonamentelor.
Monitorizare Brand la Scară: Adaugă sau elimină urmărirea mențiunilor brand pe măsură ce se lansează noi campanii, se livrează produse sau se dezvoltă situații de criză.
Aplicații SaaS Multi-Tenant: Monitorizare X în timp real cu marcă albă pentru clienții tăi, cu management programatic al abonamentelor în fundal.
Sisteme de Conformitate și Audit: Extrage istoricul complet al notificărilor cu statutul de livrare pentru raportare de reglementare, urme de audit interne sau monitorizare SLA.
Autentificare și Acces API
Fiecare plan WALLAWHATS include acces API cu cote de chei scalabile:
- Free: 1 cheie API
- Pro: 1 cheie API
- Pro+: 2 chei API
- Business: 5 chei API
- Enterprise: 20 chei API
Autentificarea folosește header-ul x-api-key (nu Authorization: Bearer). Generează cheile din secțiunea API a dashboard-ului și tratează-le ca parolele — poartă privilegii complete ale contului.
curl -H "x-api-key: cheia_ta_api_aici" \
https://api.wallawhats.com/subscriptionsEndpoint-uri API Principale
API-ul WALLAWHATS oferă cinci grupuri principale de resurse pentru construirea integrărilor:
Managementul Abonamentelor
Creează un abonament nou:
POST /subscriptions
Content-Type: application/json
x-api-key: cheia_ta_api_aici
{
"xUsername": "elonmusk"
}Listează toate abonamentele:
GET /subscriptions
x-api-key: cheia_ta_api_aiciElimină un abonament:
DELETE /subscriptions/elonmusk
x-api-key: cheia_ta_api_aiciObservă că endpoint-ul de ștergere ia handle-ul X ca parametru de cale — nu un ID intern al abonamentului.
Istoric de Notificări și Audit
Extrage istoricul notificărilor cu statutul de livrare:
GET /notifications?from=1704067200000&to=1704153600000
x-api-key: cheia_ta_api_aiciEndpoint-ul notifications returnează rezultate paginate cu fiecare rând reprezentând o alertă livrată la un canal. Valorile de status includ:
queued: Alertă acceptată, așteaptă livrareasent: Expediată către furnizorul de canaldelivered: Confirmată primită de destinațieread: Deschisă de destinatar (doar WhatsApp, necesită confirmare de citire activată)failed: Tentativa de livrare nereușită
Managementul Canalelor
Listează canalele configurate:
GET /channels
x-api-key: cheia_ta_api_aiciAdaugă un canal nou:
POST /channels
Content-Type: application/json
x-api-key: cheia_ta_api_aici
{
"type": "email",
"destination": "alerts@company-ul_tau.com"
}Elimină un canal:
DELETE /channels/id_canal_aici
x-api-key: cheia_ta_api_aiciCapturi de Tweet-uri
Accesează galeria de capturi:
GET /snapshots
x-api-key: cheia_ta_api_aiciȘterge o captură specifică:
DELETE /snapshots/id_tweet_aici
x-api-key: cheia_ta_api_aiciConstruirea Integrărilor: Exemple de Cod
Integrare Node.js
Iată un exemplu Node.js care adaugă un abonament și întreabă pentru notificări noi:
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(`Nu s-a putut adăuga abonamentul: ${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(`Nu s-au putut prelua notificările: ${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(`Nu s-au putut lista abonamentele: ${error.response?.data?.message || error.message}`);
}
}
}
// Exemplu de utilizare
async function monitorCompetitor() {
const client = new WallaWhatsClient('cheia_ta_api_aici');
// Adaugă un abonament nou
await client.addSubscription('vercel');
console.log('Acum monitorizez @vercel');
// Verifică notificările recente
const oneDayAgo = Date.now() - (24 * 60 * 60 * 1000);
const notifications = await client.getNotifications(oneDayAgo, Date.now());
console.log(`Am găsit ${notifications.items.length} alerte recente`);
notifications.items.forEach(notification => {
console.log(`${notification.xUsername}: ${notification.status} la ${notification.timestamp}`);
});
}Integrare Python
Pentru fluxuri Python, iată o clasă care gestionează managementul abonamentelor și interogarea notificărilor:
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):
"""Adaugă un cont X nou pentru monitorizare"""
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):
"""Elimină un cont X din monitorizare"""
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):
"""Preluează istoricul notificărilor cu paginare"""
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):
"""Preluează toate notificările dintr-un interval de timp, gestionând paginarea"""
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):
"""Obține toate abonamentele curente"""
response = requests.get(
f'{self.base_url}/subscriptions',
headers=self.headers
)
response.raise_for_status()
return response.json()
# Exemplu: Raport de audit zilnic
def generate_daily_report():
api = WallaWhatsAPI('cheia_ta_api_aici')
# Obține notificările de ieri
end_time = int(time.time() * 1000)
start_time = end_time - (24 * 60 * 60 * 1000)
notifications = api.get_all_notifications(start_time, end_time)
# Grupează pe cont și 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
# Afișează rezumatul
print(f"Raport Zilnic de Alerte - {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']} alerte, {success_rate:.1f}% livrate")Înțelegerea Rutării Canalelor
WALLAWHATS folosește un model de rutare globală a canalelor — fiecare alertă de la fiecare abonament se distribuie la toate canalele activate și verificate. Nu poți ruta conturi specifice la destinații specifice prin API (cum ar fi “@elonmusk → WhatsApp, @vercel → email”).
Selecția canalelor se face la nivelul contului în pagina Canale. Când adaugi un canal prin API, acesta devine disponibil pentru toate alertele odată verificat. Când elimini un canal, acesta oprește primirea alertelor de la toate abonamentele.
Acest design simplifică automatizarea previne fragmentarea alertelor. Codul tău de integrare nu trebuie să urmărească reguli de rutare per-abonament — doar gestionează ce conturi să monitorizeze și ce canale să activeze.
Limite de Rată și Plafoane de Viteză
WALLAWHATS implementează plafoane de viteză la nivel de utilizator pentru a preveni spam-ul de alerte în perioade de activitate mare:
- Free: 2 alerte/oră
- Pro: 5 alerte/oră
- Pro+: 15 alerte/oră
- Business: 30 alerte/oră
- Enterprise: 100 alerte/oră
Când plafonul de viteză este depășit, tweet-urile suplimentare sunt grupate în mesaje de rezumat și livrate la fiecare 15 minute. Integrarea ta API va vedea acestea ca înregistrări separate de notificare — una pentru alerta imediată și una pentru fiecare lot de rezumat.
API-ul în sine nu impune limite de rată separate pe managementul abonamentelor sau interogările de notificări. Totuși, evită să bombardezi endpoint-urile cu cereri inutile — păstrează listele de abonamente local în cache și grupează interogările de notificări eficient.
Gestionarea Erorilor și Depanare
Tipare comune de erori API și cum să le gestionezi:
Eșecuri de autentificare (401):
- Verifică că cheia ta API este corectă și nu a fost revocată
- Asigură-te că folosești header-ul
x-api-key, nuAuthorization
Conflicte de abonament (409):
- Cont deja monitorizat: Abonamentul există, tratează ca succes
- Cont protejat/privat: WALLAWHATS refuză acestea prin design
Limitare de rată (429):
- Retrage-te exponențial înainte de a reîncerca
- Verifică dacă te apropii de limitele planului pe conturile monitorizate
Probleme de verificare canal:
- Canalele noi necesită verificare OTP înainte să primească alerte
- Canalele adăugate programatic nu vor funcționa până când utilizatorul completează verificarea
Monitorizarea și Alertarea Integrărilor Tale
Deoarece WALLAWHATS devine infrastructură critică când este integrat în fluxurile de business, monitorizează sănătatea integrării tale:
Detectarea Devierii Abonamentelor:
// Verifică dacă abonamentele așteptate sunt încă 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(`Abonamente lipsă: ${missing.join(', ')}`);
}
return missing;
}Monitorizarea Ratei de Succes la Livrare:
def check_delivery_health():
# Verifică ultimele 6 ore
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:
# Alertează echipa de operațiuni
print(f"ATENȚIE: Rata de succes la livrare a scăzut la {success_rate:.1f}%")
return success_rateTipare de Integrare și Cele Mai Bune Practici
Procesare în Stil Webhook: Deși WALLAWHATS nu oferă direct webhook-uri, poți interoga endpoint-ul notifications pentru alerte noi și să le procesezi în timp aproape real:
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') {
// Procesează alerta - trimite la Slack, actualizează baza de date, etc.
await processAlert(notification);
}
}
localStorage.setItem('lastNotificationCheck', now);
}
// Interogare la fiecare 30 de secunde
setInterval(pollForNewAlerts, 30000);Management Condițional al Abonamentelor: Adaugă sau elimină dinamic abonamente bazat pe trigger-e externe:
def update_competitor_monitoring(portfolio_companies):
"""Actualizează monitorizarea X bazată pe portofoliul curent"""
current_subs = {s['xUsername'] for s in api.list_subscriptions()}
# Conturi pe care ar trebui să le monitorizăm
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'])
# Adaugă abonamente lipsă
for account in target_accounts - current_subs:
try:
api.add_subscription(account)
print(f"Am început să monitorizez @{account}")
except Exception as e:
print(f"Nu s-a putut adăuga @{account}: {e}")
# Elimină abonamente depășite
for account in current_subs - target_accounts:
api.remove_subscription(account)
print(f"Am oprit monitorizarea @{account}")API-ul WALLAWHATS transformă alertele X în timp real dintr-un instrument de dashboard manual într-o componentă de infrastructură programabilă. Fie că construiești fluxuri de inteligență personalizate, automatizezi monitorizarea brand-ului sau creezi servicii de notificare cu marcă albă, API-ul oferă controlul și capacitățile de audit necesare pentru integrarea în producție.
Vrei să îți extinzi monitorizarea dincolo de concurenți? Consultă ghidul nostru despre monitorizarea crypto Twitter pentru semnale de piață sau învață cum folosesc jurnaliștii WALLAWHATS pentru monitorizarea surselor în timp real.
Nu rata niciodată o postare importantă. Creează un cont gratuit — 1 număr WhatsApp, alerte în timp real, fără card de credit necesar.
