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
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
| Evento | Quando chega | O que fazer com ele |
|---|---|---|
ready | Uma vez, ao abrir | Traz 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 |
phase | Opcional (?phases=1), quando a mesa entra na resolução da mão | O roundId que a mão vai ter, antes de as cartas serem lidas |
round | Uma por mão nova | A rodada em data e os horários da entrega em timing. É o único evento com id: |
closed | Outra conexão abriu com a mesma chave | Fim de vida deste processo; reconectar derrubaria a conexão nova |
linha com : | A cada 20 segundos de silêncio | Batimento, 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_idAcima 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çalhoETagda última resposta e devolva emIf-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 /latest | Webhook | |
|---|---|---|---|
| Atraso extra além dos ~5s | nenhum | metade do seu intervalo, em média | — |
| Gasto do limite por minuto | 1 na abertura | 1 por consulta | — |
| Recupera o que passou na queda | sim, com last-event-id | sim, com after | — |
| Precisa de servidor próprio | sim, um processo de pé | não | sim, endereço público |
| Disponível na LynxMetrics | sim | sim | nã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
- API de Lightning Baccarat: resultados ao vivo em JSON
Como funciona a API do Lightning Baccarat: as cartas de cada rodada em JSON, os quatro endpoints, exemplos em Python e Node, histórico, preços e teste.
- Como fazer um bot de Lightning Baccarat no Telegram
Passo a passo para publicar cada rodada do Lightning Baccarat no Telegram: criar o bot, ligar no stream da API, formatar as cartas e não repetir mensagem.
- Precisão do Lightning Baccarat: auditoria de 143 rodadas
A auditoria que fizemos antes de abrir a API do Lightning Baccarat: 143 rodadas conferidas contra uma fonte externa e frame a frame, e o que vigiamos hoje.