Blog · Bac Bo Live

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

Resultados em tempo real com o stream · en YouTube

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 id del round, el orden garantizado de la conexión y el last-event-id lo 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 ETag de la última respuesta en If-None-Match: cuando nada cambió, la API responde 304 sin cuerpo.
  • Compará el id con el último tratado, siempre. Es lo que impide publicar la misma ronda dos veces.
Stream (SSE)Consultar /latestWebhook
Atraso extra sobre los ~4sningunola mitad de tu intervalo, en promedio—
Gasto del límite por minuto1 al abrir1 por consulta—
Avisa antes del resultadosí, el phase opcionalno—
Recupera lo que pasó en la caídasí, con last-event-idsí, con after—
Disponible en LynxMetricssí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