Resultados del Bac Bo en tiempo real: ~4 segundos por ronda
Cómo recibir cada ronda del Bac Bo Live en el instante en que se guarda: el atraso real medido, el aviso 8s antes del resultado y código listo en Python.
Publicado el 30 de octubre de 2026 · actualizado el 31 de octubre de 2026 · 6 min de lectura
Quien sigue el Bac Bo en tiempo real por software choca siempre con el mismo detalle: la ronda dura cerca de 34 segundos, y un resultado que llega tarde llega junto con la ronda siguiente. Este artículo muestra cuánto tiempo pasa de verdad entre que los dados paran en la mesa y el dato llega a tu programa, y cómo recibir cada ronda sin estar preguntando.
El mecanismo 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
Medimos el camino entero en producción, comparando el settledAt de cada ronda con el momento en que quedó guardada y visible: en el Bac Bo Live son hoy cerca de 4 segundos.
Ese número fue mucho peor. Era de 10,75 segundos, y lo que lo bajó no fue optimizar la base: fue publicar la ronda en cuanto el resultado está en la mesa, en vez de esperar que la cámara vuelva al plano abierto. El resultado ya estaba decidido ahí; esperar el encuadre era atraso puro. Hoy más del 90% de lo que queda ocurre antes de que la ronda exista para nosotros, en el lector confirmando los cuatro dados — el colector y la base suman unas décimas.
Y no hace falta que creas nuestra cuenta: cada ronda que llega por el stream trae los horarios de cada tramo del camino.
# 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")El aviso que llega cerca de 8 segundos antes del resultado
Esta es la parte más particular del Bac Bo. La mesa tiene un momento mecánico claro: el cubilete para, los dados quedan a la vista y la cámara cierra sobre ellos. Es el instante en que las apuestas ya cerraron y el resultado todavía no existe.
Nuestro lector avisa ese instante directo en el stream, en un event: phase — que es opcional: abrí la conexión con ?phases=1 para recibirlo.
event: phase
data: {"roundId":"v1793371825421","game":"bacbo-live","phase":"resolving","at":"2026-10-30T18:10:49.903Z","sentAt":"2026-10-30T18:10:53.903Z"}En el Bac Bo llega cerca de 8 segundos antes del round con el resultado, y ya trae el roundId que esa ronda va a tener. Para qué sirve, en la práctica:
- Registrar algo antes del resultado y ya atarlo a la ronda correcta. Si lo que querés es solo saber a qué ronda pertenece un resultado, no necesitás la fase: el
iddelround, el orden garantizado de la conexión y ellast-event-idlo resuelven solos. La fase adelanta esa atadura unos segundos. - Preparar el mensaje antes. Podés publicar un "ronda en curso" y después editar el mismo mensaje con el resultado, lo que deja al grupo con una línea por ronda en vez de dos.
- Saber que la mesa está viva incluso en un intervalo largo entre resultados.
Dos aclaraciones honestas, y son importantes:
Y llega por la mesa, con el atraso de ella: es el momento de la resolución, no el momento en que abrieron las apuestas. La apertura de las apuestas la sabemos solo después del hecho, por el startedAt.
El cliente, en Python
stream.py
import json
import time
import httpx
STREAM = "https://api.lynxmetrics.com/v1/bacbo-live/stream?phases=1" # sin el ?phases=1 no llega event: phase
CLAVE = "TU_CLAVE"
ultimo_id = None
def tratar(ronda):
global ultimo_id
if ronda["id"] == ultimo_id:
return # el ready repite la última a propósito
ultimo_id = ronda["id"]
datos = ronda["data"]
print(ronda["settledAt"], ronda["outcome"], datos["player"]["score"], "x", datos["banker"]["score"])
def acompanar():
cabeceras = {"x-api-key": CLAVE, "accept": "text/event-stream"}
if ultimo_id:
cabeceras["last-event-id"] = ultimo_id # devuelve lo que cerró en la ausencia
with httpx.stream("GET", STREAM, 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"])
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 la ronda", cuerpo["roundId"])
elif evento == "closed":
return "closed"
while True:
if acompanar() == "closed":
break # otra conexión tomó el lugar de esta clave
time.sleep(2)El dato del Bac Bo llega así, dentro del data del evento round:
{
"id": "v1792354840763",
"game": "bacbo-live",
"outcome": "banker",
"settledAt": "2026-10-18T20:20:49.923Z",
"data": {
"player": { "dice": [1, 2], "score": 3 },
"banker": { "dice": [4, 5], "score": 9 },
"multiplier": null
}
}Los campos están explicados uno por uno en la API del Bac Bo y en la documentación.
Reconectar sin perder una ronda
Guardá el id de la última ronda tratada y devolvelo en la cabecera last-event-id al reabrir: el ready vuelve con missed, las rondas que cerraron en tu ausencia, de la más antigua a la más nueva, hasta 50 — cerca de media hora de mesa. Por encima de eso llega resyncError: "too_many_missed" y terminás de sincronizar con el `/results?after=`, que pagina. La conexión abre en los dos casos.
Esto vale también para el fin de vida de 6 horas que toda conexión tiene: quien corre todo el día reconecta unas cuatro veces por día, y con el last-event-id ninguna de esas reconexiones cuesta una ronda.
O consultar el /latest, si no podés mantener un proceso de pie
En una función serverless, un cron o una planilla, consultar el /latest resuelve:
- Cada 2 o 3 segundos sobra. La ronda dura ~34 segundos y el dato llega en ~4.
- Mandá el
ETagde la última respuesta enIf-None-Match: cuando nada cambió, la API responde 304 sin cuerpo. - Compará el
idcon el último tratado, siempre. Es lo que impide publicar la misma ronda dos veces.
| Stream (SSE) | Consultar /latest | Webhook | |
|---|---|---|---|
| Atraso extra sobre los ~4s | ninguno | la mitad de tu intervalo, en promedio | — |
| Gasto del límite por minuto | 1 al abrir | 1 por consulta | — |
| Avisa antes del resultado | sí, el phase opcional | no | — |
| Recupera lo que pasó en la caída | sí, con last-event-id | sí, con after | — |
| Disponible en LynxMetrics | sí | sí | no |
El webhook no existe hoy, y el motivo está en el artículo de referencia: exigiría una dirección pública tuya, firma de petición y cola de reenvío, para entregar peor que el stream a quien ya tiene un proceso corriendo.
El próximo paso
Publicar cada ronda en un grupo está listo, con código, en bot de Bac Bo para Telegram. Para dibujar el Bead Road y las estadísticas sobre lo que llega, mirá gráficos del Bac Bo y estadísticas con datos reales.
Preguntas frecuentes
- ¿Cuál es el atraso entre la ronda del Bac Bo y el dato en la API?
Cerca de 4 segundos entre el fin de la ronda en la mesa y el dato guardado, medidos en producción; antes era de 10,75 segundos. Cada ronda del stream trae las marcas receivedAt y sentAt, así que lo medís con tu propio reloj.
- ¿Se puede saber que una ronda del Bac Bo está pasando antes del resultado?
Sí, si lo pedís: abriendo la conexión con ?phases=1, el stream manda un event: phase cuando la mesa entra en la resolución de la ronda, cerca de 8 segundos antes del resultado, ya con el roundId que va a tener. No es promesa de resultado: una ronda con lectura insegura se descarta y nunca aparece como round.
- ¿Cómo reconecto al stream del Bac Bo sin perder rondas?
Mandá el id de la última ronda recibida en la cabecera last-event-id. El evento ready vuelve con missed, las rondas que cerraron en tu ausencia, hasta 50. Por encima de eso llega resyncError too_many_missed y paginás el /results?after= para estar al día.
- ¿LynxMetrics tiene webhook para el Bac Bo?
No. El camino para recibir cada ronda en el instante en que se guarda es el endpoint /stream, una conexión HTTP que queda abierta (Server-Sent Events) y no exige ninguna dirección pública de tu lado.
- ¿Necesito un servidor para usar el stream?
Necesitás un proceso de pie manteniendo la conexión abierta, lo que cualquier VPS chica o contenedor resuelve. En una función serverless con tiempo límite corto, consultá el /latest cada 2 o 3 segundos y guardá el id de la última ronda tratada.
Contenido solo para mayores de 18 años. LynxMetrics no tiene relación con Evolution ni con los casinos que ofrecen Bac Bo Live, 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 Bac Bo: resultados en vivo en JSON y prueba gratis
Cómo usar la API de resultados de Bac Bo: qué trae cada ronda, ejemplos en Python y Node, stream, historial, precios y 2 horas de prueba gratis.
- Bot de Bac Bo en Telegram: crearlo con Python paso a paso
Tutorial completo para crear un bot de Bac Bo en Telegram: BotFather, resultados en vivo por la API, mensajes sin repetición, Discord y dónde alojarlo 24 horas.
- Historial del Bac Bo: LynxMetrics y CasinoScores comparados
Comparamos 72 horas de Bac Bo Live entre LynxMetrics y la lista pública de CasinoScores el 18/10/2026, con los archivos originales para que verifiques.