Blog · Baccarat 1

Bot de Baccarat 1 no Telegram: o código completo

Como publicar cada mão da Baccarat 1 da Pragmatic Play num grupo do Telegram: criar o bot, ligar no stream da API e não repetir nem perder mão.

Publicado em 2 de novembro de 2026 · 9 min de leitura

Um bot de Baccarat 1 no Telegram publica cada mão da mesa da Pragmatic Play no seu grupo poucos segundos depois de o crupiê virar a última carta, e são cerca de 80 linhas de Python em cima do /stream da API da Baccarat 1 da LynxMetrics. Este guia tem o código inteiro, sem framework e com uma única dependência, e explica as quatro coisas que separam um bot que roda meses de um que morre na primeira queda de rede.

Cada rodada vira uma mensagem assim no grupo:

♠ Baccarat 1 · 14:10:58
Player  7♠ 2♦ → 9
Banker  A♣ 9♥ → 0
Vencedor: PLAYER (natural)
Últimas 20: P B B P E P B P P B

Os três ingredientes

O queOnde se consegueQuanto custa
Um bot do Telegram@BotFather, com o comando /newbotGrátis
O id do grupohttps://api.telegram.org/bot<TOKEN>/getUpdates depois de mandar uma mensagem no grupoGrátis
Uma chave da Baccarat 1Painel da LynxMetrics, no teste de 2 horas ou numa assinaturaTeste grátis, ou R$ 21,90 por mês no Pro

O id de grupo é negativo, algo como -1001234567890: se o seu número veio positivo, você pegou o id da conversa privada com o bot, e não o do grupo. Para só mandar mensagem, o bot não precisa ser administrador do grupo.

O teste da Baccarat 1 dura 2 horas com os limites do plano Pro, não pede cartão e pode ser repetido a cada 24 horas. Como uma rodada da Baccarat 1 leva cerca de 30 segundos, duas horas de teste dão cerca de 240 mãos: é tempo de sobra para terminar o bot, ver as mensagens saindo no grupo e só então decidir se assina.

Por que o bot usa o /stream e não o /latest?

Porque o /stream entrega a mão no instante em que ela é salva, sem o bot ficar perguntando. A diferença é grande em duas frentes: na velocidade, porque não há espera até a próxima consulta, e no consumo, porque manter a conexão aberta gasta 1 pedido do seu limite por minuto, enquanto consultar o /latest a cada 3 segundos gasta 20. No plano Pro o limite é de 60 pedidos por minuto, então o /stream deixa o resto dele livre para o que você quiser fazer além de publicar. A comparação completa está em resultados ao vivo da Baccarat 1.

O bot inteiro

Uma dependência e três variáveis de 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"]

BASE = "https://api.lynxmetrics.com/v1/baccarat-1"
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"}
NOME = {"player": "PLAYER", "banker": "BANKER", "tie": "EMPATE"}

ultimas = deque(maxlen=20)   # tira curta para o rodapé da mensagem
publicadas = set()           # ids já publicados: a trava contra mensagem repetida
ultimo_id = None             # id da última mão que foi para o grupo


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]
    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>Baccarat 1</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>" + NOME[rodada["outcome"]] + "</b>" + extra,
        "Últimas " + str(len(ultimas)) + ": " + " ".join(ultimas),
    ])


