Documentación · Bac Bo Live

API de Bac Bo Live

En Bac Bo Live, Player y Banker lanzan dos dados cada uno. Resultados, dados y multiplicadores de empate. Esta página muestra cómo responde la API de Bac Bo Live, con cada campo explicado.

https://api.lynxmetrics.com/v1/bacbo-live

Ver Bac Bo Live en vivo

Ver en Markdown

Autenticación

Envía en el encabezado x-api-key una clave creada en el panel para Bac Bo Live, ya que la clave de otra API recibe key_wrong_api.

curl https://api.lynxmetrics.com/v1/bacbo-live/latest \
  -H "x-api-key: TU_CLAVE"

Las claves, la prueba y las suscripciones (puedes suscribir la misma API varias veces, cada una con sus claves) funcionan igual en todas las APIs y se explican en la documentación general.

Ejemplos de código

Ejemplos listos para copiar, en Python, Node.js y PHP. Cambia TU_CLAVE por la clave del panel y ejecútalo: cada uno llama a la función on_round (onRound en Node.js) en cada ronda nueva de Bac Bo Live, y ahí va tu código.

Tiempo real por el stream (recomendado)

Una conexión abierta que recibe cada ronda en el instante en que cierra. Solo abrir la conexión gasta una solicitud, así que no chocas con el límite por minuto, y es el camino que entrega más rápido. El ejemplo reconecta solo, envía el last-event-id para recibir en missed lo que cerró mientras estuvo fuera, y se detiene cuando llega closed.

import json
import time
import requests

API = "https://api.lynxmetrics.com/v1/bacbo-live"
KEY = "TU_CLAVE"


def on_round(r):
    print(r["id"], r["outcome"], r["data"])


def listen():
    last_id = None
    while True:
        headers = {"x-api-key": KEY, "accept": "text/event-stream"}
        if last_id:
            headers["last-event-id"] = last_id
        try:
            with requests.get(API + "/stream", headers=headers, stream=True, timeout=(10, 60)) as res:
                if res.status_code != 200:
                    print("HTTP", res.status_code, res.text)
                    time.sleep(int(res.headers.get("retry-after", 10)))
                    continue
                res.encoding = "utf-8"
                event, data = None, []
                for line in res.iter_lines(chunk_size=1, decode_unicode=True):
                    if line.startswith("event:"):
                        event = line[6:].strip()
                    elif line.startswith("data:"):
                        data.append(line[5:].strip())
                    elif line == "":
                        if event and data:
                            body = json.loads("\n".join(data))
                            if event == "ready":
                                for r in body.get("missed") or []:
                                    on_round(r)
                                if body.get("data"):
                                    last_id = body["data"]["id"]
                            elif event == "round":
                                on_round(body["data"])
                                last_id = body["data"]["id"]
                            elif event == "closed":
                                return
                        event, data = None, []
        except requests.RequestException as error:
            print("reconnecting:", error)
        time.sleep(3)


listen()

Latest con espera (sin conexión abierta)

Para quien prefiere pedir en vez de mantener una conexión abierta. ?wait=20 retiene la respuesta hasta que cierre la próxima ronda de Bac Bo Live, por un máximo de 20 segundos, así que la ronda llega en el instante en que cierra y el ejemplo hace pocas solicitudes por minuto en vez de preguntar todo el tiempo. Envía el ETag de la última respuesta en if-none-match: mientras nada cambia, la espera termina en 304 sin cuerpo, y ante un 429 espera el tiempo del encabezado retry-after en vez de insistir.

import time
import requests

API = "https://api.lynxmetrics.com/v1/bacbo-live"

session = requests.Session()
session.headers["x-api-key"] = "TU_CLAVE"


def on_round(r):
    print(r["id"], r["outcome"], r["data"])


etag = None
last_id = None
while True:
    try:
        res = session.get(
            API + "/latest",
            params={"wait": 20},
            headers={"if-none-match": etag} if etag else {},
            timeout=30,
        )
    except requests.RequestException as error:
        print("retrying:", error)
        time.sleep(5)
        continue

    if res.status_code == 200:
        etag = res.headers.get("etag")
        r = res.json()["data"]
        if r and r["id"] != last_id:
            if last_id:
                on_round(r)
            last_id = r["id"]
    elif res.status_code == 429:
        time.sleep(int(res.headers.get("retry-after", 5)))
        continue
    elif res.status_code != 304:
        print("HTTP", res.status_code, res.text)
        time.sleep(10)
        continue
    time.sleep(2)

