Eine Verbindung, viele Themen
Ein einzelner SharpAPI-Stream kann alles abdecken, was Sie brauchen — mehrere Sportarten, mehrere Ligen, mehrere Buchmacher, mehrere Events sowie Quoten und jeden Opportunity-Typ — über einen einzigen Socket. Sie müssen fast nie einen Stream pro Filter öffnen.
Das gleichzeitige Stream-Limit pro Schlüssel beträgt standardmäßig 1 für jeden kostenpflichtigen Tarif, mit Newer-Wins-Verdrängung: Eine zweite Verbindung mit demselben Schlüssel verdrängt die ältere. Diese Seite zeigt die Muster, die eine einzige Verbindung ausreichend machen. Wenn Sie tatsächlich parallele Sockets benötigen (mehrere Prozesse / Maschinen), siehe Fleet & Multi-Prozess unten.
Warum eine Verbindung ausreichtPermalink zu diesem Abschnitt
Jeder Identitätsfilter am Stream-Endpoint akzeptiert eine komma-getrennte Liste, und der channel-Parameter (all) führt Quoten- und Opportunity-Events in denselben Event-Stream zusammen. Der Server pre-serialisiert jeden Zyklus einmal und wendet Ihre Filter pro Verbindung an, sodass weite Filter günstig sind — es gibt keinen Effizienznachteil dafür, alles, was Sie interessiert, über einen Socket zu abonnieren, statt es aufzuteilen.
| Filter | Einzelner Wert | Mehrere Werte |
|---|---|---|
sport | sport=basketball | sport=basketball,football,ice_hockey |
league | league=nba | league=nba,nfl,mlb,nhl |
sportsbook | sportsbook=draftkings | sportsbook=draftkings,fanduel,pinnacle |
market | market=moneyline | market=moneyline,point_spread,total_points |
event_id | event_id=evt_abc | event_id=evt_abc,evt_def,evt_ghi |
channel (SSE) | channel=odds | channel=all (Quoten + Opportunities), channel=all,low_hold (auch Low-Hold) |
channels (WS) | channels=ev | channels=ev,odds,arbitrage,middles,low_hold |
MusterPermalink zu diesem Abschnitt
Multi-Sport: NBA + NFL + MLB auf einem SocketPermalink zu diesem Abschnitt
Anstatt drei Streams zu öffnen, übergeben Sie alle drei Ligen an einen:
JavaScript
const rows = new Map(); // id -> full odds row
const es = new EventSource(
'https://api.sharpapi.io/api/v1/stream' +
'?channel=all' +
'&league=nba,nfl,mlb' +
'&api_key=YOUR_KEY'
);
// channel=all never resumes, so every connect is followed by a full snapshot: start empty
es.addEventListener('connected', () => rows.clear());
// Snapshot rows are full Odds objects (league included): store them by id.
// Opportunity chunks carry ev / arbitrage / middles instead of odds.
es.addEventListener('snapshot', (e) => {
for (const o of JSON.parse(e.data).odds ?? []) rows.set(o.id, o);
});
es.addEventListener('odds:update', (e) => {
const { odds, book } = JSON.parse(e.data);
for (const o of odds) {
// A delta row carries id + price fields only: merge it into the stored row, then read league off that
let row = rows.get(o.id);
if (row) Object.assign(row, o);
// A line that opened after your snapshot arrives as a full row
else if (o.sportsbook !== undefined) rows.set(o.id, (row = o));
else continue; // a delta for a row you never stored has no league to route by
routeByLeague(row);
}
});Quoten + jeder Opportunity-Typ auf einem SocketPermalink zu diesem Abschnitt
Setzen Sie channel=all,low_hold (SSE) oder schließen Sie jeden Opportunity-Typ, auch low_hold, in channels= (WS) ein:
SSE
const es = new EventSource(
'https://api.sharpapi.io/api/v1/stream?channel=all,low_hold&api_key=YOUR_KEY'
);
es.addEventListener('odds:update', handleOddsDelta);
es.addEventListener('ev:detected', handleEV);
es.addEventListener('arb:detected', handleArb);
es.addEventListener('middles:detected', handleMiddle);
es.addEventListener('low_hold:detected', handleLowHold);
// Each `:detected` payload is an envelope, not a bare array — in your handlers:
// const { opportunities, count, type } = JSON.parse(e.data);Der Server kennzeichnet jede Nachricht mit ihrem Event-Typ — Ihr Handler verteilt nach Event-Namen, genau so, als hätten Sie fünf separate Streams geöffnet.
Verfolgung von N spezifischen EventsPermalink zu diesem Abschnitt
Wenn Sie eng getaktete Updates zu einer festen Liste von Events haben möchten (z. B. zehn Spiele heute Abend), übergeben Sie sie alle an event_id=:
const eventIds = [
'nba_lal_bos_2026-04-30', 'nba_phx_dal_2026-04-30',
'nfl_kc_buf_2026-05-01', /* ... */
].join(',');
const es = new EventSource(
`https://api.sharpapi.io/api/v1/stream?channel=all&event_id=${eventIds}&api_key=YOUR_KEY`
);Dies ersetzt das Muster, einen /stream/events/{eventId}-Socket pro Event zu öffnen.
Pro-Buchmacher- oder Pro-Markt-AufteilungenPermalink zu diesem Abschnitt
Dasselbe Prinzip für Buchmacher und Märkte:
// Track Pinnacle sharp moves + DK/FD live prices, moneyline + spreads only:
const es = new EventSource(
'https://api.sharpapi.io/api/v1/stream' +
'?channel=odds' +
'&sportsbook=pinnacle,draftkings,fanduel' +
'&market=moneyline,point_spread' +
'&api_key=YOUR_KEY'
);Dynamisches Re-Subscribe (WebSocket)Permalink zu diesem Abschnitt
Die bidirektionale Steuerung von WebSocket erlaubt es Ihnen, Filter mitten in der Verbindung zu ändern, ohne den Socket zu trennen. Verwenden Sie dies, wenn sich Ihre Menge an “interessanten” Themen über den Tag ändert (z. B. Benutzer öffnet / schließt Ansichten in einem Dashboard):
const ws = new WebSocket('wss://ws.sharpapi.io?api_key=YOUR_KEY');
// Initial subscription
ws.onopen = () => ws.send(JSON.stringify({
type: 'subscribe',
channels: ['odds', 'ev'],
filters: { sport: ['basketball'], league: ['nba'] },
}));
// Later — user adds NFL to their dashboard
function addNFL() {
ws.send(JSON.stringify({
type: 'subscribe',
filters: { sport: ['basketball', 'football'], league: ['nba', 'nfl'] },
}));
}Siehe die WebSocket-API-Referenz für das vollständige Subscribe-Message-Schema.
Fleet & Multi-ProzessPermalink zu diesem Abschnitt
Der eine Fall, in dem eine einzelne Verbindung wirklich nicht funktioniert: separate Prozesse oder Maschinen, die keinen Socket teilen können. Beispiele:
- Zehn Trading-Bots, die auf zehn Maschinen laufen und jeweils einen eigenen Live-Feed benötigen.
- Worker-Pool, bei dem N Worker jeweils unabhängig einen Stream konsumieren.
- Backend-Service + Browser-Dashboard, beide als derselbe Benutzer authentifiziert.
Das Standardlimit von 1 Stream bedeutet, dass eine zweite Verbindung mit demselben Schlüssel die erste verdrängt (Close-Code 4001 displaced by newer session bei WS, Writer-Teardown bei SSE). Ein verdrängter Client sollte sich nicht automatisch neu verbinden: Der Slot wird von der neueren Sitzung gehalten, und eine Neuverbindung würde ihn sofort wieder verdrängen.
Flotte mit so vielen Prozessen wie Ihr Tarif Schlüssel enthält: Jeder API-Schlüssel hat einen eigenen unabhängigen Stream-Slot. Verwenden Sie einfach einen Schlüssel pro Prozess — kein Override und kein Add-on nötig. Die Kontingente sind klein: Hobby und Pro enthalten einen Schlüssel, Sharp zwei — meta.max_keys unter GET /api/v1/account/keys zeigt Ihres an — dieser Weg deckt also ohne Enterprise höchstens eine Flotte aus zwei Prozessen ab. Tarif- und Add-on-Details finden Sie unter Pricing.
Flotte größer als Ihr Schlüssellimit, oder ein einzelner Schlüssel für mehrere Streams: Der vorgesehene Ausweg ist eine maxStreams-Override pro Schlüssel, dimensioniert für die Flotte. Es ist ein kostenpflichtiges Add-on in jedem kostenpflichtigen Tarif, pro Schlüssel bereitgestellt — kontaktieren Sie sales@sharpapi.io, um ein höheres Limit für einen bestimmten Schlüssel setzen zu lassen.
Siehe Limits für gleichzeitige Streams und den Zuverlässigkeitsvertrag für die Verdrängungssemantik.
Für alles andere — selbst sehr breite Subscriptions — ermöglichen die obigen Muster, dass ein Socket abdeckt, was wie zehn separate Anliegen aussieht.
Serverseitige KostenPermalink zu diesem Abschnitt
Es gibt keinen Effizienzgrund für eine Aufteilung. Der Hot Path des Servers:
- Berechnet den Per-Cycle-Book-Diff einmal.
- Pre-serialisiert die ungefilterten geänderten/entfernten Payloads einmal.
- Wendet für jeden verbundenen Client dessen Filter an und serialisiert die passende Teilmenge (oder sendet die pre-serialisierten Bytes direkt, wenn der Client keine Inhaltsfilter hat).
Ein Client mit league=nba,nfl,mlb,nhl kostet fast genauso viel wie vier Clients mit jeweils einer Liga — abzüglich vier Sockets, vier TLS-Handshakes, vier Sätze HTTP-Header und vier connected/snapshot-Zyklen. Das Single-Connection-Muster ist auch besser für die Delta-Konsistenz: Sie sehen alle Updates in der Reihenfolge, in der der Server sie erzeugt hat, anstatt sie über Sockets mit unabhängigem Backpressure zu verschachteln.
Migrations-ChecklistePermalink zu diesem Abschnitt
Wenn Sie von einer Multi-Stream-Architektur migrieren:
- Identitätsfilter kombinieren — sammeln Sie jeden
sport-,league-,sportsbook-,market- undevent_id-Wert aus Ihren alten Streams und verbinden Sie sie mit Kommas in einer URL. - Verwenden Sie
channel=all(SSE;channel=all,low_hold, wenn Sie Low-Hold nutzen) oder jeden benötigtenchannels=-Wert (WS) statt eines Streams pro Event-Typ. - Verteilen Sie im Handler — lesen Sie
odds[].league/odds[].sportsbook/event.event, um Nachrichten intern genau wie zuvor zu routen. - Verwerfen Sie Ihre Reconnect-N-Mal-Logik — ein Socket bedeutet einen Reconnect-Pfad. SSE verbindet sich automatisch wieder; für WS siehe das Reconnect-Muster.
- Behalten Sie
min_ev/min_profit-Schwellwerte — diese verengen den Opportunity-Stream weiterhin serverseitig und reduzieren die Bandbreite.
Siehe auchPermalink zu diesem Abschnitt
- Streaming-Übersicht — Protokollvergleich und Schnellstart
- WebSocket-Streaming-Leitfaden — Subscribe-Nachrichten, Reconnect
- SSE-API-Referenz — vollständige Liste der Filterparameter
- WebSocket-API-Referenz — Subscribe-Schema, Close-Codes