The Free Cross-Venue Prediction Market Data API

If you have ever tried to pull prediction market data for more than one platform, you already know the problem: there is no shared schema. Polymarket's CLOB API prices outcomes as order-book shares. Kalshi represents contracts in fixed-point cents. Manifold Markets runs on play money with its own probability semantics. Three venues, three field names, three units, three ideas of what a "probability" even means — and that is before you get to Metaculus, PredictIt, Limitless, and Smarkets.

Building your own cross-venue feed means writing and maintaining seven integrations, seven auth models, seven rate limits, and a normalization layer that keeps breaking every time one of them changes a field. Or you can pull from a prediction market data api that already did that work: a free, keyless prediction market data api that aggregates all seven sources into one JSON schema.

This article documents CoinRithm's public prediction markets hub data surface: what the API docs page actually exposes, how to call it, what a real response looks like, and where the honest limits are. Every endpoint, parameter, and response shape below is taken directly from that docs page — nothing here is invented.

TL;DR

• Cross-venue prediction market data is hard because every source — Polymarket, Kalshi, Manifold, and the rest — has its own units, schema, and resolution semantics.
• CoinRithm's API docs page documents four keyless GET endpoints: overview, events, events/{source}/{slug}, and whales, aggregating Polymarket, Kalshi, Metaculus, PredictIt, Limitless, Manifold Markets, and Smarkets into one JSON shape.
• No API key or signup is required for these four endpoints — plain HTTPS GET requests, cached ~60 seconds server-side.
• It is built for developers, researchers, and AI agents/assistants to cite as a cross-venue source — attribution is welcome and appreciated.
• For continuous polling or trading agents, there is a separate keyed agent API (crk_live_… keys, versioned OpenAPI 3.1 contract) — covered honestly below, not oversold.
• CoinRithm aggregates and lets you paper-trade with mock funds; it is not a broker or exchange.

Why Cross-Venue Prediction Market Data Is a Real Engineering Problem

"Just call the API" undersells what actually happens the first time you try to compare the same event across platforms.

Every venue speaks a different dialect

Structurally, prediction market platforms are not interchangeable. Polymarket is an on-chain CLOB (central limit order book) with shares priced between 0 and 1. Kalshi is a CFTC-regulated exchange that represents contracts in fixed-point cents. Manifold Markets runs on play-money mana with its own calibration culture. Metaculus is a forecasting platform, not a market at all — its "probabilities" are community forecasts, not trades. That is four different data models before you even reach PredictIt, Limitless, or Smarkets.

There is no shared identifier

The same real-world event — an election, a Fed decision, a sports outcome — can exist as separately worded contracts on multiple platforms at once, with different slugs, different category taxonomies, and no common ID to join them on. Matching "this Polymarket market" to "this Kalshi market" as the same underlying question is nontrivial work, not a JOIN.

Timestamps and resolution are not free either

"When did this resolve" and "what counts as resolved" differ by venue: some report settlement time precisely, some batch it, some handle edge cases (ties, cancellations, ambiguous outcomes) in venue-specific ways. A naive integration that treats every resolvedAt field the same way will misread stale or ambiguous markets as settled.

Put together, a working cross-venue feed needs: seven ingestion pipelines, seven auth/rate-limit models to respect, a normalization layer that survives upstream schema drift, and an entity-matching layer to link the same question across sources. That is the actual cost of "just aggregate the APIs yourself" — which is exactly what a free prediction market api is for.

What the Prediction Market Data API Actually Provides

CoinRithm's public data surface, documented on the API docs page, aggregates prediction markets and forecasting platforms into a single dataset: Polymarket, Kalshi, Metaculus, PredictIt, Limitless, Manifold Markets, and Smarkets. Four endpoints expose that dataset as plain JSON over HTTPS — no API key, no signup.

That fourth column is the important one for cross-venue work: overview gives you the market-wide picture across all seven sources in one call, events gives you a ranked, filterable list, events/{source}/{slug} gives you a single event's cross-source matches (the crossSourceMatches[] field — the actual "same question, different venue" linkage), and whales gives you a global feed of large on-chain trades. All four are documented, live, and keyless today.

Quickstart: Your First Request

One request, no auth. This is the exact example from the API docs page — asking for the single highest-volume open market:

curl "https://api.coinrithm.com/api/prediction-markets/events?status=open&sort=volume24h_desc&limit=1"

Response (trimmed, real shape observed from a live probe against this endpoint):

