Dome vs pmxt vs OddsPapi: Unified Prediction Market API Comparison (2026)

If you’re building a prediction market agent that touches more than one platform, you’ve faced the integration tax: Polymarket’s CLOB API uses EIP-712 signatures and token IDs, Kalshi uses RSA-PSS and cent-denominated prices, and every other platform has its own authentication scheme, data format, and rate limit structure. Writing platform-specific code for each one is tedious, error-prone, and a maintenance burden.

Unified APIs solve this by normalizing everything behind a single interface. Three tools compete for this role in the prediction market ecosystem: Dome (acquired by Polymarket), pmxt (open-source, CCXT-inspired), and OddsPapi (prediction markets + sportsbooks). Each serves a different developer need. This guide helps you choose.

For a summary of how these tools fit into the broader API landscape, see the Prediction Market API Reference.

The Three Contenders

Dome was a Y Combinator W25 startup that raised $5.2 million to build unified prediction market infrastructure. On February 19, 2026, Polymarket acquired Dome — its second acquisition after the $112M QCEX purchase. Dome’s cofounders (Kunal Roy and Kurush Dubash, both ex-Alchemy founding engineers) joined the Polymarket team. Dome’s existing API may continue during a transition period, but its future is now tied to Polymarket’s developer platform roadmap.

pmxt is an open-source library that describes itself as “CCXT for prediction markets.” It provides Python and TypeScript SDKs for real-time candles, orderbooks, history, and trading across multiple prediction market exchanges. With 100+ GitHub stars, it leads the open-source prediction market library space ahead of dr-manhattan (~60 stars) and predmarket (~70 stars).

OddsPapi is a commercial odds aggregation API at oddspapi.io that uniquely bridges prediction markets and traditional sportsbooks. It covers Polymarket, Kalshi, and 350+ sportsbooks (including sharps like Pinnacle, Singbet, SBOBet) through a single REST + WebSocket API. Free tier included.

Master Comparison Table

Dome: What It Built, Where It’s Going

Dome’s pitch was compelling: one API key for every prediction market. Their founding team brought serious infrastructure credibility — both cofounders were founding engineers at Alchemy, where they helped scale the company from 10 to 250 employees and a $10 billion valuation.

What Dome Offered

• Unified authentication: A single API key replaced separate credentials for Polymarket (wallet + EIP-712), Kalshi (RSA-PSS), and other platforms
• Normalized data schemas: Consistent JSON structures regardless of the underlying platform
• Historical data: Granular datasets not available natively from individual platforms, useful for backtesting
• Multi-platform trading: Place orders across platforms through Dome’s unified endpoint

The Polymarket Acquisition

On February 19, 2026, Polymarket announced the acquisition of Dome. This was Polymarket’s first developer-infrastructure acquisition (its earlier QCEX purchase was a regulatory play for CFTC licensing).

What this means for developers:

1. Dome’s standalone API is on borrowed time. It may continue during transition, but building new features against it is risky
2. Polymarket will likely integrate Dome’s technology into its own developer platform — expect improved native APIs and SDKs from Polymarket
3. Multi-platform access was Dome’s differentiator, and Polymarket has no incentive to maintain Kalshi or Manifold support. If you need multi-platform data, migrate to pmxt or direct APIs

Migration Path for Dome Users

If you have existing Dome integrations:

• For Polymarket data: Migrate to the native Polymarket CLOB API — it will get Dome’s improvements over time
• For multi-platform data: Migrate to pmxt (if pure prediction markets) or OddsPapi (if you also need sportsbooks)
• For historical data: Use pmxt’s data archive at archive.pmxt.dev or OddsPapi’s historical endpoints

pmxt: The Open-Source Standard

pmxt takes the CCXT model (which unified 100+ crypto exchange APIs) and applies it to prediction markets. If you’ve used CCXT for crypto trading, pmxt will feel immediately familiar.

Installation

# TypeScript/JavaScript
npm install pmxtjs

# Python
pip install pmxt

Core Concepts

pmxt normalizes data into consistent objects regardless of the underlying platform:

import pmxt

# Initialize exchanges
poly = pmxt.polymarket()
kalshi = pmxt.kalshi({"apiKey": "...", "secret": "..."})

# Fetch markets — same interface, different exchanges
poly_markets = poly.fetch_markets()
kalshi_markets = kalshi.fetch_markets()

# Fetch order book — normalized format across all exchanges
book = poly.fetch_order_book("polymarket:will-trump-win-2028")
# Returns: { bids: [[price, size], ...], asks: [[price, size], ...] }

# Fetch candles — same method, any exchange
candles = kalshi.fetch_ohlcv("kalshi:INXU-26MAR28-B4500", "1h")

Key Features

• Normalized market objects: Every exchange returns the same market structure (id, symbol, base, quote, status, etc.)
• CCXT-style method names: fetch_markets(), fetch_order_book(), fetch_ohlcv(), create_order() — if you know CCXT, you know pmxt
• Best Execution Price helper: Calculates volume-weighted average prices based on current order book liquidity — critical for sizing orders in thin markets
• Data archive: Historical prediction market data available at archive.pmxt.dev for backtesting

Supported Exchanges

Strengths

1. Open-source and free — no API keys, no rate limit tiers, no vendor lock-in
2. Consistent with CCXT patterns — massive developer familiarity
3. Both Python and TypeScript — covers the two most common bot languages
4. Active development — 100+ GitHub stars, regular changelog updates
5. Best Execution Price — not just data, but execution intelligence

