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.
Publicado em 30 de outubro de 2026 · 8 min de leitura
Um bot de Lightning Baccarat no Telegram é o projeto mais comum em cima de uma API de resultados, e também o mais rápido de terminar: um bot novo, uma chave da API e umas setenta linhas de Python. Este guia vai do zero até o bot publicando cada mão no grupo, com o código inteiro — sem framework e sem dependência além de uma biblioteca HTTP.
No fim, cada rodada vira uma mensagem assim:
♦ Lightning Baccarat · 15:42:31 Player K♥ 9♦ → 9 Banker 5♣ 2♠ 7♥ → 4 Vencedor: PLAYER (natural) Últimas 20: P B B P E P B P P B
O que você precisa antes de começar
- Um bot do Telegram. Fale com o @BotFather, mande
/newbot, escolha nome e usuário. Ele devolve um token, que é a senha do bot: guarde fora do código. - O id do grupo. Adicione o bot ao grupo, mande qualquer mensagem lá e abra
https://api.telegram.org/bot<SEU_TOKEN>/getUpdates. Ochat.iddo grupo aparece ali, e em grupos ele é negativo (algo como-1001234567890). - Uma chave da API do Lightning Baccarat. Crie a conta na LynxMetrics, confirme o e-mail e abra o teste de 2 horas no painel. Ele usa os limites do plano Pro e não pede cartão, então dá para terminar o bot inteiro antes de assinar. Os campos de cada rodada estão na visão geral da API.
Se o bot vai publicar num grupo, use o bot como administrador apenas se precisar: para só mandar mensagem, membro comum basta.
Por onde o bot recebe as rodadas
A API tem dois caminhos, e para um bot a escolha é clara: o /stream. Ele mantém uma conexão aberta e entrega a mão no instante em que ela é salva, sem você ficar perguntando — o que, além de ser mais rápido, gasta uma requisição do seu limite por minuto em vez de vinte. A comparação completa está em resultados ao vivo.
O bot inteiro
Instale a biblioteca HTTP e guarde os segredos no ambiente:
pip install httpx export LYNX_KEY="sk-lynx..." export TG_TOKEN="123456:ABC..." export TG_CHAT="-1001234567890"
bot.py
import json
import os
import time
from collections import deque
import httpx
LYNX_KEY = os.environ["LYNX_KEY"]
TG_TOKEN = os.environ["TG_TOKEN"]
TG_CHAT = os.environ["TG_CHAT"]
STREAM = "https://api.lynxmetrics.com/v1/lightning-baccarat/stream"
RESULTS = "https://api.lynxmetrics.com/v1/lightning-baccarat/results"
TELEGRAM = "https://api.telegram.org/bot" + TG_TOKEN + "/sendMessage"
VALORES = {"A": "A", "T": "10", "J": "J", "Q": "Q", "K": "K"}
NAIPES = {"C": "♣", "D": "♦", "H": "♥", "S": "♠"}
SIGLA = {"player": "P", "banker": "B", "tie": "E"}
ultimas = deque(maxlen=20) # histórico curto para o rodapé da mensagem
vistos = set() # ids já publicados, para nunca repetir
ultimo_id = None # id da rodada mais recente que já publicamos
def mao(cartas):
return " ".join(VALORES.get(c[0], c[0]) + NAIPES[c[1]] for c in cartas)
def mensagem(rodada):
dados = rodada["data"]
hora = rodada["settledAt"][11:19]
vencedor = {"player": "PLAYER", "banker": "BANKER", "tie": "EMPATE"}[rodada["outcome"]]
marcas = []
if dados["natural"]:
marcas.append("natural")
if dados["player"]["pair"]:
marcas.append("par no Player")
if dados["banker"]["pair"]:
marcas.append("par no Banker")
extra = " (" + ", ".join(marcas) + ")" if marcas else ""
return "\n".join([
"♦ <b>Lightning Baccarat</b> · " + hora + " UTC",
"Player " + mao(dados["player"]["cards"]) + " → <b>" + str(dados["player"]["score"]) + "</b>",
"Banker " + mao(dados["banker"]["cards"]) + " → <b>" + str(dados["banker"]["score"]) + "</b>",
"Vencedor: <b>" + vencedor + "</b>" + extra,
"Últimas " + str(len(ultimas)) + ": " + " ".join(ultimas),
])
def publicar(rodada):
global ultimo_id
if rodada["id"] in vistos: # o ready do stream repete a última rodada
return
vistos.add(rodada["id"])
ultimo_id = rodada["id"]
ultimas.append(SIGLA[rodada["outcome"]])
httpx.post(
TELEGRAM,
json={"chat_id": TG_CHAT, "text": mensagem(rodada), "parse_mode": "HTML"},
timeout=15,
)
def paginar_do_results(desde):
"""Última saída: ausência longa demais para o stream recuperar sozinho."""
while True:
resposta = httpx.get(
RESULTS,
headers={"x-api-key": LYNX_KEY},
params={"after": desde, "limit": 250},
timeout=30,
)
corpo = resposta.json()
for rodada in corpo["data"]:
publicar(rodada)
desde = rodada["id"]
if not corpo["nextCursor"]:
return
def acompanhar():
cabecalhos = {"x-api-key": LYNX_KEY, "accept": "text/event-stream"}
if ultimo_id: # reconexão: a API devolve o que fechou na ausência
cabecalhos["last-event-id"] = ultimo_id
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") == "too_many_missed":
paginar_do_results(ultimo_id)
for rodada in corpo.get("missed") or []:
publicar(rodada)
if corpo["data"]:
publicar(corpo["data"])
elif evento == "round":
publicar(corpo["data"])
elif evento == "closed":
return "closed"
while True:
try:
if acompanhar() == "closed":
print("outra conexão tomou a vaga desta chave: saindo", flush=True)
break
except Exception as erro:
print("caiu:", type(erro).__name__, erro, flush=True)
time.sleep(3)Pronto: python bot.py e o grupo começa a receber as mãos.
As quatro coisas que separam um bot que dura de um que morre na madrugada
Nunca repetir mensagem
O id de cada rodada é fixo e nunca muda, e é por isso que ele é a trava certa. O conjunto vistos resolve dois casos de uma vez: o event: ready, que ao abrir a conexão repete a última rodada de propósito, e a reconexão depois de uma queda. Sem essa trava, todo reinício do bot republica a mão anterior.
Cobrir o buraco da queda
Ao reabrir a conexão, o bot manda o id da última mão publicada no cabeçalho last-event-id. A API então devolve, no ready, um missed com as mãos que fecharam enquanto ele estava fora — até 50, da mais antiga para a mais nova. É isso que faz uma queda de dois minutos passar sem ninguém no grupo notar.
Só quando a ausência passa de 50 mãos, cerca de meia hora de mesa, o stream desiste e manda resyncError: "too_many_missed". Aí entra a função paginar_do_results, que termina o serviço pelo /results?after= — o mesmo parâmetro do artigo de histórico. Vale notar a ordem no código: o paginar_do_results roda antes de tratar o data do ready, para as mensagens saírem na ordem em que as mãos aconteceram.
Esperar a reconexão como coisa normal
Toda conexão do stream é encerrada depois de 6 horas, mesmo saudável. Quem roda o dia inteiro reconecta umas quatro vezes por dia, então o laço while True não é defesa contra bug: é o funcionamento esperado. Com o last-event-id, nenhuma dessas reconexões custa uma mão. O mesmo laço cobre queda de rede e reinício do servidor.
Se chegar um event: closed, o caso é diferente: significa que outra conexão abriu com a mesma chave e tomou a vaga. Reconectar ali só derrubaria a outra, e as duas cópias ficariam se expulsando para sempre — por isso o bot sai do laço. Normalmente é uma segunda cópia do bot que você esqueceu rodando.
Não brigar com o limite do Telegram
O Telegram aceita cerca de 20 mensagens por minuto no mesmo grupo. Uma rodada a cada 35 segundos dá menos de 2 por minuto, então você está folgado — até querer publicar estatística, aviso de sequência e resumo de hora no mesmo grupo. Se somar tudo e passar, o Telegram responde 429 com retry_after, e vale respeitá-lo.
Ideias para a mensagem
Com os campos que a API entrega, dá para enriquecer sem inventar nada:
- Avisar que a mesa está resolvendo a mão. O
event: phase, que você pede com?phases=1, chega antes das cartas, com oroundIdque a mão vai ter: dá para mandar um "mão em andamento" e depois editar a mesma mensagem com o resultado, usando oeditMessageTextdo Telegram. Guarde omessage_idporroundId— e saiba expirar a fase que não virou mão. - Marcar sequência. Quando
currentStreak.lengthdo/statspassa de 4, acrescentar uma linha. Uma consulta por rodada, no máximo. - Avisar par. O campo
pairde cada lado já diz, e é a aposta lateral mais seguida. - Resumo de hora. Um
/stats?sample=100de hora em hora, com as porcentagens e o total da amostra ao lado — e nunca a porcentagem sozinha, pelo motivo explicado em estatísticas. - Bead Road em texto. As
ultimasjá formam a tiraP B B P E; em quadradinhos coloridos, fica igual ao gráfico da mesa.
Onde rodar, e o que não fazer
O bot é leve: qualquer VPS pequena, um contêiner ou uma máquina sempre ligada dá conta, porque o trabalho é só manter uma conexão aberta. O que ele não pode é rodar em função serverless com tempo limite curto, já que o stream depende de um processo de pé — nesse caso, consulte o /latest por cron e guarde o último id em algum lugar.
Duas regras de segurança, que valem mais que o bot: a chave da API e o token do Telegram nunca vão para o repositório nem para o lado do navegador, e cada bot merece o seu próprio projeto na LynxMetrics, com a própria chave — assim você revoga uma sem derrubar as outras. Detalhes em segurança da API.
Perguntas frequentes
- Preciso saber programar para montar um bot de Lightning Baccarat?
Precisa do básico de Python ou de outra linguagem com cliente HTTP. O código completo deste artigo tem cerca de setenta linhas e usa uma única biblioteca, a httpx, mais o token do bot do Telegram e a chave da API.
- Como o bot evita publicar a mesma rodada duas vezes?
Guardando o id de cada rodada já publicada. O id é fixo e nunca muda, e o evento ready do stream repete a última rodada de propósito quando a conexão abre, então sem essa trava todo reinício do bot republicaria a mão anterior.
- O que acontece com o bot quando a conexão cai?
Ele reabre o stream mandando o id da última mão publicada no cabeçalho last-event-id, e a API devolve no ready as mãos que fecharam na ausência, até 50. Se a ausência passou disso, vem resyncError too_many_missed e o bot termina pelo /results?after=. Toda conexão também é encerrada a cada 6 horas por desenho, então reconectar é parte do funcionamento normal.
- Dá para rodar o bot de graça durante o teste?
Sim. O teste do Lightning Baccarat dura 2 horas com os limites do plano Pro, sem cartão, e pode ser repetido a cada 24 horas. É tempo suficiente para terminar e testar o bot antes de assinar.
- Posso rodar o bot numa função serverless?
Não com o stream, que precisa de um processo de pé mantendo a conexão aberta. Em serverless, consulte o /latest por cron, guarde o id da última rodada tratada em algum armazenamento e publique só quando ele mudar.
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.
- 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.
- Como funciona o Lightning Baccarat: multiplicadores
As regras do Lightning Baccarat da Evolution do começo: pontuação das cartas, quando sai a terceira carta, natural, par e o que a camada Lightning muda.