# Polymarket Prediction Markets — Odds & Volume by Category (`haketa/polymarket-scraper`) Actor

Track Polymarket prediction markets by category (politics, sports, crypto, business and more). For each market get the question, outcomes, live probabilities, volume, liquidity, best bid/ask and end date — plus the parent event. Fast, structured, no key.

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

## Pricing

from $1.50 / 1,000 results

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

## Polymarket Scraper — Prediction Market Odds, Probabilities & Volume by Category

> **Track Polymarket prediction markets by category — with live probabilities, volume, liquidity, best bid/ask and resolution dates.** Pick a category (Politics, Crypto, Sports, Business…) and pull every market as a clean row: the question, all outcomes, the favorite and its implied probability, and the parent event. Structured JSON/CSV/Excel in seconds — no API key.

[![Polymarket Data](https://img.shields.io/badge/Polymarket-Odds%20%2B%20Volume-6f42c1)]()
[![By Category](https://img.shields.io/badge/Filter-By%20Category-blue)]()
[![Live Probabilities](https://img.shields.io/badge/Includes-Implied%20Probability-success)]()
[![No Key](https://img.shields.io/badge/Auth-None%20Required-brightgreen)]()

***

### What This Actor Does

The **Polymarket Scraper** turns any Polymarket category into a structured odds dataset. Choose a category and it returns each market with:

- **Market** — the question, outcomes, and direct market link
- **Probabilities** — the implied probability of each outcome, plus the **favorite outcome** and its probability (works for Yes/No *and* multi-outcome markets), and the Yes probability for binary markets
- **Liquidity & price** — total volume, liquidity, best bid, best ask and the bid/ask spread
- **Timing & status** — start date, resolution (end) date, active/closed flags
- **Parent event** — event title, event URL, and event-level volume & liquidity

Filter by **category** (Politics, Crypto, Sports, Business, Science, Tech, Geopolitics, Economy, World, Elections — or *All*), by **status** (active/open vs. all), and sort by **24h volume, total volume, liquidity or newest**.

#### Built for prediction-market tracking

Prediction markets are a real-time, money-weighted forecast. This Actor lets you capture that signal at scale — by category — so you can monitor how the crowd is pricing outcomes, track probability moves over time, and compare markets across topics. Pairs naturally with a Kalshi tracker for cross-venue analysis.

***

### Why Use This Instead of the Raw Data

- Prices and outcomes come back **encoded as JSON strings** (e.g. `"[\"Yes\",\"No\"]"`, `"[\"0.62\",\"0.38\"]"`), a classic footgun — this Actor parses them into real arrays and a clean probability.
- Categories aren't obvious: you have to **resolve a category to its internal tag** before you can filter — handled for you.
- Markets are **nested inside events**; this Actor flattens them to one tidy row per market while keeping the parent-event context.
- It computes the **favorite outcome, implied probability and spread**, and paginates the full category for you.

You get an analysis-ready table instead of a pile of stringified fields.

***

### Quick Start

#### Run it in the console (no code)

1. Open the Actor and click **Try for free**.
2. Pick a **Category** (e.g. Politics, Crypto, Sports) — or *All categories*.
3. Choose **Market status** (Active/open or All) and a **Sort by** (24h volume is a good default).
4. Set **Max markets** and click **Start**.
5. Export as **JSON, CSV, Excel, or HTML**, or push to Google Sheets, a webhook or a database.

#### Run it via API (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "category": "politics",
    "status": "active",
    "sortBy": "volume24hr",
    "maxItems": 200,
}

run = client.actor("YOUR_USERNAME/polymarket-scraper").call(run_input=run_input)

for m in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(m["question"], "→", m["topOutcome"], m["topProbability"], "%  vol", m["volume"])
```

#### Track a category's top markets by probability (Python)

```python
run_input = {"category": "crypto", "status": "active", "sortBy": "volume24hr", "maxItems": 100}
run = client.actor("YOUR_USERNAME/polymarket-scraper").call(run_input=run_input)

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
## highest-conviction markets (favorite most likely)
rows.sort(key=lambda m: (m.get("topProbability") or 0), reverse=True)
for m in rows[:10]:
    print(f'{m["topProbability"]}%  {m["topOutcome"]:>4}  {m["question"]}')
```

#### Run it via API (Node.js)

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('YOUR_USERNAME/polymarket-scraper').call({
    category: 'sports',
    status: 'active',
    maxItems: 150,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'markets');
```

***

### Input Parameters

| Field | Type | Description |
|---|---|---|
| `category` | select | `all`, `politics`, `sports`, `crypto`, `pop-culture`, `business`, `science`, `tech`, `economy`, `geopolitics`, `world`, `elections`. |
| `status` | select | `active` (open markets trading now) or `all` (include resolved/closed). |
| `sortBy` | select | `volume24hr`, `volume`, `liquidity`, or `newest`. |
| `maxItems` | integer | Maximum markets to return. Default `100`. |
| `proxyConfiguration` | object | Optional. Use a **US proxy** if the public data is geo-restricted from your region (see note below). |

***

### Output

Each market is one dataset record. Example:

```json
{
  "marketId": "253591",
  "question": "Will Bitcoin reach $100,000 in September?",
  "category": "Crypto",
  "marketUrl": "https://polymarket.com/event/will-bitcoin-reach-100000-in-september/...",
  "outcomes": ["Yes", "No"],
  "outcomePrices": [0.38, 0.62],
  "topOutcome": "No",
  "topProbability": 62,
  "yesProbability": 38,
  "volume": 3590173.08,
  "liquidity": 154200.5,
  "bestBid": 0.37,
  "bestAsk": 0.39,
  "spread": 0.02,
  "lastTradePrice": 0.38,
  "oneDayPriceChange": -0.03,
  "active": true,
  "closed": false,
  "endDate": "2026-09-30T12:00:00Z",
  "eventTitle": "Bitcoin price in September",
  "eventUrl": "https://polymarket.com/event/bitcoin-price-in-september",
  "eventVolume": 12904331.5,
  "scrapedAt": "2026-09-23T18:50:00.000Z"
}
```

#### Field reference

| Field | Meaning |
|---|---|
| `question`, `marketUrl`, `category` | Market question, link, and category |
| `outcomes`, `outcomePrices` | Outcome names and their implied probabilities (parsed) |
| `topOutcome`, `topProbability` | The favorite outcome and its probability (binary + multi-outcome) |
| `yesProbability` | Yes probability for binary Yes/No markets |
| `volume`, `liquidity`, `bestBid`, `bestAsk`, `spread`, `lastTradePrice`, `oneDayPriceChange` | Market size and pricing |
| `active`, `closed`, `startDate`, `endDate` | Status and timing |
| `eventTitle`, `eventUrl`, `eventVolume`, `eventVolume24hr`, `eventLiquidity` | Parent event context |
| `scrapedAt` | Scrape timestamp |

***

### Use Cases

#### 1. Category odds tracking

Snapshot every Politics (or Crypto, Sports…) market with its live probability and volume. Schedule it to build a probability time series and watch sentiment shift.

#### 2. Cross-venue comparison (Polymarket ↔ Kalshi)

Pull the same topics from Polymarket and Kalshi and compare implied probabilities — the basis for spread and divergence analysis.

#### 3. Signal & sentiment research

Prediction markets are a money-weighted forecast. Aggregate by category to gauge crowd sentiment on elections, macro, crypto and sports.

#### 4. Dashboards & alerts

Feed a dashboard or alerting pipeline: flag big 24h probability moves, new high-volume markets, or markets nearing resolution.

#### 5. Content & newsletters

Populate "what the market thinks" widgets and newsletters with live, structured odds by category.

#### 6. Quant & backtesting datasets

Assemble clean, structured market data (probabilities, volume, liquidity, resolution) for research and backtests.

***

### Categories

Filter to any of: **Politics, Sports, Crypto, Pop Culture, Business, Science, Tech, Economy, Geopolitics, World, Elections** — or **All** to sweep everything. Each maps to Polymarket's own category system, so results match what you see on the site.

***

### Frequently Asked Questions

**Do I need an account or API key?**
No. The Actor reads publicly available market data — no login or key.

**How are probabilities calculated?**
They come straight from the market's outcome prices (a price of `0.62` = a 62% implied probability). The Actor parses the encoded price arrays and also surfaces the favorite outcome and its probability.

**Does it handle multi-outcome markets?**
Yes. `topOutcome`/`topProbability` work for both binary Yes/No and multi-outcome markets; `yesProbability` is provided for binary markets.

**Can I get resolved (closed) markets too?**
Yes — set `status` to `all`.

**I'm getting no data / connection errors from my region.**
Polymarket is **geo-restricted in some countries**. If the public data is blocked from your location, enable the proxy option with a **US** configuration and it will work.

**How fresh are the numbers?**
Prices reflect the latest available market data at scrape time. For sub-second order-book depth, Polymarket's order-book layer updates more frequently than the summary data.

**What export formats are supported?**
JSON, CSV, Excel, HTML, or via API — plus Google Sheets, webhooks, Make, and Zapier.

***

### Legal & Responsible Use

This Actor collects only publicly available prediction-market information for research, analytics and informational use. **It is not financial, investment, betting, or trading advice.** Prediction markets and their availability are regulated differently across jurisdictions — you are responsible for complying with the laws that apply to you. Please:

- Respect Polymarket's Terms of Service and robots directives.
- Do not use the data for unlawful purposes.
- Use reasonable request volumes and scheduling.

This project is an independent tool and is not affiliated with, endorsed by, or sponsored by Polymarket.

# Actor input Schema

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

Filter markets by category. Choose 'all' for every category.

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

Active = open markets currently trading. All = include resolved/closed markets too.

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

Ordering of events/markets.

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

Maximum number of markets to return.

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

Optional. Use a US proxy if the public API is geo-restricted from your region.

## Actor input object example

```json
{
  "category": "all",
  "status": "active",
  "sortBy": "volume24hr",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `marketId` (type: `string`):

Market ID

## `question` (type: `string`):

Market question

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

Category

## `marketUrl` (type: `string`):

Link to the market

## `topOutcome` (type: `string`):

Most likely outcome

## `topProbability` (type: `string`):

Favorite probability %

## `yesProbability` (type: `string`):

Yes outcome probability

## `outcomes` (type: `string`):

Outcome names

## `outcomePrices` (type: `string`):

Outcome probabilities

## `volume` (type: `string`):

Market volume

## `liquidity` (type: `string`):

Market liquidity

## `bestBid` (type: `string`):

Best bid

## `bestAsk` (type: `string`):

Best ask

## `lastTradePrice` (type: `string`):

Last trade price

## `oneDayPriceChange` (type: `string`):

24h price change

## `active` (type: `string`):

Is open

## `endDate` (type: `string`):

Resolution date

## `eventTitle` (type: `string`):

Parent event title

## `eventUrl` (type: `string`):

Parent event URL

## `scrapedAt` (type: `string`):

ISO timestamp

# 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 = {
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/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 = {
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/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 '{
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call haketa/polymarket-scraper --silent --output-dataset

```

## MCP server setup

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