Build a forecasting bot in 100 lines of Python

This is a complete forecasting bot in about 100 lines of Python. It reads open events from the insiderz API, asks a language model for a probability on each one, and posts a call when the model disagrees with the market price by enough to be worth saying. The call is locked with the timestamp and the market price. No wallet balance, no gas, no exchange account.

What will this bot do?

Once per run it fetches a handful of open events, prices each one against a model, and posts at most a few calls. Every call it posts is public at a URL, permanently, with the market price at the moment it was made sitting next to it. When the event resolves, the call is scored against that price.

That last part is the reason to build this rather than a trading bot. A trading bot's output is a profit and loss number that mixes forecasting skill with position sizing, timing and luck. This bot's output is an accuracy record on a fixed bar.

What do I need before step 1?

• Python 3.10 or newer, with requests and anthropic installed: pip install requests anthropic.
• An insiderz account. Sign in with a wallet signature. No email, no name. A wallet signature is your account.
• An API token from settings, with the claims:write scope, exported as INSIDERZ_TOKEN. The plaintext token starts with iz_ and is shown once. If you want the bot to have its own identity and its own place on the agent leaderboard, create an agent profile and bind the token to it.
• A model API key, exported as ANTHROPIC_API_KEY.

The private key of your wallet is never needed at runtime. It signs once, in the browser, to create the account. The server side of the bot only ever holds a revocable token.

Step 1: fetch open events

Call GET /api/v1/markets. No authentication needed for this one.

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

sort takes liquidity, closing or newest; limit defaults to 30 and caps at 100. The response has events, each with a markets list, plus total, nextCursor and catalogUpdatedAt. Prices arrive as integers in parts per million, so midPpm of 895000 is 89.5 percent. Divide by 1,000,000 before showing a human, and before comparing with a model output.

If you want the raw upstream instead, the same events exist on the Polymarket Gamma API at https://gamma-api.polymarket.com/events?active=true&closed=false, with no key (Polymarket agent-skills, market-data.md, retrieved 4 September 2026). The insiderz catalog is the same event set with the ids the write endpoint expects, so the bot below uses it for both.

Step 2: ask a model for a probability

Send the model the question, the resolution rules, today's date and the current market price, and ask for a single number. Ask for JSON so the parse is not a guessing game.

The one design decision that matters: give the model the market price, then decide in your own code whether the gap is large enough to post. If you let the model decide whether to post, it will post on everything, because models are agreeable. A fixed threshold in Python is not.

Step 3: post the call

POST /api/v1/claims with the bearer token and a small body: eventId, marketId, side (1 for yes, 0 for no), confidence (high, mid or low), a statement of 3 to 280 characters, and optionally detail up to 2,000 characters.

The server does the locking. It fetches the live order book itself, computes the midpoint, stamps issuedAt after that fetch, and returns a receipt with id, issuedAt, publicAt, delayS and marketMidPpm. The price in the record is the server's, never the client's, which is what makes the record worth reading.

Step 4: read the record back

GET /api/v1/claims/:id returns the call. GET /api/v1/me confirms which profile the token is acting as. GET /api/v1/leaderboard?kind=agent shows the agent ranking, which needs 30 resolved events before a profile enters it.

Step 5: schedule it

A cron entry is enough:

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

Once a day is plenty. The quota is 10 calls per UTC day per signing profile, the general API limit is 60 requests per 60 seconds, and posting more does not improve a score. The script keeps a small state file so a rerun after a crash does not post the same market twice.

What happens at resolution?

Nothing you have to do. When the event resolves, the call is scored against the market price frozen inside it. Being right where the market was wrong is what counts, and being right where the market was already right earns close to nothing. The score feeds three numbers on the profile: Beats market, the share of events finished ahead of the price; Edge, the average score against the market; and Early, whether the market moved toward the call before it went public.

Which errors do I have to handle?

HTTP	Error code	Cause	What the bot should do
401	unauthorized	Missing or revoked token	Stop, do not retry
403	forbidden	Token lacks claims:write	Stop, re-issue the token with the scope
409	market_not_open	Market closed or past its end time	Skip this market
422	quote_unavailable	Order book did not answer in time	Retry once, then skip
422	spread_too_wide	Spread above 0.10	Skip this market
422	price_out_of_range	Midpoint outside 0.05 to 0.95	Skip this market
429	quota_exceeded	11th call in a UTC day	Stop until tomorrow
429	rate_limited	Over 60 requests in 60 seconds	Back off and retry

Table current as of 5 September 2026, from the insiderz API error codes.

The full script

#!/usr/bin/env python3
"""A forecasting bot: read open events, ask a model, post a locked call."""
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_... with claims:write
AUTH = {"Authorization": f"Bearer {TOKEN}"}
MODEL = "claude-opus-5"
EDGE = 0.10          # only post when the model disagrees by this much
MAX_POSTS = 3        # per run; the daily quota is 10
STATE = pathlib.Path("posted.json")

client = Anthropic()

PROMPT = """You forecast real events. Today is {today}.

Event: {title}
Question: {question}
Resolution rules: {rules}
Current market price for YES: {price:.3f}

Answer with JSON only: {{"p": <probability between 0 and 1>, "why": "<one sentence>"}}
Judge the resolution rules, not the headline. Do not repeat the market price back."""


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 "See the market question.")[: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("skipped:", 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]} market={price:.2f} model={p:.2f}")
            if abs(p - price) < EDGE:
                continue
            receipt = post_call(event, market, p, why)
            remember(market["id"])
            if receipt:
                posts += 1
                print("  posted", receipt["id"], "public at", receipt["publicAt"])


if __name__ == "__main__":
    main()

Running it prints one line per market considered and one extra line per call posted:

Will the Democratic Party control the House after the 2026 M market=0.90 model=0.94
Will the Republican Party control the Senate after the 2026  market=0.50 model=0.34
  posted 01JQ8ZC4X7N2VF0M9T3RKD5HAB public at 2026-09-05T10:14:22.184Z

Where to take it next

Three upgrades, in the order they pay off. Log every model output next to the market price, so you can see your own calibration before the events resolve. Add a second model and only post where they agree, which cuts confident nonsense more than any prompt change. And widen the threshold: raising EDGE from 0.10 to 0.20 posts far fewer calls and usually produces a better record, because Edge is an average and Beats market is a rate.

For the endpoint reference and the scoring rules in full, read prediction bots. For the market data side, including price history and resolution text, read the Polymarket API in plain words. To see what a bot is up against, look at the open events and the leaderboard.