Cómo crear un bot de trading para Polymarket

Un bot de Polymarket tiene seis piezas: descubrir mercados, leer precios, decidir, colocar órdenes, gestionar posiciones y seguir vivo. Las dos primeras son fáciles, la cuarta es delicada y la sexta es donde mueren de verdad la mayoría de los bots. Esta guía recorre todo el camino con código verificado y es honesta sobre las partes que de verdad son difíciles.

Paso 0: decide qué opera tu bot

Vale la pena hacerlo antes de escribir una línea, porque determina todo lo demás. Los mercados de Polymarket se dividen en dos familias que casi no tienen nada en común:

Si vas a automatizar, casi seguro que te interesa la segunda familia: alta frecuencia, continua y lo bastante mecánica como para codificarla. Se explica a fondo en los mercados Up/Down explicados.

Paso 1: instala el SDK actual

Ambos SDK te dan una sola interfaz de cliente sobre todas las APIs de Polymarket, modelos tipados, paginación coherente y firma integrada, que es mucho trabajo delicado que no quieres volver a implementar.

pip install polymarket-client
# or: uv add polymarket-client / poetry add polymarket-client

Hay cuatro clientes de Python, y elegir el correcto importa más de lo que parece:

Paso 2: encuentra mercados

El descubrimiento público de mercados no necesita ninguna credencial. El paginador del SDK es igual en todos los métodos de listado, así que este patrón se generaliza.

import asyncio
from polymarket import AsyncPublicClient


async def main() -> None:
    async with AsyncPublicClient() as client:
        pages = client.list_markets(closed=False, page_size=50)

        # Iterate items directly when page boundaries do not matter.
        async for market in pages.iter_items():
            if "updown" in (market.slug or ""):
                print(market.slug, market.condition_id)


asyncio.run(main())

Hay dos cosas que interiorizar aquí. Primero, page.next_cursor es un cursor opaco: guárdalo tal cual si quieres reanudar un recorrido más tarde, y no intentes analizarlo ni construir uno. Segundo, /markets tiene el límite de tasa más estricto de toda la plataforma, 300 req / 10s, así que guarda en caché los metadatos de los mercados en lugar de volver a listarlos en un bucle caliente. Todas las cifras en la referencia de límites de tasa.

Paso 3: autentícate

Para operar hace falta una wallet. El SDK de Python construye el firmante a partir de una clave privada local:

import os
from polymarket import AsyncSecureClient

client = await AsyncSecureClient.create(
    private_key=os.environ["POLYMARKET_PRIVATE_KEY"],
    wallet=os.environ["POLYMARKET_WALLET_ADDRESS"],
)

Por debajo, Polymarket usa dos capas de autenticación: L1 es una firma EIP-712 de la wallet que demuestra que controlas la dirección y te permite crear o derivar credenciales de API; L2 firma cada solicitud privada con esas credenciales usando HMAC-SHA256. El SDK gestiona ambas, que es el principal motivo para usarlo.

Paso 4: obtén precios en tiempo real

El error de arquitectura más común en un primer bot es hacer polling de /book con un temporizador. Quema tu presupuesto de límite de tasa, añade latencia y escala mal. Suscríbete en su lugar: el SDK combina varios feeds en un único stream de eventos.

from polymarket.streams import MarketSpec

async with await client.subscribe([MarketSpec(token_ids=[token_id])]) as stream:
    async for event in stream:
        # MarketBookEvent | MarketPriceChangeEvent | MarketLastTradePriceEvent
        # | MarketTickSizeChangeEvent | MarketBestBidAskEvent
        # | NewMarketEvent | MarketResolvedEvent
        handle(event)

Si te conectas al WebSocket directamente en lugar de usar el SDK, debes enviar un PING cada 10 segundos o la conexión se corta, y necesitas custom_feature_enabled: true para recibir siquiera los eventos best_bid_ask, new_market y market_resolved. Eso y los patrones de reconexión se explican en la guía de WebSocket. Aparte, los precios de referencia pasaron a PolyBolt el 15 de septiembre de 2026: si tu bot recibe precios spot por streaming, consulta la guía de migración.

Paso 5: coloca una orden

Una orden de mercado es lo más sencillo que funciona, y amount está expresado en los pUSD que estás dispuesto a gastar, no en acciones:

market = await client.get_market(slug="<market-slug>")
token_id = market.outcomes.yes.token_id
assert token_id is not None

response = await client.place_market_order(
    token_id=token_id,
    side="BUY",
    amount="10",          # spend up to 10 pUSD
)

if not response.ok:
    raise RuntimeError(response.message)

# Settlement is on-chain and asynchronous — this waits for it.
hashes = await client.wait_for_order_fill_settlement(response)

