Prediction Markets

Platform     | Type              | Markets          | API       | Trading
-------------|-------------------|------------------|-----------|--------
Polymarket   | Crypto (Polygon)  | Binary/Multi     | REST+WS   | CLOB, wallet-signed orders
Kalshi       | Regulated (US)    | Binary events    | REST+WS+FIX | CLOB, API-key-signed orders
Manifold     | Play money (mana) | Any question     | REST      | AMM
Metaculus    | Forecasting       | Probability est. | REST      | No trading (API needs an account token)

# polymarket_client.py

import json
import requests

GAMMA_API = "https://gamma-api.polymarket.com"
CLOB_API = "https://clob.polymarket.com"

def get_active_events(limit: int = 100, offset: int = 0) -> list:
    """Fetch active events sorted by 24h volume (each has a `markets` list)."""
    resp = requests.get(f"{GAMMA_API}/events", params={
        "limit": limit, "offset": offset,
        "active": "true", "closed": "false",
        "order": "volume24hr", "ascending": "false",
    }, timeout=15)
    resp.raise_for_status()
    return resp.json()

def outcome_prices(market: dict) -> dict:
    """Map outcome label to price, e.g. {'Yes': 0.62, 'No': 0.38}."""
    labels = json.loads(market["outcomes"])
    prices = json.loads(market["outcomePrices"])
    return {l: float(p) for l, p in zip(labels, prices)}

def get_midpoint(token_id: str) -> float:
    r = requests.get(f"{CLOB_API}/midpoint", params={"token_id": token_id}, timeout=15)
    return float(r.json()["mid"])

def get_market_history(token_id: str, interval: str = "1d", fidelity: int = 60) -> list:
    """Price history for one outcome token: [{'t': unix_seconds, 'p': price}, ...]."""
    resp = requests.get(f"{CLOB_API}/prices-history", params={
        "market": token_id, "interval": interval, "fidelity": fidelity}, timeout=15)
    return resp.json().get("history", [])

# market_analyzer.py
import json

def find_arbitrage_opportunities(markets: list, threshold: float = 0.02) -> list:
    """Find Gamma binary markets whose outcome prices don't sum to ~1.0."""
    opportunities = []
    for market in markets:
        if not market.get('outcomePrices'):
            continue
        prices = [float(p) for p in json.loads(market['outcomePrices'])]
        if len(prices) == 2:
            total = sum(prices)
            if abs(total - 1.0) > threshold:
                opportunities.append({
                    'title': market['question'],
                    'deviation': abs(total - 1.0),
                    'volume_24h': market.get('volume24hr', 0)
                })
    return sorted(opportunities, key=lambda x: x['deviation'], reverse=True)

def calculate_expected_value(probability: float, buy_price: float,
                             fees: float = 0.0) -> float:
    """EV per share. Set `fees` (fraction of price) from the venue's current fee schedule."""
    cost = buy_price * (1 + fees)
    return probability * (1.0 - cost) - (1 - probability) * cost

# kalshi_client.py
import base64, os, time
import requests
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
from cryptography.hazmat.primitives.serialization import load_pem_private_key

BASE = "https://external-api.kalshi.com"
PREFIX = "/trade-api/v2"

def get_markets(series_ticker: str = "KXHIGHNY", status: str = "open") -> list:
    r = requests.get(f"{BASE}{PREFIX}/markets",
                     params={"series_ticker": series_ticker, "status": status, "limit": 100}, timeout=15)
    return r.json()["markets"]          # paginate with the returned `cursor`

def get_orderbook(ticker: str) -> dict:
    r = requests.get(f"{BASE}{PREFIX}/markets/{ticker}/orderbook", timeout=15)
    return r.json()["orderbook_fp"]

def signed_headers(method: str, path: str) -> dict:
    """Sign timestamp+METHOD+path (no query string). Ed25519 key; RSA keys use RSA-PSS/SHA-256."""
    key = load_pem_private_key(open(os.environ["KALSHI_PRIVATE_KEY_FILE"], "rb").read(), password=None)
    ts = str(int(time.time() * 1000))
    sig = key.sign((ts + method + path).encode())      # Ed25519 signs the message directly
    return {"KALSHI-ACCESS-KEY": os.environ["KALSHI_KEY_ID"],
            "KALSHI-ACCESS-TIMESTAMP": ts,
            "KALSHI-ACCESS-SIGNATURE": base64.b64encode(sig).decode()}

def get_balance() -> dict:
    path = f"{PREFIX}/portfolio/balance"
    return requests.get(BASE + path, headers=signed_headers("GET", path), timeout=15).json()

MANIFOLD_API = "https://api.manifold.markets/v0"

def search_markets(query: str, limit: int = 20) -> list:
    return requests.get(f"{MANIFOLD_API}/search-markets",
                        params={"term": query, "limit": limit, "sort": "liquidity", "filter": "open"}, timeout=15).json()

# market_scorer.py — Score markets for dashboard prominence

def score_market(market: dict) -> float:
    score = 0.0
    volume = float(market.get('volume24hr') or 0)
    prob = market.get('probability', 0.5)   # from outcomePrices[0] or Manifold `probability`

    if volume > 100000: score += 30
    elif volume > 10000: score += 20
    elif volume > 1000: score += 10

    uncertainty = 1 - abs(prob - 0.5) * 2  # 1.0 at 50%, 0.0 at extremes
    score += uncertainty * 25

    prob_change = abs(market.get('probability_change_24h', 0))
    if prob_change > 0.10: score += 20
    elif prob_change > 0.05: score += 10

    return min(score, 100)

Build a real-time dashboard showing the top 50 Polymarket events sorted by 24-hour volume. Show each market as a card with: title, current probability (color-coded red-green), volume, time to resolution, and 7-day probability chart. Group by category (politics, crypto, sports, tech). Add alerts for markets where probability moved more than 10% in the last 24 hours. Use React and Chart.js.

Analyze all active Polymarket binary markets. Find markets where the Yes + No prices deviate more than 3% from $1.00 (indicating potential mispricing). Also find markets where the probability has been stable for weeks but a relevant news event just occurred. Output a ranked list of opportunities with expected value calculations.

Build a system that tracks my prediction market bets across Polymarket and Kalshi, calculates my Brier score over time, and shows a calibration chart (predicted probabilities vs actual outcomes). Include position-size-weighted returns and compare my accuracy against the market's consensus probabilities.