# Polymarket Prediction Market Scraper (`parseforge/polymarket-scraper`) Actor

Scrapes Polymarket prediction markets by search query, category slug, or volume threshold. Returns each market as a flat row with prices, volume, liquidity, and optional CLOB orderbook depth.

- **URL**: https://apify.com/parseforge/polymarket-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, News
- **Features:** Limited permissions
- **Stats:** 7 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### Polymarket Prediction Market Scraper

**Scrape Polymarket prediction market data by search term, category, or volume, up to a million markets per run.** Every market comes with its prices, volume, liquidity, and optional orderbook depth. No API key required. Export to CSV, JSON, Excel, or XML.

Polymarket's public API is rate-limited and returns paginated results that are hard to join across events and markets. This Actor reads the full market catalog directly, filters by category, status, volume, liquidity, and date range, and returns each match in one fixed schema. It works for traders tracking odds shifts, researchers building datasets, and anyone who needs clean prediction-market data without writing their own collector.

| Who uses it | What they scrape Polymarket for |
|---|---|
| Prediction market traders | Monitor odds shifts and volume spikes across hundreds of markets in real time. |
| Quantitative researchers | Build historical datasets of event probabilities, trading volume, and liquidity for backtesting. |
| Crypto analysts | Track which narratives and tokens are attracting the most betting volume on Polymarket. |
| Newsrooms and journalists | Pull current event odds to report on what the market believes will happen next. |

### What it does

This Actor collects Polymarket prediction markets by search query, category slug, or volume threshold, and returns each one as a flat row with prices, volume, liquidity, and optional CLOB orderbook depth.

- 📋 **Two scrape modes:** Events returns one record per event with all child binary markets nested inside. Markets returns one row per individual binary question, so you can pivot on single Yes/No outcomes.
- 🏷️ **Category and status filters:** Narrow results to politics, sports, crypto, AI, or any of the 1,000+ supported category slugs. Filter by active, closed, or archived status.
- 📊 **Volume and liquidity thresholds:** Set minimum total volume or minimum liquidity in USDC so only the most traded markets reach your dataset.
- 📅 **Date range filters:** Limit results to markets that start or end within a chosen window, useful for tracking event-driven trading.
- 📖 **Optional orderbook depth:** Toggle on full CLOB orderbook bids and asks for every outcome token. One extra HTTP call per token, off by default.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Polymarket data

**📈 Monitor real-time odds shifts.**

A trader runs the Actor every 15 minutes on a handful of political category slugs, exports the CSV, and spots which candidate markets are moving before the news breaks.

**🧪 Build a research dataset.**

A data scientist scrapes all closed markets for the past year with minVolume set to 50,000 USDC, then trains a model on how probabilities evolved over time.

**📰 Power a newsroom dashboard.**

A journalist pulls active markets filtered to the geopolitics category, sorts by 24-hour volume, and publishes a daily roundup of what the market expects.

**🔍 Find arbitrage opportunities.**

A quant enables orderbook depth, scrapes multi-outcome events, and computes fee-adjusted basket returns to identify mispriced legs.

### Why choose this scraper

|  | What you get |
|---|---|
| **No API key** | Reads public Polymarket endpoints directly. No registration, no OAuth, no rate-limit headaches. |
| **Two output shapes** | Choose Events mode for grouped event-level records or Markets mode for one row per binary question. |
| **Full CLOB data** | Optional orderbook depth with bids and asks for every outcome token, pulled on demand. |
| **Sort and cap** | Sort by volume, liquidity, open interest, price change, or date, then cap at the number of markets you need. |

### How it compares

This Actor focuses on raw market data with flexible filtering and optional orderbook depth, while the competitors below target specific arbitrage workflows or lighter data snapshots.

| Feature | ParseForge | Polymarket Scraper | $1 / 1k | Fast & Reliable | Polymarket + Kalshi Arbitrage Finder | Polymarket Multi-Outcome Arbitrage Scanner |
|---|---|---|---|---|
| Full CLOB orderbook depth (bids and asks) | Yes, optional per-outcome-token fetch | Not listed | Not listed | Not listed |
| Events mode with nested child markets | Yes, one record per event with markets array | Not listed | Not listed | Not listed |
| Category filtering by 1,000+ slugs | Yes, multi-select from full Polymarket category list | Not listed | Not listed | Not listed |
| Volume and liquidity thresholds | Yes, minVolume and minLiquidity filters | Not listed | Not listed | Not listed |
| Date range filters (start and end date) | Yes, four datepicker fields | Not listed | Not listed | Not listed |
| Cross-platform arbitrage detection | Not listed | Not listed | Yes, Polymarket vs Kalshi | Not listed |
| Multi-outcome mathematical arbitrage scanning | Not listed | Not listed | Not listed | Yes, fee-adjusted basket returns |

### Configure the run

