# Prediction Markets API - Polymarket, Kalshi, Manifold Odds (`lost.fany/polymarket-kalshi-prediction-markets`) Actor

Live prediction market odds from Polymarket, Kalshi and Manifold in one dataset: question, probabilities, volume, liquidity and close date, cross-linked across platforms. dryRun prices a run before you pay; charged only for markets delivered.

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

## Pricing

from $1.60 / 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

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

Get **live prediction markets from Polymarket, Kalshi and Manifold in one dataset**: the question, current probabilities for every outcome, 24-hour and total volume, liquidity, close date, a unified category and the link to the market. Filter by keywords, category, volume, liquidity or closing date; the same question listed on several platforms is cross-linked so you can compare odds side by side.

The Actor reads only the platforms' **public read-only APIs** — no API keys, no wallets, no scraping, no proxies. It never places trades.

### What you can do with it

- **Odds dashboards and newsletters** — "what does the market think about the Fed, the election, Bitcoin, this weekend's games" refreshed hourly.
- **Cross-platform comparison** — the `alsoOn` field lists the same question on other platforms with its probability there; spot gaps between Polymarket, Kalshi and Manifold.
- **Event research** — pull every market closing this week in a category, or every market mentioning a company, country or person.
- **Data for AI agents** — expose forecasts to an agent through the Apify MCP server ("what is the probability of X according to prediction markets?").
- **Monitoring** — schedule runs and push changes to Slack, Sheets or a database with Apify integrations.

### Platforms

