Blog · Lightning Baccarat

Cómo hacer un bot de Lightning Baccarat en Telegram

Paso a paso para publicar cada ronda del Lightning Baccarat en Telegram: crear el bot, conectarlo al stream de la API, formatear las cartas y no repetir.

Publicado el 30 de octubre de 2026 · 8 min de lectura

Un bot de Lightning Baccarat en Telegram es el proyecto más común sobre una API de resultados, y también el más rápido de terminar: un bot nuevo, una clave de la API y unas setenta líneas de Python. Esta guía va de cero al bot publicando cada mano en el grupo, con el código entero — sin framework y sin dependencias más allá de una biblioteca HTTP.

Al final, cada ronda se convierte en un mensaje así:

♦ Lightning Baccarat · 15:42:31
Player  K♥ 9♦   → 9
Banker  5♣ 2♠ 7♥ → 4
Ganador: PLAYER (natural)
Últimas 20: P B B P E P B P P B

Qué necesitás antes de empezar

  1. Un bot de Telegram. Hablá con @BotFather, mandá /newbot, elegí nombre y usuario. Te devuelve un token, que es la contraseña del bot: guardalo fuera del código.
  2. El id del grupo. Agregá el bot al grupo, mandá cualquier mensaje ahí y abrí https://api.telegram.org/bot<TU_TOKEN>/getUpdates. El chat.id del grupo aparece ahí, y en grupos es negativo (algo como -1001234567890).
  3. Una clave de la API de Lightning Baccarat. Creá la cuenta en LynxMetrics, confirmá el correo y abrí la prueba de 1 hora en el panel. Usa los límites del plan Pro y no pide tarjeta, así que podés terminar el bot entero antes de suscribirte. Los campos de cada ronda están en la visión general de la API.

Si el bot va a publicar en un grupo, hacelo administrador solo si lo necesitás: para solo mandar mensajes, alcanza con miembro común.

Por dónde recibe las rondas el bot

La API tiene dos caminos, y para un bot la elección es clara: el /stream. Mantiene una conexión abierta y entrega la mano en el instante en que se guarda, sin que preguntes — lo que, además de ser más rápido, gasta una petición de tu límite por minuto en vez de veinte. La comparación completa está en resultados en vivo.

El bot entero

Instalá la biblioteca HTTP y guardá los secretos en el 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"]

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

ultimas = deque(maxlen=20)   # historial corto para el pie del mensaje
vistos = set()               # ids ya publicados, para no repetir nunca
ultimo_id = None             # id de la ronda más reciente que publicamos


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]
    ganador = {"player": "PLAYER", "banker": "BANKER", "tie": "EMPATE"}[ronda["outcome"]]
    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>Lightning Baccarat</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>" + ganador + "</b>" + extra,
        "Últimas " + str(len(ultimas)) + ": " + " ".join(ultimas),
    ])


def publicar(ronda):
    global ultimo_id
    if ronda["id"] in vistos:        # el ready del stream repite la última ronda
        return
    vistos.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 paginar_desde_results(desde):
    """Última salida: ausencia demasiado larga para que el stream la recupere solo."""
    while True:
        respuesta = httpx.get(
            RESULTS,
            headers={"x-api-key": LYNX_KEY},
            params={"after": desde, "limit": 250},
            timeout=30,
        )
        cuerpo = respuesta.json()
        for ronda in cuerpo["data"]:
            publicar(ronda)
            desde = ronda["id"]
        if not cuerpo["nextCursor"]:
            return


