The Complete Prediction Market API Reference

# Polymarket: Create a client with full trading auth
from py_clob_client.client import ClobClient

client = ClobClient(
    host="https://clob.polymarket.com",
    key="YOUR_PRIVATE_KEY",        # Wallet private key
    chain_id=137,                   # Polygon
    signature_type=1,               # 1 = proxy wallet
    funder="YOUR_FUNDER_ADDRESS"    # Address holding your funds
)
client.set_api_creds(client.create_or_derive_api_creds())

# Polymarket CLI: Import wallet for trading
polymarket wallet import 0xYOUR_PRIVATE_KEY
polymarket wallet show

# Kalshi: Create authenticated client
import kalshi_python

config = kalshi_python.Configuration(
    host="https://api.elections.kalshi.com/trade-api/v2"
)

with open('path/to/private_key.pem', 'r') as f:
    config.private_key_pem = f.read()

config.api_key_id = "your-api-key-id"
client = kalshi_python.KalshiClient(config)

# Kalshi: Raw curl with auth headers
curl --request GET \
  --url https://api.elections.kalshi.com/trade-api/v2/portfolio/balance \
  --header 'KALSHI-ACCESS-KEY: YOUR_API_KEY' \
  --header 'KALSHI-ACCESS-SIGNATURE: COMPUTED_SIGNATURE' \
  --header 'KALSHI-ACCESS-TIMESTAMP: UNIX_MS_TIMESTAMP'

# CLI
polymarket markets list --limit 20
polymarket -o json markets list --limit 100

# curl
curl "https://gamma-api.polymarket.com/markets?limit=20&closed=false"

# Python SDK (read-only, no auth)
from py_clob_client.client import ClobClient
client = ClobClient("https://clob.polymarket.com")
markets = client.get_markets()

# curl (no auth needed)
curl "https://api.elections.kalshi.com/trade-api/v2/markets?limit=20&status=open"

# Python SDK
markets = client.get_markets(limit=20, status="open")
for m in markets.markets:
    print(f"{m.ticker}: {m.title}")

# CLI
polymarket markets search "bitcoin"
polymarket markets search "fed rate" --limit 5

# Gamma API
curl "https://gamma-api.polymarket.com/search?query=bitcoin&limit=5"

# Filter by series ticker
curl "https://api.elections.kalshi.com/trade-api/v2/markets?series_ticker=KXBTC"

# No dedicated search endpoint — filter by series, event, or category

# CLI
polymarket markets get bitcoin-above-100k
polymarket -o json markets get bitcoin-above-100k

# Gamma API (by slug)
curl "https://gamma-api.polymarket.com/markets?slug=bitcoin-above-100k"

curl "https://api.elections.kalshi.com/trade-api/v2/markets/TICKER_HERE"

market = client.get_market("KXBTC-26FEB28-T100000")
print(f"Title: {market.market.title}")
print(f"Yes price: {market.market.yes_price}¢")

# CLI (by tag)
polymarket events list --tag politics
polymarket events list --tag crypto
polymarket events list --tag sports

# Gamma API (by tag ID)
curl "https://gamma-api.polymarket.com/events?tag_id=2&closed=false"
# Tag IDs: politics=2, crypto=21, sports=100639, tech=1401, culture=596

# Filter by category via series
curl "https://api.elections.kalshi.com/trade-api/v2/events?series_ticker=KXBTC"

# List all series to discover categories
curl "https://api.elections.kalshi.com/trade-api/v2/series/KXHIGHNY"

# CLI
polymarket clob book TOKEN_ID

# curl
curl "https://clob.polymarket.com/book?token_id=TOKEN_ID"

from py_clob_client.client import ClobClient
from py_clob_client.clob_types import BookParams

client = ClobClient("https://clob.polymarket.com")
book = client.get_order_book("TOKEN_ID")

# Batch: get multiple books at once
books = client.get_order_books([
    BookParams(token_id="TOKEN_1"),
    BookParams(token_id="TOKEN_2")
])

curl "https://api.elections.kalshi.com/trade-api/v2/markets/TICKER/orderbook"

book = client.get_market_orderbook("TICKER", depth=10)
# Returns yes bids and no bids only (no asks)
# In binary markets: yes bid at X¢ = no ask at (100-X)¢

