Streaming-Übersicht

Client                           Server
  |                                |
  |--- GET /api/v1/stream ------->|
  |                                |
  |<-- event: connected ----------|  Stream established
  |<-- event: snapshot -----------|  Full current state
  |<-- event: odds:update --------|  Delta update
  |<-- event: odds:update --------|  Delta update
  |<-- event: ev:detected --------|  Opportunity (new or updated)
  |<-- event: heartbeat ----------|  Keep-alive (every 30s)
  |         ...                    |

// Local odds map — snapshot fills it, deltas merge into it
const oddsMap = new Map();
 
const eventSource = new EventSource(
  'https://api.sharpapi.io/api/v1/stream?channel=all&league=nba&api_key=YOUR_KEY'
);
 
eventSource.addEventListener('connected', (e) => {
  const { stream_id, resumed } = JSON.parse(e.data);
  // A full snapshot follows every connect except a resume (resumed === true,
  // `odds` channel only), which replays missed deltas into the state you hold.
  // A started resume can still fall back to a full snapshot; this short example
  // leaves that out — the Streaming Reliability Contract has the complete client.
  if (resumed !== true) oddsMap.clear();
  console.log('Stream connected:', stream_id);
});
 
eventSource.addEventListener('snapshot', (e) => {
  const { odds } = JSON.parse(e.data);
  if (!odds) return; // opportunity chunks carry `ev` / `arbitrage` / `middles` / `low_hold` instead
  for (const odd of odds) oddsMap.set(odd.id, odd);
  console.log('Snapshot chunk:', odds.length, 'odds');
});
 
eventSource.addEventListener('odds:update', (e) => {
  const { odds, book } = JSON.parse(e.data);
  // Delta only contains dynamic fields — merge into local state by ID
  for (const delta of odds) {
    const full = oddsMap.get(delta.id);
    if (full) Object.assign(full, delta);
    else oddsMap.set(delta.id, delta);
  }
  console.log(`${book}: ${odds.length} odds updated`);
});
 
eventSource.addEventListener('ev:detected', (e) => {
  // {opportunities, count, type}: new opportunities, or updated versions of ones already sent (same `id`)
  const { opportunities: opps } = JSON.parse(e.data);
  opps.forEach(opp => console.log(`+EV: ${opp.selection} at ${opp.ev_percentage}% EV`));
});
 
eventSource.addEventListener('heartbeat', () => {
  console.log('Connection alive');
});
 
eventSource.onerror = () => {
  console.log('Connection lost, auto-reconnecting...');
};

import EventSource from 'eventsource';
 
const oddsMap = new Map();
 
const es = new EventSource(
  'https://api.sharpapi.io/api/v1/stream?channel=odds&league=nba',
  { headers: { 'X-API-Key': 'YOUR_KEY' } }
);
 
es.addEventListener('snapshot', (e) => {
  const { odds } = JSON.parse(e.data);
  for (const odd of odds) oddsMap.set(odd.id, odd);
  console.log(`Received ${odds.length} initial odds`);
});
 
es.addEventListener('connected', (e) => {
  const { resumed } = JSON.parse(e.data);
  if (resumed !== true) oddsMap.clear();
});
 
es.addEventListener('odds:update', (e) => {
  const { odds, book } = JSON.parse(e.data);
  // Merge compact deltas into local state
  for (const delta of odds) {
    const full = oddsMap.get(delta.id);
    if (full) Object.assign(full, delta);
    else oddsMap.set(delta.id, delta);
  }
  console.log(`${book}: ${odds.length} odds updated`);
});

import sseclient
import requests
import json
 
url = 'https://api.sharpapi.io/api/v1/stream'
params = {'channel': 'all', 'league': 'nba'}
headers = {'X-API-Key': 'YOUR_KEY'}
 
odds_map: dict[str, dict] = {}
 
response = requests.get(url, params=params, headers=headers, stream=True)
client = sseclient.SSEClient(response)
 
for event in client.events():
    data = json.loads(event.data) if event.data else {}
 
    if event.event == 'connected':
        # A full snapshot follows every connect except a resume (resumed == True,
        # odds channel only), which replays deltas into your existing state.
        # A started resume can still fall back to a full snapshot; this short
        # example leaves that out — see the Streaming Reliability Contract.
        if data.get('resumed') is not True:
            odds_map.clear()
        print(f"Stream {data['stream_id']} connected")
    elif event.event == 'snapshot':
        for odd in data.get('odds', []):
            odds_map[odd['id']] = odd
        print(f"Snapshot: {data['count']} odds")
    elif event.event == 'odds:update':
        # Delta only has dynamic fields — merge by ID
        for delta in data.get('odds', []):
            existing = odds_map.get(delta['id'])
            if existing:
                existing.update(delta)
            else:
                odds_map[delta['id']] = delta
        print(f"{data['book']}: {data['count']} odds updated")
    elif event.event == 'ev:detected':
        # {opportunities, count, type}: new, or updated versions of ones already sent (same id)
        for opp in data['opportunities']:
            print(f"+EV: {opp['selection']} at {opp['ev_percentage']}%")