· Nacho Coll · Guides · 8 min czytania
API Alertów X: Programowe Subskrypcje i Historia Powiadomień
Zbuduj własne integracje na bazie WALLAWHATS. Dodawaj i usuwaj subskrypcje X, kieruj alerty do kanałów, pobieraj historię powiadomień — wszystko przez REST.
Gdy alerty X (Twitter) w czasie rzeczywistym stają się krytyczne dla Twojego biznesu, manualne zarządzanie przez dashboard przestaje wystarczać. Czy budujesz dashboardy customer intelligence, automatyzujesz workflow monitoringu marki, czy tworzysz własne systemy powiadomień dla trading desków — potrzebujesz programowej kontroli nad subskrypcjami alertów X.
WALLAWHATS udostępnia REST API, które pozwala tworzyć, zarządzać i auditować subskrypcje alertów X bez dotykania interfejsu web. Dodawaj lub usuwaj monitorowane konta, pobieraj historię powiadomień ze statusem dostarczenia i integruj alerty X w czasie rzeczywistym z dowolnym systemem obsługującym HTTP.
Po co używać API WALLAWHATS?
Dashboard świetnie sprawdza się w ręcznych workflow, ale dostęp API odblokowuje scenariusze automatyzacji, które skalują się poza ludzkie zarządzanie:
Platformy Customer Intelligence: Automatycznie subskrybuj nowo wykrytych dyrektorów konkurencji, product leadów czy analityków branżowych w miarę ich odkrywania przez narzędzia research lub integracje CRM.
Trading i Workflow Finansowe: Programowo monitoruj konta regulacyjne, profile CEO czy dziennikarzy z konkretnych sektorów na podstawie zmian w portfolio lub wydarzeń rynkowych — bez ręcznego zarządzania subskrypcjami.
Monitoring Marki na Skalę: Dodawaj lub usuwaj tracking wzmianek o marce w miarę startowania nowych kampanii, wprowadzania produktów czy rozwoju sytuacji kryzysowych.
Aplikacje SaaS Multi-Tenant: White-label monitoring X w czasie rzeczywistym dla Twoich klientów, z programowym zarządzaniem subskrypcjami w tle.
Systemy Compliance i Audit: Pobieraj pełną historię powiadomień ze statusem dostarczenia dla raportowania regulacyjnego, wewnętrznych audit trailów czy monitoringu SLA.
Uwierzytelnianie API i Dostęp
Każdy plan WALLAWHATS zawiera dostęp API z skalowanymi limitami kluczy:
- Free: 1 klucz API
- Pro: 1 klucz API
- Pro+: 2 klucze API
- Business: 5 kluczy API
- Enterprise: 20 kluczy API
Uwierzytelnianie używa nagłówka x-api-key (nie Authorization: Bearer). Generuj klucze z sekcji API w dashboard i traktuj je jak hasła — mają pełne uprawnienia konta.
curl -H "x-api-key: twoj_klucz_api_tutaj" \
https://api.wallawhats.com/subscriptionsPodstawowe Endpointy API
API WALLAWHATS oferuje pięć głównych grup zasobów do budowy integracji:
Zarządzanie Subskrypcjami
Utwórz nową subskrypcję:
POST /subscriptions
Content-Type: application/json
x-api-key: twoj_klucz_api_tutaj
{
"xUsername": "elonmusk"
}Wylistuj wszystkie subskrypcje:
GET /subscriptions
x-api-key: twoj_klucz_api_tutajUsuń subskrypcję:
DELETE /subscriptions/elonmusk
x-api-key: twoj_klucz_api_tutajZauważ, że endpoint delete przyjmuje handle X jako parametr path — nie wewnętrzny ID subskrypcji.
Historia Powiadomień i Audit
Pobierz historię powiadomień ze statusem dostarczenia:
GET /notifications?from=1704067200000&to=1704153600000
x-api-key: twoj_klucz_api_tutajEndpoint notifications zwraca paginowane wyniki, gdzie każdy wiersz reprezentuje jeden alert dostarczony do jednego kanału. Wartości statusu to:
queued: Alert zaakceptowany, czeka na dostarczeniesent: Wysłany do dostawcy kanałudelivered: Potwierdzony jako otrzymany przez miejsce doceloweread: Otwarty przez odbiorcę (tylko WhatsApp, wymaga włączonych potwierdzeń odczytu)failed: Próba dostarczenia nieudana
Zarządzanie Kanałami
Wylistuj skonfigurowane kanały:
GET /channels
x-api-key: twoj_klucz_api_tutajDodaj nowy kanał:
POST /channels
Content-Type: application/json
x-api-key: twoj_klucz_api_tutaj
{
"type": "email",
"destination": "alerts@twojafirma.com"
}Usuń kanał:
DELETE /channels/channel_id_tutaj
x-api-key: twoj_klucz_api_tutajSnapshoty Tweetów
Uzyskaj dostęp do galerii snapshotów:
GET /snapshots
x-api-key: twoj_klucz_api_tutajUsuń konkretny snapshot:
DELETE /snapshots/tweet_id_tutaj
x-api-key: twoj_klucz_api_tutajBudowanie Integracji: Przykłady Kodu
Integracja Node.js
Oto przykład Node.js, który dodaje subskrypcję i odpytuje o nowe powiadomienia:
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(`Nie udało się dodać subskrypcji: ${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(`Nie udało się pobrać powiadomień: ${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(`Nie udało się wylistować subskrypcji: ${error.response?.data?.message || error.message}`);
}
}
}
// Przykład użycia
async function monitorCompetitor() {
const client = new WallaWhatsClient('twoj_klucz_api_tutaj');
// Dodaj nową subskrypcję
await client.addSubscription('vercel');
console.log('Teraz monitujemy @vercel');
// Sprawdź najnowsze powiadomienia
const oneDayAgo = Date.now() - (24 * 60 * 60 * 1000);
const notifications = await client.getNotifications(oneDayAgo, Date.now());
console.log(`Znaleziono ${notifications.items.length} najnowszych alertów`);
notifications.items.forEach(notification => {
console.log(`${notification.xUsername}: ${notification.status} o ${notification.timestamp}`);
});
}Integracja Python
Dla workflow Python, oto klasa obsługująca zarządzanie subskrypcjami i odpytywanie powiadomień:
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):
"""Dodaj nowe konto X do monitorowania"""
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):
"""Usuń konto X z monitorowania"""
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):
"""Pobierz historię powiadomień z paginacją"""
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):
"""Pobierz wszystkie powiadomienia w zakresie czasowym, obsługując paginację"""
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):
"""Pobierz wszystkie obecne subskrypcje"""
response = requests.get(
f'{self.base_url}/subscriptions',
headers=self.headers
)
response.raise_for_status()
return response.json()
# Przykład: Dzienny raport audytowy
def generate_daily_report():
api = WallaWhatsAPI('twoj_klucz_api_tutaj')
# Pobierz wczorajsze powiadomienia
end_time = int(time.time() * 1000)
start_time = end_time - (24 * 60 * 60 * 1000)
notifications = api.get_all_notifications(start_time, end_time)
# Grupuj według konta i 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
# Wydrukuj podsumowanie
print(f"Dzienny Raport Alertów - {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']} alertów, {success_rate:.1f}% dostarczonych")Rozumienie Routingu Kanałów
WALLAWHATS używa globalnego modelu routingu kanałów — każdy alert z każdej subskrypcji rozchodzi się do wszystkich włączonych i zweryfikowanych kanałów. Nie możesz routować konkretnych kont do konkretnych miejsc docelowych przez API (jak „@elonmusk → WhatsApp, @vercel → email”).
Wybór kanału odbywa się na poziomie konta na stronie Kanały. Kiedy dodajesz kanał przez API, staje się dostępny dla wszystkich alertów po weryfikacji. Kiedy usuwasz kanał, przestaje otrzymywać alerty ze wszystkich subskrypcji.
Ten design upraszcza automatyzację zapobiegając fragmentacji alertów. Twój kod integracji nie musi śledzić reguł routingu per-subskrypcja — wystarczy zarządzać, które konta monitorować i które kanały włączyć.
Limity Prędkości i Velocity Caps
WALLAWHATS implementuje velocity caps na poziomie użytkownika, aby zapobiec spamowi alertów w okresach wysokiej aktywności:
- Free: 2 alerty/godzinę
- Pro: 5 alertów/godzinę
- Pro+: 15 alertów/godzinę
- Business: 30 alertów/godzinę
- Enterprise: 100 alertów/godzinę
Gdy velocity caps są przekroczone, dodatkowe tweety są buforowane w wiadomościach digest i dostarczane co 15 minut. Twoja integracja API zobaczy je jako oddzielne rekordy powiadomień — jeden dla natychmiastowego alertu, i jeden dla każdej partii digest.
Samo API nie nakłada oddzielnych limitów prędkości na zarządzanie subskrypcjami czy zapytania o powiadomienia. Jednak unikaj bombardowania endpointów niepotrzebnymi żądaniami — cachuj listy subskrypcji lokalnie i batujuj zapytania o powiadomienia efektywnie.
Obsługa Błędów i Rozwiązywanie Problemów
Typowe wzorce błędów API i jak je obsługiwać:
Błędy uwierzytelniania (401):
- Sprawdź, czy Twój klucz API jest poprawny i nie został cofnięty
- Upewnij się, że używasz nagłówka
x-api-key, nieAuthorization
Konflikty subskrypcji (409):
- Konto już monitorowane: Subskrypcja istnieje, traktuj jako sukces
- Konto chronione/prywatne: WALLAWHATS odmawia ich z założenia
Rate limiting (429):
- Wycofaj się wykładniczo przed ponowną próbą
- Sprawdź, czy zbliżasz się do limitów planu na monitorowanych kontach
Problemy z weryfikacją kanału:
- Nowe kanały wymagają weryfikacji OTP przed otrzymywaniem alertów
- Kanały dodane programowo nie będą działać, aż użytkownik ukończy weryfikację
Monitorowanie i Alertowanie Twoich Integracji
Skoro WALLAWHATS staje się infrastrukturą krytyczną po zintegrowaniu w workflow biznesowe, monitoruj zdrowie swojej integracji:
Detekcja Dryfu Subskrypcji:
// Sprawdź, czy oczekiwane subskrypcje są nadal aktywne
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(`Brakujące subskrypcje: ${missing.join(', ')}`);
}
return missing;
}Monitorowanie Wskaźnika Sukcesu Dostarczenia:
def check_delivery_health():
# Sprawdź ostatnie 6 godzin
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:
# Powiadom swój zespół ops
print(f"OSTRZEŻENIE: Wskaźnik sukcesu dostarczenia spadł do {success_rate:.1f}%")
return success_rateWzorce Integracji i Najlepsze Praktyki
Przetwarzanie w Stylu Webhook: Chociaż WALLAWHATS nie oferuje webhook bezpośrednio, możesz odpytywać endpoint notifications o nowe alerty i przetwarzać je w czasie prawie rzeczywistym:
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') {
// Przetwórz alert - wyślij do Slack, zaktualizuj bazę danych, itp.
await processAlert(notification);
}
}
localStorage.setItem('lastNotificationCheck', now);
}
// Odpytuj co 30 sekund
setInterval(pollForNewAlerts, 30000);Warunkowe Zarządzanie Subskrypcjami: Dynamicznie dodawaj lub usuwaj subskrypcje na podstawie zewnętrznych wyzwalaczy:
def update_competitor_monitoring(portfolio_companies):
"""Aktualizuj monitoring X na podstawie obecnego portfolio"""
current_subs = {s['xUsername'] for s in api.list_subscriptions()}
# Konta, które powinniśmy monitorować
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'])
# Dodaj brakujące subskrypcje
for account in target_accounts - current_subs:
try:
api.add_subscription(account)
print(f"Rozpoczęto monitorowanie @{account}")
except Exception as e:
print(f"Nie udało się dodać @{account}: {e}")
# Usuń nieaktualne subskrypcje
for account in current_subs - target_accounts:
api.remove_subscription(account)
print(f"Zatrzymano monitorowanie @{account}")API WALLAWHATS przekształca alerty X w czasie rzeczywistym z ręcznego narzędzia dashboard w programowalny komponent infrastruktury. Czy budujesz własne workflow intelligence, automatyzujesz monitoring marki, czy tworzysz white-label usługi powiadomień, API oferuje kontrolę i możliwości audytu potrzebne do integracji produkcyjnej.
Chcesz rozszerzyć monitoring poza konkurentów? Sprawdź nasz przewodnik o monitorowaniu crypto Twitter dla sygnałów rynkowych lub dowiedz się, jak dziennikarze używają WALLAWHATS do monitorowania źródeł w czasie rzeczywistym.
Nigdy więcej nie przegap ważnego posta. Załóż darmowe konto — 1 numer WhatsAppa, alerty w czasie rzeczywistym, bez karty kredytowej.
