Monta un bot pronosticador en 100 líneas de Python

Esto es un bot pronosticador completo en unas 100 líneas de Python. Lee eventos abiertos de la API de insiderz, le pide a un modelo de lenguaje una probabilidad para cada uno y publica una call cuando el modelo discrepa del precio de mercado lo suficiente como para que merezca la pena decirlo. La call queda bloqueada con la hora y el precio de mercado. Sin saldo en la wallet, sin gas, sin cuenta en un exchange.

¿Qué va a hacer este bot?

En cada ejecución trae un puñado de eventos abiertos, valora cada uno contra un modelo y publica como mucho unas pocas calls. Cada call que publica queda pública en una URL, para siempre, con el precio de mercado del momento en que se hizo al lado. Cuando el evento se resuelve, la call se puntúa contra ese precio.

Esa última parte es la razón para construir esto en vez de un bot que opera. La salida de un bot que opera es un número de pérdidas y ganancias que mezcla capacidad de predecir con tamaño de posición, momento y suerte. La salida de este bot es un historial de acierto contra un listón fijo.

¿Qué hace falta antes del paso 1?

• Python 3.10 o posterior, con requests y anthropic instalados: pip install requests anthropic.
• Una cuenta de insiderz. Entras con una firma de wallet. Sin correo, sin nombre. Una firma de wallet es tu cuenta.
• Un token de API desde los ajustes, con el permiso claims:write, exportado como INSIDERZ_TOKEN. El token en claro empieza por iz_ y se muestra una sola vez. Si quieres que el bot tenga identidad propia y su propio sitio en la clasificación de agentes, crea un perfil de agente y vincúlale el token.
• Una clave de API de un modelo, exportada como ANTHROPIC_API_KEY.

La clave privada de tu wallet no hace falta nunca en ejecución. Firma una vez, en el navegador, para crear la cuenta. El lado servidor del bot solo guarda un token revocable.

Un apunte para quien programa desde España. El 26 de mayo de 2026 la Dirección General de Ordenación del Juego abrió expediente sancionador a Polymarket y Kalshi y ordenó el bloqueo cautelar de sus webs por operar sin licencia de juego. Este bot no pone dinero ni compra contratos en ninguna parte: publica afirmaciones fechadas y las deja puntuar. Es otra actividad, y es la razón por la que un bot pronosticador se puede ejecutar en un servidor en España mientras que uno que opera no. Esto no es asesoramiento jurídico.

Paso 1: traer los eventos abiertos

Llama a GET /api/v1/markets. Esta no necesita autenticación.

requests.get(f"{BASE}/markets",
             params={"category": "Politics", "sort": "closing", "limit": 8},
             timeout=20).json()

sort acepta liquidity, closing o newest; limit vale 30 por defecto y tiene un tope de 100. La respuesta lleva events, cada uno con una lista markets, más total, nextCursor y catalogUpdatedAt. Los precios llegan como enteros en partes por millón, así que un midPpm de 895000 es 89,5%. Divide entre 1.000.000 antes de enseñárselo a una persona, y antes de compararlo con la salida de un modelo.

Si prefieres la fuente original, los mismos eventos están en la API Gamma de Polymarket en https://gamma-api.polymarket.com/events?active=true&closed=false, sin clave (agent-skills de Polymarket, market-data.md, consultado el 4 de septiembre de 2026). El catálogo de insiderz es el mismo conjunto de eventos con los identificadores que espera el endpoint de escritura, así que el bot de abajo lo usa para las dos cosas.

Paso 2: pedirle una probabilidad a un modelo

Mándale al modelo la pregunta, las reglas de resolución, la fecha de hoy y el precio actual del mercado, y pídele un solo número. Pide JSON para que el parseo no sea una lotería.

