prediction-markets

What this skill does

# Prediction Markets

## Overview

Build tools for prediction market platforms — fetch data, analyze markets, create dashboards, and implement trading strategies. Cover Polymarket, Kalshi, Manifold, and Metaculus APIs.

## Instructions

### Platform overview

```
Platform     | Type              | Markets          | API       | Trading
-------------|-------------------|------------------|-----------|--------
Polymarket   | Crypto (Polygon)  | Binary/Multi     | REST+WS   | CLOB
Kalshi       | Regulated (US)    | Binary events    | REST+WS   | CLOB
Manifold     | Play money + Mana | Any question     | REST       | AMM
Metaculus    | Forecasting       | Probability est. | REST       | No trading
```

### Polymarket API

Polymarket is the largest by volume. Data is publicly accessible without authentication.

```python
# polymarket_client.py

import requests

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

def get_active_markets(limit: int = 100, offset: int = 0) -> list:
    """Fetch active markets sorted by 24h volume."""
    resp = requests.get(f"{GAMMA_API}/events", params={
        "limit": limit, "offset": offset,
        "active": True, "closed": False,
        "order": "volume24hr", "ascending": False
    })
    return resp.json()

def get_market_prices(condition_id: str) -> dict:
    """Get current prices (probabilities) for a market's outcomes."""
    return requests.get(f"{CLOB_API}/prices",
                        params={"token_ids": condition_id}).json()

def get_market_history(condition_id: str, interval: str = "1d") -> list:
    """Fetch price history for a market."""
    resp = requests.get(f"{CLOB_API}/prices-history", params={
        "market": condition_id, "interval": interval, "fidelity": 60
    })
    return resp.json().get("history", [])
```

### Market analysis

```python
# market_analyzer.py

def find_arbitrage_opportunities(markets: list, threshold: float = 0.02) -> list:
    """Find markets where outcome probabilities don't sum to ~1.0."""
    opportunities = []
    for market in markets:
        outcomes = market.get('outcomes', [])
        if len(outcomes) == 2:
            total = sum(float(o.get('price', 0)) for o in outcomes)
            if abs(total - 1.0) > threshold:
                opportunities.append({
                    'title': market['title'],
                    '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.02) -> float:
    """Calculate EV of a prediction market position."""
    cost = buy_price * (1 + fees)
    return probability * (1.0 - cost) - (1 - probability) * cost
```

### Kalshi API

Kalshi is CFTC-regulated (US-accessible). Requires authentication:

```python
# kalshi_client.py

KALSHI_API = "https://trading-api.kalshi.com/trade-api/v2"

class KalshiClient:
    def __init__(self, email: str, password: str):
        self.session = requests.Session()
        resp = self.session.post(f"{KALSHI_API}/login",
                                 json={"email": email, "password": password})
        self.session.headers["Authorization"] = f"Bearer {resp.json()['token']}"

    def get_events(self, status: str = "open", limit: int = 100) -> list:
        return self.session.get(f"{KALSHI_API}/events",
                                params={"status": status, "limit": limit}).json().get("events", [])

    def get_orderbook(self, ticker: str) -> dict:
        return self.session.get(f"{KALSHI_API}/orderbook",
                                params={"ticker": ticker}).json()

    def place_order(self, ticker: str, side: str, count: int, price: int) -> dict:
        return self.session.post(f"{KALSHI_API}/portfolio/orders", json={
            "ticker": ticker, "side": side, "count": count, "type": "limit",
            "yes_price": price if side == "yes" else None,
            "no_price": price if side == "no" else None
        }).json()
```

### Manifold Markets API

Play money — great for experimenting, no auth required for reading:

```python
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"}).json()
```

### Dashboard building

Key visualizations for a prediction market dashboard:
1. **Market cards**: Title, probability (color-coded), 24h volume, time to resolution
2. **Probability timeline**: Line chart showing momentum over time
3. **Volume bars**: 24h volume history showing market attention
4. **Alerts**: Markets where probability moved >10% in 24 hours

```python
# market_scorer.py — Score markets for dashboard prominence

def score_market(market: dict) -> float:
    score = 0.0
    volume = market.get('volume24hr', 0)
    prob = market.get('probability', 0.5)

    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)
```

## Examples

### Build a prediction market dashboard

```prompt
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.
```

### Find mispriced prediction markets

```prompt
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 forecasting accuracy tracker

```prompt
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.
```

## Guidelines

- Always check market liquidity (24h volume) before placing trades — low-liquidity markets have wide spreads
- In binary markets, verify Yes + No prices sum to ~$1.00; deviations indicate mispricing or fees
- Use Manifold (play money) for strategy testing before deploying capital on Polymarket or Kalshi
- Compare your forecasts against market consensus to measure calibration over time
- Monitor for >10% probability swings in 24 hours — these often signal new information or mispricing
- Be aware that Polymarket is crypto-based (Polygon) while Kalshi is CFTC-regulated with different rules
- Calculate expected value before every trade; don't trade based on conviction alone