Limitations

1. Prediction markets only — no sportsbook data. If you need cross-market arb between prediction markets and sportsbooks, you need OddsPapi
2. Trading maturity varies — Polymarket trading is solid, other exchanges are less battle-tested
3. No hosted infrastructure — you run the library in your own code. No hosted WebSocket streams or managed API endpoints
4. Smaller community than CCXT — 100 stars vs. CCXT’s 30,000+. Fewer edge cases documented

Competitive Position: pmxt vs dr-manhattan vs predmarket

Three open-source libraries compete for the “CCXT of prediction markets” title:

pmxt leads because it stays true to the CCXT model: clean connectors, no framework opinions, no forced inheritance patterns. dr-manhattan forces you into its own Strategy base class and internal logic loops — fine for quick prototypes, but a liability when you need custom architecture.

OddsPapi: Where Prediction Markets Meet Sportsbooks

OddsPapi is the only tool that bridges the prediction market and sportsbook worlds. This is its killer feature and the reason it exists in a category by itself.

Why This Matters

Prediction markets and sportsbooks frequently price the same events differently. A Super Bowl market on Polymarket might trade at 62¢ YES while DraftKings has the equivalent at -145 (implied 59.2%). That spread is an arbitrage opportunity — but you can only see it if you have data from both worlds in the same format.

For a deep dive on exploiting these spreads, see the Cross-Market Arbitrage Guide.

Key Features

• 350+ sportsbooks — including sharps (Pinnacle, Singbet, SBOBet), mainstream (DraftKings, FanDuel, BetMGM), and crypto books
• Prediction market coverage — Polymarket and Kalshi data alongside sportsbook odds
• Unified decimal format — all odds pre-normalized to decimal, no conversion code needed
• WebSocket streaming — sub-second updates for latency-sensitive strategies
• Historical data — included in the free tier for backtesting

API Usage

import requests

API_KEY = "your-oddspapi-key"
BASE_URL = "https://api.oddspapi.io/v1"

# Fetch odds for an event across all bookmakers
resp = requests.get(
    f"{BASE_URL}/events/super-bowl-2027/odds",
    headers={"Authorization": f"Bearer {API_KEY}"},
    params={"bookmakers": "polymarket,kalshi,pinnacle,draftkings"}
)
odds = resp.json()

# Each bookmaker returns normalized decimal odds
for bookmaker in odds["bookmakers"]:
    name = bookmaker["name"]
    for market in bookmaker["markets"]:
        for outcome in market["outcomes"]:
            print(f"{name}: {outcome['name']} @ {outcome['price']}")

Pricing

Strengths

1. Unique cross-market coverage — the only API with both prediction markets AND sportsbooks
2. Pre-normalized odds — everything in decimal format, eliminating conversion bugs
3. WebSocket streaming — critical for latency-sensitive arb strategies
4. Free tier with historical data — can backtest before committing to paid plans
5. 350+ sportsbooks — far more bookmaker coverage than alternatives like The Odds API (~40 books)

Limitations

1. Read-only — OddsPapi provides odds data, not trading execution. You still need direct API integrations or pmxt to place orders
2. Commercial product — free tier is limited to 1,000 requests/month. Production use requires a paid plan
3. Sportsbook focus — prediction market coverage is secondary. Polymarket and Kalshi data may lag behind dedicated integrations
4. No open-source option — you depend on OddsPapi’s infrastructure and uptime

Data Quality: Side-by-Side

To make this comparison concrete, here’s how the same market looks through each tool.

Example market: “Will the Fed cut rates in March 2026?”

Key insight: pmxt and OddsPapi are complementary, not competing. Use pmxt for prediction market data and trading. Use OddsPapi when you need sportsbook benchmarks for cross-market analysis.

Decision Framework

Choose based on what you’re building:

“I’m building a Polymarket-only bot”

Skip all three. Use the Polymarket CLOB API directly with py_clob_client. A unified API adds unnecessary abstraction when you only need one platform.

“I’m building a multi-platform prediction market bot”

Use pmxt. It gives you normalized data and trading across Polymarket, Kalshi, and more through a familiar CCXT interface. Free, open-source, no vendor risk.

“I’m doing cross-market arbitrage (prediction markets vs sportsbooks)”

Use OddsPapi for odds data + pmxt or direct APIs for execution. OddsPapi is the only tool that gives you both worlds in one API. Use its data to find spreads, then execute via pmxt or native APIs. See the Cross-Market Arbitrage Guide for the full strategy.

“I need historical data for backtesting”

Use pmxt’s data archive (archive.pmxt.dev) for prediction market history. Use OddsPapi’s free tier for historical sportsbook odds.

“I was using Dome and need to migrate”

For Polymarket data: Switch to the native API (py_clob_client). Polymarket will integrate Dome’s improvements. For multi-platform data: Switch to pmxt. For sportsbook cross-referencing: Add OddsPapi.

Further Reading

• Prediction Market API Reference — Polymarket, Kalshi, and every endpoint documented
• Polymarket API Tutorial — Complete CLOB API developer guide
• Kalshi API Tutorial — FIX Protocol, REST, WebSocket
• Cross-Market Arbitrage — Exploiting price differences across platforms
• Build a Polymarket Trading Bot — From scanning to production deployment
• Dome Tool Entry — Overview of Dome’s capabilities