Bac Bo results in real time: ~4 seconds per round
How to receive every Bac Bo Live round the moment it is stored: the measured delay, the 8s heads-up before the result, and ready-to-run Python code.
Published on October 30, 2026 · updated on October 31, 2026 · 6 min read
Anyone following Bac Bo in real time through software runs into the same detail: a round lasts about 34 seconds, and a result that arrives late arrives together with the next round. This article shows how much time really passes between the dice settling on the table and the data reaching your program, and how to receive every round without polling.
The stream mechanism in detail — all the events, the timestamps and the recovery errors — is in the reference article on real-time results. What follows are this table's numbers.
The real delay, measured in production
We measured the whole path in production, comparing each round's settledAt with the moment it was stored and visible: on Bac Bo Live it is about 4 seconds today.
That number used to be much worse. It was 10.75 seconds, and what brought it down was not database tuning: it was publishing the round as soon as the result is on the table, instead of waiting for the camera to pull back to the wide shot. The result was already decided there; waiting for the framing was pure delay. Today more than 90% of what remains happens before the round exists for us, in the reader confirming the four dice — the collector and the database add a few tenths.
And you do not have to take our word for it: every round that arrives over the stream carries the timestamps for each leg of the trip.
# inside the "round" event
from datetime import datetime
t = lambda iso: datetime.fromisoformat(iso.replace("Z", "+00:00"))
table_to_us = (t(event["timing"]["receivedAt"]) - t(event["data"]["settledAt"])).total_seconds()
print(table_to_us, "s from the table to our API")The heads-up that arrives about 8 seconds before the result
This is what makes Bac Bo distinctive. The table has a clear mechanical moment: the shaker stops, the dice are in view and the camera closes in on them. That is the instant when bets have closed and the result does not exist yet.
Our reader announces that instant straight into the stream, as an event: phase — which is optional: open the connection with ?phases=1 to receive it.
event: phase
data: {"roundId":"v1793371825421","game":"bacbo-live","phase":"resolving","at":"2026-10-30T18:10:49.903Z","sentAt":"2026-10-30T18:10:53.903Z"}In Bac Bo it arrives about 8 seconds before the round with the result, and it already carries the roundId that round will have. What it is for, in practice:
- Recording something before the result and binding it to the right round already. If all you want is to know which round a result belongs to, you do not need the phase: the
round'sid, the connection's guaranteed order andlast-event-idhandle that on their own. The phase moves that binding a few seconds earlier. - Preparing the message in advance. You can post a "round in progress" and then edit the same message with the result, which leaves the group with one line per round instead of two.
- Knowing the table is alive even during a long gap between results.
Two honest caveats, and they matter:
And it comes through the table, with the table's delay: it is the moment of resolution, not the moment betting opened. We only know about betting opening after the fact, from startedAt.
The client, in Python
stream.py
import json
import time
import httpx
STREAM = "https://api.lynxmetrics.com/v1/bacbo-live/stream?phases=1" # without ?phases=1 there is no event: phase
KEY = "YOUR_KEY"
last_id = None
def handle(round_):
global last_id
if round_["id"] == last_id:
return # ready repeats the last one on purpose
last_id = round_["id"]
data = round_["data"]
print(round_["settledAt"], round_["outcome"], data["player"]["score"], "x", data["banker"]["score"])
def follow():
headers = {"x-api-key": KEY, "accept": "text/event-stream"}
if last_id:
headers["last-event-id"] = last_id # returns what closed while we were away
with httpx.stream("GET", STREAM, headers=headers, timeout=None) as response:
response.raise_for_status()
event = None
for line in response.iter_lines():
if line.startswith("event:"):
event = line.split(":", 1)[1].strip()
elif line.startswith("data:"):
body = json.loads(line.split(":", 1)[1])
if event == "ready":
if body.get("resyncError"):
print("no recovery:", body["resyncError"])
for round_ in body.get("missed") or []:
handle(round_)
if body["data"]:
handle(body["data"])
elif event == "round":
handle(body["data"])
elif event == "phase":
print("resolving round", body["roundId"])
elif event == "closed":
return "closed"
while True:
if follow() == "closed":
break # another connection took this key's slot
time.sleep(2)Bac Bo data arrives like this, inside the round event's data:
{
"id": "v1792354840763",
"game": "bacbo-live",
"outcome": "banker",
"settledAt": "2026-10-18T20:20:49.923Z",
"data": {
"player": { "dice": [1, 2], "score": 3 },
"banker": { "dice": [4, 5], "score": 9 },
"multiplier": null
}
}The fields are explained one by one in the Bac Bo API article and in the documentation.
Reconnecting without losing a round
Keep the id of the last round you handled and send it back in the last-event-id header when you reopen: ready comes back with missed, the rounds that closed while you were away, oldest first, up to 50 — about half an hour of table time. Beyond that you get resyncError: "too_many_missed" and you finish syncing with `/results?after=`, which paginates. The connection opens in both cases.
This applies to the 6-hour lifetime every connection has, too: anyone running all day reconnects about four times a day, and with last-event-id none of those reconnects costs a round.
Or poll /latest, if you cannot keep a process running
In a serverless function, a cron job or a spreadsheet, polling /latest does the job:
- Every 2 or 3 seconds is plenty. The round takes ~34 seconds and the data arrives in ~4.
- Send the
ETagfrom the last response inIf-None-Match: when nothing has changed, the API answers 304 with no body. - Compare the
idwith the last one handled, always. That is what stops you publishing the same round twice.
| Stream (SSE) | Polling /latest | Webhook | |
|---|---|---|---|
| Extra delay beyond the ~4s | none | half your interval, on average | — |
| Per-minute limit spent | 1 on open | 1 per request | — |
| Warns before the result | yes, the optional phase | no | — |
| Recovers what you missed | yes, with last-event-id | yes, with after | — |
| Available at LynxMetrics | yes | yes | no |
Webhooks do not exist today, and the reason is in the reference article: they would require a public address of yours, request signing and a retry queue, to deliver worse than the stream for anyone who already has a process running.
Next step
Posting every round to a group is ready, with code, in a Bac Bo Telegram bot. To draw the Bead Road and the statistics on top of what arrives, see Bac Bo charts and statistics with real data.
Frequently asked questions
- What is the delay between a Bac Bo round and the data in the API?
About 4 seconds between the end of the round at the table and the data being stored, measured in production; it used to be 10.75 seconds. Every stream round carries the receivedAt and sentAt timestamps, so you can measure it with your own clock.
- Can I know a Bac Bo round is happening before the result?
Yes, if you ask for it: opening the connection with ?phases=1 makes the stream send an event: phase when the table starts resolving the round, about 8 seconds before the result, already carrying the roundId it will have. It is not a promise of a result: a round with an unsafe read is discarded and never shows up as a round event.
- How do I reconnect to the Bac Bo stream without losing rounds?
Send the id of the last round you received in the last-event-id header. The ready event comes back with missed, the rounds that closed while you were away, up to 50. Beyond that you get resyncError too_many_missed and you paginate /results?after= to catch up.
- Does LynxMetrics have a webhook for Bac Bo?
No. The way to receive every round the moment it is stored is the /stream endpoint, an HTTP connection that stays open (Server-Sent Events) and requires no public address on your side.
- Do I need a server to use the stream?
You need a running process holding the connection open, which any small VPS or container handles. In a serverless function with a short timeout, poll /latest every 2 or 3 seconds and store the id of the last round handled.
For adults 18 and over only. LynxMetrics is not affiliated with Evolution or with the casinos that offer Bac Bo Live, and it only sells data and stats, never predictions or betting tips, because every round is random and past results do not predict the next one.
Read also
- Bac Bo API: live results in JSON, with a free trial
How to use the Bac Bo results API: what each round contains, examples in Python and Node, the stream, history, pricing and a free 2-hour trial.
- Bac Bo Telegram bot: build one with Python, step by step
A complete tutorial for building a Bac Bo Telegram bot: BotFather, live results from the API, messages that never repeat, Discord, and where to host it 24/7.
- Bac Bo history: LynxMetrics and CasinoScores compared
We compared 72 hours of Bac Bo Live between LynxMetrics and the public CasinoScores list on 18/10/2026, with the original files for you to check.