def publicar(rodada):
    global ultimo_id
    if rodada["id"] in publicadas:
        return
    publicadas.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 recuperar_pelo_results(desde):
    """Ausência longa: o stream desistiu de remontar, então pagina o que faltou."""
    while True:
        corpo = httpx.get(
            BASE + "/results",
            headers={"x-api-key": LYNX_KEY},
            params={"after": desde, "limit": 250},
            timeout=30,
        ).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:
        cabecalhos["last-event-id"] = ultimo_id
    with httpx.stream("GET", BASE + "/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":
                        recuperar_pelo_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 assumiu esta chave: saindo", flush=True)
            break
    except Exception as erro:
        print("caiu:", type(erro).__name__, erro, flush=True)
    time.sleep(3)

python bot.py, e na próxima mão o grupo recebe a primeira mensagem.

As quatro coisas que fazem o bot durar

Nunca repetir a mesma mão

O id de cada rodada da Baccarat 1 é fixo e nunca muda, e é por isso que ele serve de trava. O conjunto publicadas resolve dois casos de uma vez. O primeiro é o event: ready: quando a conexão abre, a API manda de propósito a última rodada conhecida, para o programa ter um ponto de partida. O segundo é a reconexão depois de uma queda, que repete esse mesmo ready. Sem a trava, cada reinício do bot republica a mão anterior no grupo, e é o erro mais comum de quem monta o primeiro bot.

Cobrir o buraco da queda sem perder mão

Ao reabrir a conexão, o bot manda o id da última mão publicada no cabeçalho last-event-id. A API devolve então, dentro do ready, um missed com as mãos que fecharam enquanto o bot estava fora, da mais antiga para a mais nova, até 50 rodadas. É isso que faz uma queda de rede de três minutos passar sem ninguém no grupo perceber.

Acima de 50 mãos perdidas — cerca de meia hora de mesa — o stream não tenta remontar: ele manda resyncError: "too_many_missed", e aí entra a função recuperar_pelo_results, que termina o serviço pelo /results?after=, o mesmo parâmetro explicado em histórico da Baccarat 1. Repare na ordem dentro do código: a recuperação roda antes de tratar o data do ready, para as mensagens saírem no grupo na ordem em que as mãos aconteceram.

Tratar a reconexão como rotina, não como falha

Toda conexão do /stream é encerrada depois de 6 horas, mesmo sem nenhum problema. Um bot que roda o dia inteiro reconecta umas quatro vezes por dia, então o while True do fim não é remendo contra bug: é o funcionamento previsto. Com o last-event-id, nenhuma dessas reconexões custa uma mão.

O event: closed é outra história. Ele significa que outra conexão abriu com a mesma chave e assumiu a vaga — no plano Pro a chave mantém 1 stream, e no Business, 5. Reconectar ali faria as duas cópias se expulsarem para sempre, e por isso o bot sai do laço e escreve o motivo no log. Quase sempre é uma segunda cópia do próprio bot que ficou rodando esquecida.

Não bater no limite do Telegram

O Telegram aceita cerca de 20 mensagens por minuto no mesmo grupo. Uma mão a cada 30 segundos dá 2 por minuto, então sobra folga — até você querer publicar, no mesmo grupo, aviso de sequência, resumo de hora e alerta de par. Se a soma passar, o Telegram responde 429 com um retry_after, e respeitá-lo é o certo. Os códigos de erro da nossa API seguem a mesma lógica e estão em erros e limites de API.

Ideias para a mensagem, só com campos que já vêm prontos

  • Par e natural. Os campos data.player.pair, data.banker.pair e data.natural já vêm na rodada, e as apostas laterais de par são as mais acompanhadas do baccarat.
  • Sequência. Quando o currentStreak.length do /stats passa de 4, acrescente uma linha. É uma consulta por mão, no máximo, e cabe folgada nos 60 pedidos por minuto do Pro.
  • Resumo de hora. Um /stats?sample=100 de hora em hora, com as porcentagens e o tamanho da amostra ao lado, pelo motivo explicado em estatísticas da Baccarat 1.
  • Bead Road em texto. A tira ultimas já está montada; em quadradinhos coloridos ela fica igual ao gráfico da mesa.
  • Mão em andamento. Pedindo ?phases=1, o event: phase chega antes das cartas com o roundId que a mão vai ter: dá para mandar "mão em andamento" e depois editar a mesma mensagem com o resultado, pelo editMessageText. Guarde o message_id por roundId, e saiba descartar a fase que não virou mão.

E se eu quiser as duas mesas de baccarat no mesmo grupo?

Troque o nome do jogo na URL e use a chave daquela API. O Lightning Baccarat da Evolution responde no mesmo formato, com os mesmos quatro endpoints, então o BASE do código vira uma variável e o bot passa a rodar dois streams, um por mesa. A comparação entre elas está em Baccarat 1 ou Lightning Baccarat, e o bot da outra mesa, em bot de Lightning Baccarat no Telegram.

Onde rodar, e as duas regras de segurança

O bot é leve: o trabalho dele é manter uma conexão aberta e postar duas mensagens por minuto, então qualquer VPS pequena, contêiner ou máquina sempre ligada dá conta. O que ele não pode é viver numa função serverless com tempo limite curto, porque o /stream precisa de um processo de pé; nesse caso, consulte o /latest por cron, guarde o id da última mão tratada e publique só quando ele mudar. As opções estão em onde hospedar um bot.

As duas regras que valem mais que o código: 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, para você poder revogar uma sem derrubar as outras. Mais em segurança da API.

Perguntas frequentes

Preciso saber programar para fazer um bot de Baccarat 1 no Telegram?

Precisa do básico de Python, ou de outra linguagem com um cliente HTTP. O código completo deste artigo tem cerca de 80 linhas e usa uma única biblioteca, a httpx, mais o token do bot do Telegram e uma chave da API da Baccarat 1.

Como o bot evita publicar a mesma mão duas vezes?

Guardando o id de cada rodada já publicada. O id é fixo e nunca muda, e o evento ready do stream repete de propósito a última rodada quando a conexão abre, então sem essa trava todo reinício do bot republicaria a mão anterior no grupo.

O que acontece quando a conexão do bot 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. Passando disso vem resyncError too_many_missed, e o bot termina a recuperação pelo /results?after=. Toda conexão também é encerrada a cada 6 horas por desenho, então reconectar é rotina.

Dá para montar e testar o bot de graça?

Dá. O teste da API da Baccarat 1 dura 2 horas com os limites do plano Pro, sem cartão, e pode ser repetido a cada 24 horas. Como uma rodada leva cerca de 30 segundos, duas horas rendem cerca de 240 mãos, o suficiente para ver o bot publicando antes de assinar.

Dá para publicar a Baccarat 1 e o Lightning Baccarat no mesmo grupo?

Dá, porque as duas APIs têm o mesmo formato e os mesmos endpoints: basta trocar o nome do jogo na URL e usar a chave daquela API. Cada API é uma assinatura separada, com o seu próprio limite por minuto e as suas próprias conexões de stream.

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