Blog · Baccarat 1

Bot de Baccarat 1 en Telegram: el código completo

Cómo publicar cada mano de la Baccarat 1 de Pragmatic Play en un grupo de Telegram: crear el bot, conectarlo al stream y no repetir ni perder manos.

Publicado el 2 de noviembre de 2026 · 9 min de lectura

Un bot de Baccarat 1 en Telegram publica cada mano de la mesa de Pragmatic Play en tu grupo pocos segundos después de que el crupier dé vuelta la última carta, y son cerca de 80 líneas de Python sobre el /stream de la API de la Baccarat 1 de LynxMetrics. Esta guía tiene el programa completo, sin framework y con una sola dependencia, y explica las cuatro cosas que separan un bot que corre meses de uno que muere en la primera caída de red.

Cada ronda se convierte en un mensaje así:

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

Los tres ingredientes

QuéDónde se consigueCuánto cuesta
Un bot de Telegram@BotFather, con el comando /newbotGratis
El id del grupohttps://api.telegram.org/bot<TOKEN>/getUpdates después de escribir en el grupoGratis
Una clave de la Baccarat 1El panel de LynxMetrics, en la prueba de 2 horas o en una suscripciónPrueba gratis, o R$ 21,90 por mes en Pro

El id de grupo es negativo, algo como -1001234567890: si tu número salió positivo, tomaste el id de la conversación privada con el bot, y no el del grupo. Para solo enviar mensajes, el bot no necesita ser administrador.

La prueba de la Baccarat 1 dura 2 horas con los límites del plan Pro, no pide tarjeta y se puede repetir cada 24 horas. Como una ronda de la Baccarat 1 lleva cerca de 30 segundos, dos horas de prueba dan cerca de 240 manos: tiempo de sobra para terminar el bot, ver los mensajes llegando al grupo y solo entonces decidir si suscribes.

¿Por qué el bot usa el /stream y no el /latest?

Porque el /stream entrega la mano en el instante en que se guarda, sin que el bot pregunte. La diferencia es grande en dos frentes: en la velocidad, porque no hay espera hasta la próxima consulta, y en el consumo, porque mantener la conexión abierta gasta 1 pedido de tu límite por minuto, mientras consultar el /latest cada 3 segundos gasta 20. En el plan Pro el límite es de 60 pedidos por minuto, así que el /stream deja el resto libre para lo que quieras hacer además de publicar. La comparación completa está en resultados en vivo de la Baccarat 1.

El bot completo

Una dependencia y tres variables de entorno:

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"}
PALOS = {"C": "♣", "D": "♦", "H": "♥", "S": "♠"}
SIGLA = {"player": "P", "banker": "B", "tie": "E"}
NOMBRE = {"player": "PLAYER", "banker": "BANKER", "tie": "EMPATE"}

ultimas = deque(maxlen=20)   # tira corta para el pie del mensaje
publicadas = set()           # ids ya publicados: el candado contra el mensaje repetido
ultimo_id = None             # id de la última mano que fue al grupo


def mano(cartas):
    return " ".join(VALORES.get(c[0], c[0]) + PALOS[c[1]] for c in cartas)


def mensaje(ronda):
    datos = ronda["data"]
    hora = ronda["settledAt"][11:19]
    marcas = []
    if datos["natural"]:
        marcas.append("natural")
    if datos["player"]["pair"]:
        marcas.append("par en el Player")
    if datos["banker"]["pair"]:
        marcas.append("par en el Banker")
    extra = " (" + ", ".join(marcas) + ")" if marcas else ""
    return "\n".join([
        "♠ <b>Baccarat 1</b> · " + hora + " UTC",
        "Player  " + mano(datos["player"]["cards"]) + " → <b>" + str(datos["player"]["score"]) + "</b>",
        "Banker  " + mano(datos["banker"]["cards"]) + " → <b>" + str(datos["banker"]["score"]) + "</b>",
        "Ganador: <b>" + NOMBRE[ronda["outcome"]] + "</b>" + extra,
        "Últimas " + str(len(ultimas)) + ": " + " ".join(ultimas),
    ])


def publicar(ronda):
    global ultimo_id
    if ronda["id"] in publicadas:
        return
    publicadas.add(ronda["id"])
    ultimo_id = ronda["id"]
    ultimas.append(SIGLA[ronda["outcome"]])
    httpx.post(
        TELEGRAM,
        json={"chat_id": TG_CHAT, "text": mensaje(ronda), "parse_mode": "HTML"},
        timeout=15,
    )


