# Prediction Markets API: Polymarket, Kalshi & Manifold Odds (`t3data/prediction-markets`) Actor

Live odds from Polymarket, Kalshi and Manifold in one table: probability, bid/ask, 24h change, volume, liquidity, close date and link for every market. Search any topic or get the top markets. Official public APIs, no key. Pay per market.

- **URL**: https://apify.com/t3data/prediction-markets.md
- **Developed by:** [T3 Data](https://apify.com/t3data) (community)
- **Categories:** AI, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 markets

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Prediction Markets API: Polymarket, Kalshi & Manifold Odds

A **prediction market odds API** for **Polymarket, Kalshi and Manifold in one table**. Search any topic (an election, the Fed, bitcoin, a sports final) and get every matching market with its **implied probability**, bid/ask, 24-hour change, volume, liquidity, close date and link, normalized to the same fields across all three platforms. Or leave the search empty to get each platform's top markets. **You only pay for markets you get.**

| | |
|---|---|
| 💲 **Price** | $1.50 per 1,000 markets on Apify's Free plan, down to $0.60 on paid plans. Searches that find nothing are free. |
| ⚡ **Speed** | One search on all 3 platforms in about 5–10 seconds; 4 searches (about 200 markets) in about 30 seconds |
| 📥 **Input** | Search terms (optional), platforms, sort order, limit, minimum volume |
| 📤 **Output** | One row per market: probability, all outcomes, last price, bid/ask, 24h change, volume, liquidity, open interest, close date, tags, link |
| 🔌 **Sources** | Official public APIs of Polymarket (Gamma), Kalshi (trade API v2) and Manifold (v0). No API key, no login, no proxy. |

### What people use it for

- **Compare odds across platforms:** the same question on Polymarket, Kalshi and Manifold side by side (e.g. `"senate"`, `"fed rate"`), to spot disagreements
- **News and research:** "the market gives X a 33% chance" with a link, for articles, newsletters and dashboards
- **Trading signals and alerts:** schedule a run every hour and watch `change24h` and `volume24h` for sudden moves
- **AI agents:** give an assistant a live read on what markets expect, with sources (`url`)
- **Datasets:** collect closed and resolved markets (`includeClosed`) to study how well markets predicted outcomes

### How to use it

1. Add search terms, one per line (or leave empty for the top markets).
2. Pick platforms, a sort order (24-hour volume, total volume, liquidity or closing soonest) and how many markets per search.
3. Click **Start**, then download the results as JSON, CSV or Excel, or fetch them through the API.

### For AI agents and automations

- **One job:** live prediction-market odds for a topic. Minimal input: `{ "searchTerms": ["fed rate"] }`
- **Fast enough for a single tool call:** one search on all 3 platforms finishes in about 5–10 seconds, inside the Apify MCP server's default 30-second wait.
- **Where the results are:** dataset items (fields below). A **run summary** is in the key-value store record `OUTPUT`: `status` (`SUCCEEDED`, `PARTIAL`, `STOPPED_AT_SPEND_LIMIT`, `ABORTED`, `NO_RESULTS`, `SOURCE_UNAVAILABLE`), `results`, `errorsByCode` and a plain-English `message`.
- **Predictable billing:** pay per market returned; rows explaining an empty search are free.
- **Respects "Max cost per run":** it stops cleanly at your limit with status `STOPPED_AT_SPEND_LIMIT`, keeping everything fetched so far.
- **Graceful on abort and restarts:** partial results are kept, and a platform restart resumes without duplicates or double charges.
- **Honest failures:** if the platforms don't answer, the run fails with a clear message and you pay $0.
- Works with the **Apify MCP server** (Claude, Cursor, other agents), agentic payments, and the API.

### Input examples

Fed rate odds on all three platforms, busiest first:

```json
{ "searchTerms": ["fed rate"] }
```

Top 100 Polymarket markets by 24-hour volume:

```json
{ "platforms": ["polymarket"], "maxMarketsPerSearch": 100 }
```

Election markets with real money only, at least $100k traded, closing soonest first:

```json
{ "searchTerms": ["election"], "platforms": ["polymarket", "kalshi"], "minVolume": 100000, "sortBy": "closingSoon" }
```

### Output

A real row from a test run (2026-10-29):

```json
{
  "status": "ok",
  "search": "election",
  "rank": 2,
  "platform": "kalshi",
  "marketId": "SENATETX-26-R",
  "question": "Will Republicans win the Senate race in Texas?",
  "eventTitle": "Texas Senate winner?",
  "outcomeLabel": "Ken Paxton",
  "probability": 0.33,
  "outcomes": [
    {
      "name": "Yes",
      "probability": 0.33
    },
    {
      "name": "No",
      "probability": 0.67
    }
  ],
  "lastPrice": 0.33,
  "bestBid": 0.32,
  "bestAsk": 0.33,
  "change24h": -0.02,
  "volume": 32926844.9,
  "volume24h": 2100346.52,
  "volumeUnit": "contracts",
  "liquidity": null,
  "openInterest": 25141953.39,
  "closeTime": "2027-11-03T15:00:00.000Z",
  "isOpen": true,
  "category": [
    "Elections"
  ],
  "url": "https://kalshi.com/markets/senatetx",
  "scrapedAt": "2026-10-29T02:07:07.154Z"
}
```

| Field | Meaning |
|---|---|
| `probability` | Implied probability of **Yes**, 0–1: last traded price (Kalshi: bid/ask midpoint when nothing has traded). Empty for multi-answer Manifold markets; see `outcomes`. |
| `outcomes` | Every outcome with its probability. Multi-answer Manifold markets list each answer. |
| `eventTitle` / `outcomeLabel` | For questions split into one market per outcome (candidates, price levels): the parent question and this market's outcome |
| `change24h` | Change in the Yes price over 24 hours (Polymarket and Kalshi) |
| `volume`, `volume24h`, `volumeUnit` | **USD** on Polymarket, **contracts** on Kalshi (each pays $1 if right), **mana** on Manifold (play money) |
| `liquidity`, `openInterest` | As each platform reports them (Kalshi gives open interest, not liquidity) |
| `closeTime`, `isOpen` | When trading closes, and whether the market is still open |
| `category`, `url` | Platform tags or category, and the link to the market |
| `search`, `rank` | Which search matched, and the position after sorting |

### Cost examples

| Job | Markets | Cost (Free plan) |
|---|---|---|
| One topic on 3 platforms, 50 each | 150 | $0.23 |
| Top 100 markets on each platform | 300 | $0.45 |
| Hourly check of 5 topics × 20 markets for a month | ~72,000 | ~$108 (~$43 on Gold) |

Set **Max cost per run** to cap any run, and the actor stops cleanly at the limit.

### Integrations

- **API**: `client.actor("t3data/prediction-markets").call({ searchTerms: ["fed rate"] })` (JS), or `client.actor("t3data/prediction-markets").call(run_input={"searchTerms": ["fed rate"]})` (Python). Full snippets are on the **API** tab.
- **AI agents (MCP)**: available as a tool through the Apify MCP server.
- **Scheduling**: run it hourly or daily with Apify Schedules to track odds over time.
- **No-code**: Make, Zapier, n8n, Google Sheets, Slack and webhooks, through Apify integrations.
- **Export**: JSON, CSV, Excel, XML, HTML or RSS.

### Error codes (never charged)

| Code | Meaning |
|---|---|
| `NO_MARKETS` | No market on that platform matches every word of the search |
| `BLOCKED` | The platform kept rate-limiting or erroring after retries |
| `NETWORK_ERROR` / `PARSE_ERROR` | The platform didn't answer, or answered with something unexpected |

### FAQ

**How does search work?** Every word of your search must appear in the market's question, its parent event or its tags (case doesn't matter). `fed rate` finds "Fed rate hike in 2026?" and "Fed Decision in December?" markets about interest rates. Kalshi has no search API, so the actor reads all of Kalshi's open markets and filters them the same way.