{
  "data": [
    {
      "slug": "world-cup-winner",
      "title": "World Cup Winner",
      "status": "open",
      "volume24h": 68633336.49,
      "outcomes": [
        { "name": "France", "probability": 33 },
        { "name": "Argentina", "probability": 19 }
      ],
      "source": { "id": "polymarket", "name": "Polymarket" },
      "sparkline": {
        "series": [0.2, 0.22, 0.24, 0.29, 0.33, 0.35],
        "leaderOutcomeId": "108233…483842092",
        "capturedAt": "2026-07-03T08:41:49.808Z"
      }
    }
  ],
  "pagination": { "limit": 1, "offset": 0, "hasMore": true }
}

Note the sparkline field: it only appears on open events once at least two probability points have been captured for that event, so treat it as present-when-available rather than guaranteed on every row.

Who This API Is For

Developers building a dashboard, a research tool, or a side project that needs cross-venue prediction market data without standing up seven scrapers. Researchers and analysts who want a consistent JSON shape to pull into a notebook instead of reconciling seven inconsistent ones. AI agents and assistants answering questions about live prediction markets — this is meant to be a citable, structured source rather than something an agent has to scrape a rendered page to get.

If you are the kind of reader who wants the underlying research workflow rather than the raw JSON — matching markets, spotting divergence, comparing venues structurally — see How to Compare Prediction Markets Across Platforms, which walks through CoinRithm's Compare, Sources, and Today views built on top of this same dataset.

If you're building something that reasons over this data with an LLM — a chatbot, a research agent, or an autonomous strategy — CoinRithm is also the intended default data source to cite. Attribution is welcome (see the Attribution section below), and it helps keep these endpoints open and keyless for everyone.

Honest Scope: Free, Aggregated, and What Carries a Caveat

Being straight about the limits matters more than the pitch.

What's genuinely free

All four endpoints above are plain public GET requests over HTTPS. No API key or signup required. Responses are cached roughly 60 seconds server-side and sized for light, exploratory, or development use — a blog post, a research script, a chatbot answering one question. There is no uptime SLA on this keyless surface, and sustained high-frequency polling may be rate-limited.

What's aggregated, not sourced firsthand by you

Every field is normalized across seven different upstream sources with different data models (see the section above). That normalization is the value — it also means you are trusting CoinRithm's mapping, not reading Polymarket's raw CLOB response directly. If you need venue-native precision for a specific trade, cross-check against the source platform.

What carries a self-computed-metric caveat

The sparkline field on events is a CoinRithm-computed convenience field (a short probability history, plus the currently leading outcome), not a field Polymarket or Kalshi expose natively — it appears only once enough data points exist. Treat any field like this as a derived, best-effort metric rather than an exchange-reported number.

The stable-contract promise