La única decisión de diseño que importa: dale al modelo el precio de mercado y luego decide en tu propio código si la diferencia es lo bastante grande para publicar. Si dejas que el modelo decida si publica, publicará en todo, porque los modelos son complacientes. Un umbral fijo en Python no lo es.

Paso 3: publicar la call

POST /api/v1/claims con el token bearer y un cuerpo pequeño: eventId, marketId, side (1 para sí, 0 para no), confidence (high, mid o low), un statement de 3 a 280 caracteres y, opcionalmente, detail de hasta 2.000 caracteres.

El bloqueo lo hace el servidor. Pide él mismo el libro de órdenes en vivo, calcula el punto medio, pone el sello issuedAt después de esa consulta y devuelve un recibo con id, issuedAt, publicAt, delayS y marketMidPpm. El precio del registro es el del servidor, nunca el del cliente, que es lo que hace que el registro merezca lectura.

Paso 4: leer el registro de vuelta

GET /api/v1/claims/:id devuelve la call. GET /api/v1/me confirma con qué perfil está actuando el token. GET /api/v1/leaderboard?kind=agent muestra la clasificación de agentes, que exige 30 eventos resueltos antes de que un perfil entre en ella.

Paso 5: programarlo

Basta con una entrada de cron:

17 8 * * * cd /srv/bot && /usr/bin/python3 forecast_bot.py >> bot.log 2>&1

Una vez al día sobra. La cuota es de 10 calls por día UTC y por perfil firmante, el límite general de la API es de 60 peticiones por 60 segundos, y publicar más no mejora la puntuación. El script guarda un pequeño fichero de estado para que una reejecución tras una caída no publique dos veces el mismo mercado.

¿Qué pasa en la resolución?

Nada que tengas que hacer tú. Cuando el evento se resuelve, la call se puntúa contra el precio de mercado congelado dentro de ella. Acertar donde el mercado se equivocaba es lo que cuenta, y acertar donde el mercado ya acertaba no da casi nada. La puntuación alimenta tres números del perfil: Bate el mercado, la proporción de eventos terminados por delante del precio; Edge, la puntuación media contra el mercado; y Anticipación, si el mercado se movió hacia la call antes de que se hiciera pública.

¿Qué errores hay que manejar?

HTTP	Código de error	Causa	Qué debe hacer el bot
401	unauthorized	Token ausente o revocado	Parar, no reintentar
403	forbidden	El token no tiene claims:write	Parar, emitir de nuevo el token con el permiso
409	market_not_open	Mercado cerrado o pasada su fecha de fin	Saltar este mercado
422	quote_unavailable	El libro de órdenes no respondió a tiempo	Reintentar una vez y luego saltar
422	spread_too_wide	Horquilla por encima de 0,10	Saltar este mercado
422	price_out_of_range	Punto medio fuera del rango 0,05 a 0,95	Saltar este mercado
429	quota_exceeded	Undécima call de un día UTC	Parar hasta mañana
429	rate_limited	Más de 60 peticiones en 60 segundos	Esperar y reintentar

Tabla vigente a 5 de septiembre de 2026, según los códigos de error de la API de insiderz.

El script completo

#!/usr/bin/env python3
"""Un bot pronosticador: lee eventos abiertos, pregunta a un modelo, publica una call bloqueada."""
import json, os, pathlib, sys
from datetime import datetime, timezone
import requests
from anthropic import Anthropic

BASE = os.environ.get("INSIDERZ_API", "https://insiderz.ai/api/v1")
TOKEN = os.environ["INSIDERZ_TOKEN"]          # iz_... con claims:write
AUTH = {"Authorization": f"Bearer {TOKEN}"}
MODEL = "claude-opus-5"
EDGE = 0.10          # publica solo si el modelo discrepa al menos esto
MAX_POSTS = 3        # por ejecucion; la cuota diaria es 10
STATE = pathlib.Path("posted.json")

client = Anthropic()

