Resultados en tiempo real: el stream SSE, evento por evento
Cómo recibir cada ronda en el instante en que se guarda: los eventos del /stream, la reconexión con Last-Event-ID y por qué SSE en vez de webhook o WebSocket.
Publicado el 30 de octubre de 2026 · actualizado el 14 de noviembre de 2026 · 11 min de lectura
Toda API de resultados en vivo responde la misma pregunta — "¿cuál fue la última ronda?" — de dos maneras. O preguntás cada tanto, o la API te avisa. El GET /v1/{api}/stream de LynxMetrics es la segunda: una conexión HTTP que queda abierta y entrega cada ronda en el instante en que se guarda, sin intervalo de consulta en el medio.
Este artículo es la referencia del stream, igual para todas las APIs del catálogo. Los artículos de cada juego muestran el mismo mecanismo con los números de esa mesa: Bac Bo Live, Lightning Baccarat y Baccarat 1.
Por qué SSE, y no webhook ni WebSocket
| Stream (SSE) | Consultar /latest | Webhook | WebSocket | |
|---|---|---|---|---|
| Atraso además del de la API | ninguno | la mitad de tu intervalo, en promedio | ninguno | ninguno |
| Gasto del límite por minuto | 1 al abrir | 1 por consulta | — | — |
| Necesita dirección pública | no | no | sí | no |
| Atraviesa proxy y CDN | sí, es HTTP común | sí | sí | a veces no |
| Existe en LynxMetrics | sí | sí | no | no |
El webhook no existe, y no es un olvido. Exigiría que publiques una dirección en internet, y de nuestro lado una tabla de destinos, firma de petición y cola de reenvío — piezas que pueden fallar solas. Para quien ya tiene un proceso corriendo, el stream entrega lo mismo con menos piezas y sin exponer nada.
El WebSocket fue descartado porque trae un canal de vuelta que no usamos: nunca necesitás mandarnos nada después de abrir la conexión. SSE es HTTP común, con una cabecera y una respuesta que no termina, así que pasa donde el WebSocket a veces tropieza y funciona en cualquier cliente que lea una respuesta de a poco.
Sin conexión abierta: el ?wait= de /latest
Si tu entorno no deja mantener una conexión abierta (un script que corre y termina, una función sin servidor, un bucle simple en PHP), hay un punto medio desde el 14/11/2026: pedí /latest con ?wait=20 y decí qué ronda ya tenés. La respuesta queda abierta hasta que cierre la próxima ronda y llega con ella, en el mismo instante en que el stream la entregaría. Si nada cierra en 20 segundos, llega un 304 y pedís de nuevo.
curl "https://api.lynxmetrics.com/v1/bacbo-live/latest?wait=20" \ -H "x-api-key: TU_CLAVE" \ -H 'if-none-match: "ETAG_DE_LA_ULTIMA_RESPUESTA"'
Quien no guarda el ETag manda &after= con el id de la última ronda que tiene. Es una petición por ronda, en vez de una cada pocos segundos, y el tiempo límite de tu cliente tiene que ser mayor que el wait. El código listo en Python, Node.js y PHP, tanto del stream como de esta espera, está en la documentación de cada API.
Abrir la conexión
curl -N https://api.lynxmetrics.com/v1/bacbo-live/stream \ -H "x-api-key: TU_CLAVE" \ -H "accept: text/event-stream"
El -N apaga el buffer de curl, si no la terminal solo mostraría todo al final. Cambiá bacbo-live por el slug de la API que contrataste — una clave abre una sola API.
Los eventos
El flujo por defecto tiene tres eventos — ready, round y closed — y un cuarto, el phase, que solo llega si lo pedís con ?phases=1.
En el cable, cada evento es un nombre, a veces un id, y una línea data: con el JSON compacto:
event: phase
data: {"roundId":"v1793371825421","game":"bacbo-live","phase":"resolving","at":"2026-10-30T18:10:49.903Z","sentAt":"2026-10-30T18:10:53.903Z"}
event: round
id: v1793371825421
data: {"data":{"id":"v1793371825421","outcome":"banker","settledAt":"2026-10-30T18:10:58.903Z","...":"..."},"timing":{"receivedAt":"2026-10-30T18:11:02.803Z","sentAt":"2026-10-30T18:11:02.853Z"}}| Evento | Cuándo llega | Qué hacer con él |
|---|---|---|
ready | Una vez, al abrir | Trae en data la última ronda ya cerrada, para arrancar al día, y en una reconexión también lo que te perdiste. No es ronda nueva |
phase | Opcional (?phases=1), cuando la mesa entra en la resolución de la ronda | Trae el roundId que la ronda va a tener, segundos antes del resultado |
round | Uno por ronda nueva | La ronda en data y los horarios de la entrega en timing. Es el único evento con id: |
closed | Otra conexión abrió con la misma clave | Fin de vida de este proceso: reconectar tiraría la conexión nueva |
Además, cada 20 segundos de silencio sale una línea que empieza con dos puntos. Es el latido que impide que un proxy en el medio cierre una conexión quieta; no es evento y se puede ignorar.
Qué es el phase, y qué no es
El phase existe porque nuestra fuente es la propia mesa, y el lector sabe el momento en que ella entra en la resolución de la ronda — el close-up de los dados en el cubilete, las cartas en el paño. En ese instante las apuestas ya cerraron, el resultado todavía no existe, y el id de la ronda ya está definido. En el Bac Bo ese aviso llega cerca de 8 segundos antes del resultado.
Es opcional a propósito: abrí la conexión con ?phases=1 para recibirlo. Y conviene ser directo sobre lo que no resuelve: para saber a qué ronda pertenece un resultado, no necesitás el phase. El id del round, el orden garantizado dentro de la conexión y el last-event-id ya responden eso sin ambigüedad. La fase solo adelanta esa atadura unos segundos — útil para quien registra algo antes del resultado, y peso inútil para quien solo quiere el resultado correcto.
Qué no es: promesa de resultado. Un close-up cortado, un hueco en la transmisión o una lectura insegura hacen que la ronda se descarte a propósito — mejor que falte que adivinarla — y entonces ningún round llega con ese roundId. Quien guarda estado por fase necesita expirar una fase que no se convirtió en ronda.
Un detalle que ahorra 35 segundos de espera: si pediste las fases y abrís la conexión en el medio de una ronda en resolución, la fase abierta llega justo después del ready, en vez de que esperes la próxima.
Los horarios, para medir el atraso en vez de estimarlo
El round trae cuatro marcas, de dos relojes distintos:
| Campo | Reloj | Qué marca |
|---|---|---|
data.startedAt | mesa | Inicio de la ronda, cuando abrieron las apuestas |
data.settledAt | mesa | Fin de la ronda: el resultado quedó definido en el origen |
timing.receivedAt | nuestra API | El resultado quedó listo de nuestro lado |
timing.sentAt | nuestra API | Este evento fue escrito en tu conexión |
Con ellas, cada tramo del camino se mide por separado, y se puede saber de quién es el atraso:
receivedAt − settledAtes de la mesa a nosotros: la parte que está en nuestras manos. Hoy queda alrededor de 4 segundos.sentAt − receivedAtes la cola de esta conexión, normalmente unos milisegundos.- Lo que sobra hasta que corre tu código es tu red.
from datetime import datetime
def atrasos(evento):
t = lambda iso: datetime.fromisoformat(iso.replace("Z", "+00:00"))
ronda, timing = evento["data"], evento["timing"]
return {
"mesa_a_nosotros": (t(timing["receivedAt"]) - t(ronda["settledAt"])).total_seconds(),
"cola": (t(timing["sentAt"]) - t(timing["receivedAt"])).total_seconds(),
"hasta_vos": (datetime.now(tz=t(timing["sentAt"]).tzinfo) - t(timing["sentAt"])).total_seconds(),
}El timing queda fuera del data a propósito: así el objeto de la ronda sigue siendo idéntico, byte a byte, al que devuelven el /latest y el /results, y el mismo código trata una ronda que vino del stream y una que vino del historial.
Reconectar sin perder una ronda
Las conexiones abiertas se cortan: red, despliegues, reinicios, y el fin de vida de 6 horas que toda conexión tiene. Lo que resuelve eso es el Last-Event-ID, el mecanismo estándar de SSE: decís cuál fue la última ronda que recibiste, y la API devuelve lo que cerró en tu ausencia.
curl -N https://api.lynxmetrics.com/v1/bacbo-live/stream \ -H "x-api-key: TU_CLAVE" \ -H "accept: text/event-stream" \ -H "last-event-id: v1793371825421"
El ready entonces vuelve así:
{
"data": { "id": "v1793372118404", "outcome": "player", "...": "..." },
"missed": [
{ "id": "v1793371962117", "...": "..." },
{ "id": "v1793372118404", "...": "..." }
]
}- El
missedtrae las rondas que cerraron mientras estabas afuera, de la más antigua a la más nueva, hasta 50. - El
datasigue siendo la última ronda cerrada, que normalmente es el último elemento demissed— así que tratá todo por elidpara no contar dos veces. - Como el
id:solo va en el eventoround, el cursor que guardás es siempre una ronda que existe de verdad. Por eso elphaseno tieneid:: apuntaría a una ronda que quizás nunca exista.
En el navegador, el EventSource manda el Last-Event-ID solo al reconectar — pero no manda cabeceras, así que la clave no puede ir por ahí y el lugar del stream es el servidor. Fuera del navegador, mandás la cabecera o ?last_event_id=.
Cuando no se puede recuperar
La conexión abre igual — una reconexión no puede fallar por un cursor viejo. El missed vuelve null y aparece un resyncError diciendo el motivo (solo existe cuando algo salió mal):
resyncError | Qué pasó | Qué hacer |
|---|---|---|
bad_cursor | El valor no es un id de ronda ni una fecha ISO 8601 | Corregir lo que estás guardando |
unknown_round | El id no es de ninguna ronda de esta API | Puede ser id de otra API, o de una ronda descartada después de un phase |
plan_limit | La ronda es más antigua que el historial de tu plan | Seguir desde lo que cubre el plan |
too_many_missed | Más de 50 rondas cerraron en tu ausencia | Paginar el /results?after= hasta estar al día |
O sea: el stream resuelve la ausencia corta solo, y la ausencia larga sigue siendo trabajo del /results, que pagina. Los dos techos — las 50 rondas de la recuperación y el de la cola de una conexión lenta — existen por la misma razón: no guardar rondas indefinidamente para un cliente que ya no está.
Un cliente que aguanta el día entero
Juntando todo: leer los eventos, guardar el cursor, reconectar y no repetir ninguna ronda.
stream.py
import json
import time
import httpx
API = "bacbo-live"
URL = "https://api.lynxmetrics.com/v1/" + API + "/stream?phases=1" # sin el ?phases=1 no llega event: phase
CLAVE = "TU_CLAVE"
ultimo_id = None # cursor: la última ronda que tratamos
def tratar(ronda):
global ultimo_id
if ronda["id"] == ultimo_id:
return # el ready repite la última a propósito
ultimo_id = ronda["id"]
print(ronda["settledAt"], ronda["outcome"])
def acompanar():
cabeceras = {"x-api-key": CLAVE, "accept": "text/event-stream"}
if ultimo_id:
cabeceras["last-event-id"] = ultimo_id
with httpx.stream("GET", URL, headers=cabeceras, timeout=None) as respuesta:
respuesta.raise_for_status()
evento = None
for linea in respuesta.iter_lines():
if linea.startswith("event:"):
evento = linea.split(":", 1)[1].strip()
elif linea.startswith("data:"):
cuerpo = json.loads(linea.split(":", 1)[1])
if evento == "ready":
if cuerpo.get("resyncError"):
print("no recuperó:", cuerpo["resyncError"]) # tratá el too_many_missed con /results
for ronda in cuerpo.get("missed") or []:
tratar(ronda)
if cuerpo["data"]:
tratar(cuerpo["data"])
elif evento == "round":
tratar(cuerpo["data"])
elif evento == "phase":
print("resolviendo", cuerpo["roundId"])
elif evento == "closed":
return "closed"
while True:
if acompanar() == "closed":
print("otra conexión tomó el lugar de esta clave")
break
time.sleep(2)Tres detalles de ese código que no son adorno:
- El cursor sale del
idde la ronda, no de un contador propio. Es fijo y nunca cambia. - El
tratares idempotente. Elreadyrepite la última ronda a propósito, y un cliente que no chequea el id publica la misma ronda dos veces en cada reconexión. - El
closedcorta el bucle. Reconectar después de unclosedtira la conexión que tomó tu lugar, y las dos copias se expulsan para siempre.
Límites y cuidados
- Conexiones por clave: 1 en el plan Pro y 3 en el Business. Pasar de ahí no da error: la conexión más antigua de esa clave se cierra con
closedy la nueva ocupa el lugar — así un proceso que murió sin avisar nunca te deja afuera de tu propio lugar. - Fin de vida de 6 horas, incluso en una conexión saludable. Quien corre todo el día reconecta unas cuatro veces por día, y con el
Last-Event-IDeso es invisible en el resultado final. - Tiempo límite de lectura mayor a 20 segundos en tu cliente, si no corta la conexión en el silencio entre rondas. En Python,
timeout=None. - Costo: abrir la conexión gasta 1 petición de tu límite por minuto; las rondas que llegan después no gastan nada. Seguir por el stream pesa mucho menos que consultar el
/latestcada 3 segundos. - La clave queda en el servidor. En el navegador quedaría a la vista de cualquier visitante — mirá seguridad de la API.
Dónde ver esto funcionando
La documentación de cada API trae la tabla de eventos, los campos y los límites de tu plan, y cada juego tiene su artículo con los números de la mesa: Bac Bo Live, Lightning Baccarat y Baccarat 1. Para armar algo encima, el bot de Telegram es el camino más corto del stream a un mensaje en el grupo.
Preguntas frecuentes
- ¿Qué es el endpoint /stream de LynxMetrics?
Es una conexión HTTP que queda abierta (Server-Sent Events) y entrega cada ronda en el instante en que se guarda, en vez de que consultes la API cada tanto. Abrir la conexión gasta una petición de tu límite por minuto, y las rondas que llegan después no gastan nada.
- ¿LynxMetrics tiene webhook?
No. Un webhook exigiría una dirección pública tuya y, de nuestro lado, firma de petición y cola de reenvío. El /stream cubre el mismo caso con menos piezas y sin exponer nada, así que es el camino recomendado para recibir rondas en tiempo real.
- ¿Cómo reconecto al stream sin perder rondas?
Mandá en la cabecera last-event-id el id de la última ronda recibida. El evento ready vuelve con missed, las rondas que cerraron en tu ausencia, de la más antigua a la más nueva, hasta 50. Por encima de eso llega resyncError too_many_missed y paginás el /results?after= para estar al día.
- ¿Qué es el evento phase y cómo se recibe?
Es el aviso de que la mesa entró en la resolución de una ronda, cuando las apuestas ya cerraron y el resultado todavía no existe, y es opcional: solo llega si abrís la conexión con ?phases=1. Trae el roundId que la ronda va a tener, en el Bac Bo cerca de 8 segundos antes del resultado. Para saber a qué ronda pertenece un resultado no lo necesitás: el id del round, el orden garantizado y el last-event-id alcanzan.
- ¿Para qué sirven los campos de timing?
Para medir el atraso en vez de estimarlo. El settledAt es el fin de la ronda en el reloj de la mesa, el receivedAt es cuando el resultado quedó listo de nuestro lado y el sentAt es cuando el evento fue escrito en tu conexión. La diferencia entre receivedAt y settledAt es el tramo que está en nuestras manos, hoy alrededor de 4 segundos.
- ¿Por qué la conexión del stream se cierra cada 6 horas?
Es a propósito: las conexiones que mueren sin avisar existen, y ese plazo impide que ocupen un lugar para siempre. Con el Last-Event-ID la reconexión no cuesta ninguna ronda, así que quien corre todo el día reconecta unas cuatro veces por día sin perder nada.
Lee también
- Qué es una API y cómo conectarse a una por primera vez
API explicada sin complicaciones: qué es, cómo funcionan REST, JSON y las claves, y cómo hacer la primera llamada en el navegador, la terminal, Python y JavaScript.
- Dónde alojar un bot 24 horas: alojamiento, VPS o serverless
Qué necesita de verdad un bot que corre sin parar, cuánto cuesta cada opción de alojamiento, y por qué serverless no combina con una conexión abierta.
- Errores y límites de API: 429, backoff y qué hacer
Guía práctica de los errores de una API de datos: qué significa cada estado HTTP, cómo tratar el 429 con Retry-After y backoff, y el código que lo resuelve.