POLYMARKET DATA ARCHITECTURE
┌──────────────────────────────────────────────────┐
│                                                    │
│  GAMMA API (gamma-api.polymarket.com)             │
│  Purpose: Market Discovery & Metadata             │
│  ├── Find active markets                          │
│  ├── Read resolution criteria                     │
│  ├── Check volume & liquidity                     │
│  └── Get token IDs for CLOB                       │
│                                                    │
│           ↓ (token IDs flow down)                  │
│                                                    │
│  CLOB API (clob.polymarket.com)                   │
│  Purpose: Live Trading & Real-Time Data           │
│  ├── Live prices (bid/ask/mid)                    │
│  ├── Order book depth                             │
│  ├── Place/cancel orders                          │
│  ├── Trade history                                │
│  └── WebSocket streaming                          │
│                                                    │
└──────────────────────────────────────────────────┘

import requests

def get_active_markets(min_volume=50000):
    """Fetch all markets above a volume threshold."""
    url = "https://gamma-api.polymarket.com/markets"
    params = {
        "active": "true",
        "closed": "false",
        "limit": 100,
        "offset": 0
    }

    all_markets = []
    while True:
        response = requests.get(url, params=params).json()
        markets = response if isinstance(response, list) else response.get("markets", [])

        # Filter by volume
        filtered = [m for m in markets if float(m.get("volume", 0)) >= min_volume]
        all_markets.extend(filtered)

        if len(markets) < 100:  # Last page
            break
        params["offset"] += 100

    return all_markets

# Run it
markets = get_active_markets(min_volume=50000)
print(f"Found {len(markets)} markets with volume >= $50,000")

# Print top 5 by volume
for m in sorted(markets, key=lambda x: float(x.get('volume', 0)), reverse=True)[:5]:
    print(f"  {m['question'][:60]}... | Vol: ${float(m['volume']):,.0f}")

from py_clob_client.client import ClobClient
import os

# Initialize CLOB client
client = ClobClient(
    host="https://clob.polymarket.com",
    key=os.getenv("POLYMARKET_PRIVATE_KEY"),
    chain_id=137  # Polygon mainnet
)

def get_market_orderbook(token_id):
    """Get the current order book for a market."""
    book = client.get_order_book(token_id)

    best_bid = book.bids[0].price if book.bids else 0
    best_ask = book.asks[0].price if book.asks else 1
    mid_price = (best_bid + best_ask) / 2
    spread = best_ask - best_bid

    return {
        "token_id": token_id,
        "best_bid": best_bid,
        "best_ask": best_ask,
        "mid_price": mid_price,
        "spread": spread,
        "spread_pct": spread / mid_price * 100 if mid_price > 0 else 0
    }

import asyncio
import websockets
import json

async def stream_market_prices(token_ids: list, callback):
    """Stream real-time price updates for multiple markets."""
    uri = "wss://clob.polymarket.com/ws/"

    async with websockets.connect(uri) as ws:
        # Subscribe to price channels
        subscribe_msg = {
            "type": "subscribe",
            "channel": "market",
            "market_slugs": token_ids
        }
        await ws.send(json.dumps(subscribe_msg))

        async for message in ws:
            data = json.loads(message)
            if data.get("type") == "price_change":
                await callback(data)

async def on_price_update(data):
    print(f"Market {data['market_id']}: YES={data['yes_price']:.3f}, NO={data['no_price']:.3f}")

# asyncio.run(stream_market_prices(["token_123"], on_price_update))

import os
from py_clob_client.client import ClobClient
from py_clob_client.clob_types import ApiCreds

# Create API credentials (one-time setup)
def setup_api_credentials():
    private_key = os.getenv("POLYMARKET_PRIVATE_KEY")  # Your MetaMask private key

    client = ClobClient(
        host="https://clob.polymarket.com",
        key=private_key,
        chain_id=137
    )

    # Create API key (stores in Polymarket's system)
    api_creds = client.create_or_derive_api_creds()
    print(f"API Key: {api_creds.api_key}")
    print(f"API Secret: {api_creds.api_secret}")
    # Save these to your .env file

import time

def safe_api_call(url, params, max_retries=3):
    """API call with exponential backoff for rate limits."""
    for attempt in range(max_retries):
        response = requests.get(url, params=params)
        if response.status_code == 200:
            return response.json()
        elif response.status_code == 429:
            wait = 2 ** attempt  # 1s, 2s, 4s
            print(f"Rate limited. Waiting {wait}s...")
            time.sleep(wait)
        else:
            print(f"Error {response.status_code}: {response.text}")
            return None
    return None