Best API for Prediction Markets in 2026 (Kalshi, Polymarket)

Looking for the best API for prediction markets in 2026? The three options you're choosing between are the Polymarket API (CLOB, requires a Polygon wallet), the Kalshi API (REST + FIX, requires RSA key pairs), and Prediction Hunt's unified prediction market API — which covers both of those plus PredictIt, ProphetX, and Opinion behind a single X-API-Key header. This guide compares all five options with working code samples, real rate limits, and 2026 pricing.

The context: in early 2026, Polymarket acquired Dome — the only YC-backed cross-platform prediction market API. Overnight, the cleanest option for getting data across Polymarket and Kalshi was absorbed into one of the platforms it covered. Developers who had been relying on Dome for a unified feed are now looking for a replacement.

This guide maps the full prediction market API landscape today: Polymarket's CLOB on Polygon, Kalshi's REST API on a CFTC-regulated exchange, Opinion's blockchain-native protocol after its $20M raise, Predict.fun on BNB Chain, and the Prediction Hunt aggregation API sitting across all of them. Choosing the wrong one adds weeks of integration work, introduces brittle auth requirements, and leaves you with a single-platform view when the real edge is cross-platform.

---

---

Table of Contents

• What Happened to Dome API?
• The Problem With Building on Single-Platform APIs
• Prediction Hunt API: Unified Cross-Platform Data
• Polymarket API (CLOB)
• Kalshi API (REST + FIX)
• Opinion API
• Predict.fun API
• PredictIt and ProphetX
• Head-to-Head Comparison Table
• Use Cases: Arb Bots, Odds Widgets, Research
• Pricing: Free, Dev, Pro, Enterprise
• Which API Should You Use?
• Get Started With the Prediction Hunt API

---

---

What Happened to Dome API?

Dome was a Y Combinator-backed startup that built exactly what the prediction market developer community needed: a unified REST API that covered both Polymarket and Kalshi in a single interface. No EIP-712, no RSA keys — just one endpoint returning normalized price data across platforms.

In early 2026, Polymarket acquired Dome. The independent service shut down. The people searching for "Dome API alternative" on Reddit r/algotrading right now are the same people who had working integrations built on it.

The irony: Polymarket acquiring Dome means the only unified cross-platform API is now owned by one of the platforms it was supposed to neutrally cover. Developers who need objective data across both Polymarket and Kalshi — the two largest US prediction market venues — no longer have an independent aggregation option from Dome.

Prediction Hunt's v2 API fills that gap. It covers Kalshi, Polymarket, PredictIt, ProphetX, and Opinion — five platforms — with a free tier that requires no credit card and the same unified matching-markets endpoint that made Dome appealing to developers in the first place.

---

---

The Problem With Building on Single-Platform APIs

Every prediction market platform has an API. None of them speak the same language.

The Polymarket API uses EIP-712 signatures for order authentication, requires a Polygon wallet, and returns prices as floating-point fractions where 0.65 means 65 cents. The Kalshi API uses RSA-PSS keys, session tokens that expire every 30 minutes, returns prices in hundredths of a cent, and supports FIX 4.4 for institutional clients. Opinion runs on its own blockchain protocol with an OPN token and a maker/taker fee model where only takers pay. Predict.fun is built on BNB Chain and requires either an EOA wallet or a Privy smart wallet, plus a Discord support ticket just to get a mainnet API key. PredictIt has a REST feed but requires scraping for full market data. ProphetX has its own auth system.

If you want to build anything that touches more than one platform — an arbitrage scanner, a price comparison tool, a portfolio tracker, a research dataset — you are integrating six different authentication systems, six different data schemas, six different rate limit regimes, and six different failure modes. Most bot projects that start ambitious die in the integration layer. The trading logic never gets written because the plumbing takes too long.

The Prediction Hunt v2 API exists to eliminate most of that layer. You get a unified endpoint covering Kalshi, Polymarket, PredictIt, ProphetX, and Opinion with consistent schemas, no Web3 auth required, and live price data refreshed in real time.

---

---

Prediction Hunt API: Unified Cross-Platform Data

The Prediction Hunt v2 API is a prediction market data aggregation API that covers Kalshi, Polymarket, PredictIt, ProphetX, and Opinion in a single interface. Its core value proposition: instead of five separate API integrations with five different auth systems, you write one.

Key Endpoints

