Resultados do Bac Bo em tempo real: ~4 segundos por rodada
Como receber cada rodada do Bac Bo Live no instante em que ela é salva: o atraso real medido, o aviso 8s antes do resultado e código pronto em Python.
Publicado em 30 de outubro de 2026 · atualizado em 31 de outubro de 2026 · 6 min de leitura
Quem acompanha o Bac Bo em tempo real por software esbarra sempre no mesmo detalhe: a rodada dura cerca de 34 segundos, e um resultado que chega tarde chega junto com a rodada seguinte. Este artigo mostra quanto tempo de verdade passa entre os dados pararem na mesa e o dado chegar no seu programa, e como receber cada rodada sem ficar perguntando.
O mecanismo do stream em detalhe — todos os eventos, os carimbos de tempo e os erros de recuperação — está no artigo de referência sobre resultados em tempo real. Aqui ficam os números desta mesa.
O atraso real, medido em produção
Medimos o caminho inteiro em produção, comparando o settledAt de cada rodada com o momento em que ela ficou gravada e visível: no Bac Bo Live são hoje cerca de 4 segundos.
Esse número já foi bem pior. Ele era de 10,75 segundos, e o que o derrubou não foi otimização de banco: foi publicar a rodada assim que o resultado está na mesa, em vez de esperar a câmera voltar ao plano aberto. O resultado já estava decidido ali; esperar o enquadramento era atraso puro. Hoje mais de 90% do que resta acontece antes de a rodada existir para nós, no leitor confirmando os quatro dados — o coletor e o banco somam poucos décimos.
E você não precisa acreditar na nossa conta: cada rodada que chega pelo stream traz os horários de cada pedaço do caminho.
# dentro do evento "round"
from datetime import datetime
t = lambda iso: datetime.fromisoformat(iso.replace("Z", "+00:00"))
mesa_ate_nos = (t(evento["timing"]["receivedAt"]) - t(evento["data"]["settledAt"])).total_seconds()
print(mesa_ate_nos, "s da mesa até a nossa API")O aviso que chega cerca de 8 segundos antes do resultado
Esta é a parte que o Bac Bo tem de mais particular. A mesa tem um momento mecânico claro: o copinho para, os dados ficam à vista e a câmera fecha neles. É o instante em que as apostas já fecharam e o resultado ainda não existe.
O nosso leitor avisa esse instante direto no stream, num event: phase — que é opcional: abra a conexão com ?phases=1 para recebê-lo.
event: phase
data: {"roundId":"v1793371825421","game":"bacbo-live","phase":"resolving","at":"2026-10-30T18:10:49.903Z","sentAt":"2026-10-30T18:10:53.903Z"}No Bac Bo ele chega cerca de 8 segundos antes do round com o resultado, e já traz o roundId que aquela rodada vai ter. Para que serve, na prática:
- Registrar algo antes do resultado e já amarrar à rodada certa. Se o que você quer é só saber a que rodada um resultado pertence, não precisa da fase: o
iddoround, a ordem garantida da conexão e olast-event-idresolvem isso sozinhos. A fase adianta a amarração em alguns segundos. - Preparar a mensagem antes. Dá para publicar um "rodada em andamento" e depois editar a mesma mensagem com o resultado, o que deixa o grupo com uma linha por rodada em vez de duas.
- Saber que a mesa está viva mesmo num intervalo longo entre resultados.
Duas ressalvas honestas, e elas importam:
E ele chega pela mesa, com o atraso dela: é o momento da resolução, não o momento em que as apostas abriram. A abertura das apostas a gente só sabe depois do fato, pelo startedAt.
O cliente, em Python
stream.py
import json
import time
import httpx
STREAM = "https://api.lynxmetrics.com/v1/bacbo-live/stream?phases=1" # sem o ?phases=1 não vem event: phase
CHAVE = "SUA_CHAVE"
ultimo_id = None
def tratar(rodada):
global ultimo_id
if rodada["id"] == ultimo_id:
return # o ready repete a última de propósito
ultimo_id = rodada["id"]
dados = rodada["data"]
print(rodada["settledAt"], rodada["outcome"], dados["player"]["score"], "x", dados["banker"]["score"])
def acompanhar():
cabecalhos = {"x-api-key": CHAVE, "accept": "text/event-stream"}
if ultimo_id:
cabecalhos["last-event-id"] = ultimo_id # devolve o que fechou na ausência
with httpx.stream("GET", STREAM, headers=cabecalhos, timeout=None) as resposta:
resposta.raise_for_status()
evento = None
for linha in resposta.iter_lines():
if linha.startswith("event:"):
evento = linha.split(":", 1)[1].strip()
elif linha.startswith("data:"):
corpo = json.loads(linha.split(":", 1)[1])
if evento == "ready":
if corpo.get("resyncError"):
print("não recuperou:", corpo["resyncError"])
for rodada in corpo.get("missed") or []:
tratar(rodada)
if corpo["data"]:
tratar(corpo["data"])
elif evento == "round":
tratar(corpo["data"])
elif evento == "phase":
print("resolvendo a rodada", corpo["roundId"])
elif evento == "closed":
return "closed"
while True:
if acompanhar() == "closed":
break # outra conexão tomou a vaga desta chave
time.sleep(2)O dado do Bac Bo chega assim, dentro de data do evento round:
{
"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
}
}Os campos estão explicados um a um na API do Bac Bo e na documentação.
Reconectar sem perder rodada
Guarde o id da última rodada tratada e devolva no cabeçalho last-event-id ao reabrir: o ready volta com missed, as rodadas que fecharam na sua ausência, da mais antiga para a mais nova, até 50 — cerca de meia hora de mesa. Acima disso vem resyncError: "too_many_missed" e você termina de sincronizar com o `/results?after=`, que pagina. A conexão abre nos dois casos.
Isso vale também para o fim de vida de 6 horas que toda conexão tem: quem roda o dia inteiro reconecta umas quatro vezes por dia, e com o last-event-id nenhuma dessas reconexões custa uma rodada.
Ou consultar o /latest, se não dá para manter processo de pé
Em função serverless, cron ou planilha, consultar o /latest resolve:
- A cada 2 ou 3 segundos é de sobra. A rodada leva ~34 segundos e o dado chega em ~4.
- Mande o
ETagda última resposta emIf-None-Match: quando nada mudou, a API responde 304 sem corpo. - Compare o
idcom o último tratado, sempre. É o que impede publicar a mesma rodada duas vezes.
| Stream (SSE) | Consultar o /latest | Webhook | |
|---|---|---|---|
| Atraso extra além dos ~4s | nenhum | metade do seu intervalo, em média | — |
| Gasto do limite por minuto | 1 na abertura | 1 por consulta | — |
| Avisa antes do resultado | sim, o phase opcional | não | — |
| Recupera o que passou na queda | sim, com last-event-id | sim, com after | — |
| Disponível na LynxMetrics | sim | sim | não |
Webhook não existe hoje, e o motivo está no artigo de referência: ele exigiria endereço público seu, assinatura e fila de reentrega, para entregar pior do que o stream a quem já tem um processo rodando.
O próximo passo
Publicar cada rodada num grupo está pronto, com código, em bot de Bac Bo para Telegram. Para desenhar o Bead Road e as estatísticas em cima do que chega, veja gráficos do Bac Bo e estatísticas com dados reais.
Perguntas frequentes
- Qual é o atraso entre a rodada do Bac Bo e o dado na API?
Cerca de 4 segundos entre o fim da rodada na mesa e o dado gravado, medidos em produção; já foi de 10,75 segundos. Cada rodada do stream traz os carimbos receivedAt e sentAt, então você mede isso com o seu próprio relógio.
- Dá para saber que uma rodada do Bac Bo está acontecendo antes do resultado?
Sim, se você pedir: abrindo a conexão com ?phases=1, o stream manda um event: phase quando a mesa entra na resolução da rodada, cerca de 8 segundos antes do resultado, já com o roundId que ela vai ter. Não é promessa de resultado: uma rodada com leitura insegura é descartada e nunca aparece como round.
- Como reconectar ao stream do Bac Bo sem perder rodadas?
Mande o id da última rodada recebida no cabeçalho last-event-id. O evento ready volta com missed, as rodadas que fecharam na sua ausência, até 50. Acima disso vem resyncError too_many_missed e você pagina o /results?after= para ficar em dia.
- A LynxMetrics tem webhook para o Bac Bo?
Não. O caminho para receber cada rodada no instante em que ela é salva é o endpoint /stream, uma conexão HTTP que fica aberta (Server-Sent Events) e não exige nenhum endereço público do seu lado.
- Preciso de um servidor para usar o stream?
Precisa de um processo de pé mantendo a conexão aberta, o que qualquer VPS pequena ou contêiner resolve. Em função serverless com tempo limite curto, consulte o /latest a cada 2 ou 3 segundos e guarde o id da última rodada tratada.
Conteúdo para maiores de 18 anos. A LynxMetrics não tem ligação com a Evolution nem com os cassinos que oferecem o Bac Bo Live, e vende só dados e estatísticas, nunca previsões ou dicas de aposta, porque cada rodada é aleatória e o histórico não prevê a próxima.
Leia também
- API de Bac Bo: resultados ao vivo em JSON e teste grátis
Como usar a API de resultados do Bac Bo (BacBo): o que vem em cada rodada, exemplos em Python e Node, stream, histórico, preços e 2 horas de teste grátis.
- Bac Bo em Angola e Portugal: resultados ao vivo e API
Resultados do Bac Bo ao vivo para quem está em Angola ou Portugal: onde ver de graça, os horários de Luanda e Lisboa e quanto custa a API em kwanza e euro.
- Bot de Bac Bo no Telegram: criar com Python passo a passo
Tutorial completo para criar um bot de Bac Bo no Telegram: BotFather, resultados ao vivo pela API, mensagens sem repetição, Discord e onde hospedar 24 horas.