# Prediction Market Odds Feed: Polymarket Prices & Probabilities (`steady-scrape/prediction-markets`) Actor

Live prediction market odds in one clean table: question, outcome prices, implied probability, bid/ask, volume, liquidity, open interest, close date and result. Filter by keyword, category, volume and closing date. Optional price history. Official public API, no login.

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

## Pricing

from $1.00 / 1,000 market results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Market Odds Feed: Polymarket Prices & Probabilities

Get **live prediction market odds as one clean table**. Each row is one market with its question, every outcome price, the **implied probability**, best bid and ask, 24h and 1-week price change, **volume, liquidity and open interest**, close date, status and the result once it resolves. Filter by keyword, category, minimum volume or liquidity, and "closes within N days", and add a **price history** series if you need one.

Data comes from Polymarket's official public market-data APIs (Gamma, Data API and CLOB). There's no login, no browser and no scraping of web pages, so runs are fast: about 5,000 markets in under a minute.

- 🎯 **Odds you can use straight away:** prices are on a 0–1 scale, so `impliedProbability: 0.195` means 19.5%. Every outcome is listed with its price and token ID
- 🔎 **Keyword search that's precise:** every word has to appear, word prefixes count, and quoted phrases match exactly. "fed rates" finds Fed rate decisions, not every market that mentions "rate"
- 🗂️ **Normalized categories:** politics, elections, economy, finance, companies, crypto, sports, esports, geopolitics, tech, science, culture, weather
- ⏱️ **Event-driven filters:** closing within N days, minimum lifetime volume, minimum liquidity, open only or include resolved markets with their result
- 📈 **Optional price history:** daily or hourly probability series for up to 1,000 markets per run, up to 365 days back
- 🔗 **Look up exact markets:** paste market URLs, event URLs (you get every market in the event), slugs, IDs or condition IDs
- 🧱 **Stable flat schema:** the same field names on every row, ready for a spreadsheet, a database or a dashboard

### Who uses this

- **Analysts and researchers:** track what the crowd expects for elections, Fed decisions, crypto prices or geopolitics, and keep the history
- **Journalists and newsletters:** pull current odds for a story with a link to each market
- **Dashboards and bots:** a scheduled feed of the markets that moved, the markets closing this week, or the biggest markets in a category
- **Builders:** clean market metadata (IDs, token IDs, close dates, rules) without handling paging and API quirks yourself

### Quick start

The 100 biggest open markets, with no input needed:

```json
{}
```

Keyword search with price history:

```json
{
  "searchTerms": ["fed rates", "bitcoin"],
  "maxItems": 40,
  "includePriceHistory": true,
  "priceHistoryDays": 30
}
```

More examples:

- Crypto and economy markets with at least $50k volume that close in the next 14 days, soonest first: `{"categories": ["crypto", "economy"], "minVolume": 50000, "closingWithinDays": 14, "sortBy": "closingSoon"}`
- Exact markets, including resolved ones: `{"marketIds": ["https://polymarket.com/event/will-the-us-invade-iran-before-2027", "xi-jinping-out-before-2027"], "activeOnly": false}`
- A large daily snapshot: `{"maxItems": 5000, "sortBy": "volume24h"}`

### Output

You get one item per market. The Console's overview view shows the headline fields. Key fields:

| Field | Example |
|---|---|
| `platform`, `marketId`, `marketSlug` | `polymarket`, "665374", "will-the-us-invade-iran-before-2027" |
| `question`, `outcomeLabel` | "Will the U.S. invade Iran before 2027?", `null` (filled in multi-outcome events, e.g. a candidate or price bracket) |
| `eventId`, `eventSlug`, `eventTitle` | "73130", ..., "Will the U.S. invade Iran before 2027?" |
| `category`, `tags` | `geopolitics`, `["Military Strikes", "Politics", "Iran", ...]` |
| `outcomes` | `[{"name": "Yes", "price": 0.195, "probability": 0.195, "tokenId": "5511..."}, {"name": "No", ...}]` |
| `yesPrice`, `noPrice`, `impliedProbability`, `leadingOutcome` | 0.195, 0.805, 0.195, "No" |
| `bestBid`, `bestAsk`, `spread`, `lastTradePrice` | 0.19, 0.20, 0.01, 0.19 |
| `priceChange24h`, `priceChange1w` | -0.005, 0.04 (absolute change in the Yes price) |
| `volume`, `volume24h`, `volume1w`, `volumeUnit` | 75541247.44, 157338.15, 886168.71, `usd` |
| `liquidity`, `openInterest`, `eventOpenInterest` | 307787.42, 6844927.29, 6845032.29 |
| `status`, `acceptingOrders`, `result` | `open` / `paused` / `upcoming` / `closed` / `resolved`, true, winning outcome once resolved |
| `openDate`, `closeDate`, `resolvedDate`, `daysToClose` | "2025-11-05T17:52:17Z", "2027-01-01T04:59:00Z", null, 66.29 |
| `url`, `image` | https://polymarket.com/event/will-the-us-invade-iran-before-2027/will-the-us-invade-iran-before-2027 |
| `rules`, `resolutionSource` | full resolution rules (when `includeRules` is on) |
| `platformIds` | `{"conditionId": "0x5db9...", "clobTokenIds": [...], "negRisk": false}` |
| `priceHistory` | `[{"t": "2026-10-01T00:00:00Z", "p": 0.155}, ...]` (when `includePriceHistory` is on) |
| `updatedAt`, `scrapedAt`, `source` | when the venue last updated the market and when we fetched it |

