# Polymarket Scraper — Live Odds, Prices & Volume (`eltociear/polymarket-markets-odds`) Actor

Get Polymarket prediction market prices, bid, ask, spread and implied probability. Track odds over time, screen by 24h volume and liquidity, search markets by topic, or pull resolved outcomes for backtesting. No API key. Pay per market returned.

- **URL**: https://apify.com/eltociear/polymarket-markets-odds.md
- **Developed by:** [Ikko Eltociear Ashimine](https://apify.com/eltociear) (community)
- **Categories:** Business, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 market returneds

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/platform/actors/running/actors-in-store#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 — Live Odds, Prices & Volume

Pull every Polymarket prediction market as clean, typed rows: each outcome with its price
and implied probability, the live **best bid / best ask / spread**, 1h / 24h / 1w price
moves, volume, liquidity, resolution date and the parent event.

No API key. No browser. No proxy. Straight against Polymarket's public Gamma API, so runs
are fast and cheap and there is no anti-bot layer to break.

**You pay per market returned** — $0.005. Duplicates, markets your filters reject, and
markets that fail to parse are **not** charged.

### What it does, in the words you'd ask for it

- **Get Polymarket market prices, bid, ask and spread** for every open market.
- **Get the implied probability of a prediction market** — each outcome's price converted
  to a percentage, ready to compare against your own model.
- **Track prediction market odds over time** — put a slug watchlist on a schedule and each
  run appends a snapshot.
- **Find prediction markets by topic** — free-text search over live events (bitcoin, fed
  rate, election, ceasefire).
- **Screen for liquid prediction markets** — filter on 24h volume, order-book liquidity and
  spread, so you only see markets you could actually trade.
- **Get resolved prediction market outcomes for backtesting** — settled markets with their
  final prices, for calibration against known results.
- **Get betting odds for an event** — the price of each outcome *is* the odds, already
  normalised to a probability.
- **Get election odds data** — political markets are one of Polymarket's largest categories;
  search by candidate, race or date.
- **Get crypto prediction market data** — price-threshold markets on BTC, ETH and others,
  with the same quotes and volume as every other market.
- **Pull event probability data for a forecasting model** — implied probability per outcome,
  plus 1h/24h/1w moves so you can see which way it is drifting.
- **Export a resolved market outcomes dataset** — turn on closed markets and take the whole
  settled history as training or calibration data.

***

### What you can do with it

**Track a watchlist on a schedule.** Put your market slugs in *Exact market slugs*, set the
Actor to run every 15 minutes, and you get a time series of bid/ask and volume for exactly
the markets you care about — nothing else, nothing extra to pay for.

```
slugs: ["will-the-fed-decrease-interest-rates-by-25-bps-after-the-september-2026-meeting"]
```

**Find today's movers.** Sort by *24h price change* over the whole open board to see what
repriced while you were asleep.

```
sortBy: "priceChange24h",  maxMarkets: 100,  minVolume24hUsd: 5000
```

**Screen for tradeable markets only.** Most of the board is illiquid. Filter on liquidity
and spread so you only see markets you could actually get size into.

```
minLiquidityUsd: 25000,  minSpread: 0.02
```

**Backtest.** Turn on *Include closed markets* to get settled markets with their final
prices, for calibration work against known outcomes.

**Research one topic.** Free-text *Search* covers live events: `bitcoin`, `fed rate`,
`election`, `ceasefire`.

***

### Sample output

```json
{
  "question": "Will the price of Bitcoin be above $68,000 on August 7?",
  "slug": "will-the-price-of-bitcoin-be-above-68000-on-august-7",
  "url": "https://polymarket.com/event/bitcoin-above-68000-august-7",
  "outcomes": [
    { "name": "Yes", "price": 0.135, "implied_probability_pct": 13.5 },
    { "name": "No",  "price": 0.865, "implied_probability_pct": 86.5 }
  ],
  "best_bid": 0.13,
  "best_ask": 0.14,
  "mid_price": 0.135,
  "spread": 0.01,
  "last_trade_price": 0.14,
  "price_change_1h": -0.004,
  "price_change_24h": 0.021,
  "price_change_1w": -0.083,
  "volume_usd": 4821330.4,
  "volume_24h_usd": 193660.2,
  "volume_1w_usd": 1044201.8,
  "liquidity_usd": 88214.0,
  "start_date": "2026-08-01T00:00:00Z",
  "end_date": "2026-08-07T23:59:59Z",
  "active": true,
  "closed": false,
  "accepting_orders": true,
  "event_title": "Bitcoin price on August 7",
  "event_slug": "bitcoin-above-68000-august-7",
  "tags": ["Crypto", "Bitcoin"],
  "resolution_source": "",
  "condition_id": "0x…",
  "market_id": "512345"
}
```

***

### Input reference

| Field | Type | Default | What it does |
|---|---|---|---|
| `query` | string | — | Free-text search over live events. Ignored if `slugs` is set. |
| `slugs` | string\[] | — | Exact market lookup. Takes priority over `query`. |
| `maxMarkets` | integer | 100 | Hard cap on rows — and therefore your spending cap. |
| `sortBy` | enum | `volume24hr` | `volume24hr`, `volume`, `liquidity`, `endDate`, `priceChange24h`. Board mode only. |
| `ascending` | boolean | `false` | Reverse the sort. Pair with `endDate` for "resolving soonest". |
| `minVolume24hUsd` | integer | 0 | Drop illiquid markets. |
| `minLiquidityUsd` | integer | 0 | Order-book depth floor. |
| `minSpread` | number | 0 | Keep only markets at least this wide. |
| `includeClosed` | boolean | `false` | Include settled markets, for backtesting. |
| `tagId` | string | — | Restrict to one Polymarket tag by numeric id. |

***

### Things this Actor is careful about

These are the details that decide whether prices data is usable or quietly wrong.

- **Outcome prices are paired positionally, or not at all.** Gamma sends `outcomes` and
  `outcomePrices` as two separate JSON-encoded strings. If their lengths ever disagree,
  the mapping is unknowable, so `outcomes` comes back empty rather than guessed — a
  swapped Yes/No price is the one error that still looks completely plausible downstream.
- **No order book means `null`, not `0`.** Markets with no live quotes get
  `best_bid: null`, `spread: null`, `mid_price: null`. A fabricated `0.0` spread would
  read as a perfectly liquid market.
- **You are never charged twice for one market.** Rows are de-duplicated by market id
  before anything is billed.
- **Pagination is real.** Gamma silently caps every response at 100 rows regardless of the
  limit requested; this Actor pages past that, so `maxMarkets: 2000` returns 2000.
- **Filters are honest.** A high `minVolume24hUsd` can legitimately return zero rows —
  most of the board trades under $1,000 a day. The log says so instead of failing quietly.

### Limits

- Prices are the Gamma API's published quotes, refreshed per run. This is not a websocket
  feed — for sub-second data use Polymarket's CLOB stream directly.
- Free-text `query` searches live events only; use `includeClosed` with board mode to
  reach settled markets.
- `tags` are only populated for markets whose parent event carries them.

# Actor input Schema

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

Free-text search over live Polymarket events, e.g. 'bitcoin', 'fed rate', 'election'. Leave empty to take the whole open board instead.

## `slugs` (type: `array`):

Look up specific markets by slug (the last part of a polymarket.com URL). Overrides Search when set — use this to track a fixed watchlist on a schedule.

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

Hard cap on rows returned. You pay per market returned, so this is also your spending cap.

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

Applies when taking the whole board (no Search, no slugs).

## `ascending` (type: `boolean`):

Off gives the largest/busiest first. On is useful with 'Resolution date' to find markets resolving soonest.

## `minVolume24hUsd` (type: `integer`):

Drop illiquid markets. Most of the board trades under $1,000 a day, so a high value here can legitimately return nothing.

## `minLiquidityUsd` (type: `integer`):

Order-book depth floor. Useful when you only care about markets you could actually trade size in.

## `minSpread` (type: `number`):

Keep only markets whose spread is at least this wide (0.01 = 1 cent). Markets with no live order book are excluded rather than treated as zero-spread.

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

Off returns only markets still trading. On also returns settled ones, for backtesting against known outcomes.

## `tagId` (type: `string`):

Restrict the board to one Polymarket tag/category by its numeric id. Leave empty for all.

## Actor input object example

```json
{
  "query": "bitcoin",
  "maxMarkets": 100,
  "sortBy": "volume24hr",
  "ascending": false,
  "minVolume24hUsd": 0,
  "minLiquidityUsd": 0,
  "minSpread": 0,
  "includeClosed": false
}
```

# 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": "bitcoin"
};

// Run the Actor and wait for it to finish
const run = await client.actor("eltociear/polymarket-markets-odds").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": "bitcoin" }

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

```

## MCP server setup

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

```

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/kbMU7wa8qdemQcGti/builds/WOXg5yMs92cNLc19p/openapi.json