Blog · Lightning Baccarat

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

  1. 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.
  2. O id do grupo. Adicione o bot ao grupo, mande qualquer mensagem lá e abra https://api.telegram.org/bot<SEU_TOKEN>/getUpdates. O chat.id do grupo aparece ali, e em grupos ele é negativo (algo como -1001234567890).
  3. 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 o roundId que a mão vai ter: dá para mandar um "mão em andamento" e depois editar a mesma mensagem com o resultado, usando o editMessageText do Telegram. Guarde o message_id por roundId — e saiba expirar a fase que não virou mão.
  • Marcar sequência. Quando currentStreak.length do /stats passa de 4, acrescentar uma linha. Uma consulta por rodada, no máximo.
  • Avisar par. O campo pair de cada lado já diz, e é a aposta lateral mais seguida.
  • Resumo de hora. Um /stats?sample=100 de 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 ultimas já formam a tira P 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