# Polymarket & Kalshi Prediction Market Data, No Login (`cliqtomedia/prediction-markets-data`) Actor

Polymarket and Kalshi prediction markets in one table: question, outcome prices as implied probabilities, volume, liquidity, open interest, close time, status and URL, with optional price history. Search, filter or look up by ID or URL. No login or API key.

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

## Pricing

from $3.00 / 1,000 market rows

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

Get prediction market data from **Polymarket** and **Kalshi** in one table: the question, Yes/No prices as implied probabilities, volume, open interest, close time, status and a link to the market, with optional price history. No login and no API key.

Use it for research, news, dashboards or data science. The smallest run takes a few seconds: pick Polymarket, type `election`, keep 20 results, click **Start**.

![Prediction Markets Data: Polymarket and Kalshi markets in one table with odds, volume, open interest and price history. No login, no API key.](https://api.apify.com/v2/key-value-stores/6y5oJjEVU26vSC7Ro/records/README-HERO-20261014.png)

### Table of contents

- [What it does](#what-it-does)
- [What data you get](#what-data-you-get)
- [Quick start](#quick-start)
- [Input](#input)
- [Input examples](#input-examples)
- [Output](#output)
- [Pricing](#pricing)
- [Use cases](#use-cases)
- [Scheduling and monitoring](#scheduling-and-monitoring)
- [API, export and integrations](#api-export-and-integrations)
- [Use with AI agents (MCP)](#use-with-ai-agents-mcp)
- [Limits and partial results](#limits-and-partial-results)
- [Troubleshooting](#troubleshooting)
- [FAQ](#faq)
- [Support](#support)

### What it does

The Actor reads the public market data of two prediction markets:

- [Polymarket](https://polymarket.com) — public Gamma, CLOB and Data APIs ([docs](https://docs.polymarket.com)).
- [Kalshi](https://kalshi.com) — public market data API ([docs](https://docs.kalshi.com)).

It has two modes:

1. **Find markets.** Search by keywords, filter by category and by status (`open` or `closed`). You get the most traded markets first.
2. **Look up markets.** Paste market IDs, slugs, URLs or tickers. You get each market, and a clear "not found" row for each ID that does not exist.

Both platforms come back in **one schema**, so you can sort and compare them in one table.

#### Good fit

- Track the odds of elections, Fed decisions, crypto prices, sports and other events.
- Compare the same question on Polymarket and Kalshi.
- Get daily or hourly Yes-price history for charts and backtests.
- Check if a market is open, closed or resolved, and which outcome won.

#### Not a fit / limits

- No trading, no orders, no account data. This is a read-only data tool.
- No order book depth and no trade-by-trade history. You get best bid, best ask, last price and a price history.
- Not real time. You get the values at the moment of the run.
- Not betting or investment advice.

### What data you get

One row per market:

- **Question and event**: `question`, `outcomeLabel`, `eventTitle`, `category`, `tags`, `rules`.
- **Prices**: `outcomes` (Yes and No with `price` and `probability`), `lastTradePrice`, `bestBid`, `bestAsk`.
- **Activity**: `volume`, `volume24h`, `liquidity`, `openInterest`, `volumeUnit`.
- **Time and status**: `openTime`, `closeTime`, `status` (`open`, `closed`, `resolved`), `resolvedOutcome`.
- **Links and IDs**: `url`, `marketId`, `marketSlug`, `conditionId`, `eventId`, `seriesTicker`.
- **Optional history**: `priceHistory` (timestamp + Yes price) and `priceHistoryStatus`.
- **Provenance**: `source`, `sourceApiUrl`, `fetchedAt`.

### Quick start

1. Open the **Input** tab.
2. Keep the prefilled values: **Platforms** = `polymarket`, **Search** = `election`, **Max markets per platform** = `20`.
3. Click **Start**.
4. Open the **Output** tab, view **Markets**. Sort by `volume` or read `outcomes`.

Expected result: about 20 election markets with prices and volume, in a few seconds.

To get Kalshi too, add `kalshi` to **Platforms**. To look up exact markets, paste IDs or URLs into **Market IDs or URLs**.

### Input

All fields are optional. With an empty input the Actor lists 50 open markets on each platform, the most traded first.

| Field | Type | Default / prefill | Allowed values | What it does | Recommendation |
| --- | --- | --- | --- | --- | --- |
| `platforms` | array | default `["polymarket","kalshi"]`, prefill `["polymarket"]` | `polymarket`, `kalshi` | Which markets to search. | Use both to compare platforms. Ignored in lookup mode. |
| `search` | string | none, prefill `election` | up to 200 characters | Keywords. **Every word** must appear in the question, event title, outcome, category or tags. | Use 1–3 short words: `fed rate`, `bitcoin`, `super bowl`. |
| `category` | string | none | any category or tag, case-insensitive | Keeps only markets of this category. Polymarket: event tags (`Politics`, `Crypto`, `Sports`, `Economy`, …). Kalshi: series category (`Politics`, `Elections`, `Economics`, `Financials`, `Crypto`, `Climate and Weather`, `Sports`, …). | Check the `category` and `tags` of a first run, then filter. |
| `status` | string | `open` | `open`, `closed` | `open`: markets that still trade. `closed`: markets that stopped trading, including resolved ones with the winning outcome. | Use `closed` for results and backtests. |
| `marketIds` | array | none | up to 200 entries | **Lookup mode.** Polymarket market ID (`2589812`), condition ID (`0x…`), market or event slug, `polymarket.com/event/…` URL. Kalshi market, event or series ticker (`KXFEDDECISION-26OCT-H0`, `KXFEDDECISION-26OCT`, `KXFEDDECISION`) or `kalshi.com/markets/…` URL. Prefix `polymarket:` or `kalshi:` if an ID is ambiguous. | Use when you already know the markets. |
| `includePriceHistory` | boolean | `false` | `true`, `false` | Adds the Yes-price history to each market row. One extra request per market, so the run is slower. | Turn on for charts. |
| `priceHistoryDays` | integer | `30` | 1–365 | Days of history, ending now (or at close time for closed markets). 7 days or less = hourly points, more = daily points. | 30 for trends, 7 for hourly detail. |
| `maxItems` | integer | `50`, prefill `20` | 1–1000 | Maximum market rows **per platform**. Each row is one paid result. | Start small, then raise. |

#### How the settings work together

| When | Effect |
| --- | --- |
| `marketIds` is not empty | Lookup mode. `search`, `category`, `status` and `platforms` are ignored. Each ID names its own platform. `maxItems` still caps rows per platform: an event or series ID can return many markets. |
| `search` + `category` + `status` | All filters apply together. No match → `NO_RESULTS`, only the start fee is charged. |
| `search` is empty | You get the most traded open markets (or the most recently closed, with `status: closed`). |
| Both platforms, large `maxItems` + history | Each platform gets an equal share of the run time. See [Limits](#limits-and-partial-results). |
| The same market appears twice | It is saved and charged once. |

### Input examples

#### Find election markets on Polymarket (prefill)

```json
{
  "platforms": ["polymarket"],
  "search": "election",
  "maxItems": 20
}
```

Expected output: 20 election market rows. Cost: start fee + 20 market rows.

#### Kalshi economics markets with 30-day history

```json
{
  "platforms": ["kalshi"],
  "category": "Economics",
  "includePriceHistory": true,
  "priceHistoryDays": 30,
  "maxItems": 50
}
```

Expected output: up to 50 open Kalshi economics markets, each with about 30 daily Yes prices in `priceHistory`.

#### Look up exact markets on both platforms

```json
{
  "marketIds": [
    "https://polymarket.com/event/fed-decision-in-october-20260617190323537",
    "KXFEDDECISION-26OCT",
    "kalshi:KXNOPE-99ZZZ"
  ],
  "includePriceHistory": true,
  "priceHistoryDays": 90
}
```

Expected output: all markets of both Fed decision events (one per outcome), with 90 days of history, and one `not_found` row for `kalshi:KXNOPE-99ZZZ`.

#### Resolved markets for a backtest

```json
{
  "platforms": ["polymarket", "kalshi"],
  "search": "fed",
  "status": "closed",
  "maxItems": 100
}
```

Expected output: closed and resolved Fed markets with `resolvedOutcome`.

### Output

The default Dataset has three views. Views choose columns, they do not filter rows: every view lists all rows of the run.

- **Markets** — market columns. Lookup-status rows (if any) show here with empty market cells.
- **Price history** — market ID, question and the `priceHistory` list.
- **Not found / invalid IDs** — identifier, platform and status columns. Look at rows with `recordType: "lookup-status"`; market rows show here too. To get only one kind, filter the Dataset by `recordType`.

#### Output example (Polymarket market, lookup with history, trimmed)

```json
{
  "recordType": "market",
  "platform": "polymarket",
  "marketId": "2589812",
  "marketSlug": "will-there-be-no-change-in-fed-interest-rates-after-the-october-2026-meeting-20260617190324031",
  "conditionId": "0xdf9bf27ee5757c55b44b8b9826ddc9ec3a8809aa3278634c45edbb7fc8f1a3e3",
  "eventId": "606422",
  "eventTitle": "Fed Decision in October?",
  "seriesTicker": null,
  "question": "Will there be no change in Fed interest rates after the October 2026 meeting?",
  "outcomeLabel": "No change",
  "category": "Economy",
  "tags": ["Fed", "fomc", "Economy", "Fed Rates"],
  "outcomes": [
    { "name": "Yes", "price": 0.795, "probability": 0.795 },
    { "name": "No", "price": 0.205, "probability": 0.205 }
  ],
  "lastTradePrice": 0.8,
  "bestBid": 0.79,
  "bestAsk": 0.8,
  "volume": 9190598.64,
  "volume24h": 461867.16,
  "liquidity": 424329.6,
  "openInterest": 3340859.05,
  "volumeUnit": "USD",
  "openTime": "2026-06-18T00:02:51.727Z",
  "closeTime": "2026-10-29T03:59:00.000Z",
  "status": "open",
  "sourceStatus": "active",
  "resolvedOutcome": null,
  "rules": "The FED interest rates are defined in this market by the upper bound of the target federal funds range. …",
  "url": "https://polymarket.com/event/fed-decision-in-october-20260617190323537/will-there-be-no-change-in-fed-interest-rates-after-the-october-2026-meeting-20260617190324031",
  "priceHistoryStatus": "complete",
  "priceHistory": [
    { "timestamp": "2026-07-16T00:00:04.000Z", "price": 0.66 },
    { "timestamp": "2026-07-17T00:00:06.000Z", "price": 0.68 }
  ],
  "source": "Polymarket Gamma, CLOB and Data public APIs",
  "sourceApiUrl": "https://gamma-api.polymarket.com/events?slug=fed-decision-in-october-20260617190323537",
  "fetchedAt": "2026-10-13T18:20:02.515Z"
}
```

The same run returned this Kalshi row (trimmed):

```json
{
  "recordType": "market",
  "platform": "kalshi",
  "marketId": "KXFEDDECISION-26OCT-H0",
  "eventId": "KXFEDDECISION-26OCT",
  "eventTitle": "Fed decision in Oct 2026?",
  "seriesTicker": "KXFEDDECISION",
  "question": "Will the Federal Reserve Hike rates by 0bps at their October 2026 meeting?",
  "outcomeLabel": "Fed maintains rate",
  "category": "Economics",
  "outcomes": [
    { "name": "Yes", "price": 0.81, "probability": 0.81 },
    { "name": "No", "price": 0.19, "probability": 0.19 }
  ],
  "lastTradePrice": 0.81,
  "bestBid": 0.81,
  "bestAsk": 0.82,
  "volume": 4131219.6,
  "liquidity": null,
  "openInterest": 1571499.2,
  "volumeUnit": "contracts",
  "status": "open",
  "url": "https://kalshi.com/markets/kxfeddecision/kxfeddecision-26oct"
}
```

A not-found lookup row:

```json
{
  "recordType": "lookup-status",
  "status": "not_found",
  "statusReason": "No Polymarket market or event matches these identifiers",
  "errorCode": null,
  "queryIds": ["999999999999"],
  "fetchedAt": "2026-10-13T18:20:03.528Z"
}
```

#### Output fields

| Field | Type | Can be null? | Example | Meaning |
| --- | --- | --- | --- | --- |
| `recordType` | string | no | `market` | `market` or `lookup-status`. |
| `platform` | string | no (market rows) | `kalshi` | `polymarket` or `kalshi`. |
| `marketId` | string | no (market rows) | `KXFEDDECISION-26OCT-H0` | Polymarket market ID or Kalshi market ticker. |
| `marketSlug` | string | yes | `will-there-be-…` | Polymarket slug. Null for Kalshi. |
| `conditionId` | string | yes | `0xdf9b…` | Polymarket condition ID. Null for Kalshi. |
| `eventId` | string | yes | `KXFEDDECISION-26OCT` | Event ID (Polymarket) or event ticker (Kalshi). |
| `eventTitle` | string | yes | `Fed decision in Oct 2026?` | Title of the event that groups the markets. |
| `seriesTicker` | string | yes | `KXFEDDECISION` | Kalshi series ticker. Null for Polymarket. |
| `question` | string | no | `Will the Federal Reserve …?` | The market question. |
| `outcomeLabel` | string | yes | `No change` | Short name of this market inside its event. |
| `category` | string | yes | `Economics` | Polymarket: main event category. Kalshi: event category. |
| `tags` | array | no (may be empty) | `["Fed","Economy"]` | Polymarket event tags. Empty for Kalshi. |
| `outcomes` | array | no | `[{"name":"Yes","price":0.81,"probability":0.81}, …]` | Outcome names with price (0–1). `probability` = price, the crowd-implied chance. `price` is null when there is no price. |
| `lastTradePrice` | number | yes | `0.81` | Last traded Yes price. |
| `bestBid` | number | yes | `0.79` | Best Yes bid. Null when there is no bid. |
| `bestAsk` | number | yes | `0.8` | Best Yes ask. Null when there is no ask. |
| `volume` | number | yes | `9190598.64` | Total traded volume, in `volumeUnit`. |
| `volume24h` | number | yes | `461867.16` | Volume in the last 24 hours. |
| `liquidity` | number | yes | `424329.6` | Polymarket order book liquidity in USD. Null for Kalshi. |
| `openInterest` | number | yes | `1571499.2` | Open interest. Polymarket: USD. Kalshi: contracts. Null when the source does not return it. |
| `volumeUnit` | string | no | `USD` | `USD` (Polymarket) or `contracts` (Kalshi, $1 payout each). |
| `openTime` | string | yes | `2026-06-18T00:02:51.727Z` | When trading started (ISO 8601, UTC). |
| `closeTime` | string | yes | `2026-10-29T03:59:00.000Z` | Planned end of trading. A Polymarket market can resolve early; then this date can still be in the future. |
| `status` | string | no | `open` | `open`, `closed` or `resolved`. |
| `sourceStatus` | string | yes | `active` | The raw status from the platform. |
| `resolvedOutcome` | string | yes | `Yes` | Winning outcome for resolved markets. Null otherwise. |
| `rules` | string | yes | `If the Federal Reserve …` | Resolution rules, up to 2,000 characters. |
| `url` | string | yes (rare) | `https://kalshi.com/markets/…` | Link to the market. Kalshi links go to the event page (Kalshi has no page per market). |
| `priceHistoryStatus` | string | no | `complete` | `complete`, `empty` (no trades in the period), `unavailable` (no history source for this market), `error`, or `not_requested` when history is off. |
| `priceHistory` | array | yes | `[{"timestamp":"…","price":0.66}]` | Yes price over time. Null when history is off. Days without trades can be missing. |
| `status` / `statusReason` / `errorCode` / `queryIds` | — | — | `not_found` | Lookup-status rows only: `not_found` or `invalid`, a plain reason, and the IDs you sent. |
| `source` | string | no | `Kalshi public market data API` | Where the row comes from. |
| `sourceApiUrl` | string | no | `https://api.elections.kalshi.com/…` | The public API URL used. |
| `fetchedAt` | string | no | `2026-10-13T18:20:03.824Z` | When the row was read. |

**How the Yes price is set.** Polymarket: the outcome price that Polymarket itself shows (in most markets the middle of best bid and best ask). Kalshi: the last trade price; the middle of bid and ask when there was no trade. A price is never invented: no data → `null`, not `0`.

#### Run summary

Each run also saves `RUN_SUMMARY` in the default Key-value store: `status`, `reason`, `message`, counts per platform, charged rows, warnings and source links. The run status message shows the same short result, for example `COMPLETE: 20 market row(s).`

| `status` | Meaning |
| --- | --- |
| `COMPLETE` | Rows saved, no problem. Not-found IDs, if any, are listed in the message. |
| `NO_RESULTS` | The search ran, but no market matches. Not an error. |
| `NOT_FOUND` | Lookup mode: none of the IDs exist. |
| `INVALID_INPUT` | No ID could be read. Fix the input. |
| `PARTIAL` | Some data is missing. `reason` is `SOURCE_ERROR` (a platform failed) or `PRICE_HISTORY_ERROR` (history failed for some markets). |
| `CAPPED` | The run stopped early: `CHARGE_LIMIT` (your max charge), `DEADLINE` (internal time limit) or `REQUEST_CAP`. Saved rows are kept. |
| `ERROR` | A platform failed before any row was saved, or a technical error. |
| `CANCELLED` | You stopped the run. Saved rows are kept. |

### Pricing

Pay per event. You pay only for saved markets, plus a small start fee.

| Event | Price | When |
| --- | ---: | --- |
| Actor start | $0.007 | Once per run (one event per GB of memory, minimum one; the Actor runs at 256 MB, so one event). |
| Market row | $0.0035 (Free plan), $0.0033 (Bronze), $0.0031 (Silver), $0.003 (Gold and higher) | Each saved market row. Price history for that market is included. |
| Market ID not found | $0.0003 | Each lookup ID the platform does not know. |

Invalid IDs (not a Polymarket or Kalshi ID) have no row charge. The Actor start fee is charged on every run, also when all IDs are invalid (`INVALID_INPUT`). The platform usage (compute) is included in these prices.

#### Cost examples (Free plan prices)

| Scenario | Rows | Cost |
| --- | ---: | ---: |
| Prefill: 20 election markets | 20 | $0.077 |
| 10 markets | 10 | $0.042 |
| 100 markets with 30-day history | 100 | $0.357 |
| 1,000 markets on one platform | 1,000 | $3.507 |
| 1,000 + 1,000 markets on both platforms | 2,000 | $7.007 |
| Search with no match | 0 | $0.007 |
| Lookup of 10 IDs that do not exist | 0 (10 not found) | $0.010 |

To keep a hard budget, set **Max total charge** in the run options. The Actor stops before the next paid row and keeps what it saved (`CAPPED`, `CHARGE_LIMIT`).

A failed or partial run charges only the start fee and the rows that were really saved.

### Use cases

| Job | Input | Key fields | Next step |
| --- | --- | --- | --- |
| Election and policy research | `search: "election"`, both platforms | `question`, `outcomes`, `volume`, `closeTime` | Export to a sheet, compare platforms |
| Macro tracking (Fed, CPI, recession) | `category: "Economics"` or `search: "fed"` | `outcomes`, `openInterest`, `priceHistory` | Chart odds over time |
| Newsroom: "what do markets say?" | `marketIds` of the markets you cite | `outcomes`, `url`, `fetchedAt` | Quote the price with time and link |
| Backtest or data science | `status: "closed"`, `includePriceHistory: true` | `resolvedOutcome`, `priceHistory` | Load the JSON or CSV into Python |
| Crypto event odds | `search: "bitcoin"` | `outcomes`, `volume24h` | Join with your price data |

### Scheduling and monitoring

Add a **Schedule** in Apify Console (for example, every hour) with a `marketIds` list or a search. Each run saves a fresh snapshot with `fetchedAt`, so you can build a time series of odds. The Actor does not compare runs; every run returns the current values.

### API, export and integrations

- **Export:** JSON, CSV, Excel, XML or HTML from the **Output** tab or the Dataset API.
- **API:** start runs and read the Dataset with the [Apify API](https://docs.apify.com/api/v2) or the JavaScript and Python clients.
- **No-code:** connect the Dataset to Make, Zapier, n8n or Google Sheets through Apify integrations.

### Use with AI agents (MCP)

- MCP server with only this Actor: `https://mcp.apify.com?tools=cliqtomedia/prediction-markets-data`
- Smallest useful input: `{"platforms": ["polymarket"], "search": "election", "maxItems": 20}`
- Key output fields: `question` (what the market asks), `outcomes[].probability` (crowd-implied chance, 0–1), `volume` (traded amount in `volumeUnit`), `status` (`open`, `closed`, `resolved`), `url` (market page).
- Typical run: 3–10 seconds and under $0.10 for 20 markets. With history, about 400 markets per platform fit in one run.
- Market prices are crowd-implied probabilities from public market data, not forecasts or advice.

### Limits and partial results

- **Max rows:** `maxItems` is per platform, up to 1,000. Without history, 1,000 markets per platform (2,000 per run) were tested. With history, about 400 markets per platform fit in one run.
- **Memory:** 256 MB (default and maximum). More memory does not make the run faster; the time goes to waiting for the platforms.
- **Time limit:** source work stops after about 4 minutes. Each platform gets an equal share of the time. If a platform reaches its share, the run ends `CAPPED` with `reason: DEADLINE`; rows saved so far are kept, and you pay only for them. Split big jobs into smaller runs.
- **Search:** every search word must be in the market text: question, event title, outcome label, category, tags, slug, market/event ID or Kalshi series ticker. Words match as parts of words, so a short word like `us` also matches `bonus`; use longer words. The platforms' own search is fuzzy, so the Actor removes loose matches. Very general words can match fewer markets than you expect.
- **Kalshi category:** the `category` filter uses the Kalshi series category, but the row shows the event category. So a `Politics` filter can return rows with `category: "Elections"`.
- **Kalshi URL:** links go to the event page. Kalshi has no page for a single market.
- **Open interest:** can be `null` if the Polymarket Data API does not return it for a market. A warning in `RUN_SUMMARY` names how many markets are affected.
- **Price history:** best effort. If history fails for some markets, the run is `PARTIAL` with `reason: PRICE_HISTORY_ERROR`, and those rows have `priceHistoryStatus: "error"`. Days without trades are missing from the list.
- **Platform failure:** if one platform fails after some rows were saved, the run is `FAILED` in Apify, `RUN_SUMMARY.status` is `PARTIAL` with `reason: SOURCE_ERROR`, and the saved rows stay in the Dataset.
- **Terms:** data comes from public, read-only APIs. Check the [Polymarket terms](https://polymarket.com/tos) and [Kalshi terms](https://kalshi.com/docs/kalshi-terms-of-service) before commercial reuse.

### Troubleshooting

#### The run returned no markets

Symptom: `RUN_SUMMARY.status` is `NO_RESULTS`.
Likely reason: no market has all your search words, or the category name does not match.
Action: use fewer words, remove `category`, or try `status: "closed"`.

#### A Kalshi ID was not found

Symptom: a row with `status: "not_found"`.
Likely reason: a typo, or a Polymarket-like ID was read as Kalshi.
Action: copy the ticker from the Kalshi URL, or add the prefix `kalshi:` or `polymarket:`.

#### The run stopped with CAPPED

Symptom: `RUN_SUMMARY.status` is `CAPPED`.
Likely reason: your max charge (`CHARGE_LIMIT`) or the internal time limit (`DEADLINE`).
Action: raise the max charge, lower `maxItems`, turn off history, or run one platform at a time.

#### The run FAILED with PARTIAL

Symptom: Apify shows `FAILED`, `RUN_SUMMARY.status` is `PARTIAL`, `reason: SOURCE_ERROR`.
Likely reason: Polymarket or Kalshi was down or limited requests.
Action: run again in a few minutes. You paid only for saved rows and the start fee.

### FAQ

#### Do I need a Polymarket or Kalshi account or API key?

No. The Actor uses only public market data. No login, no API key.

#### Is the data real time?

No. You get the values at the moment of the run (`fetchedAt`). Prices on both platforms can change every second.

#### Why is a price null and not 0?

`null` means the platform has no price (no trade and no quote). The Actor never turns missing data into `0`.

#### Why do Polymarket and Kalshi show different numbers for the same event?

They are different markets with different traders. Volume units also differ: Polymarket uses USD, Kalshi uses contracts.

#### Is this betting or investment advice?

No. This is a data export tool. Prices are crowd-implied probabilities copied from public data, not forecasts or buy and sell signals.

### Support

For bugs, questions or feature requests, use the **Issues** tab of this Actor. Include the run ID, your input and the error text. Never send API tokens, passwords or account data.

# Changelog

This Actor's version history is a separate document: https://apify.com/cliqtomedia/prediction-markets-data/changelog.md

# Actor input Schema

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

Which prediction markets to search: polymarket, kalshi or both. Default: both. Ignored when Market IDs or URLs are given (each identifier names its own platform).

## `search` (type: `string`):

Keywords such as election, fed rate, bitcoin or super bowl. Every word must appear in the market question, event title, outcome or tags. Leave empty to list the most traded markets. Up to 200 characters.

## `category` (type: `string`):

Optional category or tag, e.g. Politics, Economics, Crypto, Sports, Elections. Polymarket matches event tags; Kalshi matches its series category (Politics, Elections, Economics, Financials, Crypto, Climate and Weather, Sports, ...). Case-insensitive.

## `status` (type: `string`):

open (default): markets that still trade. closed: markets that stopped trading, including resolved ones with their outcome.

## `marketIds` (type: `array`):

Look up specific markets instead of searching. Up to 200 entries: Polymarket market ID (561229), condition ID (0x…), market or event slug, or polymarket.com/event/… URL; Kalshi market, event or series ticker (KXFEDDECISION-26OCT-H0, KXFEDDECISION-26OCT, KXFEDDECISION) or kalshi.com/markets/… URL. Prefix with polymarket: or kalshi: if unsure. An event or series returns all its markets (up to Max markets per platform). Unknown IDs are reported in one not-found row.

## `includePriceHistory` (type: `boolean`):

Add the Yes-price history of each market (hourly for 7 days or less, otherwise daily). One extra request per market, so runs are slower. Default false.

## `priceHistoryDays` (type: `integer`):

How many days of history, ending now (or at the close time for closed markets). 1–365, default 30.

## `maxItems` (type: `integer`):

Maximum market rows per platform, 1–1000. Default 50. Each market row is one paid result.

## Actor input object example

```json
{
  "platforms": [
    "polymarket"
  ],
  "search": "election",
  "status": "open",
  "includePriceHistory": false,
  "priceHistoryDays": 30,
  "maxItems": 20
}
```

# Actor output Schema

## `markets` (type: `string`):

Market rows as a table.

## `priceHistory` (type: `string`):

Price history per market.

## `runSummary` (type: `string`):

Status, counts per platform, charged rows, sources and request statistics.

# 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 = {
    "platforms": [
        "polymarket"
    ],
    "search": "election",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("cliqtomedia/prediction-markets-data").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 = {
    "platforms": ["polymarket"],
    "search": "election",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("cliqtomedia/prediction-markets-data").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 '{
  "platforms": [
    "polymarket"
  ],
  "search": "election",
  "maxItems": 20
}' |
apify call cliqtomedia/prediction-markets-data --silent --output-dataset

```

## MCP server setup

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

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/06e41lRSYwvkYOIOm/builds/yQNWz1V1yNRAQDP8N/openapi.json