Endpoint	What It Returns
GET /api/v2/markets	All markets across platforms, filterable by platform, category, status
GET /api/v2/events	Events with associated markets across platforms
GET /api/v2/matching-markets	Cross-platform market groups — same real-world event, all platforms
GET /api/v2/matching-markets/url	Cross-platform group for a specific market by URL
GET /api/v2/matching-markets/sports	Sports markets matched across platforms by sport/league
GET /api/v2/prices/history	OHLC candle data at 1m / 5m / 15m / 1h / 1d intervals
GET /api/v2/prices/bulk	Batch price lookup for up to 100 platform:market_id pairs
GET /api/v2/orderbook	Live orderbook snapshot for Polymarket, Kalshi, Opinion, Predict.fun
GET /api/v2/arb	Live arbitrage signals across matched platforms (Dev/Pro tier)
GET /api/v2/ev	Live positive-EV signals across matched platforms (Dev/Pro tier)
GET /api/v2/status	API health and platform data freshness

The matching-markets family of endpoints is what makes Prediction Hunt different from any single-platform API. Each response is a MarketMatchGroup: a canonical grouping of equivalent markets across platforms. If the Celtics vs Heat game has contracts on both Kalshi and Polymarket, they appear in the same group object with their respective prices side by side.

Authentication

Authentication is a single header. Get a free key at predictionhunt.com/api/docs — keys are prefixed pmx_ and delivered instantly, no credit card required.

curl -H "X-API-Key: pmx_your_key_here" \
  "https://www.predictionhunt.com/api/v2/events?limit=5"

