# Polymarket & Kalshi Prediction Markets Scraper (`cirkit/polymarket-kalshi-scraper`) Actor

Export Polymarket and Kalshi prediction markets in one schema: live odds, implied probability, volume, liquidity, open interest, resolved outcomes, events with nested markets, price history and trades. Filter by keyword, category, volume or expiry. No API key, no login. $1 per 1,000 rows.

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

## Pricing

$1.00 / 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.

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

### What is Polymarket & Kalshi Prediction Markets Scraper?

**Polymarket & Kalshi Prediction Markets Scraper** lets you export live odds, resolved outcomes, price history and trades from the two largest prediction markets in one shared column layout, helping you track event probabilities, backtest strategies, spot cross-exchange price gaps and feed dashboards without stitching five APIs together yourself.

- 📊 **Track any question as a probability:** every row carries the yes price, implied probability, 24h move, volume, liquidity and close date, from a Fed decision to a World Cup match.
- 🔁 **One schema for both exchanges:** a Kalshi row lines up column for column with a Polymarket row, so a spreadsheet, a BI tool or an agent reads them the same way.
- 🧪 **Backtest with real history:** pull hourly, daily or minute-level price series and executed trades per market, plus resolved markets with their final outcome, which is the data paid vendors charge for.
- 🔎 **Find markets by keyword, category, tag or link:** search "fed rate" across both exchanges, pull every crypto market, or paste a Polymarket or Kalshi link and get exactly that market.
- 🏷 **Events with their markets nested:** multi-outcome events (who wins the tournament, how many rate cuts) come back as one row with every sub-market inside.
- 💸 **Flat $1 per 1,000 rows:** twelve times cheaper than the closest single-exchange actor, with no API key, no wallet and no login.

Polymarket's and Kalshi's official APIs are free but fragmented: markets, events, price history and trades live on five different hosts with different pagination, Kalshi has no server-side sort or search across its 100,000 open markets, and prices arrive as JSON strings in three different units. This Actor does the stitching, sorting and normalising, and hands you clean rows on a schedule, through the API, or into any integration.

### What data does Polymarket & Kalshi Prediction Markets Scraper extract?

Market rows (`resultsType: markets`):

- 🏛 Exchange (`exchange`), market id, event id and the parent event title
- ❓ Market question and the outcome it prices (`question`, `outcome`, `outcomes`)
- 💲 Yes price, no price and implied probability in percent (`yesPrice`, `noPrice`, `impliedProbability`)
- 📉 Best bid, best ask, spread and last trade price
- 📈 24-hour and 7-day price change (`priceChange24h`, `priceChange1w`)
- 💰 24-hour volume, lifetime volume, liquidity and open interest
- ⏱ Status, resolved flag and the resolved outcome on closed markets (`status`, `resolved`, `resolvedOutcome`)
- 📅 Start date, end date and minutes until close
- 🗂 Category, tags, group title, negative-risk flag, description and Kalshi settlement rules
- 🔗 Market URL, slug, Polymarket condition id and CLOB token ids, Kalshi ticker, event ticker and series ticker
- 🕒 Scrape timestamp on every row

Event rows (`resultsType: events`) add the market count and a nested `markets` array with each sub-market's question, price, volume and link. Price history rows (`priceHistory`) carry `timestamp`, `price` and, for Kalshi, `open`, `high`, `low`, `close`, `volume` and `openInterest` per candle. Trade rows (`trades`) carry `timestamp`, `side`, `outcome`, `price`, `size`, `sizeUsd` and, on Polymarket, the trader's wallet and transaction hash.

Every field is present on every row; a value the exchange does not publish is `null`, never missing or `"N/A"`. Guaranteed on every market row: exchange, question, yes price, status, end date and URL. Best effort: liquidity (Kalshi reports 0 for most markets), 7-day change (Polymarket only), trader identity (Polymarket only).

### How to use Polymarket & Kalshi Prediction Markets Scraper

1. Open the Actor and pick the exchanges and what to export: markets, events, price history or trades.
2. Narrow the set with keywords, categories, tags or specific market links, or leave everything empty for the highest-volume open markets on both exchanges.
3. Set **Max results**. You pay per row, so this is your budget.
4. Click **Start**. A default run finishes in about a minute.
5. Download JSON, CSV or Excel from the Output tab, or read the dataset through the API.

