Blog · Lightning Baccarat

Resultados del Lightning Baccarat: cada mano en ~5 segundos

Cómo recibir cada ronda del Lightning Baccarat en el instante en que cierra: el atraso medido, el aviso antes del resultado y código en Python y Node.

Publicado el 30 de octubre de 2026 · actualizado el 31 de octubre de 2026 · 8 min de lectura

A API do Lightning Baccarat está no ar · en YouTube

Recibir resultados del Lightning Baccarat en vivo es un problema distinto de consultar el historial. En el historial, el atraso no importa. En vivo importa todo: si tu mensaje llega 20 segundos después de la mano, llega junto con la mano siguiente, y quien lo lee ya no sabe de qué ronda estás hablando.

Este artículo muestra los dos caminos que ofrece la API de Lightning Baccarat para seguir la mesa en vivo, cuál es el más rápido, y cuánto tiempo pasa de verdad entre el cierre de la mano y el dato llegando a tu programa. El funcionamiento del stream en detalle — todos los eventos, las marcas de tiempo y los errores de recuperación — está en el artículo de referencia sobre resultados en tiempo real; acá quedan los números de esta mesa.

El atraso real, medido en producción

La vara correcta no es "la API es rápida", es cuántos segundos pasan entre el fin de la ronda y el dato disponible. En el Lightning Baccarat lo medimos en producción, comparando el settledAt de cada ronda con el momento en que quedó guardada: hoy son cerca de 5 segundos.

Lo interesante es dónde está ese tiempo. Más del 90% ocurre antes de que la ronda exista para nosotros: es el lector asegurándose de cuáles son las cartas. El colector y la base suman unas décimas de segundo. Por eso no hay truco del lado del cliente que recupere esos segundos — y por eso tampoco sirve consultar la API diez veces por segundo: el dato simplemente no está ahí antes.

Y no hace falta que nos creas: cada ronda que llega por el stream trae los horarios de cada tramo del camino, así que el número de arriba es verificable de tu lado, con tu propio reloj.

# dentro del evento "round"
from datetime import datetime

t = lambda iso: datetime.fromisoformat(iso.replace("Z", "+00:00"))
mesa_a_nosotros = (t(evento["timing"]["receivedAt"]) - t(evento["data"]["settledAt"])).total_seconds()
print(mesa_a_nosotros, "s de la mesa a nuestra API")

Una ronda de Lightning Baccarat dura cerca de 35 segundos. Con 5 segundos de atraso te quedan unos 30 segundos de sobra antes de la mano siguiente, tiempo más que suficiente para formatear y publicar el mensaje.

Camino 1: el stream, el más rápido

El GET /v1/lightning-baccarat/stream es una conexión HTTP que queda abierta. La abrís una vez y la API empuja cada ronda en el instante en que se guarda, en formato Server-Sent Events. No hay intervalo de consulta, así que no hay atraso de consulta.

En Python, con httpx:

stream.py

import json
import httpx

URL = "https://api.lynxmetrics.com/v1/lightning-baccarat/stream"
CABECERAS = {"x-api-key": "TU_CLAVE", "accept": "text/event-stream"}

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:") and evento == "round":
            cuerpo = json.loads(linea.split(":", 1)[1])
            mano = cuerpo["data"]
            print(mano["outcome"], mano["data"]["player"]["cards"], mano["data"]["banker"]["cards"])

En Node.js 18 o más nuevo, sin dependencias:

stream.mjs

const respuesta = await fetch("https://api.lynxmetrics.com/v1/lightning-baccarat/stream", {
  headers: { "x-api-key": process.env.LYNX_KEY, accept: "text/event-stream" },
});

let buffer = "";
for await (const trozo of respuesta.body) {
  buffer += new TextDecoder().decode(trozo);
  const bloques = buffer.split("\n\n");
  buffer = bloques.pop() ?? "";
  for (const bloque of bloques) {
    const evento = bloque.match(/^event: (.+)$/m)?.[1];
    const datos = bloque.match(/^data: (.+)$/m)?.[1];
    if (evento === "round" && datos) {
      const { data: mano } = JSON.parse(datos);
      console.log(mano.outcome, mano.data.player.score, mano.data.banker.score);
    }
  }
}

Qué llega en la conexión

EventoCuándo llegaQué hacer con él
readyUna vez, al abrirTrae la última mano ya cerrada, para arrancar al día, y en una reconexión también lo que te perdiste, en missed. No es ronda nueva
phaseOpcional (?phases=1), cuando la mesa entra en la resolución de la manoEl roundId que la mano va a tener, antes de que se lean las cartas
roundUno por mano nuevaLa ronda en data y los horarios de la entrega en timing. Es el único evento con id:
closedOtra conexión abrió con la misma claveFin de vida de este proceso; reconectar tiraría la conexión nueva
línea con :Cada 20 segundos de silencioLatido, para que ningún proxy cierre la conexión quieta. Ignoralo

Reconectar sin perder una mano

Las conexiones abiertas se cortan — red, despliegues, y el fin de vida de 6 horas que toda conexión tiene. Guardá el id de la última mano que trataste y devolvelo en la cabecera last-event-id al reabrir: el ready vuelve con missed, las manos que cerraron mientras estuviste afuera, de la más antigua a la más nueva, hasta 50.

cabeceras = {"x-api-key": "TU_CLAVE", "accept": "text/event-stream"}
if ultimo_id:
    cabeceras["last-event-id"] = ultimo_id

Por encima de 50 manos de ausencia — cerca de media hora de mesa — el stream no lo resuelve solo: llega resyncError: "too_many_missed" y terminás de sincronizar con el `/results?after=`, que pagina. La conexión abre en los dos casos; una reconexión nunca falla por un cursor viejo.

