# 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.

Base URL: `https://api.lynxmetrics.com/v1/bacbo-live`

Source: https://lynxmetrics.com/es/docs/bacbo-live · Ver Bac Bo Live en vivo: https://lynxmetrics.com/es/apis/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`.

```bash
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](https://lynxmetrics.com/es/docs#autenticacao). (https://lynxmetrics.com/es/docs.md)

## 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`.

Python

```python
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()
```

Node.js

```js
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

```php
<?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.

Python

```python
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)
```

Node.js

```js
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

```php
<?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.

Python

```python
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,
    )
```

Node.js

```js
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));
}
```

PHP

```php
$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 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.

| Field | Type |  |
| --- | --- | --- |
| `wait` | `number` | 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`. |
| `after` | `id` | El `id` de la última ronda que tienes. Solo sirve junto con `wait`, para quien no guarda el `ETag`. |

```json
{
  "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.

| Field | Type |  |
| --- | --- | --- |
| `limit` | `number` | Cuántas rondas traer, 50 por defecto y 250 a 1000 como máximo. |
| `before` | `ISO 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. |
| `after` | `ISO 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`. |

```json
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.

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

```text
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

| Field | Type |  |
| --- | --- | --- |
| `ready` | `event` | 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. |
| `phase` | `opcional` | 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`. |
| `round` | `event` | 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. |
| `correction` | `opcional` | 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. |
| `gap` | `event` | 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. |
| `closed` | `event` | 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. |
| `: ping` | `comentario` | 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.

```text
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: }

```

| Field | Type |  |
| --- | --- | --- |
| `ref` | `string` | 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. |
| `roundId` | `string` | 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. |
| `phase` | `betting \| 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. |
| `at` | `ISO 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.

| Field | Type |  |
| --- | --- | --- |
| `data.startedAt` | `ISO 8601` | Inicio de la ronda en el reloj de la mesa, que es cuando se abrieron las apuestas. |
| `data.settledAt` | `ISO 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.receivedAt` | `ISO 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.sentAt` | `ISO 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.

```bash
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"
```

| Field | Type |  |
| --- | --- | --- |
| `bad_cursor` | `resyncError` | El valor enviado no es un id de ronda ni una fecha ISO 8601. |
| `unknown_round` | `resyncError` | 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_limit` | `resyncError` | La ronda es más antigua que el historial de tu plan. |
| `too_many_missed` | `resyncError` | 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.

| Field | Type |  |
| --- | --- | --- |
| `sample` | `number` | Sobre cuántas rondas recientes calcular, 100 por defecto y 250 a 1000 como máximo. |

```json
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.

| Field | Type |  |
| --- | --- | --- |
| `id` | `string` | 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. |
| `game` | `string` | Slug de la API, que aquí siempre es "bacbo-live". |
| `tableId` | `string \| null` | Id de la mesa en el proveedor, o null cuando la fuente no lo informa. |
| `startedAt` | `string \| null` | Inicio de la ronda en UTC, o null cuando la fuente no lo informa. |
| `settledAt` | `string` | 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.score` | `number` | 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.score` | `number` | Suma de los dados del Banker, de 2 a 12. |
| `data.multiplier` | `number \| 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

| Field | Type |  |
| --- | --- | --- |
| `total` | `number` | 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.

| Plan | Precio | Por minuto | Conexiones | limit | sample | before |
| --- | --- | --- | --- | --- | --- | --- |
| Prueba | 2 horas, sin tarjeta | 60 | 1 | 250 | 250 | 7 días |
| Pro | 21,90 BRL/mes | 60 | 1 | 250 | 250 | 7 días |
| Business | 49,90 BRL/mes | 400 | 5 | 1000 | 1000 | completo |

Los errores tienen el mismo formato en todas las APIs y están en la [documentación general](https://lynxmetrics.com/es/docs#erros).