def recuperar_por_results(desde):
    """Ausencia larga: el stream se rindió, así que pagina lo que faltó."""
    while True:
        cuerpo = httpx.get(
            BASE + "/results",
            headers={"x-api-key": LYNX_KEY},
            params={"after": desde, "limit": 250},
            timeout=30,
        ).json()
        for ronda in cuerpo["data"]:
            publicar(ronda)
            desde = ronda["id"]
        if not cuerpo["nextCursor"]:
            return


def seguir():
    cabeceras = {"x-api-key": LYNX_KEY, "accept": "text/event-stream"}
    if ultimo_id:
        cabeceras["last-event-id"] = ultimo_id
    with httpx.stream("GET", BASE + "/stream", headers=cabeceras, timeout=None) as respuesta:
        respuesta.raise_for_status()
        evento = None
        for linea in respuesta.iter_lines():
            if linea.startswith("event:"):
                evento = linea.split(":", 1)[1].strip()
            elif linea.startswith("data:"):
                cuerpo = json.loads(linea.split(":", 1)[1])
                if evento == "ready":
                    if cuerpo.get("resyncError") == "too_many_missed":
                        recuperar_por_results(ultimo_id)
                    for ronda in cuerpo.get("missed") or []:
                        publicar(ronda)
                    if cuerpo["data"]:
                        publicar(cuerpo["data"])
                elif evento == "round":
                    publicar(cuerpo["data"])
                elif evento == "closed":
                    return "closed"


while True:
    try:
        if seguir() == "closed":
            print("otra conexión tomó esta clave: saliendo", flush=True)
            break
    except Exception as error:
        print("se cayó:", type(error).__name__, error, flush=True)
    time.sleep(3)

python bot.py, y en la próxima mano el grupo recibe el primer mensaje.

Las cuatro cosas que hacen que el bot dure

Nunca repetir la misma mano

El id de cada ronda de la Baccarat 1 es fijo y nunca cambia, y por eso sirve de candado. El conjunto publicadas resuelve dos casos a la vez. El primero es el event: ready: cuando la conexión abre, la API manda a propósito la última ronda conocida, para que el programa tenga un punto de partida. El segundo es la reconexión después de una caída, que repite ese mismo ready. Sin el candado, cada reinicio del bot vuelve a publicar la mano anterior, y es el error más común en un primer bot.

Cubrir el hueco sin perder mano

Al reabrir la conexión, el bot manda el id de la última mano publicada en la cabecera last-event-id. La API devuelve entonces, dentro del ready, un missed con las manos que cerraron mientras el bot estaba fuera, de la más antigua a la más nueva, hasta 50 rondas. Eso es lo que hace que una caída de red de tres minutos pase sin que nadie en el grupo lo note.

Por encima de 50 manos perdidas, cerca de media hora de mesa, el stream no intenta reconstruir: manda resyncError: "too_many_missed", y entra la función recuperar_por_results, que termina el trabajo por /results?after=, el mismo parámetro explicado en historial de la Baccarat 1. Fíjate en el orden dentro del código: la recuperación corre antes de tratar el data del ready, para que los mensajes salgan en el orden en que las manos ocurrieron.

Tratar la reconexión como rutina, no como falla

Toda conexión del /stream se cierra después de 6 horas, incluso sana. Un bot que corre todo el día reconecta unas cuatro veces por día, así que el while True del final no es un parche contra un bug: es el funcionamiento previsto. Con el last-event-id, ninguna de esas reconexiones cuesta una mano.

El event: closed es otra historia. Significa que otra conexión abrió con la misma clave y tomó el lugar: en Pro la clave mantiene 1 stream, y en Business, 5. Reconectar ahí haría que las dos copias se expulsaran para siempre, y por eso el bot sale del ciclo y escribe el motivo en el log. Casi siempre es una segunda copia del propio bot que quedó corriendo olvidada.

No chocar con el límite de Telegram

Telegram acepta cerca de 20 mensajes por minuto en el mismo grupo. Una mano cada 30 segundos da 2 por minuto, así que sobra holgura, hasta que quieras publicar en el mismo grupo aviso de racha, resumen de hora y alerta de par. Si la suma pasa, Telegram responde 429 con un retry_after, y respetarlo es lo correcto. Los códigos de error de nuestra API siguen la misma lógica y están en errores y límites de API.