### Input

Top 200 open markets by 24-hour volume across both exchanges (the default):

```json
{
    "exchanges": ["polymarket", "kalshi"],
    "resultsType": "markets",
    "status": "active",
    "sortBy": "volume24h",
    "kalshiHorizonDays": 120,
    "maxItems": 200
}
```

Every politics market on both exchanges with at least $1,000 traded in the last day:

```json
{
    "exchanges": ["polymarket", "kalshi"],
    "categories": ["politics"],
    "minVolume24h": 1000,
    "maxItems": 500
}
```

Hourly price history for one Polymarket market and one Kalshi market over the last 30 days:

```json
{
    "markets": [
        "https://polymarket.com/event/fed-decision-in-september-762",
        "KXFED"
    ],
    "resultsType": "priceHistory",
    "historyRange": "1m",
    "historyResolution": "1h",
    "maxItems": 0
}
```

`markets` accepts Polymarket event or market links, market slugs, condition ids, Kalshi market tickers and Kalshi series tickers, in any mix. `maxItems: 0` means no cap.

### Output

One market row, trimmed:

```json
{
    "type": "market",
    "exchange": "kalshi",
    "marketId": "KXNCAAFGAME-26SEP04INSTPUR-INST",
    "question": "Indiana St. wins",
    "eventTitle": "Indiana St. vs Purdue",
    "outcome": "Indiana St.",
    "yesPrice": 0.02,
    "noPrice": 0.98,
    "impliedProbability": 2,
    "bestBid": 0.01,
    "bestAsk": 0.02,
    "priceChange24h": 0,
    "volume24h": 1812734.54,
    "volumeTotal": 1900580.58,
    "openInterest": 1872729.38,
    "status": "active",
    "resolved": false,
    "endDate": "2026-09-06T23:00:00.000Z",
    "minutesUntilEnd": 3302,
    "category": "sports",
    "tags": ["Sports", "KXNCAAFGAME"],
    "url": "https://kalshi.com/markets/kxncaafgame/college-football-game/kxncaafgame-26sep04instpur",
    "ticker": "KXNCAAFGAME-26SEP04INSTPUR-INST",
    "seriesTicker": "KXNCAAFGAME",
    "scrapedAt": "2026-09-04T16:03:11.482Z",
    "...": "..."
}
```

The Output tab shows four table views over the same rows: **Overview** (markets), **Events**, **Price history** and **Trades**, each with the columns that matter for that row type in a sensible order. Exports include every field.

### How much does it cost to scrape Polymarket and Kalshi?

A flat **$1.00 per 1,000 rows**, charged as rows are written. One market, one event, one price point or one trade is one row. There is no start fee and no charge for platform compute on top.

| Rows | Cost |
|---|---|
| 1,000 | $1.00 |
| 10,000 | $10.00 |
| 100,000 | $100.00 |

The closest Polymarket-only actor on the Store charges $12.00 per 1,000 rows for a five-field snapshot of one exchange. The Apify free plan's monthly credit covers about 5,000 rows here.

Two habits keep bills small: set **Max results** to what you will actually use, and for price history use **Max markets** and **Max rows per market** so a wide selection does not multiply into hundreds of thousands of points.

### Measured coverage

From 15 cloud QA runs on 2026-09-04 through the Apify proxy (4,397 market rows, 4,047 price points, 200 trades, 40 events), audited row by row in `qa/results/integrity_audit.txt`: zero type drift, zero duplicates, every sort honoured, every URL absolute.

| Field | Polymarket | Kalshi |
|---|---|---|
| exchange, question, yesPrice, impliedProbability, status, url, category, eventTitle | 100% | 100% |
| endDate on active markets | 93% (Gamma leaves it empty on some open-ended markets) | 100% |
| bestBid / bestAsk on active markets | 91% on top-volume runs, 77% across long-tail tag scans | 100% |
| priceChange24h on active markets | 71% on top-volume runs, 41% across long-tail tag scans (Gamma omits it on thin markets) | 100% |
| priceChange1w | 47% | not published by Kalshi |
| volume24h on active markets | 100% on top-volume runs, 56% across long-tail tag scans | 100% |
| liquidity | 100% | 100%, published as 0 on most markets |
| openInterest | 90% (event level) | 100% |
| resolvedOutcome on resolved markets | 100% | 100% |
| Price history points, hourly over 7 days | about 165 per market | 95 to 168 per market, thin hours are skipped by Kalshi |