def acompanar():
    cabeceras = {"x-api-key": LYNX_KEY, "accept": "text/event-stream"}
    if ultimo_id:                        # reconexión: la API devuelve lo que cerró en la ausencia
        cabeceras["last-event-id"] = ultimo_id
    with httpx.stream("GET", 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":
                        paginar_desde_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 acompanar() == "closed":
            print("otra conexión tomó el lugar de esta clave: saliendo", flush=True)
            break
    except Exception as error:
        print("se cortó:", type(error).__name__, error, flush=True)
    time.sleep(3)

Listo: python bot.py y el grupo empieza a recibir las manos.

Las cuatro cosas que separan un bot que dura de uno que muere de madrugada

No repetir nunca un mensaje

El id de cada ronda es fijo y nunca cambia, y por eso es la traba correcta. El conjunto vistos resuelve dos casos de una vez: el event: ready, que al abrir la conexión repite la última ronda a propósito, y la reconexión después de una caída. Sin esa traba, cada reinicio del bot vuelve a publicar la mano anterior.

Cubrir el hueco de la caída

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

Solo cuando la ausencia pasa de 50 manos, cerca de media hora de mesa, el stream se rinde y manda resyncError: "too_many_missed". Ahí entra la función paginar_desde_results, que termina el trabajo por el /results?after= — el mismo parámetro del artículo de historial. Fijate en el orden del código: el paginar_desde_results corre antes de tratar el data del ready, para que los mensajes salgan en el orden en que ocurrieron las manos.

Tratar la reconexión como algo normal

Toda conexión del stream se cierra después de 6 horas, incluso saludable. Quien corre todo el día reconecta unas cuatro veces por día, así que el bucle while True no es defensa contra un bug: es el funcionamiento esperado. Con el last-event-id, ninguna de esas reconexiones cuesta una mano. El mismo bucle cubre la caída de red y el reinicio del servidor.

Si llega un event: closed, el caso es distinto: significa que otra conexión abrió con la misma clave y tomó el lugar. Reconectar ahí tiraría la otra, y las dos copias se expulsarían para siempre — por eso el bot sale del bucle. Normalmente es una segunda copia del bot que te olvidaste corriendo.

No pelear con el límite de Telegram

Telegram acepta cerca de 20 mensajes por minuto en el mismo grupo. Una ronda cada 35 segundos da menos de 2 por minuto, así que vas holgado — hasta que quieras publicar estadísticas, aviso de racha y resumen por hora en el mismo grupo. Si todo junto pasa el límite, Telegram responde 429 con retry_after, y conviene respetarlo.

Ideas para el mensaje

Con los campos que entrega la API, se puede enriquecer sin inventar nada:

  • Avisar que la mesa está resolviendo la mano. El event: phase, que pedís con ?phases=1, llega antes de las cartas, con el roundId que la mano va a tener: podés mandar un "mano en curso" y después editar el mismo mensaje con el resultado, usando el editMessageText de Telegram. Guardá el message_id por roundId — y sabé expirar la fase que no se convirtió en mano.
  • Marcar racha. Cuando el currentStreak.length del /stats pasa de 4, agregar una línea. Una consulta por ronda, como máximo.
  • Avisar par. El campo pair de cada lado ya lo dice, y es la apuesta lateral más seguida.
  • Resumen por hora. Un /stats?sample=100 cada hora, con los porcentajes y el total de la muestra al lado — y nunca el porcentaje solo, por el motivo explicado en estadísticas.
  • Bead Road en texto. El ultimas ya forma la tira P B B P E; en cuadraditos de color queda igual al gráfico de la mesa.

Dónde correrlo, y qué no hacer

El bot es liviano: cualquier VPS chica, un contenedor o una máquina siempre encendida alcanza, porque el trabajo es solo mantener una conexión abierta. Lo que no puede es correr en una función serverless con tiempo límite corto, ya que el stream depende de un proceso de pie — en ese caso, consultá el /latest por cron y guardá el último id en algún lugar.

Dos reglas de seguridad, que valen más que el bot: 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 — así revocás una sin tirar las otras. Detalles en seguridad de la API.

Preguntas frecuentes

¿Necesito saber programar para armar un bot de Lightning Baccarat?

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

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

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

¿Qué pasa con el bot cuando se corta la conexión?

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. Si la ausencia pasó de eso, llega resyncError too_many_missed y el bot termina por /results?after=. Toda conexión también se cierra cada 6 horas por diseño, así que reconectar es parte del funcionamiento normal.

¿Se puede correr el bot gratis durante la prueba?

Sí. La prueba del Lightning Baccarat dura 2 horas con los límites del plan Pro, sin tarjeta, y se puede repetir cada 24 horas. Es tiempo suficiente para terminar y probar el bot antes de suscribirte.

¿Puedo correr el bot en una función serverless?

No con el stream, que necesita un proceso de pie manteniendo la conexión abierta. En serverless, consultá el /latest por cron, guardá el id de la última ronda tratada en algún almacenamiento y publicá solo cuando cambie.

Contenido solo para mayores de 18 años. LynxMetrics no tiene relación con Evolution ni con los casinos que ofrecen Lightning Baccarat, 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