En las órdenes límite en reposo, hay dos reglas que te morderán antes que nada. Los precios deben estar en la cuadrícula de ticks del mercado: llama a GET /tick-size para cada mercado en lugar de suponer 0.01, porque el tamaño del tick varía y puede reducirse a medida que el mercado madura. Y las órdenes por debajo del tamaño mínimo del mercado se rechazan directamente. Ambas vuelven como 400 con mensajes concretos, recogidos en la referencia de errores.

Paso 6: averigua si la estrategia funciona

Todo lo anterior es fontanería, y la fontanería es la mitad fácil. La pregunta difícil es si tu estrategia gana dinero, y aquí es donde crear bots para Polymarket se aleja mucho de crear bots para cripto spot.

No hay testnet. Ni sandbox, ni API de demostración, ni endpoint de paper trading. Esas palabras no aparecen en ninguna parte de la documentación de Polymarket. Tu primera orden real es dinero real frente a contrapartes reales. Consulta ¿Polymarket tiene testnet? para ver las cuatro alternativas.

Y no hay libro de órdenes histórico. Cuando un mercado se resuelve, su libro devuelve 404. Conserva una serie de precios de aproximadamente un punto por minuto, y solo si la pides con un inicio y un fin explícitos:

TOK=<token_id_of_a_resolved_market>
START=<epoch seconds the window opened>
END=$((START + 300))

curl -s "https://clob.polymarket.com/book?token_id=$TOK"
# {"error":"No orderbook exists for the requested token id"}   HTTP 404

curl -s "https://clob.polymarket.com/prices-history?market=$TOK&startTs=$START&endTs=$END&fidelity=1"
# about 6 points for a 5-minute market; interval=max returns [] for older ones

Así que no puedes hacer backtesting desde Polymarket. Necesitas snapshots puntuales que alguien haya grabado mientras los mercados estaban activos. Eso es lo que ofrece PolyTest para los mercados cripto Up/Down: 240M+ snapshots, 8 niveles de profundidad del libro por lado, marcas de tiempo por debajo del segundo y mercados resueltos conservados:

import os, requests

BASE = "https://api.polytest.io/api/v1"
H = {"X-API-Key": os.environ["POLYTEST_KEY"]}

markets = requests.get(f"{BASE}/markets",
                       params={"coin": "btc", "market_type": "5m", "limit": 50},
                       headers=H).json()["markets"]

snaps = requests.get(f"{BASE}/markets/{markets[0]['id']}/snapshots",
                     params={"include_orderbook": "true"},
                     headers=H).json()["snapshots"]


def simulate_fill(levels, qty):
    """Walk the ladder. Mid-price is not a price you can trade at."""
    filled = cost = 0.0
    for lvl in levels:
        take = min(lvl["size"], qty - filled)
        cost += take * lvl["price"]
        filled += take
        if filled >= qty:
            break
    return cost / filled if filled >= qty else None


print(simulate_fill(snaps[0]["orderbook"]["asks"], 500))

Paso 7: sobrevive al contacto con producción

Un bot que opera bien durante una hora y luego se queda colgado es peor que no tener bot. Estos son los modos de fallo que ocurren de verdad, más o menos en orden de frecuencia:

• Prueba la ruta de cancelación antes que la de entrada. No poder salir es mucho peor que no poder entrar.
• Limita la exposición en el código, no en tu cabeza. Un límite estricto de posición convierte un bug de lógica en una pérdida pequeña en lugar de una ilimitada.
• Construye un interruptor de emergencia y pruébalo de verdad. Un interruptor de emergencia sin probar es un comentario.
• Añade jitter al trabajo programado. Los workers que se despiertan en el segundo exacto crean un pico sincronizado muy por encima de tu tasa media.
• Registra cada solicitud y cada respuesta durante la primera semana. Las vas a necesitar y no podrás reconstruirlas después.
• Alerta por categorías, no por mensajes. Polymarket incluye IDs de órdenes y precios en los strings de error, así que alertar por el string literal es puro ruido.

Un orden de construcción realista

La secuencia que menos tiempo y dinero desperdicia:

1. Integración de solo lectura, cliente público, sin claves. Demuestra el descubrimiento, el parsing, la paginación y el backoff. Un día, gratis.
2. Haz backtesting de la estrategia con libros históricos y una simulación de ejecuciones honesta. La mayoría de las ideas mueren aquí. Ese es el objetivo.
3. Paper trading en vivo durante al menos una semana: registra las órdenes que pretendías enviar en lugar de enviarlas. Demuestra la disponibilidad, las reconexiones y el timing.
4. Sal en vivo con el tamaño mínimo, con un tope estricto de exposición y un interruptor de emergencia probado.
5. Escala solo cuando las cifras en vivo coincidan con las del papel. Si divergen, tu modelo de ejecuciones estaba mal: vuelve al paso 2.

Los pasos 1, 3 y 4 puedes construirlos en unos días. El paso 2 necesita datos que Polymarket no conserva, y también es el paso que con más fiabilidad ahorra dinero. Empieza una prueba gratuita en PolyTest: suficiente para averiguar si tu idea sobrevive al spread.