Enviar cada ronda a Telegram

Cambia la función on_round de cualquiera de los ejemplos de arriba por esta, con el token de tu bot (el que entrega @BotFather) y el id del chat o del canal. El outcome y todo lo que viene en data están explicados más abajo, en Campos de cada ronda.

BOT_TOKEN = "123456:ABC..."
CHAT_ID = "-1001234567890"


def on_round(r):
    text = f"{r['outcome'].upper()} · {r['id']}"
    requests.post(
        f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage",
        json={"chat_id": CHAT_ID, "text": text},
        timeout=10,
    )

Lo que más problemas da en un bot

  • No consultes más rápido de lo que juega la mesa. Con menos de 1 segundo entre consultas solo gastas el límite y recibes 429: la ronda nueva no llega antes por eso. Si necesitas el resultado en el mismo segundo, usa /stream.
  • Ante un 429, lee el encabezado retry-after y espera ese tiempo, porque repetir al instante no sirve. Toda respuesta trae x-ratelimit-remaining y x-ratelimit-reset, que dicen cuánto cabe todavía en el minuto.
  • Un 401 en cada llamada quiere decir clave equivocada, revocada o cambiada en el panel: copia la clave de nuevo. Muchos intentos seguidos con una clave inválida hacen que tu IP reciba 429 por un tiempo, incluso después de corregirla.
  • trial_expired quiere decir que las horas de la prueba terminaron. Al suscribirte a un plan en el panel, la misma clave vuelve a funcionar, sin tocar el código.
  • Si tu bot estuvo detenido, no intentes adivinar lo que perdió: pide /results?after= con el id de la última ronda que tienes y recibe, en orden, todas las que cerraron después.
  • Cada clave tiene un número de conexiones de stream, en la tabla de límites. Si lo superas, la conexión más antigua se cierra con closed. Para ejecutar varios bots, crea una clave para cada uno en el panel.

GET /v1/bacbo-live/latest

La ronda más reciente de Bac Bo Live, o null si todavía no hay ninguna.

  • waitnumber

    Segundos que la respuesta puede esperar a la próxima ronda, hasta 20. Solo espera quien ya tiene la última: envía su ETag en if-none-match o su id en after. Cuando una ronda cierra, la respuesta sale al instante con ella; si el tiempo se acaba antes, llega 304 (con ETag) o la misma ronda (con after). Cuenta como una sola solicitud, y el tiempo límite de tu cliente debe ser mayor que el wait.

  • afterid

    El id de la última ronda que tienes. Solo sirve junto con wait, para quien no guarda el ETag.

Respuesta

{
  "data": {
    "id": "v1794669483249",
    "game": "bacbo-live",
    "tableId": "BacBo00000000001",
    "startedAt": "2026-11-14T15:17:48.079Z",
    "settledAt": "2026-11-14T15:18:12.409Z",
    "outcome": "tie",
    "data": {
      "player": { "dice": [4, 1], "score": 5 },
      "banker": { "dice": [1, 4], "score": 5 },
      "multiplier": 6
    }
  }
}

GET /v1/bacbo-live/results

Rondas de Bac Bo Live de la más nueva a la más antigua. Para traer la página siguiente, pasa el nextCursor de la respuesta en before, y cuando venga null ya no hay más resultados.

  • limitnumber

    Cuántas rondas traer, 50 por defecto y 250 a 1000 como máximo.

  • beforeISO 8601

    Trae solo rondas cerradas antes de esta fecha, como el nextCursor de la página anterior, y hasta dónde puedes volver depende del plan.

  • afterISO 8601 | id

    Para sincronizar sin repetir ni saltar rondas, pasa el settledAt o el id de la última ronda que ya tienes, y la respuesta trae solo las cerradas después de ella, de la más antigua a la más nueva, hasta el limit. Si la página viene llena, pasa su nextCursor en el siguiente after, y cuando venga null ya estás al día. También respeta el historial del plan y se puede usar junto con before.