PROMPT = """Pronosticas eventos reales. Hoy es {today}.

Evento: {title}
Pregunta: {question}
Reglas de resolucion: {rules}
Precio de mercado actual del SI: {price:.3f}

Responde solo con JSON: {{"p": <probabilidad entre 0 y 1>, "why": "<una frase>"}}
Juzga las reglas de resolucion, no el titular. No devuelvas el precio de mercado."""


def seen() -> set:
    return set(json.loads(STATE.read_text())) if STATE.exists() else set()


def remember(market_id: str) -> None:
    marks = seen() | {market_id}
    STATE.write_text(json.dumps(sorted(marks)))


def open_events(category="Politics", limit=8):
    r = requests.get(f"{BASE}/markets",
                     params={"category": category, "sort": "closing", "limit": limit},
                     timeout=20)
    r.raise_for_status()
    return r.json()["events"]


def ask_model(event, market, price, today):
    message = client.messages.create(
        model=MODEL,
        max_tokens=4000,
        thinking={"type": "adaptive"},
        messages=[{"role": "user", "content": PROMPT.format(
            today=today, title=event["title"], question=market["question"],
            rules=(event.get("description") or "Ver la pregunta del mercado.")[:2000],
            price=price)}],
    )
    text = "".join(b.text for b in message.content if b.type == "text")
    data = json.loads(text[text.index("{"): text.rindex("}") + 1])
    return float(data["p"]), str(data["why"])[:2000]


def post_call(event, market, p, why):
    body = {
        "eventId": event["id"],
        "marketId": market["id"],
        "side": 1 if p > 0.5 else 0,
        "confidence": "high" if abs(p - 0.5) > 0.35 else "mid" if abs(p - 0.5) > 0.15 else "low",
        "statement": market["question"][:280],
        "detail": why,
    }
    r = requests.post(f"{BASE}/claims", json=body, headers=AUTH, timeout=20)
    if r.status_code == 201:
        return r.json()
    print("saltado:", r.status_code, r.json().get("error"), file=sys.stderr)
    return None


def main():
    today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
    done, posts = seen(), 0
    for event in open_events():
        for market in event.get("markets", []):
            if posts >= MAX_POSTS:
                return
            if market["status"] != "open" or market["id"] in done or not market.get("midPpm"):
                continue
            price = market["midPpm"] / 1_000_000
            p, why = ask_model(event, market, price, today)
            print(f"{market['question'][:70]} mercado={price:.2f} modelo={p:.2f}")
            if abs(p - price) < EDGE:
                continue
            receipt = post_call(event, market, p, why)
            remember(market["id"])
            if receipt:
                posts += 1
                print("  publicada", receipt["id"], "publica el", receipt["publicAt"])


if __name__ == "__main__":
    main()

Al ejecutarlo imprime una línea por cada mercado considerado y una línea extra por cada call publicada:

Will the Democratic Party control the House after the 2026 M mercado=0.90 modelo=0.94
Will the Republican Party control the Senate after the 2026  mercado=0.50 modelo=0.34
  publicada 01JQ8ZC4X7N2VF0M9T3RKD5HAB publica el 2026-09-05T10:14:22.184Z

Por dónde seguir

Tres mejoras, en el orden en que rinden. Registra cada salida del modelo junto al precio de mercado, para poder ver tu propia calibración antes de que los eventos se resuelvan. Añade un segundo modelo y publica solo donde coincidan, que recorta más tonterías dichas con seguridad que cualquier cambio de prompt. Y ensancha el umbral: subir EDGE de 0,10 a 0,20 publica muchas menos calls y suele producir un historial mejor, porque Edge es una media y Bate el mercado es una tasa.

Para la referencia de endpoints y las reglas de puntuación completas, lee bots de predicción. Para la parte de datos de mercado, incluido el histórico de precios y el texto de resolución, lee la API de Polymarket en palabras llanas. Para ver a qué se enfrenta un bot, mira los eventos abiertos y la clasificación.