The run summary is saved as `OUTPUT` in the key-value store. It has counts by status and category, request counts, notes (for example references that weren't found) and the filters used.

### Good to know

- **One row per tradable market.** Multi-outcome events such as "2028 Democratic nominee" are made of many yes/no markets, so you get one row per candidate. `eventTitle` and `outcomeLabel` group them, and an event URL in `marketIds` returns the whole event.
- **Prices are probabilities on a 0–1 scale.** `impliedProbability` is the price the venue shows (the order-book midpoint, or the last trade when the spread is wide). Thin markets can show large spreads, so check `spread` and `liquidity`.
- **Volume and liquidity are in USD.** `openInterest` is `null` when the venue reports none for a market (common for small sub-markets).
- **Keyword search** goes through the venue's own search first and then applies the strict word match. Set `strictKeywordMatch: false` to keep everything the venue returns.
- **Price history** covers the first outcome (Yes). It costs one extra request per market and is capped by `priceHistoryMaxMarkets`.
- **Freshness:** data is read live when the run starts. Schedule the Actor (for example every 15 minutes or hourly) to build your own time series.
- **Not for capital-markets or data-redistribution businesses.** Polymarket's terms require brokers, exchanges, trading firms, market data distributors and similar firms to license data directly from Polymarket. This Actor is meant for research, journalism, dashboards and personal analysis. Please check the venue's terms for your use.
- This Actor isn't affiliated with or endorsed by Polymarket. It is not financial advice.

### Pricing

Pay per event: **$1 per 1,000 markets** ($0.001 per market row returned), plus Apify's tiny default start fee per run. Nothing is charged for references that aren't found. A run stops cleanly at your maximum charge.

### More tools from SteadyScrape

- [Keyword Search Volume](https://apify.com/steady-scrape/keyword-search-volume): Google search volume and a 12-month trend for the topics behind the markets you follow.
- [Career Site Jobs Search](https://apify.com/steady-scrape/career-jobs-search): open jobs from tens of thousands of company career sites, another public signal for research dashboards.

Questions or a missing field? Open an issue on the Actor page. SteadyScrape

# Actor input Schema

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

Which venues to read. Kalshi is currently unavailable; runs that include it return Polymarket only and say so in the summary.

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

Markets matching any of these. Every word must appear in the question, event title, outcome or tags (word prefixes count: "elect" matches "election"). Put a phrase in quotes for an exact match.

## `categories` (type: `array`):

Only markets in any of these categories.

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

Market URLs, event URLs (every market in the event), slugs, numeric market IDs or 0x condition IDs. When set, keywords, categories and filters are ignored and the markets come back as given, even if closed.

## `activeOnly` (type: `boolean`):

Skip closed and resolved markets. Turn off to include resolved markets with their result.

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

Only markets that have traded at least this much in total.

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

Only markets with at least this much resting liquidity in the order book.

## `closingWithinDays` (type: `integer`):

Only markets whose scheduled close date is within this many days from now. 0 = closing today.

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

Order of the results (and which markets are kept when Max markets is reached).

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

Stop after this many markets. Each market is one charged result.

## `strictKeywordMatch` (type: `boolean`):

Keep only markets where every keyword word appears. Turn off to keep everything the venue's own search returns.

## `includeOpenInterest` (type: `boolean`):

Per-market open interest (USD). Adds a few quick requests per run.

## `includeRules` (type: `boolean`):

Include the full resolution rules text on each row (long).

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

Attach a probability time series for the first market outcome (Yes) of each market.

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

How far back the history goes.

## `priceHistoryInterval` (type: `string`):

One point per day or per hour.

## `priceHistoryMaxMarkets` (type: `integer`):

History is added to the first N markets in the result order (one extra request per market).

## Actor input object example

```json
{
  "platforms": [
    "polymarket"
  ],
  "searchTerms": [
    "fed rates",
    "bitcoin"
  ],
  "activeOnly": true,
  "sortBy": "volume",
  "maxItems": 100,
  "strictKeywordMatch": true,
  "includeOpenInterest": true,
  "includeRules": false,
  "includePriceHistory": false,
  "priceHistoryDays": 30,
  "priceHistoryInterval": "daily",
  "priceHistoryMaxMarkets": 50
}
```

# Actor output Schema

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

One item per market. Use /items without ?view for every field.

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

Counts by platform, status and category, request counts, notes and the filters used.

# 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": [
        "fed rates",
        "bitcoin"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("steady-scrape/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": [
        "fed rates",
        "bitcoin",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("steady-scrape/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": [
    "fed rates",
    "bitcoin"
  ]
}' |
apify call steady-scrape/prediction-markets --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,steady-scrape/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/o8aWvZsHzmyg4lV92/builds/jcwGrveKMgLbNTNq4/openapi.json