GET /v1/bacbo-live/results?limit=1

{
  "data": [
    {
      "id": "v1794669483249",
      "game": "bacbo-live",
      "tableId": "BacBo00000000001",
      "startedAt": "2026-11-14T15:17:48.079Z",
      "settledAt": "2026-11-14T15:18:12.409Z",
      "outcome": "tie",
      "data": {
        "player": { "dice": [4, 1], "score": 5 },
        "banker": { "dice": [1, 4], "score": 5 },
        "multiplier": 6
      }
    }
  ],
  "nextCursor": "2026-11-14T15:18:12.409Z"
}

GET /v1/bacbo-live/stream

Rondas de Bac Bo Live en vivo, por una conexión que queda abierta (SSE, Server-Sent Events): cada ronda llega en el instante en que se guarda, sin que preguntes. Es el camino más rápido, porque elimina el intervalo entre tus consultas. Es HTTP común, así que atraviesa proxy y CDN y funciona con cualquier cliente que acepte cabecera y lectura continua.

curl -N https://api.lynxmetrics.com/v1/bacbo-live/stream \
  -H "x-api-key: TU_CLAVE" \
  -H "accept: text/event-stream"

Respuesta

event: round
data: {
data:   "data": {
data:     "id": "v1794669483249",
data:     "game": "bacbo-live",
data:     "tableId": "BacBo00000000001",
data:     "startedAt": "2026-11-14T15:17:48.079Z",
data:     "settledAt": "2026-11-14T15:18:12.409Z",
data:     "outcome": "tie",
data:     "data": {
data:       "player": { "dice": [4, 1], "score": 5 },
data:       "banker": { "dice": [1, 4], "score": 5 },
data:       "multiplier": 6
data:     }
data:   },
data:   "timing": {
data:     "receivedAt": "2026-11-14T15:18:16.309Z",
data:     "sentAt": "2026-11-14T15:18:16.359Z"
data:   }
data: }

Qué llega por la conexión

  • readyevent

    Llega una sola vez, apenas se abre la conexión, con la última ronda ya cerrada, para que empieces al día. No es una ronda nueva: compara su id con el de la última que tienes y no la cuentes dos veces. El data llega null mientras no haya ninguna ronda. En una reconexión trae además, en missed, las rondas que cerraron mientras no estabas.

  • phaseopcional

    Opcional: solo llega si lo pides con ?phases=1. Son dos avisos por ronda, ambos con ref, game, phase, at y sentAt: betting, cuando la mesa vuelve al plano abierto y abren las apuestas de la próxima ronda, y resolving, cuando entra en la resolución y las apuestas ya cerraron — este lleva también el roundId, el id que la ronda va a tener en round, varios segundos antes del resultado. Para saber a qué ronda pertenece un resultado NO necesitas esto: basta el id del round, el orden garantizado y el last-event-id. La fase sirve para atar más temprano, y no es una promesa de resultado: un close-up cortado, un hueco en la transmisión de la mesa o una lectura insegura hacen que descartemos la ronda a propósito, y entonces ningún round llega con ese ref.

  • roundevent

    Una por ronda nueva, con el mismo objeto que devuelve /latest en data, los horarios de la entrega en timing y, cuando la ronda tuvo fase, su ref. El id del evento es el id de la ronda, y solo round lleva id, porque es el punto de retomada en la reconexión.

  • correctionopcional

    Opcional: solo llega si lo pides con ?corrections=1. Avisa que una ronda que ya había salido como round cambió: en Bac Bo, cerca de una vez cada 2.000 rondas la mesa repite la tirada de un cubilete después de que los dados se detuvieron, y el dado publicado deja de valer. Llega con data, la ronda como queda (el mismo id y los mismos horarios), previous, con el outcome y el data que se habían entregado, y sentAt. No lleva id de evento, así que el last-event-id no cambia. Llega cuando esa ronda termina en la mesa, de 30 segundos a 3 minutos después del round. Aunque no lo pidas, /latest, /results y /stats pasan a devolver la ronda corregida.

  • gapevent

    La fila de esta conexión se desbordó y se descartaron rondas: tu cliente no estaba siguiendo el ritmo. Llega con resyncError: too_many_missed, el mismo código de una reconexión que se alargó. La conexión sigue abierta, y es el único caso en que falta una ronda en medio del stream — siempre anunciado, porque los ids no son secuenciales y no tendrías cómo notarlo. Para cerrar el hueco, pide /results?after= con el id de la última ronda que recibiste.

  • closedevent

    Tu conexión se cerró porque se abrió otra más nueva con la misma clave. Llega con reason: "replaced". No es una caída de red, así que no reconectes automáticamente: reconectar aquí solo cerraría la conexión nueva, que entonces reconectaría y cerraría la tuya, sin fin.

  • : pingcomentario

    Cada 20 segundos sin ronda sale una línea que empieza con dos puntos. No es un evento y puedes ignorarla; solo evita que algún proxy cierre la conexión inactiva.