**Why are Kalshi's auto-generated combo markets missing?** Kalshi lists thousands of multi-leg parlays (tickers starting `KXMVE`). They aren't questions anyone searches for, so they're skipped.

**Is Manifold real money?** No. Manifold uses play money (mana), so its volumes aren't comparable to Polymarket's dollars. Its odds are still a useful third opinion.

**Do I need an API key, a wallet or a proxy?** No. All three APIs are public and read-only.

**Something broke?** Open an issue on the **Issues** tab with your input. Fixes usually ship within a day.

**Found it useful?** A star rating on this page helps other people find it.

### Limits

- Odds are what each platform reports at run time and move constantly. Schedule runs to track them.
- Polymarket search goes up to about 500 events per term; Kalshi is read up to about 12,000 events per run.
- Polymarket is not available to US users and Kalshi is US-regulated; this actor only reads public data and places no trades.

### More from T3 Data

- [Google Trends API](https://apify.com/t3data/google-trends): search interest over time, by region, related queries, trending now
- [Google News Scraper](https://apify.com/t3data/google-news): articles with real publisher URLs and optional full text
- [YouTube Transcripts](https://apify.com/t3data/youtube-transcripts), [Google Ads Transparency](https://apify.com/t3data/google-ads-transparency), [Google Hotels](https://apify.com/t3data/google-hotels)

***

*This Actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by Polymarket, Kalshi or Manifold. It only reads their public APIs and places no trades. Nothing here is financial advice.*

# Actor input Schema

## `searchTerms` (type: `array`):

Topics to search, one per line (e.g. "bitcoin", "fed rate", "election"). Each term is searched on every chosen platform. Leave empty to get the top markets on each platform.

## `platforms` (type: `array`):

Which prediction markets to search. Polymarket and Kalshi trade real money; Manifold uses play money (mana).

## `maxMarketsPerSearch` (type: `integer`):

Upper limit of markets returned for each search term on each platform, after sorting.

## `sortBy` (type: `string`):

Which markets come first (and are kept when the limit cuts the list).

## `minVolume` (type: `integer`):

Skip thin markets: only keep markets with at least this total volume (USD on Polymarket, contracts on Kalshi, mana on Manifold). 0 keeps all.

## `includeClosed` (type: `boolean`):

Off: only open markets. On: closed and resolved markets too (useful for research on past questions).

## Actor input object example

```json
{
  "searchTerms": [
    "bitcoin",
    "fed rate"
  ],
  "platforms": [
    "polymarket",
    "kalshi",
    "manifold"
  ],
  "maxMarketsPerSearch": 50,
  "sortBy": "volume24h",
  "minVolume": 0,
  "includeClosed": false
}
```

# Actor output Schema

## `results` (type: `string`):

One item per market with probability, prices, volume, liquidity, close date and link, plus free error rows for searches that found nothing.

## `summary` (type: `string`):

One JSON object: status (SUCCEEDED, PARTIAL, STOPPED_AT_SPEND_LIMIT, ABORTED, NO_RESULTS, SOURCE_UNAVAILABLE), results count, failed searches by error code, and a plain-English message.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchTerms": [
        "bitcoin",
        "fed rate"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("t3data/prediction-markets").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "searchTerms": [
        "bitcoin",
        "fed rate",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("t3data/prediction-markets").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "bitcoin",
    "fed rate"
  ]
}' |
apify call t3data/prediction-markets --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,t3data/prediction-markets"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/VD8ctAtaLF5bkaSAA/builds/mvr5Z3sR81P2yjw86/openapi.json