· Nacho Coll · Guides · 8 min čtení
X Alerts API: Programové odběry a historie notifikací
Vybudujte si vlastní integrace na platformě WALLAWHATS. Přidávejte a odebírejte odběry X-u, směrujte upozornění do kanálů, stahujte historii notifikací — vše přes REST.
Když se upozornění na X (Twitter) v reálném čase stanou pro váš byznys klíčovými, ruční správa přes dashboard narazí na své limity. Ať už stavíte zákaznické dashboardy, automatizujete pracovní postupy pro monitorování značky, nebo vytváříte vlastní notifikační systémy pro obchodní týmy, potřebujete programové ovládání svých odběrů upozornění na X.
WALLAWHATS poskytuje REST API, které vám umožní vytvářet, spravovat a auditovat odběry upozornění na X bez nutnosti používat webové rozhraní. Přidávejte nebo odebírejte monitorované účty, stahujte historii notifikací se statusem doručení a integrujte upozornění na X v reálném čase do jakéhokoli systému, který rozumí HTTP.
Proč použít WALLAWHATS API?
Dashboard funguje skvěle pro ruční procesy, ale přístup k API odemyká automatizační scénáře, které se škálují nad rámec lidské správy:
Platformy zákaznické inteligence: Automaticky se přihlašte k odběru nově identifikovaných vedoucích pracovníků konkurence, produktových lídrů nebo odvětvových analytiků, jak jsou objevováni přes výzkumné nástroje nebo CRM integrace.
Obchodní a finanční procesy: Programově monitorujte regulační účty, CEO profily nebo novinářů specializující se na konkrétní sektory na základě změn portfolia nebo tržních událostí—bez ruční správy odběrů.
Monitorování značky ve velkém měřítku: Přidávejte nebo odebírejte sledování zmínek značky při spuštění nových kampaní, uvedení produktů na trh nebo vzniku krizových situací.
Multi-tenant SaaS aplikace: White-label monitorování X-u v reálném čase pro vaše zákazníky s programovou správou odběrů na pozadí.
Compliance a auditní systémy: Stahujte kompletní historii notifikací se statusem doručení pro regulační reporty, interní auditní záznamy nebo monitorování SLA.
API autentifikace a přístup
Každý plán WALLAWHATS obsahuje přístup k API se škálováním kvót klíčů:
- Free: 1 API klíč
- Pro: 1 API klíč
- Pro+: 2 API klíče
- Business: 5 API klíčů
- Enterprise: 20 API klíčů
Autentifikace používá hlavičku x-api-key (ne Authorization: Bearer). Vygenerujte své klíče z API sekce dashboardu a zacházejte s nimi jako s hesly—nesou plná oprávnění účtu.
curl -H "x-api-key: your_api_key_here" \
https://api.wallawhats.com/subscriptionsHlavní API endpointy
WALLAWHATS API poskytuje pět hlavních skupin zdrojů pro vytváření integrací:
Správa odběrů
Vytvořte nový odběr:
POST /subscriptions
Content-Type: application/json
x-api-key: your_api_key_here
{
"xUsername": "elonmusk"
}Vypište všechny odběry:
GET /subscriptions
x-api-key: your_api_key_hereOdeberte odběr:
DELETE /subscriptions/elonmusk
x-api-key: your_api_key_herePozor, delete endpoint bere handle na X-u jako parametr cesty—ne interní ID odběru.
Historie notifikací a audit
Stáhněte historii notifikací se statusem doručení:
GET /notifications?from=1704067200000&to=1704153600000
x-api-key: your_api_key_hereEndpoint notifications vrací stránkované výsledky s každým řádkem představujícím jedno upozornění doručené do jednoho kanálu. Hodnoty statusu zahrnují:
queued: Upozornění přijato, čeká na doručenísent: Odesláno poskytovateli kanáludelivered: Potvrzeno přijetí cílemread: Otevřeno příjemcem (pouze WhatsApp, vyžaduje povolené potvrzení přečtení)failed: Pokus o doručení neúspěšný
Správa kanálů
Vypište nakonfigurované kanály:
GET /channels
x-api-key: your_api_key_herePřidejte nový kanál:
POST /channels
Content-Type: application/json
x-api-key: your_api_key_here
{
"type": "email",
"destination": "alerts@yourcompany.com"
}Odeberte kanál:
DELETE /channels/channel_id_here
x-api-key: your_api_key_hereSnímky tweetů
Přistupte k galerii snímků:
GET /snapshots
x-api-key: your_api_key_hereSmažte konkrétní snímek:
DELETE /snapshots/tweet_id_here
x-api-key: your_api_key_hereTvorba integrací: Příklady kódu
Node.js integrace
Zde je příklad Node.js, který přidá odběr a zjišťuje nové notifikace:
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}`);
}
}
}
// Příklad použití
async function monitorCompetitor() {
const client = new WallaWhatsClient('your_api_key_here');
// Přidejte nový odběr
await client.addSubscription('vercel');
console.log('Nyní monitorujeme @vercel');
// Zkontrolujte nedávné notifikace
const oneDayAgo = Date.now() - (24 * 60 * 60 * 1000);
const notifications = await client.getNotifications(oneDayAgo, Date.now());
console.log(`Nalezeno ${notifications.items.length} nedávných upozornění`);
notifications.items.forEach(notification => {
console.log(`${notification.xUsername}: ${notification.status} v ${notification.timestamp}`);
});
}Python integrace
Pro Python pracovní postupy zde je třída, která zvládá správu odběrů a zjišťování notifikací:
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):
"""Přidejte nový X účet k monitorování"""
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):
"""Odeberte X účet z monitorování"""
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):
"""Získejte historii notifikací se stránkováním"""
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):
"""Získejte všechny notifikace v časovém rozmezí, zpracujte stránkování"""
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):
"""Získejte všechny aktuální odběry"""
response = requests.get(
f'{self.base_url}/subscriptions',
headers=self.headers
)
response.raise_for_status()
return response.json()
# Příklad: Denní auditní report
def generate_daily_report():
api = WallaWhatsAPI('your_api_key_here')
# Získejte včerejší notifikace
end_time = int(time.time() * 1000)
start_time = end_time - (24 * 60 * 60 * 1000)
notifications = api.get_all_notifications(start_time, end_time)
# Seskupte podle účtu a statusu
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
# Tisk shrnutí
print(f"Denní report upozornění - {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']} upozornění, {success_rate:.1f}% doručeno")Porozumění směrování kanálů
WALLAWHATS používá globální model směrování kanálů—každé upozornění od každého odběru se rozešle do všech povolených a ověřených kanálů. Nemůžete směrovat konkrétní účty do konkrétních cílů přes API (jako “@elonmusk → WhatsApp, @vercel → email”).
Výběr kanálu se děje na úrovni účtu na stránce Kanály. Když přidáte kanál přes API, stane se dostupným pro všechna upozornění po ověření. Když kanál odeberete, přestane přijímat upozornění ze všech odběrů.
Tento design zjednodušuje automatizaci a zároveň předchází fragmentaci upozornění. Váš integrační kód nemusí sledovat pravidla směrování podle odběru—jen spravujte, které účty monitorovat a které kanály povolit.
Rychlostní limity a rychlostní stropy
WALLAWHATS implementuje rychlostní stropy na úrovni uživatele, aby předešlo spamu upozornění během období vysoké aktivity:
- Free: 2 upozornění/hodina
- Pro: 5 upozornění/hodina
- Pro+: 15 upozornění/hodina
- Business: 30 upozornění/hodina
- Enterprise: 100 upozornění/hodina
Když jsou rychlostní stropy překročeny, další tweety jsou uloženy do zásobníku digest zpráv a doručovány každých 15 minut. Vaše API integrace to uvidí jako samostatné záznamy notifikací—jeden pro okamžité upozornění a jeden pro každou digest dávku.
API samotné neukládá samostatné rychlostní limity na správu odběrů nebo dotazy na notifikace. Nicméně vyhněte se bombardování endpointů zbytečnými požadavky—lokálně cachujte seznamy odběrů a efektivně dávkujte dotazy na notifikace.
Zpracování chyb a řešení problémů
Běžné vzory API chyb a jak je řešit:
Selhání autentifikace (401):
- Ověřte, že váš API klíč je správný a nebyl zrušen
- Ujistěte se, že používáte hlavičku
x-api-key, neAuthorization
Konflikty odběrů (409):
- Účet již monitorován: Odběr existuje, považujte za úspěch
- Účet chráněný/soukromý: WALLAWHATS to záměrně odmítá
Rychlostní omezení (429):
- Exponenciálně ustupte před opakováním
- Zkontrolujte, zda se blížíte limitům plánu na monitorované účty
Problémy s ověřením kanálu:
- Nové kanály vyžadují OTP ověření před přijímáním upozornění
- Programově přidané kanály nebudou fungovat, dokud uživatel nedokončí ověření
Monitorování a upozorňování vašich integrací
Protože se WALLAWHATS stává kritickou infrastrukturou při integraci do byznysových procesů, monitorujte zdraví své integrace:
Detekce drift odběrů:
// Zkontrolujte, zda očekávané odběry jsou stále aktivní
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(`Chybějící odběry: ${missing.join(', ')}`);
}
return missing;
}Monitorování úspěšnosti doručení:
def check_delivery_health():
# Zkontrolujte posledních 6 hodin
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:
# Upozorni svůj ops tým
print(f"VAROVÁNÍ: Úspěšnost doručení klesla na {success_rate:.1f}%")
return success_rateIntegrační vzory a nejlepší postupy
Zpracování ve stylu webhook: Ačkoli WALLAWHATS neposkytuje přímo webhooky, můžete dotazovat endpoint notifikací na nová upozornění a zpracovávat je téměř v reálném čase:
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') {
// Zpracujte upozornění - pošlete do Slacku, aktualizujte databázi, atd.
await processAlert(notification);
}
}
localStorage.setItem('lastNotificationCheck', now);
}
// Dotazujte každých 30 sekund
setInterval(pollForNewAlerts, 30000);Podmíněná správa odběrů: Dynamicky přidávejte nebo odebírejte odběry na základě externích spouštěčů:
def update_competitor_monitoring(portfolio_companies):
"""Aktualizujte monitorování X-u na základě aktuálního portfolia"""
current_subs = {s['xUsername'] for s in api.list_subscriptions()}
# Účty, které bychom měli monitorovat
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'])
# Přidejte chybějící odběry
for account in target_accounts - current_subs:
try:
api.add_subscription(account)
print(f"Začali jsme monitorovat @{account}")
except Exception as e:
print(f"Nepodařilo se přidat @{account}: {e}")
# Odeberte zastaralé odběry
for account in current_subs - target_accounts:
api.remove_subscription(account)
print(f"Přestali jsme monitorovat @{account}")WALLAWHATS API transformuje upozornění na X v reálném čase z ručního nástroje dashboardu na programovatelnou komponentu infrastruktury. Ať už stavíte vlastní inteligentní pracovní postupy, automatizujete monitorování značky, nebo vytváříte white-label notifikační služby, API poskytuje kontrolu a auditní schopnosti potřebné pro produkční integraci.
Chcete rozšířit své monitorování nad rámec konkurence? Podívejte se na našeho průvodce monitorováním krypto Twitteru pro tržní signály nebo se dozvědte, jak novináři používají WALLAWHATS pro monitorování zdrojů v reálném čase.
Nikdy znovu nezmeškejte důležitý post. Vytvořte si bezplatný účet — 1 WhatsApp číslo, upozornění v reálném čase, nevyžaduje kreditní kartu.