El aviso que llega antes del resultado

El evento phase es opcional — abrí la conexión con ?phases=1 para recibirlo — y avisa cuando la mesa entra en la resolución de la mano, momento en que las apuestas ya cerraron y las cartas todavía no se leyeron. Trae el roundId que esa mano va a tener en el round, y sirve para atar lo que tu programa registra a la mano correcta antes de que salga el resultado. Para solo saber a qué mano pertenece un resultado no lo necesitás: el id del round, el orden garantizado y el last-event-id alcanzan.

No es promesa de resultado: un close-up cortado o una lectura insegura hacen que la mano se descarte a propósito — mejor que falte que adivinarla —, y entonces ningún round llega con ese id. Quien guarda estado por fase necesita expirar la fase que no se convirtió en mano.

Cuánto gasta el stream de tu límite

Abrir la conexión gasta una petición de tu límite por minuto. Las rondas que llegan después no gastan nada. O sea: seguir por el stream pesa mucho menos que consultar el /latest cada 3 segundos, que son 20 peticiones por minuto. El plan Pro mantiene 1 conexión por clave y el Business, 5.

Si pasás del número de conexiones del plan, no hay error: la conexión más antigua de esa clave se cierra con un event: closed y la nueva ocupa el lugar. Así un proceso que murió sin avisar nunca te deja afuera de tu propio lugar.

Camino 2: consultar el /latest cada tanto

Si tu programa no puede mantener una conexión abierta — una función serverless, un cron, una planilla — consultar el /latest funciona bien. Dos reglas lo hacen eficiente:

  • Cada 3 segundos sobra. La ronda dura 35 segundos y el dato llega en 5; consultar más rápido solo quema tu límite por minuto.
  • Mandá el ETag. Guardá la cabecera ETag de la última respuesta y devolvela en If-None-Match. Cuando nada cambió, la API responde 304 sin cuerpo: la petición sigue contando en el límite, pero el tráfico y el trabajo de tu lado bajan mucho.
etag = None
while True:
    cabeceras = {"x-api-key": "TU_CLAVE"}
    if etag:
        cabeceras["if-none-match"] = etag
    r = requests.get("https://api.lynxmetrics.com/v1/lightning-baccarat/latest", headers=cabeceras, timeout=10)
    if r.status_code == 200:
        etag = r.headers.get("etag")
        tratar(r.json()["data"])
    time.sleep(3)

Y siempre compará el id de la ronda con el último que trataste. Es la forma de no publicar nunca la misma mano dos veces, y vale en los dos caminos.

Stream, consulta o webhook: cuál elegir

Stream (SSE)Consultar /latestWebhook
Atraso extra sobre los ~5sningunola mitad de tu intervalo, en promedio—
Gasto del límite por minuto1 al abrir1 por consulta—
Recupera lo que pasó en la caídasí, con last-event-idsí, con after—
Necesita servidor propiosí, un proceso de pienosí, dirección pública
Disponible en LynxMetricssísíno

El webhook es la pregunta que más recibimos, y la respuesta es directa: no existe hoy. Un webhook exige dirección pública, firma de petición y cola de reenvío de nuestro lado, y entrega peor que el stream para quien ya tiene un proceso corriendo. El stream cubre el mismo caso con menos piezas.

El próximo paso

Con el stream funcionando, publicar la mano en un grupo es el paso siguiente, y está listo en cómo hacer un bot de Lightning Baccarat en Telegram. Para entender cada campo que llega en el evento, mirá la API de Lightning Baccarat y la documentación.

Preguntas frecuentes

¿Cuál es el atraso entre la ronda de Lightning Baccarat y el dato en la API?

Cerca de 5 segundos entre el cierre de la mano y el dato guardado, medidos en producción. Más del 90% de ese tiempo es el lector confirmando las cartas, y cada ronda del stream trae receivedAt y sentAt para que lo midas de tu lado.

¿LynxMetrics tiene webhook para el Lightning Baccarat?

No. Para recibir cada ronda en el instante en que se guarda, usá el endpoint /stream, que mantiene una conexión HTTP abierta (Server-Sent Events). Cubre el mismo caso de uso con menos piezas que un webhook.

¿Cómo reconecto al stream sin perder manos?

Mandá el id de la última mano recibida en la cabecera last-event-id al reabrir la conexión. El evento ready vuelve con missed, las manos que cerraron en tu ausencia, hasta 50. Por encima de eso llega resyncError too_many_missed y terminás de sincronizar por /results?after=.

¿Cuántas conexiones de stream puedo mantener abiertas?

Una por clave en el plan Pro y cinco en el Business. Si abrís más con la misma clave, la conexión más antigua se cierra con un event: closed y la nueva ocupa el lugar, sin error.

¿El evento phase dice cuál va a ser el resultado de la mano?

No. Es opcional, solo llega si abrís la conexión con ?phases=1, y avisa que la mesa entró en la resolución de la mano, con el id que va a tener, antes de que se lean las cartas. Sirve para atar lo que tu programa registra a la mano correcta antes del resultado; una mano con lectura insegura se descarta y nunca aparece como round.

¿Se puede usar el stream directo desde el navegador?

No es recomendable. El EventSource del navegador no envía cabeceras, así que la clave no pasa por ahí, y una clave en el navegador quedaría visible para cualquier visitante. Usá un cliente HTTP en el servidor.

Contenido solo para mayores de 18 años. LynxMetrics no tiene relación con Evolution ni con los casinos que ofrecen Lightning Baccarat, y vende solo datos y estadísticas, nunca predicciones ni consejos de apuestas, porque cada ronda es aleatoria y el historial no predice la siguiente.

Lee también