Atar un pronóstico antes del cierre

El id de una ronda es el instante mismo en que cerraron las apuestas, al milisegundo: no existe mientras están abiertas, y no hay forma de adivinarlo. Para quien publica un pronóstico antes del cierre existe el ref, una referencia nuestra, creada en la apertura de las apuestas y repetida en la resolución y en el resultado. Sella el pronóstico con el ref del betting y cásalo con el round que traiga el mismo ref, sin depender del orden de llegada y sin esperar el id. Pide las fases con ?phases=1; quien conecta a mitad de ronda recibe enseguida la fase en la que está la mesa.

La misma ronda, de la apertura de apuestas al resultado

event: phase
data: {
data:   "ref": "r1761939000000-7",
data:   "game": "bacbo-live",
data:   "phase": "betting",
data:   "at": "2026-11-14T15:17:46.409Z",
data:   "sentAt": "2026-11-14T15:17:46.509Z"
data: }

event: phase
data: {
data:   "ref": "r1761939000000-7",
data:   "roundId": "v1794669483249",
data:   "game": "bacbo-live",
data:   "phase": "resolving",
data:   "at": "2026-11-14T15:18:03.249Z",
data:   "sentAt": "2026-11-14T15:18:05.409Z"
data: }

event: round
data: {
data:   "data": {
data:     "id": "v1794669483249",
data:     "game": "bacbo-live",
data:     "tableId": "BacBo00000000001",
data:     "startedAt": "2026-11-14T15:17:48.079Z",
data:     "settledAt": "2026-11-14T15:18:12.409Z",
data:     "outcome": "tie",
data:     "data": {
data:       "player": { "dice": [4, 1], "score": 5 },
data:       "banker": { "dice": [1, 4], "score": 5 },
data:       "multiplier": 6
data:     }
data:   },
data:   "ref": "r1761939000000-7",
data:   "timing": {
data:     "receivedAt": "2026-11-14T15:18:16.309Z",
data:     "sentAt": "2026-11-14T15:18:16.359Z"
data:   }
data: }
  • refstring

    La referencia de la ronda, igual en los tres eventos. Es una cadena opaca: no intentes interpretarla ni derivar de ella la siguiente. Un ref puede quedarse sin resultado: si la ronda se descarta, ningún round llega con él, y el betting siguiente abre otro.

  • roundIdstring

    El id definitivo de la ronda. Solo aparece a partir del resolving, porque está anclado al instante del cierre de las apuestas. Es el que viene en el id del evento round y el que sirve de last-event-id en la reconexión.

  • phasebetting | resolving

    betting: abrieron las apuestas de la próxima ronda. resolving: la mesa entró en la resolución y las apuestas cerraron. Comprueba siempre este campo en vez de suponer, porque pueden agregarse fases nuevas.

  • atISO 8601

    Instante de la fase en el reloj de la mesa, el mismo de startedAt y settledAt. El sentAt, al lado, es cuándo salió el aviso por tu conexión.

Horarios y retraso

