How to Build a BTC 5-Minute and 15-Minute Bot on Polymarket

export BRAVADO_API_KEY="your-bearer-token"
export BASE="https://bravado-api-k7kaq.ondigitalocean.app"

{
  "cryptoMarketConfig": {
    "id": "btc-5m-twap-30",
    "asset": "btc",
    "duration": "5m",
    "twapEnabled": true,
    "twapLookbackSeconds": 30
  }
}

btc-updown-5m-<unix timestamp of window start, UTC>
btc-updown-15m-<unix timestamp of window start, UTC>

import time

def slug_for(duration_sec: int, window_start: int) -> str:
    tag = "5m" if duration_sec == 300 else "15m"
    return f"btc-updown-{tag}-{window_start}"

now = int(time.time())
current_5m = now - now % 300          # window already running
next_5m    = current_5m + 300         # window that opens next

curl -s "https://gamma-api.polymarket.com/markets?slug=btc-updown-5m-1786331400"

fee_per_share = 0.07 × p × (1 − p)

import asyncio, json, websockets
from decimal import Decimal

RTDS = "wss://ws-live-data.polymarket.com"

SUB = {
    "action": "subscribe",
    "subscriptions": [
        {"topic": "crypto_prices_twap_thirty", "type": "update",
         "filters": '{"symbol":"btc/usd"}'},
        {"topic": "crypto_prices_twap_sixty", "type": "update",
         "filters": '{"symbol":"btc/usd"}'},
    ],
}

E18 = Decimal(10) ** 18


async def stream_twap(state: dict):
    async for ws in websockets.connect(RTDS, ping_interval=None):
        try:
            await ws.send(json.dumps(SUB))
            asyncio.create_task(heartbeat(ws))
            async for raw in ws:
                msg = json.loads(raw)
                p = msg.get("payload") or {}
                if "full_accuracy_value" not in p:
                    continue
                window = int(p["window_s"])
                state[window] = {
                    # exact E18 fixed point, never the float in `value`
                    "price": Decimal(p["full_accuracy_value"]) / E18,
                    "observed_at": int(p["timestamp"]) // 1000,
                }
        except websockets.ConnectionClosed:
            continue          # reconnect and resubscribe


async def heartbeat(ws):
    while True:
        await asyncio.sleep(5)
        await ws.send("PING")

import json, requests
from decimal import Decimal

GAMMA = "https://gamma-api.polymarket.com"
CLOB = "https://clob.polymarket.com"


def load_window(duration_sec: int, window_start: int) -> dict | None:
    tag = "5m" if duration_sec == 300 else "15m"
    r = requests.get(f"{GAMMA}/markets",
                     params={"slug": f"btc-updown-{tag}-{window_start}"},
                     timeout=5)
    r.raise_for_status()
    rows = r.json()
    if not rows:
        return None

    m = rows[0]
    cfg = m.get("cryptoMarketConfig") or {}
    if not cfg.get("twapEnabled"):
        return None                      # pre-TWAP or unmigrated series

    up, down = json.loads(m["clobTokenIds"])
    return {
        "slug": m["slug"],
        "condition_id": m["conditionId"],
        "up": up,
        "down": down,
        "lookback": int(cfg["twapLookbackSeconds"]),
        "opens_at": window_start,
        "closes_at": window_start + duration_sec,
        "tick": Decimal(str(m["orderPriceMinTickSize"])),
        "min_size": Decimal(str(m["orderMinSize"])),
        "accepting": bool(m.get("acceptingOrders")),
    }


def book(token_id: str) -> tuple[Decimal | None, Decimal | None]:
    b = requests.get(f"{CLOB}/book", params={"token_id": token_id}, timeout=5).json()
    bids = sorted((Decimal(x["price"]) for x in b.get("bids", [])), reverse=True)
    asks = sorted(Decimal(x["price"]) for x in b.get("asks", []))
    return (bids[0] if bids else None, asks[0] if asks else None)

from decimal import Decimal
from statistics import NormalDist


def fair_up_probability(reference: Decimal, current: Decimal,
                        seconds_left: int, sigma_per_sqrt_sec: Decimal) -> Decimal:
    """Drift-free diffusion estimate. Replace with your own model."""
    if seconds_left <= 0:
        return Decimal(1) if current >= reference else Decimal(0)

    move = (current - reference) / reference
    scale = sigma_per_sqrt_sec * Decimal(seconds_left).sqrt()
    if scale == 0:
        return Decimal(1) if current >= reference else Decimal(0)

    return Decimal(NormalDist().cdf(float(move / scale)))

import os, uuid, requests
from decimal import Decimal

BASE = os.environ["BASE"]
H = {"Authorization": f"Bearer {os.environ['BRAVADO_API_KEY']}"}

DRY_RUN = True
TAKER_RATE = Decimal("0.07")
BRAVADO_BIPS = Decimal("0.001")


def taker_fee_per_share(price: Decimal) -> Decimal:
    return TAKER_RATE * price * (1 - price)


def place(payload: dict, key: str) -> dict:
    if DRY_RUN:
        print(f"  DRY RUN  {payload}")
        return {"dry_run": True}
    r = requests.post(f"{BASE}/v2/trade/order",
                      headers={**H, "Idempotency-Key": key},
                      json=payload, timeout=10)
    r.raise_for_status()
    return r.json()


def trade_window(win: dict, fair: Decimal, size: Decimal):
    token = win["up"]
    bid, ask = book(token)
    if bid is None or ask is None:
        return

    # Taking: only when the edge clears the fee outright.
    if ask is not None:
        edge = fair - ask - taker_fee_per_share(ask) - ask * BRAVADO_BIPS
        if edge > 0:
            key = str(uuid.uuid4())
            return place({
                "type": "MARKET",
                "symbol": token,
                "side": "BUY",
                "quote_amount": str((size * ask).quantize(Decimal("0.01"))),
                "time_in_force": "IOC",
            }, key)

    # Otherwise rest inside the spread and get paid to wait.
    quote = min(fair - win["tick"], bid + win["tick"])
    quote = quote.quantize(win["tick"])
    if quote <= 0 or size < win["min_size"]:
        return

    key = str(uuid.uuid4())
    return place({
        "type": "LIMIT",
        "symbol": token,
        "side": "BUY",
        "price": str(quote),
        "size": str(size),
        "time_in_force": "GTC",
    }, key)

def flatten(win: dict):
    # CLOB orders: LIMIT, MARKET, TAKE_PROFIT
    requests.delete(f"{BASE}/v2/trade/orders", headers=H, timeout=10)

    # Managed strategies: PEGGED, TWAP, ICEBERG, STOP_LOSS, TRAILING_STOP
    strategies = requests.get(f"{BASE}/v2/trade/strategies",
                              headers=H, timeout=10).json()["strategies"]
    for s in strategies:
        if s["status"] in ("ACTIVE", "PENDING") and s["symbol"] in (win["up"], win["down"]):
            requests.delete(f"{BASE}/v2/trade/strategies/{s['record_id']}",
                            headers=H, timeout=10)

curl -s https://polymarket.com/api/geoblock

{ "blocked": false, "ip": "203.0.113.4", "country": "US", "region": "NY" }