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
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()const API = "https://api.lynxmetrics.com/v1/bacbo-live";
const KEY = "TU_CLAVE";
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
function onRound(r) {
console.log(r.id, r.outcome, r.data);
}
async function listen() {
let lastId = null;
for (;;) {
try {
const headers = { "x-api-key": KEY, accept: "text/event-stream" };
if (lastId) headers["last-event-id"] = lastId;
const res = await fetch(API + "/stream", { headers });
if (!res.ok) {
console.error("HTTP", res.status, await res.text());
await sleep(Number(res.headers.get("retry-after") ?? 10) * 1000);
continue;
}
const decoder = new TextDecoder();
let buffer = "";
for await (const chunk of res.body) {
buffer += decoder.decode(chunk, { stream: true });
let end;
while ((end = buffer.indexOf("\n\n")) >= 0) {
const block = buffer.slice(0, end);
buffer = buffer.slice(end + 2);
const event = /^event: (.+)$/m.exec(block)?.[1];
const data = block
.split("\n")
.filter((line) => line.startsWith("data:"))
.map((line) => line.slice(5).trim())
.join("\n");
if (!event || !data) continue;
const body = JSON.parse(data);
if (event === "ready") {
for (const r of body.missed ?? []) onRound(r);
if (body.data) lastId = body.data.id;
} else if (event === "round") {
onRound(body.data);
lastId = body.data.id;
} else if (event === "closed") {
return;
}
}
}
} catch (error) {
console.error("reconnecting:", error.message);
}
await sleep(3000);
}
}
listen();<?php
$api = "https://api.lynxmetrics.com/v1/bacbo-live";
$key = "TU_CLAVE";
function on_round(array $r): void
{
echo $r["id"], " ", $r["outcome"], " ", json_encode($r["data"]), PHP_EOL;
}
$lastId = null;
while (true) {
$headers = ["x-api-key: $key", "accept: text/event-stream"];
if ($lastId) $headers[] = "last-event-id: $lastId";
$buffer = "";
$closed = false;
$ch = curl_init("$api/stream");
curl_setopt_array($ch, [
CURLOPT_HTTPHEADER => $headers,
CURLOPT_CONNECTTIMEOUT => 10,
CURLOPT_WRITEFUNCTION => function ($ch, $chunk) use (&$buffer, &$lastId, &$closed) {
$buffer .= $chunk;
while (($end = strpos($buffer, "\n\n")) !== false) {
$block = substr($buffer, 0, $end);
$buffer = substr($buffer, $end + 2);
if (!preg_match('/^event: (.+)$/m', $block, $event)) continue;
preg_match_all('/^data: ?(.*)$/m', $block, $data);
$body = json_decode(implode("\n", $data[1]), true);
if (!is_array($body)) continue;
if ($event[1] === "ready") {
foreach ($body["missed"] ?? [] as $r) on_round($r);
if (!empty($body["data"])) $lastId = $body["data"]["id"];
} elseif ($event[1] === "round") {
on_round($body["data"]);
$lastId = $body["data"]["id"];
} elseif ($event[1] === "closed") {
$closed = true;
return 0;
}
}
return strlen($chunk);
},
]);
curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
if ($closed) break;
if ($status !== 200) fwrite(STDERR, "HTTP $status" . PHP_EOL);
sleep($status === 200 ? 3 : 10);
}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)const API = "https://api.lynxmetrics.com/v1/bacbo-live";
const KEY = "TU_CLAVE";
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
function onRound(r) {
console.log(r.id, r.outcome, r.data);
}
async function poll() {
let etag = null;
let lastId = null;
for (;;) {
let res;
try {
const headers = { "x-api-key": KEY };
if (etag) headers["if-none-match"] = etag;
res = await fetch(API + "/latest?wait=20", { headers, signal: AbortSignal.timeout(30_000) });
} catch (error) {
console.error("retrying:", error.message);
await sleep(5000);
continue;
}
if (res.status === 200) {
etag = res.headers.get("etag");
const { data } = await res.json();
if (data && data.id !== lastId) {
if (lastId) onRound(data);
lastId = data.id;
}
} else if (res.status === 429) {
await sleep(Number(res.headers.get("retry-after") ?? 5) * 1000);
continue;
} else if (res.status !== 304) {
console.error("HTTP", res.status, await res.text());
await sleep(10_000);
continue;
}
await sleep(2000);
}
}
poll();<?php
$api = "https://api.lynxmetrics.com/v1/bacbo-live";
$key = "TU_CLAVE";
function on_round(array $r): void
{
echo $r["id"], " ", $r["outcome"], " ", json_encode($r["data"]), PHP_EOL;
}
$etag = null;
$lastId = null;
while (true) {
$headers = ["x-api-key: $key"];
if ($etag) $headers[] = "if-none-match: $etag";
$received = [];
$ch = curl_init("$api/latest?wait=20");
curl_setopt_array($ch, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => $headers,
CURLOPT_TIMEOUT => 30,
CURLOPT_HEADERFUNCTION => function ($ch, $line) use (&$received) {
$parts = explode(":", $line, 2);
if (count($parts) === 2) $received[strtolower(trim($parts[0]))] = trim($parts[1]);
return strlen($line);
},
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
if ($status === 200) {
$etag = $received["etag"] ?? null;
$round = json_decode($body, true)["data"] ?? null;
if ($round && $round["id"] !== $lastId) {
if ($lastId) on_round($round);
$lastId = $round["id"];
}
} elseif ($status === 429) {
sleep((int) ($received["retry-after"] ?? 5));
continue;
} elseif ($status !== 304) {
fwrite(STDERR, "HTTP $status $body" . PHP_EOL);
sleep(10);
continue;
}
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,
)const BOT_TOKEN = "123456:ABC...";
const CHAT_ID = "-1001234567890";
function onRound(r) {
fetch(`https://api.telegram.org/bot${BOT_TOKEN}/sendMessage`, {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ chat_id: CHAT_ID, text: `${r.outcome.toUpperCase()} · ${r.id}` }),
signal: AbortSignal.timeout(10_000),
}).catch((error) => console.error("telegram:", error.message));
}$botToken = "123456:ABC...";
$chatId = "-1001234567890";
function on_round(array $r): void
{
global $botToken, $chatId;
$ch = curl_init("https://api.telegram.org/bot$botToken/sendMessage");
curl_setopt_array($ch, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 10,
CURLOPT_POSTFIELDS => ["chat_id" => $chatId, "text" => strtoupper($r["outcome"]) . " · " . $r["id"]],
]);
curl_exec($ch);
curl_close($ch);
}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 encabezadoretry-aftery espera ese tiempo, porque repetir al instante no sirve. Toda respuesta traex-ratelimit-remainingyx-ratelimit-reset, que dicen cuánto cabe todavía en el minuto. - Un
401en 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 reciba429por un tiempo, incluso después de corregirla. trial_expiredquiere 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 elidde 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.
waitnumberSegundos que la respuesta puede esperar a la próxima ronda, hasta 20. Solo espera quien ya tiene la última: envía su
ETagenif-none-matcho suidenafter. Cuando una ronda cierra, la respuesta sale al instante con ella; si el tiempo se acaba antes, llega304(con ETag) o la misma ronda (conafter). Cuenta como una sola solicitud, y el tiempo límite de tu cliente debe ser mayor que elwait.afteridEl
idde la última ronda que tienes. Solo sirve junto conwait, para quien no guarda elETag.
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.
limitnumberCuántas rondas traer, 50 por defecto y 250 a 1000 como máximo.
beforeISO 8601Trae solo rondas cerradas antes de esta fecha, como el
nextCursorde la página anterior, y hasta dónde puedes volver depende del plan.afterISO 8601 | idPara sincronizar sin repetir ni saltar rondas, pasa el
settledAto elidde 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 ellimit. Si la página viene llena, pasa sunextCursoren el siguienteafter, y cuando venganullya estás al día. También respeta el historial del plan y se puede usar junto conbefore.
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
readyeventLlega 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
idcon el de la última que tienes y no la cuentes dos veces. Eldatalleganullmientras no haya ninguna ronda. En una reconexión trae además, enmissed, las rondas que cerraron mientras no estabas.phaseopcionalOpcional: solo llega si lo pides con
?phases=1. Son dos avisos por ronda, ambos conref,game,phase,atysentAt:betting, cuando la mesa vuelve al plano abierto y abren las apuestas de la próxima ronda, yresolving, cuando entra en la resolución y las apuestas ya cerraron — este lleva también elroundId, el id que la ronda va a tener enround, varios segundos antes del resultado. Para saber a qué ronda pertenece un resultado NO necesitas esto: basta eliddelround, el orden garantizado y ellast-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únroundllega con eseref.roundeventUna por ronda nueva, con el mismo objeto que devuelve
/latestendata, los horarios de la entrega entimingy, cuando la ronda tuvo fase, suref. Eliddel evento es el id de la ronda, y soloroundllevaid, porque es el punto de retomada en la reconexión.correctionopcionalOpcional: solo llega si lo pides con
?corrections=1. Avisa que una ronda que ya había salido comoroundcambió: 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 condata, la ronda como queda (el mismoidy los mismos horarios),previous, con eloutcomey eldataque se habían entregado, ysentAt. No llevaidde evento, así que ellast-event-idno cambia. Llega cuando esa ronda termina en la mesa, de 30 segundos a 3 minutos después delround. Aunque no lo pidas,/latest,/resultsy/statspasan a devolver la ronda corregida.gapeventLa 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.closedeventTu 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.: pingcomentarioCada 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: }
refstringLa referencia de la ronda, igual en los tres eventos. Es una cadena opaca: no intentes interpretarla ni derivar de ella la siguiente. Un
refpuede quedarse sin resultado: si la ronda se descarta, ningúnroundllega con él, y elbettingsiguiente abre otro.roundIdstringEl 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 eliddel eventoroundy el que sirve delast-event-iden la reconexión.phasebetting | resolvingbetting: 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 8601Instante de la fase en el reloj de la mesa, el mismo de
startedAtysettledAt. ElsentAt, 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 8601Inicio de la ronda en el reloj de la mesa, que es cuando se abrieron las apuestas.
data.settledAtISO 8601Fin 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
beforey enafter.timing.receivedAtISO 8601Cuándo el resultado quedó listo de nuestro lado. La diferencia entre eso y el
settledAtes el retraso del origen hasta nosotros, que es la parte que está en nuestras manos.timing.sentAtISO 8601Cuándo se escribió este evento en tu conexión. La diferencia entre eso y el
receivedAtes 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_cursorresyncErrorEl valor enviado no es un id de ronda ni una fecha ISO 8601.
unknown_roundresyncErrorEse id no es de ninguna ronda nuestra en esta API. Puede ser de otra API, o de una ronda que terminamos descartando: un
phaseno garantiza que la ronda vaya a existir.plan_limitresyncErrorLa ronda es más antigua que el historial de tu plan.
too_many_missedresyncErrorCerraron 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,resolvingyround, con el mismoref—, y cadaroundcon unsettledAtmayor que el anterior. Elbettingde una ronda puede llegar poco antes delroundde 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 unevent: gapavisando. - 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: closedy 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
closedes 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 elEventSourcedel navegador no sirve: no envía encabezados. En el navegador, el camino es unfetchque 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.
samplenumberSobre 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.
idstringId 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.
gamestringSlug de la API, que aquí siempre es "bacbo-live".
tableIdstring | nullId de la mesa en el proveedor, o null cuando la fuente no lo informa.
startedAtstring | nullInicio de la ronda en UTC, o null cuando la fuente no lo informa.
settledAtstringFin 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.scorenumberSuma 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.scorenumberSuma de los dados del Banker, de 2 a 12.
data.multipliernumber | nullMultiplicador pagado en el empate, como 4, 6 u 88, y null cuando la ronda no termina en empate.
Campos de las estadísticas
totalnumberCuá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 } | nullEl 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 } | nullPeriodo 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.
| Plan | Precio | Por minuto | Conexiones | limit | sample | before |
|---|---|---|---|---|---|---|
| Prueba | 2 horas, sin tarjeta | 60 | 1 | 250 | 250 | 7 días |
| Pro | ≈ 3,72 US$/mes | 60 | 1 | 250 | 250 | 7 días |
| Business | ≈ 8,47 US$/mes | 400 | 5 | 1000 | 1000 | completo |
Los errores tienen el mismo formato en todas las APIs y están en la documentación general.