Blog · Lightning Baccarat

Resultados do Lightning Baccarat: cada mão em ~5 segundos

Como receber cada rodada do Lightning Baccarat no instante em que ela fecha: o atraso real medido, o aviso antes do resultado e código em Python e Node.

Publicado em 30 de outubro de 2026 · atualizado em 31 de outubro de 2026 · 8 min de leitura

A API do Lightning Baccarat está no ar · no YouTube

Receber resultados do Lightning Baccarat ao vivo é um problema diferente de consultar o histórico. No histórico, atraso não importa. Ao vivo, importa tudo: se a sua mensagem chega 20 segundos depois da mão, ela chega junto com a mão seguinte, e quem lê não sabe mais de qual rodada você está falando.

Este artigo mostra os dois caminhos que a API do Lightning Baccarat oferece para acompanhar a mesa ao vivo, qual deles é o mais rápido, e quanto tempo de verdade passa entre a mão fechar e o dado chegar no seu programa. O funcionamento 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

A régua certa não é "a API é rápida", é quantos segundos se passam entre o fim da rodada e o dado disponível. No Lightning Baccarat medimos isso em produção, comparando o settledAt de cada rodada com o momento em que ela ficou gravada: hoje são cerca de 5 segundos.

O interessante é onde esse tempo está. Mais de 90% dele acontece antes de a rodada existir para nós: é o leitor esperando ter certeza de quais são as cartas. O coletor e o banco somam poucos décimos de segundo. Por isso não existe truque de cliente que ganhe esses segundos — e por isso também não vale a pena consultar a API dez vezes por segundo: o dado simplesmente não está lá antes disso.

E você não precisa acreditar nessa conta: cada rodada que chega pelo stream vem com os horários de cada pedaço do caminho, então o número acima é verificável do seu lado, com o seu relógio.

# 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(round(mesa_ate_nos, 2), "s da mesa até a nossa API")

Uma rodada do Lightning Baccarat leva cerca de 35 segundos. Com 5 segundos de atraso, você tem cerca de 30 segundos de sobra antes da próxima mão, o que é tempo mais que suficiente para formatar e publicar a mensagem.

Caminho 1: o stream, o mais rápido

O GET /v1/lightning-baccarat/stream é uma conexão HTTP que fica aberta. Você abre uma vez e a API empurra cada rodada no instante em que ela é salva, no formato Server-Sent Events. Não há intervalo de consulta, então não há atraso de consulta.

Em Python, com httpx:

stream.py

import json
import httpx

URL = "https://api.lynxmetrics.com/v1/lightning-baccarat/stream"
CABECALHOS = {"x-api-key": "SUA_CHAVE", "accept": "text/event-stream"}

