Una conexión, muchos topics

Un único stream de SharpAPI puede cubrir todo lo que necesitas — múltiples deportes, múltiples ligas, múltiples casas de apuestas, múltiples eventos, y odds + cada tipo de oportunidad — en un solo socket. Casi nunca necesitas abrir un stream por cada filtro.

Por qué una conexión es suficienteEnlace permanente a esta sección

Cada filtro de identidad en el endpoint del stream acepta una lista separada por comas, y el parámetro channel (all) fusiona los eventos de odds y oportunidades en el mismo flujo de eventos. El servidor preserializa cada ciclo una vez y aplica tus filtros por conexión, por lo que los filtros amplios son baratos — no hay penalización de eficiencia por suscribirse a “todo lo que te interesa” en un solo socket frente a dividirlo.

PatronesEnlace permanente a esta sección

Multideporte: NBA + NFL + MLB en un solo socketEnlace permanente a esta sección

En lugar de abrir tres streams, pasa las tres ligas a uno solo:

const es = new EventSource(
  'https://api.sharpapi.io/api/v1/stream' +
  '?channel=all' +
  '&league=nba,nfl,mlb' +
  '&api_key=YOUR_KEY'
);
 
es.addEventListener('odds:update', (e) => {
  const { odds, book } = JSON.parse(e.data);
  // odds[].league tells you which league this update is for
  for (const o of odds) routeByLeague(o);
});

import sseclient, requests, json
 
response = requests.get(
    'https://api.sharpapi.io/api/v1/stream',
    params={'channel': 'all', 'league': 'nba,nfl,mlb'},
    headers={'X-API-Key': 'YOUR_KEY'},
    stream=True,
)
for event in sseclient.SSEClient(response).events():
    if event.event == 'odds:update':
        data = json.loads(event.data)
        for o in data['odds']:
            route_by_league(o)

Odds + cada tipo de oportunidad en un solo socketEnlace permanente a esta sección

Establece channel=all (SSE) o incluye cada tipo de oportunidad en channels= (WS):

const es = new EventSource(
  'https://api.sharpapi.io/api/v1/stream?channel=all&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);

const ws = new WebSocket(
  'wss://ws.sharpapi.io' +
  '?api_key=YOUR_KEY' +
  '&channels=odds,ev,arbitrage,middles,low_hold'
);

El servidor etiqueta cada mensaje con su tipo de evento — tu handler despacha por nombre de evento, exactamente como si hubieras abierto cinco streams separados.

Seguimiento de N eventos específicosEnlace permanente a esta sección

Si quieres actualizaciones precisas sobre una lista fija de eventos (p. ej. diez partidos esta noche), pásalos todos a 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`
);

Esto reemplaza el patrón de abrir un socket /stream/events/{eventId} por evento.

Divisiones por casa de apuestas o por mercadoEnlace permanente a esta sección

La misma idea se aplica a casas de apuestas y mercados:

// 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'
);

Resuscripción dinámica (WebSocket)Enlace permanente a esta sección

El control bidireccional de WebSocket te permite cambiar filtros a mitad de conexión sin cerrar el socket. Úsalo cuando tu conjunto de topics “interesantes” cambie a lo largo del día (p. ej. el usuario abre / cierra vistas en un 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'] },
  }));
}

Consulta la Referencia de la API WebSocket para el esquema completo del mensaje subscribe.

Flota y multiprocesoEnlace permanente a esta sección

El único caso en el que una sola conexión realmente no funciona: procesos o máquinas separadas que no pueden compartir un socket. Ejemplos:

• Diez bots de trading ejecutándose en diez servidores, cada uno necesitando su propio feed en vivo.
• Pool de workers donde N workers consumen un stream cada uno de forma independiente.
• Servicio backend + dashboard del navegador, ambos autenticados como el mismo usuario.

El límite por defecto de 1 stream significa que una segunda conexión con la misma key desplazará a la primera (código de cierre 4001 displaced by newer session en WS, cierre del writer en SSE). Un cliente desplazado no debe reconectarse automáticamente: el slot está ocupado por la sesión más nueva, y reconectarse la expulsaría de inmediato.

Flota con tantos procesos como keys incluye tu plan: cada API key tiene su propio slot de stream independiente. Asigna una key por proceso — no se necesita ningún override ni add-on. Las asignaciones son pequeñas: Hobby y Pro incluyen una key, Sharp dos — meta.max_keys en GET /api/v1/account/keys muestra la tuya — así que, sin Enterprise, esta vía cubre como máximo una flota de dos procesos. Consulta Pricing para ver detalles de planes y add-ons.

Flota mayor que tu límite de keys, o una sola key para múltiples streams: la vía de escape prevista es un override de maxStreams por key, dimensionado para la flota. Es un add-on de pago en cualquier plan de pago, aprovisionado por key — contacta con sales@sharpapi.io para que se fije un límite mayor en una key específica.

Consulta los Límites de streams concurrentes y el contrato de fiabilidad para la semántica de desplazamiento.

Para todo lo demás — incluso suscripciones muy amplias — los patrones anteriores permiten que un solo socket cubra lo que parecen diez preocupaciones distintas.

Coste en el servidorEnlace permanente a esta sección

No hay ninguna razón de eficiencia para dividir. La ruta caliente del servidor:

1. Calcula el diff por ciclo del libro una vez.
2. Preserializa los payloads sin filtrar de cambios/eliminados una vez.
3. Para cada cliente conectado, aplica su filtro y serializa el subconjunto correspondiente (o envía los bytes preserializados directamente cuando el cliente no tiene filtros de contenido).

Un cliente con league=nba,nfl,mlb,nhl cuesta casi lo mismo que cuatro clientes cada uno con una liga — menos cuatro sockets, cuatro handshakes TLS, cuatro conjuntos de cabeceras HTTP y cuatro ciclos connected/snapshot. El patrón de conexión única también es mejor para la consistencia de los deltas: ves todas las actualizaciones en el orden en que el servidor las produjo, en lugar de intercalarlas entre sockets con backpressure independiente.

Lista de comprobación de migraciónEnlace permanente a esta sección

Si estás migrando desde una arquitectura multi-stream:

1. Combina los filtros de identidad — recopila cada valor de sport, league, sportsbook, market y event_id de tus streams antiguos y únelos con comas en una sola URL.
2. Usa channel=all (SSE) o cada valor necesario de channels= (WS) en lugar de un stream por tipo de evento.
3. Despacha en tu handler — lee odds[].league / odds[].sportsbook / event.event para enrutar mensajes internamente exactamente como antes.
4. Elimina tu lógica de reconexión N veces — un solo socket significa una sola ruta de reconexión. SSE se reconecta automáticamente; para WS, consulta el patrón de reconexión.
5. Mantén los umbrales min_ev / min_profit — estos siguen reduciendo el stream de oportunidades en el servidor y reducen el ancho de banda.

Véase tambiénEnlace permanente a esta sección

• Visión general de streaming — comparación de protocolos e inicio rápido
• Guía de streaming WebSocket — mensajes subscribe, reconexión
• Referencia de la API SSE — lista completa de parámetros de filtro
• Referencia de la API WebSocket — esquema subscribe, códigos de cierre