# CLI
polymarket clob midpoint TOKEN_ID
polymarket -o json clob midpoint TOKEN_ID | jq '.mid'

# Python
mid = client.get_midpoint("TOKEN_ID")

# No dedicated midpoint endpoint — compute from orderbook
# Midpoint = (best_yes_bid + (100 - best_no_bid)) / 2

# CLI
polymarket clob price-history TOKEN_ID --interval 1d
polymarket clob price-history TOKEN_ID --interval 1h

# CLOB API
curl "https://clob.polymarket.com/prices-history?market=TOKEN_ID&interval=1d"

curl "https://api.elections.kalshi.com/trade-api/v2/markets/TICKER/history?limit=100"

# CLI
polymarket clob create-order \
  --token TOKEN_ID \
  --side buy \
  --price 0.45 \
  --size 10

from py_clob_client.clob_types import OrderArgs, OrderType
from py_clob_client.order_builder.constants import BUY

order = OrderArgs(
    token_id="TOKEN_ID",
    price=0.45,     # Price per share in USDC (0.00-1.00)
    size=10.0,      # Number of shares
    side=BUY
)
signed = client.create_order(order)
resp = client.post_order(signed, OrderType.GTC)  # Good-til-canceled

// TypeScript
import { ClobClient, Side } from "@polymarket/clob-client";

const order = await client.createAndPostOrder(
  { tokenID: "TOKEN_ID", price: 0.50, size: 10, side: Side.BUY },
  { tickSize: "0.01", negRisk: false }
);

import uuid

order = client.create_order(
    ticker="MARKET_TICKER",
    action="buy",
    side="yes",
    count=10,             # Number of contracts
    type="limit",
    yes_price=45,         # Price in cents (1-99)
    client_order_id=str(uuid.uuid4())
)

curl --request POST \
  --url https://api.elections.kalshi.com/trade-api/v2/portfolio/orders \
  --header 'Content-Type: application/json' \
  --header 'KALSHI-ACCESS-KEY: KEY' \
  --header 'KALSHI-ACCESS-SIGNATURE: SIG' \
  --header 'KALSHI-ACCESS-TIMESTAMP: TS' \
  --data '{
    "ticker": "MARKET_TICKER",
    "action": "buy",
    "side": "yes",
    "count": 10,
    "type": "limit",
    "yes_price": 45,
    "client_order_id": "UUID"
  }'

# CLI
polymarket clob market-order \
  --token TOKEN_ID \
  --side buy \
  --amount 5

from py_clob_client.clob_types import MarketOrderArgs, OrderType
from py_clob_client.order_builder.constants import BUY

mo = MarketOrderArgs(
    token_id="TOKEN_ID",
    amount=25.0,         # USDC amount to spend
    side=BUY,
    order_type=OrderType.FOK  # Fill-or-kill
)
signed = client.create_market_order(mo)
resp = client.post_order(signed, OrderType.FOK)

order = client.create_order(
    ticker="MARKET_TICKER",
    action="buy",
    side="yes",
    count=10,
    type="market",         # No price needed for market orders
    client_order_id=str(uuid.uuid4())
)

# CLI
polymarket clob orders

# Python
orders = client.get_orders()

orders = client.get_orders(status="resting")

curl "https://api.elections.kalshi.com/trade-api/v2/portfolio/orders?status=resting" \
  --header 'KALSHI-ACCESS-KEY: KEY' \
  --header 'KALSHI-ACCESS-SIGNATURE: SIG' \
  --header 'KALSHI-ACCESS-TIMESTAMP: TS'

# CLI: Cancel one
polymarket clob cancel ORDER_ID

# CLI: Cancel all
polymarket clob cancel-all

# Python
client.cancel(order_id="ORDER_ID")
client.cancel_all()
client.cancel_market_orders(market="CONDITION_ID")

# Cancel one
client.cancel_order("ORDER_ID")

# Cancel all (batch)
client.batch_cancel_orders(
    tickers=["TICKER1", "TICKER2"]
)

# Cancel one
curl --request DELETE \
  "https://api.elections.kalshi.com/trade-api/v2/portfolio/orders/ORDER_ID" \
  --header 'KALSHI-ACCESS-KEY: KEY' \
  --header 'KALSHI-ACCESS-SIGNATURE: SIG' \
  --header 'KALSHI-ACCESS-TIMESTAMP: TS'

