Best API for Prediction Markets in 2026: Prediction Hunt vs Polymarket vs Kalshi vs Opinion vs Predict.fun

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

This guide maps the full prediction market API landscape as it stands today: Polymarket's CLOB on Polygon, Kalshi's REST 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. None speak the same language. Choosing the wrong one adds weeks of integration work, introduces brittle authentication requirements, and leaves you with a single-platform view when the real edge is cross-platform.

This guide covers what each API actually does, where each one breaks down, and which one to reach for depending on what you're building.

---

---

Table of Contents

• What Happened to Dome API?
• The Core Problem With Building on Single-Platform APIs
• Prediction Hunt API: Cross-Platform Aggregation
• Polymarket CLOB API
• Kalshi REST API
• Opinion API
• Predict.fun API
• PredictIt and ProphetX
• Head-to-Head Comparison
• Which API Should You Use?
• Getting 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 demo tier that requires no authentication and the same unified matching-markets endpoint that made Dome appealing to developers in the first place.

---

---

The Core Problem With Building on Single-Platform APIs

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

Polymarket uses EIP-712 signatures for order authentication, requires a Polygon wallet, and returns prices as floating-point fractions where 0.65 means 65 cents. Kalshi 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 model where only takers pay fees. 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: Cross-Platform Aggregation

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/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 and Rate Limits

Demo endpoints at /api/v2/demo/* work without authentication — useful for prototyping and testing without signing up. Authenticated endpoints require a Prediction Hunt API key, passed as a bearer token.

Rate limits on the authenticated tier are designed for production workloads. The data refresh cycle is fast enough for near-real-time arbitrage detection.

Sample: Scanning for NBA Arbitrage

import requests

headers = {"Authorization": "Bearer YOUR_API_KEY"}

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

for group in response.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(f"{group['title']}")
        for platform, price in sorted(platforms.items()):
            print(f"  {platform}: {price:.2f}")
        print(f"  spread: {spread:.2f}\n")

This is the whole arbitrage 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. You can 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 is: Prediction Hunt tells you where and what; the platform APIs let you act.

---

---

Polymarket CLOB API

Polymarket's CLOB (Central Limit Order Book) API is the most feature-complete native API among prediction market platforms. It 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 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.

What It Covers

Polymarket's CLOB 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.

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.

---

---

Kalshi REST API

Kalshi's 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 requests
import time
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes, serialization

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

# Generate HMAC-like signature for each request (simplified)
# In practice, Kalshi requires signing the timestamp + method + path
timestamp = str(int(time.time() * 1000))
# ... (full implementation is significantly longer)

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.

Predict.fun is not currently integrated into the Prediction Hunt API, so cross-platform comparison with Predict.fun markets requires a direct integration.

---

---

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 Polymarket or Kalshi. For research and price monitoring purposes, both are better accessed through the Prediction Hunt aggregation layer than built on directly.

---

---

Head-to-Head Comparison

	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	API key (bearer)	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	Wallet-based	Account signup	Wallet-based	Discord ticket (mainnet)
Cross-platform matching	✓ Native	✗	✗	✗	✗
Arbitrage detection	✓ Built-in	✗	✗	✗	✗
Order execution	✗ Data only	✓ Full CLOB	✓ Full REST + FIX	✓	✓
WebSocket support	—	✓	✓	—	✓
FIX 4.4	✗	✗	✓	✗	✗
Rate limits	Production-grade	~10 req/s (data)	10 req/s	—	240 req/min
Demo/unauthenticated tier	✓	Limited	✗	✗	✓ (testnet)
Python SDK	standard requests	py-clob-client	Official client	—	predict-sdk (PyPI)
TypeScript SDK	—	—	—	—	@predictdotfun/sdk
Focus markets	All platforms	Crypto, politics, sports	US-regulated events	Macro, crypto, culture	Crypto-native
Best for	Data, research, arbitrage scanning	Polymarket-specific bots	Kalshi-specific bots	Opinion-specific execution	BNB Chain prediction 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. Polymarket CLOB and Kalshi 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.

---

---

Which API Should You Use?

If you're building a price monitor, research tool, or arbitrage scanner: Start with the Prediction Hunt API. You get five platforms — Kalshi, Polymarket, PredictIt, ProphetX, and 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 CLOB API. 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 REST API. 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.

---

---

Getting Started With the Prediction Hunt API

The fastest path to a working prototype:

import requests

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

data = response.json()

for group in data["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. No authentication, no SDK installation, no wallet. When you're ready to move beyond demo data, generate an API key at predictionhunt.com/api and swap in your bearer token.

The full endpoint reference — parameters, response schemas, filtering options, rate limits — is at Prediction Hunt API Docs.

Ready to build? Get your free Prediction Hunt API key →