with httpx.stream("GET", URL, 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:") and evento == "round":
            corpo = json.loads(linha.split(":", 1)[1])
            mao = corpo["data"]
            print(mao["outcome"], mao["data"]["player"]["cards"], mao["data"]["banker"]["cards"])

Em Node.js 18 ou mais novo, sem dependência:

stream.mjs

const resposta = await fetch("https://api.lynxmetrics.com/v1/lightning-baccarat/stream", {
  headers: { "x-api-key": process.env.LYNX_KEY, accept: "text/event-stream" },
});

let buffer = "";
for await (const pedaco of resposta.body) {
  buffer += new TextDecoder().decode(pedaco);
  const blocos = buffer.split("\n\n");
  buffer = blocos.pop() ?? "";
  for (const bloco of blocos) {
    const evento = bloco.match(/^event: (.+)$/m)?.[1];
    const dados = bloco.match(/^data: (.+)$/m)?.[1];
    if (evento === "round" && dados) {
      const { data: mao } = JSON.parse(dados);
      console.log(mao.outcome, mao.data.player.score, mao.data.banker.score);
    }
  }
}

O que chega na conexão

EventoQuando chegaO que fazer com ele
readyUma vez, ao abrirTraz a última mão já encerrada, para você começar em dia, e numa reconexão traz em missed o que fechou na sua ausência. Não é rodada nova
phaseOpcional (?phases=1), quando a mesa entra na resolução da mãoO roundId que a mão vai ter, antes de as cartas serem lidas
roundUma por mão novaA rodada em data e os horários da entrega em timing. É o único evento com id:
closedOutra conexão abriu com a mesma chaveFim de vida deste processo; reconectar derrubaria a conexão nova
linha com :A cada 20 segundos de silêncioBatimento, para nenhum proxy fechar a conexão parada. Ignore

Reconectar sem perder mão

Conexão aberta cai — rede, deploy, e o fim de vida de 6 horas que toda conexão tem. Guarde o id da última mão que você tratou e devolva no cabeçalho last-event-id ao reabrir: o ready volta com missed, as mãos que fecharam enquanto você estava fora, da mais antiga para a mais nova, até 50.

cabecalhos = {"x-api-key": "SUA_CHAVE", "accept": "text/event-stream"}
if ultimo_id:
    cabecalhos["last-event-id"] = ultimo_id

Acima de 50 mãos de ausência — cerca de meia hora de mesa — o stream não resolve sozinho: vem resyncError: "too_many_missed" e você termina de sincronizar com o `/results?after=`, que pagina. A conexão abre nos dois casos; uma reconexão nunca falha por causa de um cursor velho.

O aviso que chega antes do resultado

O evento phase é opcional — abra a conexão com ?phases=1 para recebê-lo — e avisa quando a mesa entra na resolução da mão, momento em que as apostas já fecharam e as cartas ainda não foram lidas. Ele traz o roundId que aquela mão vai ter no round, e serve para amarrar o que o seu programa registra à mão certa antes de o resultado sair. Para só saber a que mão um resultado pertence você não precisa dele: o id do round, a ordem garantida e o last-event-id bastam.

Ele não é promessa de resultado: um close-up cortado ou uma leitura insegura fazem a mão ser descartada de propósito — melhor faltar do que chutar —, e aí nenhum round chega com aquele id. Quem guarda estado por fase precisa expirar a fase que não virou mão.

Quanto o stream custa do seu limite

Abrir a conexão gasta uma requisição do seu limite por minuto. As rodadas que chegam depois não gastam nada. Ou seja: acompanhar pelo stream pesa muito menos no limite do que consultar o /latest a cada 3 segundos, que são 20 requisições por minuto. O plano Pro mantém 1 conexão por chave e o Business, 5.

Se você passar do número de conexões do plano, não dá erro: a conexão mais antiga daquela chave é encerrada com um event: closed e a nova entra no lugar. Assim um processo que caiu sem avisar nunca tranca você fora da sua própria vaga.

Caminho 2: consultar o /latest de tempo em tempo

Se o seu programa não pode manter uma conexão aberta — uma função serverless, um cron, uma planilha — consultar o /latest funciona bem. Duas regras tornam isso eficiente:

  • A cada 3 segundos é de sobra. A rodada leva 35 segundos e o dado chega em 5; consultar mais rápido que isso só queima o seu limite por minuto.
  • Mande o ETag. Guarde o cabeçalho ETag da última resposta e devolva em If-None-Match. Quando nada mudou, a API responde 304 sem corpo: a requisição ainda conta no limite, mas o tráfego e o trabalho do seu lado caem muito.
etag = None
while True:
    cabecalhos = {"x-api-key": "SUA_CHAVE"}
    if etag:
        cabecalhos["if-none-match"] = etag
    r = requests.get("https://api.lynxmetrics.com/v1/lightning-baccarat/latest", headers=cabecalhos, timeout=10)
    if r.status_code == 200:
        etag = r.headers.get("etag")
        tratar(r.json()["data"])
    time.sleep(3)

E sempre compare o id da rodada com o último que você tratou. É o jeito de nunca publicar a mesma mão duas vezes, e vale nos dois caminhos.

Stream, polling ou webhook: qual escolher

Stream (SSE)Consultar o /latestWebhook
Atraso extra além dos ~5snenhummetade do seu intervalo, em média—
Gasto do limite por minuto1 na abertura1 por consulta—
Recupera o que passou na quedasim, com last-event-idsim, com after—
Precisa de servidor própriosim, um processo de pénãosim, endereço público
Disponível na LynxMetricssimsimnão

Webhook é a pergunta que mais recebemos, e a resposta é direta: não existe hoje. Um webhook exige endereço público, assinatura de requisição e fila de reentrega do nosso lado, e entrega pior do que o stream para quem já tem um processo rodando. O stream cobre o mesmo caso com menos peças.

O próximo passo

Com o stream funcionando, publicar a mão num grupo é o passo seguinte, e está pronto em como fazer um bot de Lightning Baccarat no Telegram. Para entender cada campo que chega no evento, veja a API do Lightning Baccarat e a documentação.

Perguntas frequentes

Qual é o atraso entre a rodada do Lightning Baccarat e o dado na API?

Cerca de 5 segundos entre o fim da mão e o dado gravado, medidos em produção. Mais de 90% desse tempo é o leitor confirmando as cartas, e cada rodada do stream traz os carimbos receivedAt e sentAt para você medir isso do seu lado.

A LynxMetrics tem webhook para o Lightning Baccarat?

Não. Para receber cada rodada no instante em que ela é salva, use o endpoint /stream, que mantém uma conexão HTTP aberta (Server-Sent Events). Ele cobre o mesmo caso de uso com menos peças do que um webhook.

Como reconectar ao stream sem perder mãos?

Mande o id da última mão recebida no cabeçalho last-event-id ao reabrir a conexão. O evento ready volta com missed, as mãos que fecharam na sua ausência, até 50. Acima disso vem resyncError too_many_missed e você termina de sincronizar pelo /results?after=.

Quantas conexões de stream eu posso manter abertas?

Uma por chave no plano Pro e cinco no Business. Se você abrir mais que isso com a mesma chave, a conexão mais antiga é encerrada com um event: closed e a nova entra no lugar, sem erro.

O evento phase diz qual vai ser o resultado da mão?

Não. Ele é opcional, só chega se você abrir a conexão com ?phases=1, e avisa que a mesa entrou na resolução da mão, com o id que ela vai ter, antes de as cartas serem lidas. Serve para amarrar o que o seu programa registra à mão certa antes do resultado; uma mão com leitura insegura é descartada e nunca aparece como round.

Dá para usar o stream direto do navegador?

Não é recomendado. O EventSource do navegador não envia cabeçalhos, então a chave não passa por ele, e uma chave no navegador ficaria visível para qualquer visitante. Use um cliente HTTP no servidor.

Conteúdo para maiores de 18 anos. A LynxMetrics não tem ligação com a Evolution nem com os cassinos que oferecem o Lightning Baccarat, 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