Demo endpoints at /api/v2/demo/* work without any key at all — useful for prototyping and sharing code samples. No EIP-712, no RSA keys, no session tokens.

Sample: Scanning for NBA Arbitrage

import os
import requests

headers = {"X-API-Key": os.environ["PREDICTION_HUNT_API_KEY"]}

resp = requests.get(
    "https://www.predictionhunt.com/api/v2/matching-markets/sports",
    params={"sport": "nba"},
    headers=headers,
)

for group in resp.json()["data"]:
    platforms = {m["platform"]: m["yes_price"] for m in group["markets"]}
    spread = max(platforms.values()) - min(platforms.values())
    if spread > 0.04:
        print(group["title"])
        for platform, price in sorted(platforms.items()):
            print(f"  {platform}: {price:.2f}")
        print(f"  spread: {spread:.2f}\n")

This is the whole cross-platform arb scanner. No wallet, no Web3 SDK, no session token refresh loop. One HTTP call, one consistent schema, five platforms.

What It Doesn't Do

The Prediction Hunt API is a data and intelligence API, not an execution API. Use it to find opportunities, monitor prices, and build research datasets. To place an order, you still go through each platform's native API. The right mental model: Prediction Hunt tells you where and what; the platform APIs let you act.

---

---

Polymarket API (CLOB)

The Polymarket API is the most feature-complete native API among prediction market platforms. Polymarket's CLOB (Central Limit Order Book) supports full order management, real-time WebSocket streams, and historical trade data.

Authentication: The Hard Part

Polymarket's auth model is built around crypto wallets. Two separate signature schemes:

• L1 (account setup, approvals): EIP-712 signatures using your private key on Polygon (chain ID 137)
• L2 (order signing): HMAC-SHA256 with a separate API key derived from your wallet

If you've never worked with EIP-712 before, expect to spend a day or two on setup. The official Python SDK py-clob-client abstracts most of this away:

from py_clob_client.client import ClobClient

client = ClobClient(
    "https://clob.polymarket.com",
    key=YOUR_PRIVATE_KEY,
    chain_id=137,  # Polygon Mainnet
)

# Get the order book for a specific market
order_book = client.get_order_book(token_id="YOUR_MARKET_TOKEN_ID")
print(order_book)

py-clob-client has over 500,000 monthly PyPI downloads — there's a large community around it and the official Polymarket documentation is reasonably maintained.

Rate Limits

Polymarket is relatively permissive on the data side. Market data endpoints allow ~10 requests/second without authentication. Authenticated trading endpoints have separate, tighter limits.

WebSocket Support

Polymarket offers WebSocket streams for real-time order book updates and trade events. This is necessary for any latency-sensitive strategy. The CLOB API is genuinely well-built for Polymarket-specific work.

What It Covers

The Polymarket API covers Polymarket only. It gives you deep data for that platform — full order books, real-time WebSocket streams, individual trade history — but zero visibility into Kalshi, PredictIt, or ProphetX.

---

---

Kalshi API (REST + FIX)

The Kalshi API covers a CFTC-regulated US exchange with tighter authentication requirements than Polymarket.

Authentication

Kalshi uses RSA-PSS key pairs. You generate a key, upload the public key to your account, and sign requests with the private key. Session tokens are time-limited — they expire every 30 minutes and must be refreshed. In a long-running bot, you need to implement token refresh logic or the session will go stale mid-operation.

import base64
import time
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding

# Load private key
with open("kalshi_private_key.pem", "rb") as f:
    private_key = serialization.load_pem_private_key(f.read(), password=None)

# Sign each request: timestamp + method + path
timestamp = str(int(time.time() * 1000))
message = (timestamp + "GET" + "/trade-api/v2/markets").encode()
signature = private_key.sign(
    message,
    padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.DIGEST_LENGTH),
    hashes.SHA256(),
)
sig_b64 = base64.b64encode(signature).decode()
# Pass KALSHI-ACCESS-KEY, KALSHI-ACCESS-TIMESTAMP, KALSHI-ACCESS-SIGNATURE as headers

This is before you write any actual trading logic.

Rate Limits

Kalshi enforces 10 requests/second on most endpoints — tighter than Polymarket. For price scanning across hundreds of markets, you'll hit this ceiling quickly and need to implement backoff logic.

FIX 4.4 Support

Kalshi supports FIX 4.4 for institutional-grade low-latency order routing. Relevant for HFT-style strategies; irrelevant for most developers building data tools or bots that operate on minute-level intervals.

What It Covers

Kalshi only. Like every single-platform API, it gives you a complete picture of one exchange and nothing else.

---

---

Opinion API

Opinion emerged as one of the fastest-growing prediction market platforms in 2025–2026, reaching roughly 31% of global prediction market volume ($8B+ monthly) by early 2026. Its $20M pre-Series A from Hack VC and Jump Crypto funded a crypto-native protocol with its own OPN token, launched March 2026.

What Opinion Covers

Opinion focuses on macro events, crypto, culture, and geopolitical outcomes — the higher-stakes, higher-conviction category of markets. It's designed for traders who have strong directional views on things like FOMC decisions, CPI prints, and token launches, rather than sports prop bets.

Authentication and Protocol

Opinion is built on a blockchain protocol with a native token model. Like Polymarket, you need a crypto wallet to trade. The fee model is taker-only: makers pay zero fees, takers pay a fee that scales with the market. This is the same structure that has attracted liquidity providers to Polymarket — it rewards patient, limit-order-based trading.

What That Means for Developers

Opinion's API requires crypto wallet integration and familiarity with their protocol. Because Opinion's market data is already integrated into the Prediction Hunt API, you can access Opinion prices, match them against equivalent Kalshi or Polymarket markets, and scan for cross-platform spreads without setting up an Opinion wallet at all. For execution, you go to Opinion directly.

---

---

Predict.fun API

Predict.fun is a prediction market platform built exclusively on BNB Chain (Binance Smart Chain). It has an official developer API and SDKs in both Python and TypeScript, which puts its developer experience ahead of most crypto-native prediction platforms.

Authentication

Two account types are supported: standard EOA (externally owned account, i.e. a normal crypto wallet) and Predict's smart wallet option built on Privy account abstraction. The smart wallet approach is friendlier for developers who want to avoid managing private keys directly.

Getting a mainnet API key requires joining Predict's Discord and opening a support ticket. Testnet access at api-testnet.predict.fun requires no credentials and is available immediately — useful for development.

SDKs

Predict.fun has official SDKs that go beyond raw REST calls:

# Python SDK — pip install predict-sdk
from predict_sdk import PredictClient

client = PredictClient(api_key="YOUR_API_KEY", network="mainnet")

# Get available markets
markets = client.get_markets(status="active")
for market in markets:
    print(market["title"], market["yes_price"])

// TypeScript — npm install @predictdotfun/sdk
import { PredictClient } from "@predictdotfun/sdk";

const client = new PredictClient({ apiKey: "YOUR_API_KEY" });
const orderBook = await client.getOrderBook({ marketId: "MARKET_ID" });

Rate Limits

Both testnet and mainnet enforce 240 requests per minute — significantly more permissive than Kalshi's 10 req/sec ceiling, and reasonable for most scanning or monitoring workloads.

WebSocket Support

Predict.fun supports WebSocket connections for real-time order book and trade event streams. The structure follows standard subscription topics similar to Polymarket's approach.

The Catch

Predict.fun is BNB Chain only. If your primary interest is US-regulated markets (Kalshi) or the largest global liquidity pool (Polymarket), Predict.fun is a separate ecosystem entirely. It's best thought of as a crypto-native prediction venue rather than a direct competitor to Kalshi.

---

---

PredictIt and ProphetX

PredictIt operates as a research market under a CFTC no-action letter. Its public data feed provides market prices but is not designed for high-frequency programmatic access. Trading integration requires additional setup and approval.

ProphetX caters primarily to the sports betting market with a more permissioned API structure. Access typically requires an agreement with their platform.

Neither has the developer ecosystem or documentation quality of the Polymarket API or Kalshi API. For research and price monitoring purposes, both are better accessed through the Prediction Hunt aggregation layer than built on directly.

---

---

Head-to-Head Comparison Table

	Prediction Hunt	Polymarket CLOB	Kalshi REST	Opinion	Predict.fun
Platforms covered	Kalshi, Polymarket, PredictIt, ProphetX, Opinion	Polymarket only	Kalshi only	Opinion only	Predict.fun only
Blockchain	None (REST)	Polygon	None (CFTC-regulated)	Own protocol	BNB Chain
Authentication	X-API-Key header	EIP-712 + HMAC-SHA256	RSA-PSS + session tokens	Crypto wallet	EOA or Privy Smart Wallet
Auth complexity	Low	High	Medium-High	High	Medium (smart wallet helps)
Session expiry	No	No	Yes (30 min)	No	No
API key acquisition	Self-serve, instant	Wallet-based	Account signup + RSA	Wallet-based	Discord ticket (mainnet)
Cross-platform matching	Native	No	No	No	No
Arbitrage detection	Built-in	No	No	No	No
Order execution	Data only	Full CLOB	Full REST + FIX	Yes	Yes
REST API	Yes	Yes	Yes	Yes	Yes
WebSocket support	Yes (paid tiers)	Yes	Yes	—	Yes
FIX 4.4	No	No	Yes	No	No
Rate limits (burst)	1–100 req/s (tier)	~10 req/s (data)	10 req/s	—	240 req/min
Free tier / unauth'd access	Yes (free key + demo endpoints)	Limited (data only)	No	No	Testnet only
Starting price	$0 (1k req/mo free)	Free (native exchange)	Free (native exchange)	N/A	N/A
Python SDK	standard requests	py-clob-client	Official client	—	predict-sdk
TypeScript SDK	standard fetch	—	—	—	@predictdotfun/sdk
Focus markets	All platforms	Crypto, politics, sports	US-regulated events	Macro, crypto, culture	Crypto-native
Best for	Data, research, arb scanning	Polymarket bots	Kalshi bots	Opinion execution	BNB Chain trading

The table reveals a clear division of labor. Prediction Hunt is the right tool when you need cross-platform visibility — one API covering five platforms, no blockchain auth required. The native Polymarket API (CLOB) and Kalshi API (REST) are the tools when you need to execute on their specific exchanges. Opinion and Predict.fun are crypto-native platforms with their own SDKs, best integrated directly when you want to trade on them specifically.

In most serious production workflows, you use two layers: Prediction Hunt to identify the opportunity across platforms, then the native API for execution.

---

---

Use Cases: Arb Bots, Odds Widgets, Research

Arbitrage Bots

Cross-platform arbitrage is the canonical reason to build on a unified prediction market API. Two contracts on the same real-world event priced differently on Kalshi vs Polymarket = free money if you can take both sides before the spread closes.

import os, requests

headers = {"X-API-Key": os.environ["PREDICTION_HUNT_API_KEY"]}
resp = requests.get(
    "https://www.predictionhunt.com/api/v2/arb",
    headers=headers,
)
for signal in resp.json()["signals"]:
    print(signal["event_title"], signal["edge"], signal["legs"])

The /api/v2/arb endpoint returns pre-computed signals with 15-second delay. You still execute on each platform's native API — but you don't spend engineering time reimplementing the matching layer.

Odds Widgets and Embedded Displays

If you're publishing a news site, sports blog, or crypto newsletter and want to show live prediction market odds next to your editorial content, the /api/v2/matching-markets/url endpoint resolves any Polymarket or Kalshi URL into a cross-platform group:

// Fetch cross-platform prices for a known Polymarket URL
const resp = await fetch(
  "https://www.predictionhunt.com/api/v2/matching-markets/url?" +
    "url=https://polymarket.com/event/will-trump-win-2028",
  { headers: { "X-API-Key": process.env.PREDICTION_HUNT_API_KEY } },
);
const { markets } = await resp.json();
markets.forEach((m) => console.log(m.platform, m.yes_price));

One URL in, all matched platform prices out. No scraping, no per-platform integration.

Academic and Quant Research

Unlimited historical depth is on every tier. Pull OHLC candles for any market back to the beginning of its history with /api/v2/prices/history:

curl -H "X-API-Key: $KEY" \
  "https://www.predictionhunt.com/api/v2/prices/history?platform=polymarket&market_id=MARKET_ID&interval=1h&from=2026-01-01T00:00:00Z"

Trading Automation

For live trading, the pattern is: Prediction Hunt as the intelligence layer, native platform API for execution. Cross-reference prices across Kalshi + Polymarket via Prediction Hunt, then route orders through py-clob-client (Polymarket) or the Kalshi REST client. If you're building an arbitrage tool, that split is structural — aggregation belongs in one layer, order routing in another.

---

---

Pricing: Free, Dev, Pro, Enterprise

Every Prediction Hunt tier includes unlimited historical data and all core REST endpoints. The differences are rate limits, signal access, WebSocket capabilities, and support. Full details at /api/docs/pricing.

Tier	Price	Rate limit	Monthly requests	WebSocket	Arb + EV signals
Free	$0	1 req/sec	1,000	—	—
Dev	$49/mo	20 req/sec	1,000,000	Prices channel	500 arb + 500 EV
Pro	$249/mo	100 req/sec	5,000,000	All channels	5,000 arb + 5,000 EV
Enterprise	Custom	Custom	Unlimited	All channels	Unlimited

The Free tier is designed for experimentation — no credit card, 10 cross-platform matching requests and unlimited sports matching per month. Dev unlocks the WebSocket prices channel and the /api/v2/arb and /api/v2/ev signal endpoints. Pro adds all WebSocket channels (orderbook, arb, EV, lifecycle) and 10x the signal quota. Enterprise removes limits entirely and adds dedicated account management.

Compared to the native APIs: Polymarket CLOB and Kalshi REST are free to query on the data side, but you pay the cost in integration time — a week of EIP-712 or RSA work before your first live trade — plus the ongoing cost of maintaining two or more separate auth systems. Prediction Hunt's $49/mo Dev tier is typically cheaper than the engineering time it saves.

---

---

Which API Should You Use?

If you're building a price monitor, research tool, or arbitrage scanner: Start with the Prediction Hunt API. Five platforms — Kalshi, Polymarket, PredictIt, ProphetX, Opinion — with a consistent schema and no Web3 auth. The /api/v2/matching-markets endpoint does the cross-platform comparison work that would take months to replicate manually.

If you're building a Polymarket-specific execution bot: You need the Polymarket API (CLOB). Use py-clob-client to manage the authentication complexity. Complement it with Prediction Hunt to monitor prices on Kalshi and Opinion simultaneously.

If you're building a Kalshi-specific execution bot: You need the Kalshi API (REST). Budget time for RSA key setup and session refresh logic. Use Prediction Hunt as the intelligence layer to surface opportunities before routing execution to Kalshi.

If you're building on Opinion: Opinion's protocol is crypto-native with a taker-only fee model that rewards limit order traders. Go direct to their API for execution. Use Prediction Hunt to monitor how Opinion prices compare to Polymarket and Kalshi on the same event.

If you're building on Predict.fun: The predict-sdk Python package and @predictdotfun/sdk TypeScript package give you the fastest path to integration. Get comfortable on testnet first — no API key needed there. Mainnet requires a Discord ticket.

If you're building a multi-platform execution bot: Use Prediction Hunt to identify cross-platform opportunities, then fan out to each platform's native API for execution. This is the architecture behind most serious prediction market algos: one aggregation layer, multiple execution legs.

If you're doing academic research on prediction market prices: The Prediction Hunt API is the cleanest source for normalized data across platforms. No crypto wallet, no session tokens, no Discord tickets. Unlimited historical depth on every tier, including Free.

---

---

Get Started With the Prediction Hunt API

The fastest path to a working prototype uses the unauthenticated demo endpoints:

import requests

# No auth required for demo endpoints
resp = requests.get(
    "https://www.predictionhunt.com/api/v2/demo/matching-markets",
    params={"limit": 10},
)

for group in resp.json()["data"]:
    print(group["title"])
    for market in group["markets"]:
        print(f"  {market['platform']:12} YES: {market['yes_price']:.2f}")
    print()

Run that script and you'll see cross-platform prices for the same events in about 30 seconds of setup. When you're ready to move beyond demo data, generate a free API key at predictionhunt.com/api/docs and swap in the X-API-Key header.

The full endpoint reference — parameters, response schemas, filtering options, rate limits — is at the Prediction Hunt API docs. The two-minute quickstart walks through the first request end-to-end. And if you want to see the arbitrage output before you write any code, the live arbitrage dashboard runs the same signals you'd get from /api/v2/arb.