Run time in the cloud at 512 MB: Polymarket-only runs finish in 3 to 35 seconds; anything that ranks or searches Kalshi runs 2 to 3 minutes because Kalshi has to be scanned (see Limits); explicit tickers and history or trade runs finish in under 10 seconds.

### Limits

- **Kalshi has no server-side sort or search.** A Kalshi run scans its open markets (about 120,000 today, in close-time lanes through the Apify proxy) to rank or match them. With the Console default of a 120-day **Kalshi close horizon** that is about 90 pages and two minutes in the cloud; with the horizon at 0 it is every open market, about 135 pages and two to three minutes. Explicit tickers and series skip the scan. Kalshi rate-limits each IP, so with the proxy switched off the scan runs two lanes at a time and takes several minutes.
- **Kalshi keyword matching is on market and outcome titles.** "Purdue" matches the "Purdue wins" market but not a sibling "Indiana St. wins" market in the same game.
- **Uncapped Kalshi runs** (`maxItems: 0`) keep the series title as the event title, because reading every event would not scale. Capped runs get the exact event title. Uncapped events runs return the top 1,000 Kalshi events by the sort key.
- **Resolved markets are bounded by the Resolved lookback** (default the last 24 hours, up to one year) because both exchanges settle tens of thousands of markets a day; Kalshi alone settled 74,000 on the day before launch and 434,000 in the prior 30 days. A week or more is practical only with a category, series or keyword. Older resolved markets need a series ticker, a tag or an explicit link.
- **Polymarket listings stop at 20,000 markets per query** (200 pages of 100). Narrow by tag to reach the rest of the resolved archive.
- **Price history on Polymarket** is for the first outcome token (the yes side of a binary market); the no side is one minus that price. Long ranges are fetched in 14-day chunks, so a lifetime minute-level series on an old market is many calls and many rows: cap it with **Max rows per market**.
- **Trades** are capped at 40 pages per market (20,000 Polymarket trades, 40,000 Kalshi trades) per run.
- **Parlay and combo markets** on Kalshi (multivariate collections) are excluded; they are not tradable as standalone questions.

### FAQ

#### Is it legal to scrape Polymarket and Kalshi?

Both exchanges publish this data through public, unauthenticated APIs intended for programmatic access, and this Actor reads only that public data. It does not log in, does not use cookies and does not collect personal data beyond the pseudonymous wallet addresses Polymarket itself publishes on every trade. You are responsible for how you use the data and for complying with each exchange's terms and your local law.

#### Can I use Polymarket & Kalshi Prediction Markets Scraper as an API?

