# Polymarket Scraper & API — Odds, Probabilities, Volume (`lergassy/polymarket-scraper`) Actor

Every Polymarket market in one table: implied probability, yes and no price, best bid and ask, 24h move, volume, liquidity and close date. Events with all outcomes, price history and full order books. No wallet, no API key.

- **URL**: https://apify.com/lergassy/polymarket-scraper.md
- **Developed by:** [Matvey](https://apify.com/lergassy) (community)
- **Categories:** Developer tools, Automation, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

**Polymarket Scraper & API** turns the whole Polymarket exchange into a table. Every market comes back with the implied probability in per cent, the yes and no price, best bid and ask, the 24-hour move, volume, resting liquidity, the close date and a link — no wallet, no API key, no browser.

![One run of Polymarket Scraper: markets with implied probability, price move, volume and liquidity.](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/polymarket-scraper/polymarket-scraper-output-table.png)

Five modes: **markets** (one row per tradable contract), **events** (one row per question with every outcome and its probability), **search** by keyword, **price history**, and the **order book** with both sides. A run over the active markets takes a few seconds.

### What is Polymarket Scraper?

Polymarket is the global crypto-settled prediction market: contracts that pay $1 if something happens, on elections, wars, rates, crypto prices, culture and sport. Its price is the crowd's probability, and this Actor reads all of it in one call — for traders, journalists, researchers, dashboards and AI agents that get asked "what are the odds this candidate wins".

### What data does it return?

#### Markets

| Field | Example |
|---|---|
| `marketId`, `slug`, `clobTokenIds` | 516729 · will-the-fed-cut-in-september |
| `question`, `shortTitle`, `eventTitle` | Will the Fed cut rates in September? |
| `probability`, `yesPrice`, `noPrice` | 62.0 (per cent) · 0.62 · 0.38 |
| `bestBid`, `bestAsk`, `spread`, `lastPrice` | 0.61 · 0.63 · 0.02 · 0.62 |
| `priceChange24h` | 0.04 — a move in price, so ±0.04 is four points of probability |
| `volume`, `volume24h`, `volume1w`, `liquidity` | 4,120,880 · 218,400 · … · 96,300 |
| `status`, `result` | open · empty until it settles |
| `openTime`, `closeTime`, `endDate` | ISO 8601 |
| `category`, `tags`, `image` | Economics · \["Fed Rates", "Politics"] |
| `outcomes` | \[{name: "Yes", price: 0.62, probability: 62.0}, {name: "No", …}] |
| `rules`, `url` | resolution text · link to the market |

`liquidity` is the money resting in the order book — Polymarket's own depth figure. `clobTokenIds` is what the history and order-book modes need, and it comes back on every row.

#### Events

One row per question with `outcomes` sorted most likely first, `favourite` and `favouriteProbability`, `outcomeCount`, total `volume` and `liquidity`, and a ready `summary` sentence. This is the shape for "who will win": one row for the whole race with every candidate and their probability, instead of one contract per candidate.

#### Price history and order book

History returns one row per point with `time`, `price` and `probability` — a week at fine resolution by default, up to 90 days at daily granularity. The order book returns both sides with price and size per level.

### How much does it cost?

Pay per row, and only for rows you actually get:

| Event | Price |
| --- | --- |
| Market | $0.0015 |
| Event | $0.0008 |
| Price point | $0.0002 |
| Order book snapshot | $0.001 |

**Error rows are never charged.** There is no browser and no proxy — one public JSON API — so platform usage on top of that is negligible.

| Job | Cost |
| --- | --- |
| 500 active markets | $0.75 |
| 100 markets with 30 days of price history | $0.80 |
| A daily 200-market snapshot for a month | $9.00 |

Other Polymarket Actors charge $0.001 to $0.012 per row, and the ones at the top of that range return the market list only. This one sits near the bottom of the range and adds events, history and order books.

### How to use it

1. Choose **📋 What to get**: markets, events, search, history or order book.
2. Narrow with **🔍 Keyword** (`fed`, `election`, `bitcoin`, `super bowl`) and **🏷️ Category** — several at once, `Politics, Crypto` keeps a market matching either.
3. Set **💧 Minimum volume** or **💧 Minimum liquidity**. Polymarket lists thousands of near-empty contracts; a volume floor of 1000 keeps the ones people actually trade.
4. Sort by 24-hour volume, total volume, liquidity, closing date, probability or biggest 24-hour move.
5. Click **Start**, then export as JSON, CSV or Excel, or read the dataset through the API.

![The input form of Polymarket Scraper: mode, keyword, category, volume and liquidity filters.](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/polymarket-scraper/polymarket-scraper-input-form.png)

### ⬇️ Input

```json
{
  "mode": "markets",
  "query": "election",
  "minVolume": 1000,
  "sortBy": "volume24h",
  "maxMarkets": 200
}
```

#### Events with all outcomes

```json
{ "mode": "events", "category": "Politics", "minVolume": 5000, "maxMarkets": 50 }
```

#### Price history for specific markets

```json
{ "mode": "history", "marketIds": ["516729"], "historyDays": 30 }
```

#### The deepest books only

```json
{ "mode": "markets", "minLiquidity": 50000, "sortBy": "liquidity" }
```

### ⬆️ Output

```json
{
  "type": "market",
  "platform": "polymarket",
  "marketId": "516729",
  "slug": "will-the-fed-cut-in-september",
  "question": "Will the Fed cut rates in September?",
  "eventTitle": "Fed decision in September",
  "category": "Economics",
  "probability": 62,
  "yesPrice": 0.62,
  "noPrice": 0.38,
  "bestBid": 0.61,
  "bestAsk": 0.63,
  "spread": 0.02,
  "lastPrice": 0.62,
  "priceChange24h": 0.04,
  "volume": 4120880.5,
  "volume24h": 218400.25,
  "liquidity": 96300.75,
  "status": "open",
  "closeTime": "2026-09-18T20:00:00Z",
  "outcomes": [
    { "name": "Yes", "price": 0.62, "probability": 62 },
    { "name": "No", "price": 0.38, "probability": 38 }
  ],
  "clobTokenIds": ["7147...", "1029..."],
  "url": "https://polymarket.com/event/will-the-fed-cut-in-september",
  "scrapedAt": "2026-09-04T01:00:00.000Z"
}
```

A request that fails arrives as a `type: "error"` row with the reason, never as a silently short list.

### Use cases

#### Odds for a theme

Filter on `election`, `bitcoin` or `fed` and get every Polymarket contract on it with the probability each one implies.

#### Dashboards and newsletters

Sort by 24-hour move to see what repriced overnight, or by closing date for what resolves this week.

#### Research

Pull price history for a set of markets and study how the crowd's estimate moved against the news.

#### Bots and alerts

Schedule the run and alert when a probability crosses a threshold you care about.

#### AI agents

An agent asked "what does Polymarket say about the election" runs the search mode and reads `probability` straight off the rows.

### 🤖 For AI Agents & LLM Apps

Compact reference for agents calling this Actor through the [Apify MCP server](https://mcp.apify.com) or the Apify API (`lergassy/polymarket-scraper`).

**Purpose:** returns what Polymarket currently prices for a question. Use it for "what are the odds of X", "which markets moved most today", "what does the crowd think about the election".

**Minimal input:**

```json
{ "query": "election", "minVolume": 1000, "maxMarkets": 50 }
```

**Output:** one row per market — `marketId`, `slug`, `question`, `eventTitle`, `category`, `tags`, `probability` (per cent, the number to quote), `yesPrice`, `noPrice`, `bestBid`, `bestAsk`, `spread`, `lastPrice`, `priceChange24h`, `volume`, `volume24h`, `liquidity`, `status`, `openTime`, `closeTime`, `outcomes`, `clobTokenIds`, `rules`, `url`, `scrapedAt`. Event mode returns `outcomes` sorted by probability with `favourite` and a `summary` sentence; history mode one row per price point; order-book mode one row per market with both sides.

**Behaviors an agent should know:**

- **`probability` is the field to quote**, in per cent. `yesPrice` is the same number as a price between 0 and 1, because one contract pays $1 if the event happens.
- `priceChange24h` is a change in *price*, so 0.04 means four percentage points of probability.
- Polymarket lists thousands of near-empty markets. Always pass `minVolume` (1000 is a good floor) or the answer fills with noise.
- Depth here is `liquidity`, in dollars resting in the book. Polymarket publishes no open-interest figure at all.
- Filters are applied by this Actor: `query` matches the question, event title and tags; `category` matches Polymarket tags.
- Read `rules` before treating a market as the bet you have in mind — the resolution wording decides what actually pays.
- History and order books need the market's `clobTokenIds`, which come from the markets mode; passing a bare `marketIds` without having read the market first will not resolve a token.
- The API is public: no wallet, no key, no proxy.

### Polymarket API without a wallet

Polymarket's Gamma and CLOB endpoints are open but awkward: prices arrive as strings, outcomes as encoded arrays, and paging past the end answers with an HTTP 422 that is not an error. This Actor handles all of it and returns one stable row shape.

### ❓ FAQ

#### Is this financial advice or a trading tool?

No. It reads public market data and returns it as a table. It places no orders and holds no positions. Polymarket is restricted in some jurisdictions.

#### Is the probability the true chance of the event?

It is what the market pays, which is the crowd's price after fees and risk appetite. Treat it as a market price, not a forecast from a model.

#### How fresh are the numbers?

Live at the moment of the run. Schedule the Actor to build a time series of your own.

#### Do I need a wallet or an account?

No. The endpoints used here are public and read-only.

#### Why is there no open-interest column?

Because Polymarket does not publish one. Liquidity — money resting in the order book — is its depth measure.

#### Can I use it with the Apify API or an MCP server?

Yes. It runs from the API and the official clients, and AI agents reach it through the Apify MCP server without extra setup.

### Your feedback

Missing a field, or a market type you want covered? Open an issue on the **Issues** tab — every one gets answered.

### You might also like

| Actor | What it does |
|---|---|
| [Prediction Markets API](https://apify.com/lergassy/prediction-markets-api) | Kalshi and Polymarket in one table |
| [Kalshi Scraper & API](https://apify.com/lergassy/kalshi-scraper) | The same shape for Kalshi |
| [Sports Betting Odds API](https://apify.com/lergassy/sports-odds-api) | Bookmaker lines, arbitrage and value bets |
| [Sports Scores & Schedules API](https://apify.com/lergassy/sports-scores-api) | Live scores and schedules for 33 leagues |

### Also known as

People look for this Actor as a Polymarket API, a Polymarket scraper, prediction market data, Polymarket odds, implied probability data, event contracts and election odds.

# Actor input Schema

## `mode` (type: `string`):

<b>Markets</b> gives one row per tradable contract. <b>Events</b> collapses them into one row per question with every outcome and its probability, which is the shape you want for “who will win” questions.

## `query` (type: `string`):

Filter to markets whose question, event or tags contain this text: <code>fed</code>, <code>election</code>, <code>bitcoin</code>, <code>super bowl</code>.

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

Kalshi category or Polymarket tag: Politics, Economics, Crypto, Sports, Culture, Science. Several at once, comma separated — <code>Politics, Crypto</code> keeps a market matching either.

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

Drop thin markets. Both venues list thousands of near-empty contracts; 1000 keeps the ones people actually trade.

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

Drop markets with less than this much money resting in the book, in US dollars. Polymarket publishes this figure; Kalshi reports zero on almost every market, so on Kalshi use <b>Minimum open interest</b> instead.

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

How to order the result.

## `maxMarkets` (type: `integer`):

Cap on rows per run.

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

Off by default: only markets you can still trade.

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

For the history and order-book modes: Kalshi tickers such as <code>KXOAIANTH-40-OAI</code> or Polymarket numeric ids. Leave empty to use the most active markets.

## `historyDays` (type: `integer`):

How far back the price history goes.

## `orderbookDepth` (type: `integer`):

Price levels per side in the order-book mode.

## Actor input object example

```json
{
  "mode": "markets",
  "minVolume": 0,
  "minLiquidity": 0,
  "sortBy": "volume24h",
  "maxMarkets": 200,
  "includeClosed": false,
  "historyDays": 7,
  "orderbookDepth": 10
}
```

# Actor output Schema

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

One row per market with the venue, the question, implied probability in per cent, yes and no prices, best bid and ask, 24h price move, volume, liquidity, close date and link. Compare mode returns one row per matched question with both probabilities and the gap; history mode one row per price point; order-book mode one row per market with both sides.

# 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 = {
    "query": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("lergassy/polymarket-scraper").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 = { "query": "" }

# Run the Actor and wait for it to finish
run = client.actor("lergassy/polymarket-scraper").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 '{
  "query": ""
}' |
apify call lergassy/polymarket-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/ukalASNid0hKgqo6C/builds/zbi67boyHMEn8PKf1/openapi.json