Blog · Bac Bo Live

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

Resultados em tempo real com o stream · no YouTube

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 id do round, a ordem garantida da conexão e o last-event-id resolvem 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 ETag da última resposta em If-None-Match: quando nada mudou, a API responde 304 sem corpo.
  • Compare o id com o último tratado, sempre. É o que impede publicar a mesma rodada duas vezes.
Stream (SSE)Consultar o /latestWebhook
Atraso extra além dos ~4snenhummetade do seu intervalo, em média—
Gasto do limite por minuto1 na abertura1 por consulta—
Avisa antes do resultadosim, o phase opcionalnão—
Recupera o que passou na quedasim, com last-event-idsim, com after—
Disponível na LynxMetricssimsimnã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