Polymarket arbitrage bot: catch Up + Down under $1

[
  {"as_of_ts": 1792948158349, "level": 1, "price": 0.91, "side": "ask", "size": 208.75},
  {"as_of_ts": 1792948158349, "level": 2, "price": 0.92, "side": "ask", "size": 58.5},
  {"as_of_ts": 1792948158349, "level": 3, "price": 0.93, "side": "ask", "size": 338.5},
  {"as_of_ts": 1792948158349, "level": 1, "price": 0.9, "side": "bid", "size": 220.19},
  {"as_of_ts": 1792948158349, "level": 2, "price": 0.89, "side": "bid", "size": 347.98},
  {"as_of_ts": 1792948158349, "level": 3, "price": 0.88, "side": "bid", "size": 216.0}
]

pip install requests
export VIKE_API_KEY=...
python pm-updown-arb-loop.py             # real run: five polls of both books, three seconds apart
python pm-updown-arb-loop.py --dry-run   # prints the requests it would make, calls nothing

"""Watch the live 5-minute BTC Up/Down market for an Up ask plus a Down ask under $1 after fees, size it against both books, and log it.

Run:  VIKE_API_KEY=... python pm-updown-arb-loop.py    (--dry-run lists the requests and makes none)
"""
import os
import sys
import time
from datetime import datetime, timezone
from urllib.parse import urlencode

NAME = "pm-updown-arb-loop"
BASE = "https://data.vike.io"
DRY = "--dry-run" in sys.argv
TICKS = 5  # polls of both books per run; a real bot keeps looping
POLL_S = 3  # two requests a tick: about 30 a minute, inside the 200 a minute a key allows
# Polymarket's taker fee rate for Crypto markets on 2026-10-25 (docs.polymarket.com/trading/fees). Check it: it changes.
FEE_RATE = 0.07
SAMPLE_TOKENS = [  # --dry-run has no response to read: the Up and Down tokens of btc-updown-5m-1792947900
    "71017960874711395588755286498180410277662891295563354128010828164009876221919",
    "15264935561093061531769473839831866712081495406158977870773121572402304828303",
]


def fail(why):
    sys.exit(f"{NAME}: {why}")


def call(path, method="GET", **params):
    url = BASE + path + ("?" + urlencode(params) if params else "")
    if DRY:
        print(method, url)
        return None
    key = os.environ.get("VIKE_API_KEY") or fail("set VIKE_API_KEY")
    import requests

    r = requests.request(method, url, headers={"X-API-Key": key}, timeout=60)
    if r.status_code != 200:
        fail(f"{method} {path} answered HTTP {r.status_code}: {r.text[:200]}")
    return r.json()


def fee(price):
    """Taker fee per share, Polymarket's formula: rate * p * (1 - p). Largest at 0.50, near zero at the extremes."""
    return FEE_RATE * price * (1 - price)


def asks(book):
    """The ask ladder, best first, each level once: a snapshot can repeat its rows."""
    levels = {r["level"]: (r["price"], r["size"]) for r in book if r["side"] == "ask"}
    return [levels[k] for k in sorted(levels)]


def pairs_under_one(up, down):
    """Buy one Up and one Down at a time, cheapest asks first, while a pair plus both taker fees costs under $1.
    Returns (pairs, dollars spent)."""
    up, down = [list(x) for x in up], [list(x) for x in down]
    pairs = spent = 0.0
    while up and down:
        (pu, su), (pd, sd) = up[0], down[0]
        unit = pu + pd + fee(pu) + fee(pd)
        if unit >= 1:
            break
        q = min(su, sd)
        pairs, spent = pairs + q, spent + q * unit
        up[0][1] -= q
        down[0][1] -= q
        for ladder in (up, down):
            if ladder[0][1] <= 1e-9:
                ladder.pop(0)
    return pairs, spent


# 4 pairs at 0.50 + 0.40 plus fees; the next Down level makes the pair cost $1 before fees, so the walk stops
assert pairs_under_one([(0.50, 10)], [(0.40, 4), (0.50, 9)])[0] == 4


def main():
    start = int(time.time()) // 300 * 300  # 5-minute windows start on multiples of 300 s; the slug ends in that start
    slug = f"btc-updown-5m-{start}"
    rows = call("/v1/polymarket/markets", query=slug, limit=1)
    up_id, down_id = SAMPLE_TOKENS
    if not DRY:
        if not rows:
            fail(f"{slug} is not in the market directory")
        up_id, down_id = rows[0]["token_ids"]  # in the order of the outcomes: Up, then Down

    for _ in range(1 if DRY else TICKS):
        up_book = call("/v1/polymarket/orderbook", token_id=up_id, depth=25)
        down_book = call("/v1/polymarket/orderbook", token_id=down_id, depth=25)
        if DRY:
            return
        if not up_book or not down_book:
            fail(f"{slug}: no recorded book for one of its tokens")
        now = datetime.now(timezone.utc).strftime("%H:%M:%S")
        up_asks, down_asks = asks(up_book), asks(down_book)
        if not up_asks or not down_asks:
            print(f"{now} {slug}: one token has no asks left (the market is all but decided)")
        else:
            pairs, spent = pairs_under_one(up_asks, down_asks)
            # Two snapshots of two moments can add up to under $1 when neither moment did: act on one moment only.
            same_moment = up_book[0]["as_of_ts"] == down_book[0]["as_of_ts"]
            verdict = "no edge" if not pairs else ("HIT" if same_moment else "stale pair, skipped")
            print(f"{now} {slug}: Up {up_asks[0][0]} + Down {down_asks[0][0]} = {up_asks[0][0] + down_asks[0][0]:.2f}; "
                  f"{pairs:g} pairs under $1 after fees for ${spent:,.2f}; {verdict}")
        time.sleep(POLL_S)


if __name__ == "__main__":
    try:
        main()
    except Exception as e:  # a shape the example does not expect fails by name, not by traceback
        fail(f"{type(e).__name__}: {e}")

In Polymarket's current 5-minute BTC Up or Down market, do the best Up ask and the best Down ask add up to less than $1, and are both books from the same moment?