Los eventos llevan los horarios de cada tramo del camino, para que midas el retraso real en vez de estimarlo. Los horarios de la ronda están en el reloj de la mesa; los de la entrega, en el reloj de nuestra API. El retraso de Bac Bo Live se mide contra la mesa y aparece en los propios sellos de tiempo de cada evento, ronda por ronda.

  • data.startedAtISO 8601

    Inicio de la ronda en el reloj de la mesa, que es cuando se abrieron las apuestas.

  • data.settledAtISO 8601

    Fin de la ronda en el reloj de la mesa: el instante en que el resultado quedó definido en el origen. Es también la fecha que se usa en el orden, en before y en after.

  • timing.receivedAtISO 8601

    Cuándo el resultado quedó listo de nuestro lado. La diferencia entre eso y el settledAt es el retraso del origen hasta nosotros, que es la parte que está en nuestras manos.

  • timing.sentAtISO 8601

    Cuándo se escribió este evento en tu conexión. La diferencia entre eso y el receivedAt es lo que la ronda esperó en la cola de esta conexión, normalmente unos milisegundos; el resto del retraso hasta tu código es red.

Reconectar sin perder rondas

Al reconectar, manda en la cabecera last-event-id el id de la última ronda que recibiste — un cliente de SSE que reconecta solo ya manda esa cabecera, y si controlas la reconexión mandas la cabecera o ?last_event_id=, como prefieras. El ready vuelve con missed: las rondas que cerraron mientras no estabas, de la más antigua a la más nueva. El stream resuelve ausencias de hasta 50 rondas; si cerraron más que eso, no te entrega las más recientes ni lo intenta — missed llega null con too_many_missed, y cierras el hueco con /results?after=. El data sigue siendo la última ronda cerrada, que normalmente es el último elemento de missed. Cuando no se puede recuperar, missed llega null y resyncError dice por qué; la conexión abre de todos modos, porque una reconexión no puede fallar por un cursor viejo.

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: v1794669483249"
  • bad_cursorresyncError

    El valor enviado no es un id de ronda ni una fecha ISO 8601.

  • unknown_roundresyncError

    Ese id no es de ninguna ronda nuestra en esta API. Puede ser de otra API, o de una ronda que terminamos descartando: un phase no garantiza que la ronda vaya a existir.

  • plan_limitresyncError

    La ronda es más antigua que el historial de tu plan.

  • too_many_missedresyncError

    Cerraron más de 50 rondas mientras no estabas, o sea que estuviste fuera demasiado tiempo para que el stream lo resuelva solo. Pide /results?after= con el id que tienes y pagina hasta quedar al día.

Cómo mantener la conexión

  • Dentro de una conexión los eventos salen uno por vez y en orden cronológico: las fases de una ronda siempre antes de su resultado — betting, resolving y round, con el mismo ref —, y cada round con un settledAt mayor que el anterior. El betting de una ronda puede llegar poco antes del round de la anterior, porque uno viene de la mesa y el otro de la base; lo que vale es el orden dentro de cada ronda. Ninguna ronda llega dos veces en la misma conexión. Si tu conexión se pone lenta y su fila se desborda, las rondas más antiguas se descartan y sale un event: gap avisando.
  • Cada plan permite un número de conexiones simultáneas por clave, en la tabla de límites de abajo. Pasarse de ese número no da 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 murió sin avisar nunca te deja fuera de tu propia plaza.
  • Toda conexión se cierra después de 6 horas, aunque funcione bien, y el cliente debe reconectar. Ese cierre no manda ningún evento: la conexión simplemente se cierra, y el closed es solo de la sustitución, así que una lectura que termina sin motivo después de horas abierta es este plazo. Es a propósito: hay conexiones que mueren sin avisar, y ese plazo es lo que impide que ocupen lugar para siempre. Algo que corre todo el día reconecta unas cuatro veces al día.
  • Si tu cliente tiene tiempo límite de lectura, déjalo por encima de 20 segundos, o cortará la conexión en el silencio entre una ronda y otra.
  • Abrir la conexión gasta una solicitud de tu límite por minuto. Las rondas que llegan después no gastan nada, así que seguir el stream pesa menos en el límite que consultar /latest.
  • La clave solo se acepta en el encabezado x-api-key, nunca en la URL, que quedaría en registros de proxy y en el historial. Por eso el EventSource del navegador no sirve: no envía encabezados. En el navegador, el camino es un fetch que lee el cuerpo a medida que llega; mejor aún es que tu propio servidor escuche el stream y lo reenvíe, porque una clave en el navegador quedaría a la vista de cualquier visitante.

GET /v1/bacbo-live/stats

