Resultados de la Baccarat 1 en vivo: cada mano al cerrar
Cómo recibir cada mano de la Baccarat 1 de Pragmatic Play en el instante en que cierra, con el stream de LynxMetrics: el retraso medido y el código.
Publicado el 2 de noviembre de 2026 · 8 min de lectura
Recibir resultados de la Baccarat 1 en vivo es un problema distinto de consultar el historial. En el historial, el retraso no importa. En vivo importa todo: la mesa reparte una mano cada 30 segundos, así que si tu mensaje sale 20 segundos después de la mano, llega casi junto con la siguiente, y quien lo lee ya no sabe de qué ronda hablás.
Este artículo muestra los dos caminos que ofrece la API de Baccarat 1 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 en tu programa. El funcionamiento del stream en detalle — todos los eventos, los sellos 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 retraso 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 mano y el dato disponible. En la Baccarat 1 lo medimos en las rondas que están en la base, comparando el settledAt de cada mano con el momento en que quedó guardada: la mediana fue de 3,0 segundos, en 268 manos verificadas.
| Qué medimos | Valor |
|---|---|
| Mediana del fin de la mano al dato guardado | 3,0 s |
| Mediana del intervalo entre manos | 30 s |
| Intervalo más corto observado | 26 s |
| Cuando la mesa mezcla o cambia de crupier | pausa de minutos |
Casi todo ese tiempo es la confirmación de la mano, antes de que la ronda exista para nosotros; nuestra base de datos se lleva una fracción. Por eso no hay truco del cliente que gane esos segundos, y por eso tampoco vale consultar la API diez veces por segundo: el dato simplemente no está antes.
Y no hace falta que nos creas: cada mano 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_hasta_nosotros = (t(evento["timing"]["receivedAt"]) - t(evento["data"]["settledAt"])).total_seconds()
print(round(mesa_hasta_nosotros, 2), "s de la mesa a nuestra API")Con 3 segundos de retraso en una mano de 30, quedan unos 27 segundos hasta la próxima: margen sobrado para formatear y publicar.
Camino 1: el stream, el más rápido
El GET /v1/baccarat-1/stream es una conexión HTTP que queda abierta. La abrís una vez y la API empuja cada mano en el instante en que se guarda, en formato Server-Sent Events. No hay intervalo de consulta, así que no hay retraso de consulta.
En Python, con httpx:
stream.py
import json
import httpx
URL = "https://api.lynxmetrics.com/v1/baccarat-1/stream"
ENCABEZADOS = {"x-api-key": "TU_CLAVE", "accept": "text/event-stream"}
with httpx.stream("GET", URL, headers=ENCABEZADOS, 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/baccarat-1/stream", {
headers: { "x-api-key": process.env.LYNX_KEY, accept: "text/event-stream" },
});
let buffer = "";
for await (const pedazo of respuesta.body) {
buffer += new TextDecoder().decode(pedazo);
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
| Evento | Cuándo llega | Qué hacer con él |
|---|---|---|
ready | Una vez, al abrir | Trae la última mano ya cerrada, para que arranques al día, y en una reconexión trae en missed lo que cerró en tu ausencia. No es mano nueva |
round | Uno por mano 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 |
línea con : | Cada 20 segundos de silencio | Latido, para que ningún proxy cierre la conexión quieta. Ignoralo |
En esta mesa la conexión recibe esos tres eventos. El phase que el Lightning Baccarat manda cuando la mesa entra en la resolución de la mano no se publica para la Baccarat 1 — y no lo necesitás para saber a qué mano pertenece un resultado: el id del round, el orden garantizado y el last-event-id alcanzan.
Reconectar sin perder manos
Una conexión abierta se cae — red, despliegues, y el fin de vida que toda conexión tiene. Guardá el id de la última mano que trataste y devolvelo en el encabezado 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.
encabezados = {"x-api-key": "TU_CLAVE", "accept": "text/event-stream"}
if ultimo_id:
encabezados["last-event-id"] = ultimo_idPor encima de 50 manos de ausencia — en esta mesa, unos 25 minutos — el stream no lo resuelve solo: llega resyncError: "too_many_missed" y terminás de sincronizar con `/results?after=`, que pagina. La conexión abre en los dos casos; una reconexión nunca falla por un cursor viejo.
Cuando la mesa simplemente para
La mezcla y el cambio de crupier paran la mesa por minutos, y en esos intervalos no llega ningún round. Eso no es una caída: el latido sigue llegando y la conexión sigue viva. Si tu programa dibuja un "en vivo" en pantalla, usá el settledAt de la última mano para decir hace cuánto salió, en vez de suponer que una pausa larga es un error.
Una mano con lectura insegura se descarta a propósito — mejor que falte una mano que publicar una equivocada —, así que tu programa nunca debería asumir que las manos llegan en intervalos exactos.
Cuánto cuesta el stream de tu límite
Abrir la conexión gasta una petición de tu límite por minuto. Las manos que llegan después no gastan nada. O sea: seguir la mesa por el stream pesa mucho menos en el límite 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 su lugar. Así un proceso que se cayó 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 mano dura 30 segundos y el dato llega en 3; consultar más rápido que eso solo quema tu límite por minuto.
- Mandá el
ETag. Guardá el encabezadoETagde la última respuesta y devolvelo enIf-None-Match. Cuando nada cambió, la API responde 304 sin cuerpo: la petición igual cuenta en el límite, pero el tráfico y el trabajo de tu lado bajan mucho.
etag = None
while True:
encabezados = {"x-api-key": "TU_CLAVE"}
if etag:
encabezados["if-none-match"] = etag
r = requests.get("https://api.lynxmetrics.com/v1/baccarat-1/latest", headers=encabezados, 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 mano con el último que trataste. Es la forma de no publicar nunca la misma ronda dos veces, y vale en los dos caminos.
Stream, polling o webhook: cuál elegir
| Stream (SSE) | Consultar el /latest | Webhook | |
|---|---|---|---|
| Retraso extra sobre los ~3s | ninguno | la mitad de tu intervalo, en promedio | — |
| Gasto del límite por minuto | 1 al abrir | 1 por consulta | — |
| Recupera lo que pasó en la caída | sí, con last-event-id | sí, con after | — |
| Necesita servidor propio | sí, un proceso de pie | no | sí, dirección pública |
| Disponible en LynxMetrics | sí | sí | no |
El webhook es la pregunta que más recibimos, y la respuesta es directa: hoy no existe. Un webhook exige dirección pública, firma de petición y cola de reentrega de nuestro lado, y entrega peor que el stream para quien ya tiene un proceso corriendo.
El próximo paso
Con el stream funcionando, lo que queda es decidir qué hacer con cada mano: publicarla en un grupo, guardarla en tu propia base (el camino está en guardar datos en tiempo real) o dibujarla en pantalla. Para entender cada campo que llega en el evento, mirá la API de Baccarat 1 y la documentación. Quien solo quiere ver la mesa tiene la página en vivo de la Baccarat 1, abierta y sin clave.
Preguntas frecuentes
- ¿Cuál es el retraso entre la mano de la Baccarat 1 y el dato en la API?
La mediana medida en producción es de 3 segundos entre el fin de la mano y el dato guardado, en 268 manos verificadas. Casi todo ese tiempo es la confirmación de la mano, y cada ronda del stream trae los sellos de horario para que lo midas de tu lado.
- ¿LynxMetrics tiene webhook para la Baccarat 1?
No. Para recibir cada mano 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 reconectar al stream de la Baccarat 1 sin perder manos?
Mandá el id de la última mano recibida en el encabezado 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 que eso con la misma clave, la conexión más antigua se cierra con un event: closed y la nueva ocupa su lugar, sin error.
- ¿Por qué la Baccarat 1 pasa minutos sin mandar ninguna mano?
Porque la mesa paró para mezclar o cambiar de crupier, lo que lleva minutos. La conexión sigue viva y el latido sigue llegando; usá el settledAt de la última mano para mostrar hace cuánto salió en vez de tratar la pausa como un error.
Contenido solo para mayores de 18 años. LynxMetrics no tiene relación con Pragmatic Play ni con los casinos que ofrecen Baccarat 1, 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
- API de Baccarat 1 de Pragmatic Play: resultados en JSON
Cómo funciona la API de Baccarat 1 de LynxMetrics: las cartas de cada mano en JSON, los cuatro endpoints, ejemplos en Python y Node, precios y prueba gratis.
- Baccarat 1 en Portugal y Angola: resultados, husos y API
Resultados de la Baccarat 1 de Pragmatic Play para Portugal y Angola: dónde verlos gratis, cómo convertir los horarios a Lisboa y Luanda y el precio de la API.
- Bot de Baccarat 1 en Telegram: el código completo
Cómo publicar cada mano de la Baccarat 1 de Pragmatic Play en un grupo de Telegram: crear el bot, conectarlo al stream y no repetir ni perder manos.