Ideas para el mensaje, solo con campos que ya vienen

  • Par y natural. Los campos data.player.pair, data.banker.pair y data.natural ya vienen en la ronda, y las apuestas laterales de par son las más seguidas del baccarat.
  • Racha. Cuando el currentStreak.length del /stats pasa de 4, agrega una línea. Es una consulta por mano como máximo, y cabe holgada en los 60 pedidos por minuto del Pro.
  • Resumen de hora. Un /stats?sample=100 cada hora, con los porcentajes y el tamaño de la muestra al lado, por el motivo explicado en estadísticas de la Baccarat 1.
  • Bead Road en texto. La tira ultimas ya está armada; en cuadraditos de color queda igual al gráfico de la mesa.
  • Mano en curso. Pidiendo ?phases=1, el event: phase llega antes de las cartas con el roundId que la mano va a tener: puedes mandar "mano en curso" y después editar ese mismo mensaje con el resultado, por editMessageText. Guarda el message_id por roundId, y sabe descartar la fase que no se volvió mano.

¿Y si quiero las dos mesas de baccarat en el mismo grupo?

Cambia el nombre del juego en la URL y usa la clave de esa API. El Lightning Baccarat de Evolution responde en el mismo formato, con los mismos cuatro endpoints, así que el BASE del código se vuelve una variable y el bot corre dos streams, uno por mesa. La comparación está en Baccarat 1 o Lightning Baccarat, y el bot de la otra mesa, en bot de Lightning Baccarat en Telegram.

Dónde correrlo, y las dos reglas de seguridad

El bot es liviano: su trabajo es mantener una conexión abierta y publicar dos mensajes por minuto, así que cualquier VPS pequeña, contenedor o máquina siempre encendida alcanza. Lo que no puede es vivir en una función serverless con tiempo límite corto, porque el /stream necesita un proceso de pie; en ese caso, consulta el /latest por cron, guarda el id de la última mano tratada y publica solo cuando cambie. Las opciones están en dónde alojar un bot.

Las dos reglas que valen más que el código: la clave de la API y el token de Telegram nunca van al repositorio ni al lado del navegador, y cada bot merece su propio proyecto en LynxMetrics, con su propia clave, para poder revocar una sin tumbar las otras. Más en seguridad de la API.

Preguntas frecuentes

¿Necesito saber programar para hacer un bot de Baccarat 1 en Telegram?

Necesitas lo básico de Python, o de otro lenguaje con un cliente HTTP. El código completo de este artículo tiene cerca de 80 líneas y usa una sola biblioteca, httpx, más el token del bot de Telegram y una clave de la API de la Baccarat 1.

¿Cómo evita el bot publicar la misma mano dos veces?

Guardando el id de cada ronda ya publicada. El id es fijo y nunca cambia, y el evento ready del stream repite a propósito la última ronda cuando la conexión abre, así que sin ese candado cada reinicio volvería a publicar la mano anterior.

¿Qué pasa cuando se cae la conexión del bot?

Reabre el stream mandando el id de la última mano publicada en la cabecera last-event-id, y la API devuelve en el ready las manos que cerraron en la ausencia, hasta 50. Pasando de ahí llega resyncError too_many_missed, y el bot termina la recuperación por /results?after=. Toda conexión también se cierra cada 6 horas por diseño, así que reconectar es rutina.

¿Se puede armar y probar el bot gratis?

Sí. La prueba de la API de la Baccarat 1 dura 2 horas con los límites del plan Pro, sin tarjeta, y se puede repetir cada 24 horas. Como una ronda lleva cerca de 30 segundos, dos horas rinden cerca de 240 manos, suficiente para ver el bot publicando antes de suscribir.

¿Puedo publicar la Baccarat 1 y el Lightning Baccarat en el mismo grupo?

Sí, porque las dos APIs comparten formato y endpoints: cambias el nombre del juego en la URL y usas la clave de esa API. Cada API es una suscripción separada, con su propio límite por minuto y sus propias conexiones de stream.

Contenido solo para mayores de 18 años. LynxMetrics no tiene relación con Pragmatic Play ni con los casinos que ofrecen Baccarat 1, y vende solo datos y estadísticas, nunca predicciones ni consejos de apuestas, porque cada ronda es aleatoria y el historial no predice la siguiente.

Lee también