| Platform | Currency | Coverage | Notes |
|---|---|---|---|
| [Polymarket](https://polymarket.com) | USD | Events with nested markets, tags, 24h volume, order-book best bid/ask | Sorted by 24h volume |
| [Kalshi](https://kalshi.com) | USD | Regulated US exchange: politics, economics, weather, sports, culture | Category from Kalshi itself; combo/provisional markets skipped |
| [Manifold](https://manifold.markets) | MANA (play money) | Community markets on anything, thousands of questions | Volume and liquidity are in MANA, not dollars |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `keywords` | array | `[]` | Whole-word match in question, event title, tags and outcome names. Empty = everything. |
| `excludeKeywords` | array | `[]` | Drop markets containing any of these. |
| `category` | select | `all` | `politics`, `crypto`, `sports`, `weather`, `economics`, `science-tech`, `culture`, `other`. |
| `platforms` | array | all three | Any of `polymarket`, `kalshi`, `manifold`. |
| `minVolume` / `minLiquidity` | number | `0` | Skip thin markets. |
| `closesWithinDays` | number | — | Only markets resolving within N days. |
| `sortBy` | select | `volume24h` | `volume24h`, `volume`, `liquidity`, `closesAt`, `probability`. |
| `maxItems` | number | `500` | Cap after filtering; platforms are interleaved fairly at the cap. |
| `includeClosed` | boolean | `false` | Include closed/resolved markets. |
| `includeDescription` | boolean | `false` | Add resolution rules / description text. |

Example — hottest crypto markets closing this month, at least $10k volume:

```json
{ "category": "crypto", "closesWithinDays": 30, "minVolume": 10000, "sortBy": "volume24h", "maxItems": 200 }
```

### Output

```json
{
  "id": "polymarket:4434785",
  "platform": "polymarket",
  "platformName": "Polymarket",
  "title": "Will the Fed cut rates in September?",
  "event": "Fed decision in September?",
  "url": "https://polymarket.com/event/fed-decision-in-september",
  "marketType": "binary",
  "outcomes": [{ "name": "Yes", "probability": 0.81 }, { "name": "No", "probability": 0.19 }],
  "probability": 0.81,
  "lastPrice": 0.81,
  "bestBid": 0.8,
  "bestAsk": 0.82,
  "volume": 2203656.01,
  "volume24h": 50231.4,
  "liquidity": 33603.98,
  "openInterest": null,
  "currency": "USD",
  "category": "economics",
  "platformCategory": null,
  "tags": ["fomc", "fed-rates", "economic-policy"],
  "status": "open",
  "closesAt": "2026-09-17T00:00:00Z",
  "createdAt": "2026-08-01T12:00:00Z",
  "imageUrl": "https://…",
  "alsoOn": [{ "platform": "manifold", "url": "https://manifold.markets/…", "probability": 0.7 }],
  "scrapedAt": "2026-09-10T15:02:11Z"
}
```

`probability` is the Yes price for binary markets and the leading outcome for multi-outcome markets. Kalshi prices are mid-market when there was no last trade. The `OUTPUT` record in the key-value store holds a run summary with per-platform counts and any platform errors (a run still succeeds if at least one platform answers).

### Use cases

Ready-made examples you can run without configuring anything:

- [Track Manifold Markets questions](https://apify.com/lost.fany/polymarket-kalshi-prediction-markets/examples/manifold-markets) — ready-made task, run it as is
- [Compare Polymarket and Kalshi odds](https://apify.com/lost.fany/polymarket-kalshi-prediction-markets/examples/polymarket-kalshi-odds) — ready-made task, run it as is

#### Track Manifold Markets questions

Manifold's play-money markets with probabilities, volume and close dates in the same schema as the real-money venues.

```json
{ "platforms": ["manifold"], "keywords": ["AI"] }
```

#### Compare Polymarket and Kalshi odds

The same question listed on both venues is cross-linked, so the spread between them is one subtraction away.

```json
{ "platforms": ["polymarket", "kalshi"], "minVolume": 10000 }
```

#### Monitor event contracts odds

Filter by category, volume, liquidity or close date and run it on a schedule to build a time series of implied probabilities.

```json
{ "platforms": ["polymarket", "kalshi", "manifold"], "category": "politics" }
```

### Pricing

Pay per event: a small fee per Actor start plus a fee per market returned. Filtering is free — you pay only for markets in the dataset. Current prices are in the **Pricing** tab.

### Good to know

- Categories come from the platform where it provides one (Kalshi categories, Polymarket tags); otherwise a keyword heuristic assigns them. Use `keywords` when you need precision.
- Manifold uses play money; treat its volume as engagement, not dollars.
- Polymarket sports markets (thousands of match-winner markets) dominate 24h volume. Use `category` or `excludeKeywords` to hide them.
- Data is a snapshot at run time. For history, schedule the Actor and keep each run's dataset.

### Use with AI agents (MCP)

Add the Actor to the [Apify MCP server](https://apify.com/apify/actors-mcp-server) and ask an agent: "What do prediction markets say about a rate cut this month?" Typical tool input: `{ "keywords": ["rate cut", "fed"], "maxItems": 20 }`.

### Related Actors

- [SEC EDGAR API](https://apify.com/lost.fany/sec-edgar-filings)
- [Hacker News Search API](https://apify.com/lost.fany/hacker-news-search-scraper)
- [Bulk URL Status Checker](https://apify.com/lost.fany/bulk-url-status-checker)

### Disclaimer

Not affiliated with Polymarket, Kalshi or Manifold. Market data belongs to the platforms; this Actor only reads their public APIs. Nothing here is financial advice.

### Cost control

Pay per event only works if you can see the bill before you pay it:

- Set `dryRun` to count every result and print what a full run would cost - nothing is charged, and only a few sample rows are stored.
- You are charged only for rows actually delivered to the dataset; a run that finds nothing costs nothing beyond the start event.
- `maxItems` is respected exactly, and the run stops before the platform's Max total charge for the run.
- Every run writes a `COST` record to the key-value store: chargeable events, charged events, the amount in USD and whether a limit was hit.

# Actor input Schema

## `keywords` (type: `array`):

Keep markets whose question, event, tags or outcomes contain ANY of these words (whole-word, case-insensitive), e.g. bitcoin, fed, election. Empty = all markets.

## `excludeKeywords` (type: `array`):

Drop markets containing any of these words.

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

Preset category. Uses the platform's own category where available (Kalshi, Polymarket tags), otherwise keyword heuristics.

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

Which platforms to query. All three by default.

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

Skip thin markets below this total volume (USD for Polymarket and Kalshi, MANA for Manifold).

## `minLiquidity` (type: `integer`):

Skip markets with less liquidity than this.

## `closesWithinDays` (type: `integer`):

Only markets that resolve within this many days (e.g. 7 for this week's events). Empty = any close date.

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

Order of results; also decides which markets are kept when Max markets is reached.

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

Stop after this many markets (after filtering). Platforms are interleaved fairly when the limit is reached.

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

By default only open markets are returned.

## `includeDescription` (type: `boolean`):

Adds the market's description or resolution rules text. Makes the dataset larger.

## `proxyConfiguration` (type: `object`):

Not needed normally; enable only if a platform starts blocking Apify's IPs.

## `dryRun` (type: `boolean`):

Count every result and show what a full run would cost, without charging for it. Only a few sample rows are stored. Use it to check the price before you pay.

## Actor input object example

```json
{
  "keywords": [
    "bitcoin"
  ],
  "excludeKeywords": [],
  "category": "all",
  "platforms": [
    "polymarket",
    "kalshi",
    "manifold"
  ],
  "minVolume": 0,
  "minLiquidity": 0,
  "sortBy": "volume24h",
  "maxItems": 500,
  "includeClosed": false,
  "includeDescription": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "dryRun": false
}
```

# Actor output Schema

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

One item per market: question, outcomes with probabilities, volume, liquidity, close date, category, link.

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

Counts and errors of the run.

# 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 = {
    "keywords": [
        "bitcoin"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lost.fany/polymarket-kalshi-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 = { "keywords": ["bitcoin"] }

# Run the Actor and wait for it to finish
run = client.actor("lost.fany/polymarket-kalshi-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 '{
  "keywords": [
    "bitcoin"
  ]
}' |
apify call lost.fany/polymarket-kalshi-prediction-markets --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lost.fany/polymarket-kalshi-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/3r60jC2wTWYXwT4Oc/builds/9zNUxKCGYq7xdkgwT/openapi.json