# Lightning Baccarat API

Rounds from Evolution's Lightning Baccarat table: Player and Banker cards, score, winner, pairs and naturals. Lightning multipliers not included. This page shows how the Lightning Baccarat API responds, with every field explained.

Base URL: `https://api.lynxmetrics.com/v1/lightning-baccarat`

Source: https://lynxmetrics.com/en/docs/lightning-baccarat · See Lightning Baccarat live: https://lynxmetrics.com/en/apis/lightning-baccarat

## Authentication

Send a key created in the dashboard for Lightning Baccarat in the `x-api-key` header, since a key from another API gets `key_wrong_api`.

```bash
curl https://api.lynxmetrics.com/v1/lightning-baccarat/latest \
  -H "x-api-key: YOUR_KEY"
```

Keys, the trial and subscriptions (you can subscribe to the same API several times, each with its own keys) work the same on every API and are explained in the [general documentation](https://lynxmetrics.com/en/docs#autenticacao). (https://lynxmetrics.com/en/docs.md)

## Code examples

Ready-to-copy examples in Python, Node.js and PHP. Replace `YOUR_KEY` with the key from your dashboard and run it: each one calls the `on_round` function (`onRound` in Node.js) on every new Lightning Baccarat round, and that is where your code goes.

### Real time over the stream (recommended)

One open connection that receives every round the moment it closes. Only opening the connection costs a request, so you never hit the per-minute limit, and it is the fastest way to get the data. The example reconnects on its own, sends `last-event-id` to receive in `missed` whatever closed while it was away, and stops when `closed` arrives.

Python

```python
import json
import time
import requests

API = "https://api.lynxmetrics.com/v1/lightning-baccarat"
KEY = "YOUR_KEY"


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/lightning-baccarat";
const KEY = "YOUR_KEY";

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/lightning-baccarat";
$key = "YOUR_KEY";

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 with wait (no open connection)

For those who prefer to ask instead of keeping a connection open. `?wait=20` holds the response until the next Lightning Baccarat round closes, for at most 20 seconds, so the round arrives the moment it closes and the example makes a few requests per minute instead of asking all the time. It sends the `ETag` of the last response in `if-none-match`: while nothing changes, the wait ends in a bodiless `304`, and on a `429` it waits for the time in the `retry-after` header instead of insisting.

Python

```python
import time
import requests

API = "https://api.lynxmetrics.com/v1/lightning-baccarat"

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


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/lightning-baccarat";
const KEY = "YOUR_KEY";

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/lightning-baccarat";
$key = "YOUR_KEY";

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

### Send every round to Telegram

Replace the `on_round` function of any example above with this one, using your bot token (the one @BotFather gives you) and the id of the chat or channel. `outcome` and everything inside `data` are explained further down, in Fields of each round.

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

### What breaks bots most often

- Do not poll faster than the table plays. With less than 1 second between requests you only burn your limit and get `429`: the new round does not arrive any sooner. If you need the result within the same second, use `/stream`.
- On a `429`, read the `retry-after` header and wait that long, because retrying right away does not help. Every response carries `x-ratelimit-remaining` and `x-ratelimit-reset`, which tell you how much still fits in the minute.
- A `401` on every call means the key is wrong, revoked or was rotated in the dashboard: copy the key again. Many attempts in a row with an invalid key make your IP receive `429` for a while, even after you fix it.
- `trial_expired` means the trial hours are over. Subscribe to a plan in the dashboard and the same key works again, with no code change.
- If your bot was down, do not guess what it missed: call `/results?after=` with the `id` of the last round you have and receive, in order, every round that closed after it.
- Each key has a number of stream connections, shown in the limits table. Go over it and the oldest connection is ended with `closed`. To run several bots, create one key for each in the dashboard.

## GET /v1/lightning-baccarat/latest

The latest Lightning Baccarat round, or null if there is none yet.

| Field | Type |  |
| --- | --- | --- |
| `wait` | `number` | Seconds the response may wait for the next round, up to 20. It only waits if you already have the latest one: send its `ETag` in `if-none-match` or its `id` in `after`. When a round closes, the response comes right away with it; if the time runs out first, you get `304` (with ETag) or the same round (with `after`). It counts as a single request, and your client timeout must be longer than `wait`. |
| `after` | `id` | The `id` of the last round you have. Only used together with `wait`, for clients that do not keep the `ETag`. |

```json
{
  "data": {
    "id": "v1793314712000",
    "game": "lightning-baccarat",
    "tableId": "LightningBac0001",
    "startedAt": "2026-10-29T22:58:36.000Z",
    "settledAt": "2026-10-29T22:59:02.000Z",
    "outcome": "banker",
    "data": {
      "player": {
        "cards": ["QH", "TH", "QD"],
        "score": 0,
        "pair": false
      },
      "banker": { "cards": ["AS", "6H"], "score": 7, "pair": false },
      "natural": false
    }
  }
}
```

## GET /v1/lightning-baccarat/results

Lightning Baccarat rounds from newest to oldest. To fetch the next page, pass the response's `nextCursor` as `before`, and when it comes back `null` there are no more results.

| Field | Type |  |
| --- | --- | --- |
| `limit` | `number` | How many rounds to return, 50 by default and 250 to 1000 at most. |
| `before` | `ISO 8601` | Returns only rounds settled before this date, like the `nextCursor` of the previous page, and how far back you can go depends on the plan. |
| `after` | `ISO 8601 \| id` | To sync without repeating or skipping rounds, pass the `settledAt` or the `id` of the last round you already have, and the response brings only the rounds settled after it, from oldest to newest, up to `limit`. When the page comes back full, pass its `nextCursor` as the next `after`, and when it comes back `null` you are up to date. It also follows the plan's history limit and can be combined with `before`. |

```json
GET /v1/lightning-baccarat/results?limit=1

{
  "data": [
    {
      "id": "v1793314712000",
      "game": "lightning-baccarat",
      "tableId": "LightningBac0001",
      "startedAt": "2026-10-29T22:58:36.000Z",
      "settledAt": "2026-10-29T22:59:02.000Z",
      "outcome": "banker",
      "data": {
        "player": {
          "cards": ["QH", "TH", "QD"],
          "score": 0,
          "pair": false
        },
        "banker": { "cards": ["AS", "6H"], "score": 7, "pair": false },
        "natural": false
      }
    }
  ],
  "nextCursor": "2026-10-29T22:59:02.000Z"
}
```

## GET /v1/lightning-baccarat/stream

Live Lightning Baccarat rounds over a connection that stays open (SSE, Server-Sent Events): every round arrives the moment it is saved, with no polling on your side. It is the fastest path, because it removes the gap between your requests. It is plain HTTP, so it goes through proxies and CDNs and works with any client that can send a header and read continuously.

```bash
curl -N https://api.lynxmetrics.com/v1/lightning-baccarat/stream \
  -H "x-api-key: YOUR_KEY" \
  -H "accept: text/event-stream"
```

```text
event: round
data: {
data:   "data": {
data:     "id": "v1793314712000",
data:     "game": "lightning-baccarat",
data:     "tableId": "LightningBac0001",
data:     "startedAt": "2026-10-29T22:58:36.000Z",
data:     "settledAt": "2026-10-29T22:59:02.000Z",
data:     "outcome": "banker",
data:     "data": {
data:       "player": {
data:         "cards": ["QH", "TH", "QD"],
data:         "score": 0,
data:         "pair": false
data:       },
data:       "banker": { "cards": ["AS", "6H"], "score": 7, "pair": false },
data:       "natural": false
data:     }
data:   },
data:   "timing": {
data:     "receivedAt": "2026-10-29T22:59:05.900Z",
data:     "sentAt": "2026-10-29T22:59:05.950Z"
data:   }
data: }

```

### What arrives on the connection

| Field | Type |  |
| --- | --- | --- |
| `ready` | `event` | Arrives once, as soon as the connection opens, carrying the latest settled round so you start in sync. It is not a new round: compare its `id` with the last one you have and don't count it twice. `data` comes `null` while there is no round yet. On a reconnect it also carries, in `missed`, the rounds that settled while you were away. |
| `phase` | `optional` | Optional: it only arrives if you ask for it with `?phases=1`. There are two notices per round, both carrying `ref`, `game`, `phase`, `at` and `sentAt`: `betting`, when the table returns to the wide shot and betting on the next round opens, and `resolving`, when it enters the round's resolution and betting has already closed — that one also carries `roundId`, the id the round will have in `round`, several seconds ahead of the result. To know which round a result belongs to you do NOT need this: the `round` event's `id`, the guaranteed order and `last-event-id` are enough. The phase is for binding earlier, and it is not a promise of a result — a cut close-up, a gap in the feed or an unsure read make us drop the round on purpose, and then no `round` ever comes with that `ref`. |
| `round` | `event` | One per new round, carrying in `data` the same object `/latest` returns, the delivery timestamps in `timing` and, when the round had a phase, its `ref`. The event `id` is the round id, and only `round` carries an `id`, because it is the resume point on a reconnect. |
| `correction` | `optional` | Optional: it only arrives if you ask for it with `?corrections=1`. It tells you that a round already delivered as `round` has changed: in Bac Bo, about once every 2,000 rounds the table re-shakes one cup after the dice had settled, and the die that was published no longer counts. It carries `data`, the round as it now stands (same `id` and same timestamps), `previous`, with the `outcome` and `data` that had been delivered, and `sentAt`. It has no event `id`, so `last-event-id` does not move. It arrives when that round ends on the table, from 30 seconds to 3 minutes after the `round`. Even if you don't ask for it, `/latest`, `/results` and `/stats` start returning the corrected round. |
| `gap` | `event` | This connection's queue overflowed and rounds were dropped: your client wasn't keeping up. It carries `resyncError: too_many_missed`, the same code as a reconnect that went long. The connection stays open, and this is the only case where a round is missing mid-stream — always announced, because the ids aren't sequential and you'd have no way to notice. To close the hole, ask `/results?after=` with the id of the last round you received. |
| `closed` | `event` | Your connection was ended because a newer one was opened with the same key. It carries `reason: "replaced"`. This is not a network drop, so do not reconnect automatically: reconnecting here would only kill the newer connection, which would then reconnect and kill yours, with no end to it. |
| `: ping` | `comment` | Every 20 seconds without a round, a line starting with a colon goes out. It is not an event and can be ignored; it only stops a proxy in between from closing an idle connection. |

### Binding a tip before betting closes

A round's id is the very instant betting closed, down to the millisecond: it does not exist while betting is open, and there is no way to guess it. For anyone publishing a tip before the close there is `ref`, a reference of ours, created when betting opens and repeated at resolution and on the result. Stamp your tip with the `ref` from `betting` and match it to the `round` that carries the same `ref` — no arrival order to rely on, and no waiting for the id. Ask for the phases with `?phases=1`; a client that connects mid-round gets the phase the table is in right away.

```text
event: phase
data: {
data:   "ref": "r1761939000000-7",
data:   "game": "lightning-baccarat",
data:   "phase": "betting",
data:   "at": "2026-10-29T22:58:36.000Z",
data:   "sentAt": "2026-10-29T22:58:36.100Z"
data: }

event: phase
data: {
data:   "ref": "r1761939000000-7",
data:   "roundId": "v1793314712000",
data:   "game": "lightning-baccarat",
data:   "phase": "resolving",
data:   "at": "2026-10-29T22:58:52.840Z",
data:   "sentAt": "2026-10-29T22:58:55.000Z"
data: }

event: round
data: {
data:   "data": {
data:     "id": "v1793314712000",
data:     "game": "lightning-baccarat",
data:     "tableId": "LightningBac0001",
data:     "startedAt": "2026-10-29T22:58:36.000Z",
data:     "settledAt": "2026-10-29T22:59:02.000Z",
data:     "outcome": "banker",
data:     "data": {
data:       "player": {
data:         "cards": ["QH", "TH", "QD"],
data:         "score": 0,
data:         "pair": false
data:       },
data:       "banker": { "cards": ["AS", "6H"], "score": 7, "pair": false },
data:       "natural": false
data:     }
data:   },
data:   "ref": "r1761939000000-7",
data:   "timing": {
data:     "receivedAt": "2026-10-29T22:59:05.900Z",
data:     "sentAt": "2026-10-29T22:59:05.950Z"
data:   }
data: }

```

| Field | Type |  |
| --- | --- | --- |
| `ref` | `string` | The round's reference, identical across the three events. It is an opaque string: do not parse it, and do not derive the next one from it. A `ref` may end without a result — if the round is dropped, no `round` ever arrives with it, and the next `betting` opens a new one. |
| `roundId` | `string` | The round's final id. It only appears from `resolving` on, because it is anchored to the instant betting closed. It is what comes in the `round` event's `id` and what serves as `last-event-id` on a reconnect. |
| `phase` | `betting \| resolving` | `betting`: betting on the next round has opened. `resolving`: the table entered the round's resolution and betting has closed. Always test this field instead of assuming, because new phases may be added. |
| `at` | `ISO 8601` | The phase's instant on the table's clock, the same one as `startedAt` and `settledAt`. The `sentAt` next to it is when the notice went out on your connection. |

### Timestamps and delay

Events carry the timestamps of each leg of the trip, so you measure the real delay instead of estimating it. The round's timestamps are on the table's clock; the delivery ones are on our API's clock. The delay for Lightning Baccarat is measured against the table and shows up in each event's own timestamps, round by round.

| Field | Type |  |
| --- | --- | --- |
| `data.startedAt` | `ISO 8601` | Start of the round on the table's clock, which is when betting opened. |
| `data.settledAt` | `ISO 8601` | End of the round on the table's clock: the moment the result was settled at the source. It is also the date used for ordering, for `before` and for `after`. |
| `timing.receivedAt` | `ISO 8601` | When the result was ready on our side. The gap between it and `settledAt` is the delay from the source to us, which is the part that is in our hands. |
| `timing.sentAt` | `ISO 8601` | When this event was written to your connection. The gap between it and `receivedAt` is how long the round waited in this connection's queue, usually a few milliseconds; the rest of the delay to your code is network. |

### Reconnecting without losing a round

When reconnecting, send the id of the last round you received in the `last-event-id` header — an SSE client that reconnects on its own already sends that header, and if you drive the reconnect yourself you send either the header or `?last_event_id=`, whichever suits you. `ready` comes back with `missed`: the rounds that settled while you were away, oldest to newest. The stream covers absences of up to 50 rounds; if more than that settled, it does not hand you the most recent ones and does not even try — `missed` comes `null` with `too_many_missed`, and you close the gap with `/results?after=`. `data` is still the latest settled round, which is normally the last item of `missed`. When recovery isn't possible, `missed` comes `null` and `resyncError` says why; the connection opens either way, because a reconnect must never fail over a stale cursor.

```bash
curl -N https://api.lynxmetrics.com/v1/lightning-baccarat/stream \
  -H "x-api-key: YOUR_KEY" \
  -H "accept: text/event-stream" \
  -H "last-event-id: v1793314712000"
```

| Field | Type |  |
| --- | --- | --- |
| `bad_cursor` | `resyncError` | The value sent is neither a round id nor an ISO 8601 date. |
| `unknown_round` | `resyncError` | That id is not one of our rounds on this API. It may be from another API, or from a round we ended up dropping: a `phase` is no guarantee that the round will exist. |
| `plan_limit` | `resyncError` | The round is older than your plan's history. |
| `too_many_missed` | `resyncError` | More than 50 rounds settled while you were away, which means you were out too long for the stream to sort it out on its own. Ask `/results?after=` with the id you have and page through until you are in sync. |

### Keeping the connection

- Within a connection, events go out one at a time and in chronological order: a round's phases always before its result — `betting`, `resolving` and `round`, carrying the same `ref` —, and each `round` with a `settledAt` later than the previous one. A round's `betting` may arrive just before the previous round's `round`, because one comes from the table and the other from the database; what holds is the order within each round. No round arrives twice on the same connection. If your connection gets slow and its queue overflows, the oldest rounds are dropped and an `event: gap` goes out to tell you.
- Each plan allows a number of simultaneous connections per key, shown in the limits table below. Going over it is not an error: the oldest connection on that key is ended with an `event: closed` and the new one takes its place. That way a process that died without the system telling us never locks you out of your own slot.
- Every connection ends after 6 hours, even a healthy one, and the client is expected to reconnect. That ending carries no event: the connection simply closes, and `closed` is only about replacement, so a read that ends for no reason after hours open is this deadline. This is deliberate: connections do die silently, and this deadline is what stops one from holding a slot forever. Something running all day reconnects about four times a day.
- If your client has a read timeout, keep it above 20 seconds, or it will cut the connection during the silence between rounds.
- Opening the connection spends one request from your per-minute limit. The rounds that arrive afterwards cost nothing, so following the stream weighs less on the limit than polling `/latest`.
- The key is only accepted in the `x-api-key` header, never in the URL, which would end up in proxy logs and browsing history. That is why the browser's `EventSource` won't do: it cannot send headers. In the browser, the way in is a `fetch` reading the body as it arrives; better still is your own server listening to the stream and passing it on, because a key in the browser would be visible to every visitor.

## GET /v1/lightning-baccarat/stats

Lightning Baccarat statistics computed on the fly over the latest rounds.

| Field | Type |  |
| --- | --- | --- |
| `sample` | `number` | How many recent rounds to compute over, 100 by default and 250 to 1000 at most. |

```json
GET /v1/lightning-baccarat/stats

{
  "data": {
    "total": 100,
    "counts": { "player": 44, "banker": 47, "tie": 9 },
    "percentages": { "player": 44, "banker": 47, "tie": 9 },
    "currentStreak": { "outcome": "banker", "length": 2 },
    "outcomes": {
      "player": {
        "count": 44,
        "percent": 44,
        "longestStreak": 4,
        "sinceLast": 2
      },
      "banker": {
        "count": 47,
        "percent": 47,
        "longestStreak": 7,
        "sinceLast": 0
      },
      "tie": {
        "count": 9,
        "percent": 9,
        "longestStreak": 1,
        "sinceLast": 6
      }
    },
    "sample": {
      "from": "2026-11-14T14:20:31.204Z",
      "to": "2026-11-14T15:18:27.939Z"
    },
    "pairs": { "player": 7, "banker": 8 },
    "naturals": 31
  }
}
```

## Round fields

Shape of each Lightning Baccarat round in latest and results.

| Field | Type |  |
| --- | --- | --- |
| `id` | `string` | Round id, unique and stable. It is generated by us, not by the provider, so use it only to compare and as a cursor (in after and last-event-id), without parsing its content. |
| `game` | `string` | API slug, always "lightning-baccarat" here. |
| `tableId` | `string \| null` | Table id at the provider, or null when the source does not provide it. |
| `startedAt` | `string \| null` | Round start in UTC, or null when the source does not provide it. |
| `settledAt` | `string` | Round end in UTC, which is the date used for ordering and for before. |
| `outcome` | `"player" \| "banker" \| "tie"` | Who won the round: player, banker or tie. |
| `data.player.cards` | `string[]` | The Player's cards in the order they were dealt, two or three, each one like KH: rank in A23456789TJQK (T is the ten) and suit in CDHS. |
| `data.player.score` | `number` | The Player's score, from 0 to 9: the sum of the cards modulo 10. |
| `data.player.pair` | `boolean` | true when the Player's first two cards have the same rank. |
| `data.banker.cards` | `string[]` | The Banker's cards in the order they were dealt, in the same format as the Player's. |
| `data.banker.score` | `number` | The Banker's score, from 0 to 9. |
| `data.banker.pair` | `boolean` | true when the Banker's first two cards have the same rank. |
| `data.natural` | `boolean` | true when either side made 8 or 9 with its first two cards, which ends the round with no third card. |

## Statistics fields

| Field | Type |  |
| --- | --- | --- |
| `total` | `number` | How many rounds were counted, equal to sample or fewer if there are not enough yet. |
| `counts` | `{ player, banker, tie }` | Player wins, Banker wins and ties in the sample. |
| `percentages` | `{ player, banker, tie }` | The same counts as percentages, with one decimal place. |
| `currentStreak` | `{ outcome, length } \| null` | The outcome repeating right now and for how many rounds, or null with no rounds. |
| `outcomes` | `{ player, banker, tie }` | One block per outcome: count (how many times it came up), percent, longestStreak (the longest run in the sample) and sinceLast (rounds since the last time, with 0 for the most recent round and null if it did not come up in the sample). Same shape on every API. |
| `sample` | `{ from, to } \| null` | Sample period: the settledAt of the oldest round (from) and of the newest (to), or null with no rounds. |
| `pairs` | `{ player, banker }` | How many rounds in the sample had a pair on the Player and on the Banker. |
| `naturals` | `number` | How many rounds in the sample ended in a natural. |

## Plans and limits

Limits of the Lightning Baccarat API on each plan. A parameter above the maximum is lowered to the maximum, and a before older than the plan's history returns plan_limit. The per minute column is the requests per minute limit of each subscription, adding up all of its keys, and the connections column is how many /stream connections the same key can keep open at once.

| Plan | Price | Per minute | Connections | limit | sample | before |
| --- | --- | --- | --- | --- | --- | --- |
| Trial | 2 hours, no card | 60 | 1 | 250 | 250 | 7 days |
| Pro | R$21.90/month | 60 | 1 | 250 | 250 | 7 days |
| Business | R$49.90/month | 400 | 5 | 1000 | 1000 | full |

Errors have the same format on every API and are listed in the [general documentation](https://lynxmetrics.com/en/docs#erros).