Estadísticas de Bac Bo Live calculadas al momento sobre las últimas rondas.

  • samplenumber

    Sobre cuántas rondas recientes calcular, 100 por defecto y 250 a 1000 como máximo.

GET /v1/bacbo-live/stats

{
  "data": {
    "total": 100,
    "counts": { "player": 46, "banker": 45, "tie": 9 },
    "percentages": { "player": 46, "banker": 45, "tie": 9 },
    "currentStreak": { "outcome": "banker", "length": 3 },
    "outcomes": {
      "player": {
        "count": 46,
        "percent": 46,
        "longestStreak": 5,
        "sinceLast": 3
      },
      "banker": {
        "count": 45,
        "percent": 45,
        "longestStreak": 6,
        "sinceLast": 0
      },
      "tie": {
        "count": 9,
        "percent": 9,
        "longestStreak": 1,
        "sinceLast": 11
      }
    },
    "sample": {
      "from": "2026-11-14T14:27:05.112Z",
      "to": "2026-11-14T15:18:12.409Z"
    },
    "tieMultipliers": { "4": 5, "6": 3, "88": 1 }
  }
}

Campos de cada ronda

Formato de cada ronda de Bac Bo Live en latest y results.

  • idstring

    Id de la ronda, único y estable. Lo generamos nosotros, no el proveedor, así que úsalo solo para comparar y como cursor (en after y last-event-id), sin interpretar su contenido.

  • gamestring

    Slug de la API, que aquí siempre es "bacbo-live".

  • tableIdstring | null

    Id de la mesa en el proveedor, o null cuando la fuente no lo informa.

  • startedAtstring | null

    Inicio de la ronda en UTC, o null cuando la fuente no lo informa.

  • settledAtstring

    Fin de la ronda en UTC, que es la fecha usada para ordenar y en before.

  • outcome"player" | "banker" | "tie"

    Quién ganó la ronda: player, banker o tie, que es el empate.

  • data.player.dice[number, number]

    Los dos dados del Player, de 1 a 6.

  • data.player.scorenumber

    Suma de los dados del Player, de 2 a 12.

  • data.banker.dice[number, number]

    Los dos dados del Banker, de 1 a 6.

  • data.banker.scorenumber

    Suma de los dados del Banker, de 2 a 12.

  • data.multipliernumber | null

    Multiplicador pagado en el empate, como 4, 6 u 88, y null cuando la ronda no termina en empate.

Campos de las estadísticas

  • totalnumber

    Cuántas rondas entraron en la cuenta, igual a sample o menos si todavía hay pocas.

  • counts{ player, banker, tie }

    Victorias de Player, de Banker y empates en la muestra.

  • percentages{ player, banker, tie }

    Los mismos conteos en porcentaje, con un decimal.

  • currentStreak{ outcome, length } | null

    El resultado que se repite ahora y desde hace cuántas rondas, o null sin rondas.

  • outcomes{ player, banker, tie }

    Un bloque por resultado: count (cuántas veces salió), percent, longestStreak (la racha más larga en la muestra) y sinceLast (rondas desde la última vez, con 0 para la ronda más reciente y null si no salió en la muestra). Tiene la misma forma en todas las APIs.

  • sample{ from, to } | null

    Periodo de la muestra: el settledAt de la ronda más antigua (from) y de la más nueva (to), o null sin rondas.

  • tieMultipliers{ [multiplier]: number }

    Cuántos empates de la muestra pagaron cada multiplicador, con el multiplicador como clave.

Planes y límites

Límites de la API de Bac Bo Live en cada plan. Un parámetro por encima del máximo se reduce al máximo, y un before más antiguo que el historial del plan responde plan_limit. La columna por minuto es el límite de solicitudes por minuto de cada suscripción, sumando todas sus claves, y la columna de conexiones es cuántas conexiones de /stream puede tener abiertas al mismo tiempo la misma clave.

PlanPrecioPor minutoConexioneslimitsamplebefore
Prueba2 horas, sin tarjeta6012502507 días
Pro≈ 3,72 US$/mes6012502507 días
Business≈ 8,47 US$/mes400510001000completo

Los errores tienen el mismo formato en todas las APIs y están en la documentación general.