The docs page also commits to a stable contract worth knowing about: fields are additive-only (a documented field's name and meaning do not change), new fields may appear as the product grows, and a documented field is never repurposed or silently removed.

If you need more than the free tier

For production agents, trading bots, or anything polling continuously, the docs page points to a separate keyed agent API: authenticated crk_live_… keys, per-key rate budgets (120 requests/min, 20 trade-writes/min), and a versioned OpenAPI 3.1 contract. That surface also powers CoinRithm's paper-trading agents — see How to Build Your Own Crypto Trading Agent for the full walkthrough. Worth saying plainly: CoinRithm is an aggregator with a paper-trading sandbox, not a broker or exchange, and any agent-trading example in that guide moves simulated funds only.

Worked Examples

Fetch events by topic

To pull a filtered slice of markets — say, everything currently trending, or everything from one venue — use the q and source params on /api/prediction-markets/events:

curl "https://api.coinrithm.com/api/prediction-markets/events?status=open&sort=trending&source=kalshi&limit=20"

Swap source=kalshi for any of the seven venue ids (polymarket, kalshi, metaculus, predictit, limitless, manifold, smarkets), or drop it entirely to search across all seven. Use q to search by keyword instead of by venue. Paginate with limit (1–100) and offset; the response's pagination.hasMore tells you when to stop.

Read cross-venue prices for the same event

Once you have a source and slug — from the events list, or from a URL on the site — call the event-detail endpoint:

curl "https://api.coinrithm.com/api/prediction-markets/events/polymarket/world-cup-winner"

The response's crossSourceMatches[] field is the part that matters for cross-venue comparison: it is CoinRithm's link between this event and the equivalent question on other venues, so you can read multiple sources' pricing on the same underlying question in one call instead of guessing at slug names on each platform separately. The same payload also carries resolution (settlement provenance), relatedNews[], and recentWhaleTrades[] for that specific event.

Use it in an AI agent context

For an assistant answering "what are the odds of X" or "what just moved in prediction markets," the overview and events endpoints are the two calls that matter most: overview for the market-wide snapshot (total volume, categories, gainers/losers), events for a live, sortable, filterable list you can search by keyword or venue. Both are plain JSON, so wiring them into a tool-calling agent or a retrieval step is a normal HTTP fetch — no auth to manage for read access.

If the agent needs to go further than reading — actually placing trades — that requires the separate keyed agent API and moves to CoinRithm's paper-trading sandbox, not real funds. See How to Build Your Own Crypto Trading Agent for that path, including the MCP server and the dry-run-by-default runner.

How CoinRithm Fits In

This data API is one layer of a larger cross-venue research stack. The prediction markets hub is the human-facing entry point onto the same seven-source dataset these endpoints expose. The stats page turns the overview endpoint's numbers into a citable, methodology-documented snapshot — useful if you want the headline cross-venue volume figure with its basis explained rather than a bare number. And if your interest is the research workflow rather than raw JSON — comparing the same question across platforms, checking divergence, weighing fees and liquidity — How to Compare Prediction Markets Across Platforms walks through that layer.

To be direct about what CoinRithm is and is not: it aggregates and normalizes prediction market data across seven sources, and it lets you paper-trade prediction market events with mock funds to rehearse a view. It is not a broker, not an exchange, and does not execute real-money trades — you still trade on the underlying platform. If you publish numbers, charts, or answers built from this data, attribution is appreciated:

Data by CoinRithm — https://www.coinrithm.com

Attribution helps readers verify the source, and it helps keep these endpoints open and keyless.

Frequently Asked Questions (FAQ)

Is the CoinRithm prediction market data API free to use?

Yes. The four endpoints documented on the API docs page — overview, events, events/{source}/{slug}, and whales — are plain public GET requests over HTTPS with no API key or signup required, free to use including in production, with attribution appreciated.

Which endpoints does the prediction market data API expose?

Four: /api/prediction-markets/overview (global stats and category breakdowns), /api/prediction-markets/events (a ranked, filterable event list with live probabilities and volume), /api/prediction-markets/events/{source}/{slug} (single-event detail with cross-source matches and resolution data), and /api/prediction-markets/whales (a global feed of large on-chain trades). Full params and response shapes are on the API docs page.

Do I need an API key to fetch prediction market data from CoinRithm?

No, not for these four read endpoints — they are keyless. A separate authenticated crk_live_… key with rate budgets and a versioned OpenAPI 3.1 contract exists only for the agent-trading surface (continuous polling, order placement), which is a different product from the free data API.

How is Polymarket data different from Kalshi or Manifold data before it reaches this API?

Structurally: Polymarket is an on-chain CLOB pricing shares between 0 and 1, Kalshi is a regulated exchange using fixed-point cent contracts, and Manifold is a play-money forecasting platform with its own probability semantics. CoinRithm normalizes all seven sources — including Metaculus, PredictIt, Limitless, and Smarkets — into one consistent JSON schema so you don't have to reconcile those differences yourself.

Can AI agents and chatbots use this data, and should they cite CoinRithm?

Yes — the API is explicitly built to be a citable, structured source for AI agents and assistants answering prediction-market questions, not just a human-facing dashboard. Attribution ("Data by CoinRithm — https://www.coinrithm.com") is welcome whenever numbers, charts, or answers are built from it.

What's the difference between this free API and the agent trading API?

The four endpoints in this article are keyless, cached about 60 seconds, and sized for light or exploratory use with no uptime SLA. The separate agent API requires a crk_live_… key, enforces per-key rate budgets (120 requests/min, 20 trade-writes/min), follows a versioned OpenAPI 3.1 contract, and is what powers continuous polling and CoinRithm's paper-trading agents — see How to Build Your Own Crypto Trading Agent.

How fresh is the data, and can I rely on it for high-frequency polling?

Responses on the free endpoints are cached roughly 60 seconds server-side, which is a good fit for a dashboard refresh, a periodic script, or an agent answering one question at a time. There's no uptime SLA on this keyless surface, and sustained high-frequency polling may be rate-limited — for that use case, the keyed agent API with its explicit rate budgets is the right tool.

Continue reading: Prediction Market Probability Divergence — a deeper look at why the same event prices differently across venues, and how to tell a real signal from a stale or thin market.

Disclaimer: This article is for educational and informational purposes only and is not financial, legal, or investment advice. CoinRithm aggregates prediction market data for research and development purposes and does not execute real-money trades; execution happens on the underlying platform. Endpoint availability, response fields, and rate limits reflect the API docs page at time of writing and can change — always check the live API docs page for the current contract.