Drive the Actor from a free-text search query, one or more category slugs, or leave everything blank to pull the full Polymarket catalog ordered by 24-hour volume. Filters run as each market is read so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10
}
```

A larger pull:

```json
{
  "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.0115 per result** ($11.50 per 1,000) from September 25, 2026, down from $0.03. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $1.15 |
| 1,000 results | $11.50 |
| 10,000 results | $115.00 |

**Optional orderbook depth:** with `includeOrderbook` on, each event or market that comes back with at least one order book adds an `orderbook-depth` event at **$0.005** ($5 per 1,000). Leave it off and you pay only the per-result price above.

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Polymarket Prediction Market Scraper](https://apify.com/parseforge/polymarket-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Polymarket through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/polymarket-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check your filters. If you set a high minimum volume or liquidity threshold, or picked a narrow date range, you may be excluding all markets. Try relaxing the filters or setting Status to All to see if closed markets appear.

**Why is the run slow when I enable orderbook depth?**

Orderbook depth adds one extra HTTP request per outcome token. A single event with 10 binary markets can mean 20 extra calls. Disable this option unless you need the full bids and asks.

**Why do I see fewer results than my maxItems setting?**

The Actor stops when it has collected maxItems matches that pass your filters. If Polymarket has fewer matching markets than your limit, you will get everything available. Try broadening your search or removing category filters.

**Why are some markets missing fields like volume or liquidity?**

Polymarket sometimes returns null or zero for fields on brand-new or very thin markets. This is expected. Use the minVolume or minLiquidity filters to exclude them.

**Why do I get an error about invalid category slugs?**

The category slug list is pre-loaded from Polymarket. If a slug has been renamed or removed, the API may reject it. Try removing the slug and re-running, or leave categories blank to pull everything.

**Can I scrape markets that are not in English?**

Polymarket primarily lists markets in English, but some event titles may include other languages. The search query and category filters work on the raw text Polymarket provides.

### FAQ

| Question | Answer |
|---|---|
| Do I need a Polymarket API key to use this Actor? | No. This Actor reads the same public endpoints your browser hits when you visit polymarket.com. No registration, no API key, no OAuth flow. |
| What is the difference between Events mode and Markets mode? | Events mode returns one record per prediction-market event, with all its child binary markets nested inside an array. Markets mode flattens everything so each binary Yes/No question gets its own row. Use Events for grouped analysis and Markets for row-level pivoting. |
| How do I filter by a specific category like politics or sports? | Use the Categories multi-select input. You can pick one or more slugs such as politics, sports, crypto, geopolitics, ai, or economy. The Actor will return only markets tagged with those categories. |
| Can I scrape only markets with high trading volume? | Yes. Set the Minimum total volume (USDC) or Minimum liquidity (USDC) fields. Markets below your threshold are skipped before they reach your dataset. |
| What does the orderbook depth option do? | When enabled, the Actor fetches the full CLOB order book for every outcome token in every market. You get arrays of bids and asks with price and size. This adds one HTTP call per token, so it is off by default. |
| How many markets can I scrape in one run? | You can set the Maximum markets field up to 1,000,000. The Actor respects the limit and stops once it has collected that many matches. |
| Can I search for markets by keyword? | Yes. The Search term field does a free-text search across event and market titles. Leave it blank to browse the full catalog. |
| What export formats are supported? | Like every Apify Actor, you can export your dataset to CSV, JSON, Excel, XML, or push it directly to a webhook, S3 bucket, or database. |
| Does this Actor handle closed or resolved markets? | Yes. Set the Status filter to Closed (resolved), Archived, or All to pull historical markets. Active is the default. |
| Can I sort results by something other than 24-hour volume? | Yes. The Sort by dropdown lets you order by total volume, liquidity, open interest, price change over various windows, start date, end date, or creation date. |
| Is this Actor suitable for arbitrage scanning? | It collects the raw data you would need, including optional orderbook depth. You can feed the output into your own arbitrage logic, but this Actor does not compute arbitrage opportunities itself. |
| How often should I run this Actor? | That depends on your use case. Traders often run it every 5 to 15 minutes on a schedule. Researchers building historical datasets may run it once a day or once a week. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Polymarket. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text search across event and market titles. Leave blank to browse all markets.

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

Maximum number of markets to collect per run.

## `scrapeMode` (type: `string`):

Events return one record per prediction-market event (with all child binary markets nested). Markets returns one record per individual binary market (each Yes/No question).

## `tagSlugs` (type: `array`):

Filter by one or more Polymarket category slugs. Common picks: politics, sports, crypto, geopolitics, ai, economy.

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

Active = open for trading. Closed = market resolved or stopped accepting orders. Archived = removed from public listings. All = no status filter.

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

Field used to order results before applying max items.

## `sortDirection` (type: `string`):

Descending = biggest first (default). Ascending = smallest first.

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

Only include markets/events whose total volume is at or above this number.

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

Only include markets/events whose current liquidity is at or above this number.

## `startDateMin` (type: `string`):

ISO-8601 date or datetime. Only include events/markets that started on or after this point.

## `startDateMax` (type: `string`):

ISO-8601 date or datetime. Only include events/markets that started on or before this point.

## `endDateMin` (type: `string`):

ISO-8601 date or datetime. Only include events/markets that end on or after this point.

## `endDateMax` (type: `string`):

ISO-8601 date or datetime. Only include events/markets that end on or before this point.

## `includeOrderbook` (type: `boolean`):

Fetch full CLOB order book (bids + asks) for every market outcome. Slower; adds one HTTP call per outcome token.

## Actor input object example

```json
{
  "maxItems": 10,
  "scrapeMode": "events",
  "status": "active",
  "sortBy": "volume24hr",
  "sortDirection": "desc",
  "includeOrderbook": false
}
```

# Actor output Schema

## `predictionMarkets` (type: `string`):

Complete dataset with all scraped Polymarket events or markets, including outcomes, odds, volume, liquidity, and resolution data

## `overview` (type: `string`):

Overview view with key Polymarket fields displayed in table format

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

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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": 10 }

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

```

## MCP server setup

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