Yes. Every run can be started and read through the [Apify API](https://docs.apify.com/api/v2): start the Actor with a JSON input, poll or wait for the run, then read the dataset as JSON, CSV or Excel. The run-sync-get-dataset-items endpoint does all three in one call for small runs.

#### Can I use this in Python?

Yes, with the `apify-client` package:

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("cirkit/polymarket-kalshi-scraper").call(run_input={"searchTerms": ["fed rate"], "maxItems": 100})
rows = client.dataset(run["defaultDatasetId"]).list_items().items
```

#### How do I get price history for a market?

Set **What to export** to price history, paste the market links or tickers into **Specific markets or events**, then choose a range (24 hours to the whole lifetime) and a resolution (1 minute, 1 hour or 1 day). One row is written per time point. Leave the market list empty to pull history for the top markets by your sort key instead, capped by **Max markets**.

#### How do I get resolved markets for a backtest?

Set **Market status** to resolved and pick a **Resolved lookback** (default the last 24 hours). Rows carry `resolvedOutcome` ("Yes" or "No", or the winning outcome name) and the final prices. Combine with price history or trades on the same markets to reconstruct what the market believed before it resolved.

#### Can I compare the same question on Polymarket and Kalshi?

Yes. Search both exchanges with the same keyword and both come back in one dataset with identical columns, so a spreadsheet can line up "Fed cuts in September" on each side and show the gap in implied probability.

#### Can I integrate it with other apps?

Yes. Apify integrations connect a finished run to Google Sheets, Slack, Make, Zapier, Airtable, webhooks and more, and the Actor is MCP-ready for AI agents. A common setup is a scheduled run that appends the day's top markets to a sheet.

#### How do I schedule it to run automatically?

Save your input as a Task, then add a Schedule to it in the Apify Console: hourly for live odds, daily for a market census, weekly for history refreshes. Each run writes a fresh dataset.

#### Why did I get fewer results than expected?

Usually one of four things. A keyword that only appears in a Kalshi event title and not in its market titles. A volume, liquidity or price-move threshold that most markets fail (Kalshi reports liquidity as 0 on most markets, so `minLiquidity` removes nearly all of them). **Market status** left on active when the markets you wanted have already resolved. Or **Max results** doing exactly its job. The run log names which filters were active.

#### Why is a run empty but marked as succeeded?

When nothing matches, the Actor writes one row with `type: "no_results"` and a `noResultsReason` explaining what was asked and what to change, and finishes successfully. A scheduled consumer can read the reason instead of guessing from a failed run.

#### Can I get a field that is not listed?

Open an issue on the Actor's Issues tab with the field and the exchange. Both APIs expose more than is mapped here (order book depth, Polymarket leaderboards, Kalshi settlement sources), and useful requests get added.

### You might also like

- [TradingView Screener Scraper](https://apify.com/cirkit/tradingview-screener-scraper) for equity, crypto and forex screens
- [Google Trends Scraper](https://apify.com/cirkit/google-trends-scraper) to line up search interest against market odds
- [Google News Scraper](https://apify.com/cirkit/google-news-scraper) for the headlines behind a price move
- [Telegram Channel Posts Scraper](https://apify.com/cirkit/telegram-channel-scraper) and [Bluesky Scraper](https://apify.com/cirkit/bluesky-scraper) for the social signal

### Changelog

- **0.1** (2026-09-04): first release. Polymarket and Kalshi markets, events, price history and trades in one schema, keyword and category filters, flat $1 per 1,000 rows.

# Actor input Schema

## `exchanges` (type: `array`):

Which prediction markets to pull from. Both exchanges are returned in the same column layout, so a row from Kalshi lines up with a row from Polymarket.

## `resultsType` (type: `string`):

Markets returns one row per tradable market with its live odds. Events groups markets under their parent question, one row per event with the markets nested. Price history returns one row per time point for each selected market. Trades returns one row per executed trade for each selected market.

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

Optional. Only keep markets whose question, event title or description mentions one of these words. Polymarket is searched server side; Kalshi titles are matched as the actor walks its market list.

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

Optional. Restrict to these categories. Each one maps to the matching Polymarket tag and Kalshi category, so 'politics' means Polymarket's politics tag plus Kalshi's Politics category.

## `tags` (type: `array`):

Optional. Raw Polymarket tag slugs or tag IDs (fomc, nba, 100196) and Kalshi series tickers (KXFED, KXNBA). Use this when the category list is too coarse.

## `markets` (type: `array`):

Optional. Exact markets to pull, which is the usual way to request price history or trades. Accepts Polymarket market or event links (https://polymarket.com/event/...), market slugs, condition IDs (0x...), Kalshi market tickers (KXFED-26SEP-T3.75) and Kalshi series tickers (KXFED).

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

Active returns markets still trading. Resolved returns markets that closed within the Resolved lookback window (default the last 24 hours) with their final outcome, which is what a backtest needs. All returns both.

## `resolvedLookback` (type: `string`):

Only when Market status is resolved or all. How long ago a market may have closed to be included. Kalshi settles tens of thousands of markets a day (74,000 on 2026-09-03), so a day is about 80 pages to scan and a week about 500; pick a longer window only together with a category, series or keyword.

## `minVolume24h` (type: `integer`):

Optional. Drop markets that traded less than this in the last 24 hours. A few hundred dollars removes most dormant markets.

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

Optional. Drop markets with less than this much resting liquidity in the order book.

## `minTotalVolume` (type: `integer`):

Optional. Drop markets whose all-time traded volume is below this.

## `minPriceChangePct` (type: `number`):

Optional. Only keep markets whose yes price moved at least this many percentage points in either direction over the last 24 hours. 5 means a move of 5 points or more, for example 0.40 to 0.45.

## `minMinutesUntilEnd` (type: `integer`):

Optional. Drop markets that close sooner than this. 1440 skips everything resolving within a day.

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

Order markets are ranked in before the cap is applied. Polymarket is sorted by its API. Kalshi has no server-side sort, so the actor scans its open markets and keeps the top rows by this key; when Max results is 0 Kalshi rows arrive in exchange order instead.

## `kalshiHorizonDays` (type: `integer`):

Only scan Kalshi markets that close within this many days when browsing by sort, category, tag or keyword. Kalshi has no server-side sort, so a full scan of its 120,000 open markets takes two to three minutes; the 120-day horizon covers everything that trades actively and cuts that by about a third. Set to 0 to scan every open market, for example for 2028 election markets. Explicit tickers, series and Polymarket are never affected.

## `historyRange` (type: `string`):

Only for price history and trades. How far back to go for each selected market.

## `historyResolution` (type: `string`):

Only for price history. Spacing between time points. One row is written per point, so an hourly series over 30 days is about 720 rows per market.

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

Only for price history and trades. How many markets to pull series for when they are chosen by keyword, category or sort rather than listed explicitly. Keeps an accidental 'top 200 markets, one-minute history' run from producing millions of rows.

## `maxRowsPerMarket` (type: `integer`):

Only for price history and trades. Cap on time points or trades written per market. Leave empty for no per-market cap; Max results still applies.

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

Hard cap on the total rows returned. You are charged per row, so this is your budget control. Set to 0 for no limit.

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

Both exchanges answer Apify's standard proxy pool without blocks, so the default works. Change it only if you have a reason to.

## Actor input object example

```json
{
  "exchanges": [
    "polymarket",
    "kalshi"
  ],
  "resultsType": "markets",
  "searchTerms": [
    "fed rate",
    "bitcoin",
    "world cup"
  ],
  "categories": [
    "politics",
    "crypto"
  ],
  "tags": [
    "fomc",
    "KXFED"
  ],
  "markets": [
    "https://polymarket.com/event/fed-decision-in-september",
    "KXFED"
  ],
  "status": "active",
  "resolvedLookback": "1d",
  "minVolume24h": 1000,
  "minLiquidity": 5000,
  "minTotalVolume": 10000,
  "minPriceChangePct": 5,
  "minMinutesUntilEnd": 1440,
  "sortBy": "volume24h",
  "kalshiHorizonDays": 120,
  "historyRange": "1m",
  "historyResolution": "1h",
  "maxMarkets": 20,
  "maxRowsPerMarket": 500,
  "maxItems": 200,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Everything this run collected as the Overview table: exchange, question, yes price, implied probability, 24h change, volume, liquidity, end date and link.

## `events` (type: `string`):

Event-level rows: title, market count, total volume, liquidity, open interest and end date.

## `history` (type: `string`):

Time series rows: market, timestamp, price or open/high/low/close and volume.

## `trades` (type: `string`):

Individual trades: market, time, side, outcome, price, size and trader.

## `resultsCsv` (type: `string`):

The full result set as CSV, ready for a spreadsheet or a backtest.

## `consoleRun` (type: `string`):

The Apify Console page for this run, including the live log.

# 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 = {
    "exchanges": [
        "polymarket",
        "kalshi"
    ],
    "resultsType": "markets",
    "status": "active",
    "sortBy": "volume24h",
    "kalshiHorizonDays": 120,
    "maxItems": 200,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cirkit/polymarket-kalshi-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 = {
    "exchanges": [
        "polymarket",
        "kalshi",
    ],
    "resultsType": "markets",
    "status": "active",
    "sortBy": "volume24h",
    "kalshiHorizonDays": 120,
    "maxItems": 200,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("cirkit/polymarket-kalshi-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 '{
  "exchanges": [
    "polymarket",
    "kalshi"
  ],
  "resultsType": "markets",
  "status": "active",
  "sortBy": "volume24h",
  "kalshiHorizonDays": 120,
  "maxItems": 200,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call cirkit/polymarket-kalshi-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cirkit/polymarket-kalshi-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/sSnmVO8RViAh8tm9g/builds/1tzaYDUR0ItmufuDt/openapi.json