# Amend an existing order (change price/size without cancel+replace)
client.amend_order(
    order_id="ORDER_ID",
    count=15,
    yes_price=48
)

curl --request POST \
  "https://api.elections.kalshi.com/trade-api/v2/portfolio/orders/ORDER_ID/amend" \
  --header 'Content-Type: application/json' \
  --data '{"count": 15, "yes_price": 48}'

# CLI
polymarket data positions YOUR_ADDRESS

# Data API
curl "https://data-api.polymarket.com/positions?user=YOUR_ADDRESS"

positions = client.get_positions(settlement_status="unsettled")
for p in positions.market_positions:
    print(f"{p.ticker}: {p.position} contracts")

curl "https://api.elections.kalshi.com/trade-api/v2/portfolio/positions" \
  --header 'KALSHI-ACCESS-KEY: KEY' \
  --header 'KALSHI-ACCESS-SIGNATURE: SIG' \
  --header 'KALSHI-ACCESS-TIMESTAMP: TS'

# CLI
polymarket clob balance --asset-type collateral

# Python
balance = client.get_balance_allowance()

balance = client.get_balance()
# Returns balance in cents + portfolio_value (balance + positions value)
print(f"Available: ${balance.balance / 100:.2f}")
print(f"Portfolio: ${balance.portfolio_value / 100:.2f}")

# CLI
polymarket data value YOUR_ADDRESS

balance = client.get_balance()
# portfolio_value includes balance + position market values

# CLI
polymarket clob trades

# Python
trades = client.get_trades()

fills = client.get_fills(ticker="MARKET_TICKER")
# A "fill" = a completed trade match

# Subscribe to market channel
import websocket
import json

ws = websocket.create_connection(
    "wss://ws-subscriptions-clob.polymarket.com/ws/market"
)

# Subscribe to specific assets
ws.send(json.dumps({
    "type": "subscribe",
    "assets_ids": ["TOKEN_ID_1", "TOKEN_ID_2"]
}))

while True:
    msg = json.loads(ws.recv())
    # msg contains orderbook updates, trade events

# Kalshi WebSocket subscription
import websocket
import json

ws = websocket.create_connection(
    "wss://api.elections.kalshi.com/trade-api/ws/v2"
)

# Authenticate
ws.send(json.dumps({
    "id": 1,
    "cmd": "subscribe",
    "params": {
        "channels": ["orderbook", "ticker"],
        "market_tickers": ["TICKER1", "TICKER2"]
    }
}))

polymarket markets list [--limit N] [--offset N]
polymarket markets search "QUERY" [--limit N]
polymarket markets get SLUG
polymarket events list [--tag TAG] [--limit N]
polymarket clob book TOKEN_ID
polymarket clob midpoint TOKEN_ID
polymarket clob price-history TOKEN_ID [--interval 1d|1h|1m]
polymarket status                    # API health check

polymarket wallet create             # Generate new wallet
polymarket wallet import 0xKEY       # Import existing private key
polymarket wallet show               # Display wallet address and config
polymarket approve set               # Approve USDC for trading (needs MATIC)

polymarket clob market-order --token TOKEN --side buy|sell --amount USDC
polymarket clob create-order --token TOKEN --side buy|sell --price 0.XX --size N
polymarket clob balance [--asset-type collateral|conditional]
polymarket clob orders               # List open orders
polymarket clob trades               # List trade history
polymarket clob cancel ORDER_ID
polymarket clob cancel-all

polymarket data positions ADDRESS    # All positions for an address
polymarket data value ADDRESS        # Portfolio value

polymarket setup                     # Guided first-time setup
polymarket upgrade                   # Update CLI to latest version
polymarket shell                     # Interactive REPL mode
polymarket --version
polymarket --help
polymarket -o json COMMAND           # JSON output (on any command)

def normalize_price(polymarket_price=None, kalshi_price=None):
    """Convert to a common 0-1 probability format."""
    if polymarket_price is not None:
        return polymarket_price  # Already 0.00-1.00
    if kalshi_price is not None:
        return kalshi_price / 100  # Convert cents to 0.00-1.00

def denormalize_price(probability, platform):
    """Convert common probability to platform-native format."""
    if platform == "polymarket":
        return round(probability, 2)  # 0.00-1.00
    elif platform == "kalshi":
        return int(probability * 100)  # 1-99 cents