# Polymarket & Kalshi Arbitrage, Odds & Whale Radar (`enigmalabs/polymarket-kalshi-arbitrage-scraper`) Actor

Real-time Polymarket and Kalshi prediction market odds, cross-venue arbitrage spread detector, CLOB orderbook liquidity, and live whale trade tracker for AI agents and trading bots.

- **URL**: https://apify.com/enigmalabs/polymarket-kalshi-arbitrage-scraper.md
- **Developed by:** [Enigma Labs](https://apify.com/enigmalabs) (community)
- **Categories:** AI, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 prediction market / arbitrage signals

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?

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

Extract real-time **Polymarket** and **Kalshi** prediction market probabilities, synthetic Dutch-book **cross-venue arbitrage spreads**, orderbook bid-ask depth, and high-conviction **whale trade fills** in a single normalized JSON feed. Built by **Enigma Labs** for quantitative trading desks, financial researchers, newsletter authors, and autonomous **AI Agents (`mcp.apify.com`)**—executing in seconds with zero headless browser overhead.

### What does Polymarket & Kalshi Arbitrage, Odds & Whale Radar do?

Prediction market liquidity is split between crypto-native orderbooks (**Polymarket CLOB**) and US CFTC-regulated event contracts (**Kalshi v2**). Because retail and institutional capital react at different speeds on each exchange, identical macro, political, crypto, tech, and sports events frequently trade at divergent implied probabilities.

This Actor queries both venues simultaneously, normalizes heterogeneous schemas (`outcomePrices` vs `yes_ask_dollars` / `no_ask_dollars`), and delivers ready-to-trade signals:

| Capability | Details |
| :--- | :--- |
| **Cross-Venue Arbitrage Matcher** | Pairs overlapping Polymarket and Kalshi contracts via token-similarity scoring and computes synthetic Dutch-book cost (`YES_VenueA + NO_VenueB < $1.00`) plus raw probability divergence (`arb_edge_pct`). |
| **Unified Dual-Venue Odds** | Converts Polymarket Gamma/CLOB contracts and Kalshi v2 dollar orderbooks into one clean schema (`yes_price`, `no_price`, `volume_usd`, `liquidity_usd`). |
| **Live Whale Orderflow Tape** | Tracks large cash fills above your `min_whale_usd` threshold (default `$2,500+`) with direction (`BUY`/`SELL`), outcome, share size, and transaction hash. |
| **Zero-Browser Cloud Speed** | Runs natively in `< 5 seconds` on minimal RAM (`128–256 MB`) with `$0` proxy overhead. |

### Why use this Actor? (Top Use Cases)

- **Quantitative & Arbitrage Bots**: Schedule every 5–15 minutes via Apify Schedules or Webhooks to alert your Slack, Telegram, or execution engine whenever `arb_edge_pct` exceeds transaction and settlement fees.
- **AI Agents & MCP Workflows**: Connect directly to **Claude Desktop, Cursor, OpenAI Agents, or LangGraph** via `https://mcp.apify.com` so your AI research copilot can answer *"What are the current Polymarket vs Kalshi odds on the next Fed rate decision, and are whales buying YES?"* with live numbers.
- **Macro, Crypto & Election Dashboards**: Pipe normalized implied probabilities and 24-hour volume straight into Google Sheets, Notion, Supabase, or BI dashboards.
- **Smart-Money & Newsletter Alpha**: Surface the largest `$10,000+` whale positions of the day automatically for daily market intelligence briefings.

### How much does it cost?

This Actor uses transparent **Pay-Per-Event (PPE)** pricing (`$0.003` per emitted signal, or **$3.00 per 1,000 signals**) so you only pay for real data delivered:

- **Quick Radar Scan (~35 signals)**: `~$0.10` total
- **Deep Quant Sweep (~200 signals)**: `~$0.60` total
- **Apify Free Plan (`$5/month` free credit)**: Covers **~1,600+ live market, arbitrage, and whale signals every month** at zero out-of-pocket cost.
- **Zero Charge on Empty Queries**: If a niche keyword filter matches zero active contracts, a clean diagnostic status row is returned with **$0 event charge**.

### Input parameters

Click **Try for free** with default settings for an instant cross-venue scan, or customize your run with these parameters:

- **`mode`** *(select, default: `"all"`)*: Choose `"all"` (arbitrage + odds + whales), `"arbitrage_and_markets"`, or `"whale_trades_only"`.
- **`search_query`** *(string, optional)*: Filter contracts by keyword such as `"Bitcoin"`, `"Fed"`, `"Inflation"`, `"Trump"`, or `"AI"`. Leave empty to scan the highest-volume live markets.
- **`max_markets_per_venue`** *(integer, default: `25`)*: Maximum active contracts fetched per exchange (`5` to `200`).
- **`min_whale_usd`** *(integer, default: `2500`)*: Minimum cash notional in USD required to include a Polymarket whale trade.
- **`max_whale_trades`** *(integer, default: `10`)*: Maximum number of live whale trades returned per run.

#### Example Input JSON

```json
{
  "mode": "all",
  "search_query": "Bitcoin",
  "max_markets_per_venue": 25,
  "min_whale_usd": 2500,
  "max_whale_trades": 10
}
```

### Output example

Results are saved to the default **Dataset** and can be exported in **JSON, CSV, Excel, XML, or RSS** formats via Console or REST API:

```json
[
  {
    "record_type": "cross_venue_arbitrage",
    "venue": "Polymarket x Kalshi",
    "title": "Fed rate cut at next FOMC meeting?  <->  Federal Reserve rate cut",
    "category": "Macro & Economics",
    "yes_price": 0.61,
    "no_price": 0.36,
    "kalshi_yes_price": 0.64,
    "arb_edge_pct": 3.0,
    "volume_usd": 1482900.5,
    "liquidity_usd": 412000.0,
    "strategy_hint": "PM YES ($0.61) + Kalshi NO ($0.36) = $0.970 | Prob Δ=3.0%",
    "url": "https://polymarket.com",
    "scraped_at": "2026-11-15T01:00:00Z"
  },
  {
    "record_type": "whale_trade",
    "venue": "Polymarket Whale Tape",
    "title": "[BUY YES] Will Bitcoin reach $150,000 this year?",
    "category": "Whale Orderflow",
    "yes_price": 0.42,
    "no_price": 0.58,
    "arb_edge_pct": 0.0,
    "volume_usd": 14700.0,
    "liquidity_usd": 35000.0,
    "strategy_hint": "Whale BUY 35,000 shares of 'YES' @ $0.420 ($14,700.00)",
    "url": "https://polymarket.com",
    "scraped_at": "2026-11-15T01:00:00Z"
  }
]
```

### Integrations: AI Agents (MCP) & Python API

Because this Actor runs under strict **`LIMITED_PERMISSIONS`** with full Input, Output, and Dataset schemas, it works seamlessly with **Apify's MCP Server** (`https://mcp.apify.com`) as well as standard REST/SDK pipelines:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_API_TOKEN")
run = client.actor("enigmalabs/polymarket-kalshi-arbitrage-scraper").call(
    run_input={"mode": "all", "max_markets_per_venue": 30, "min_whale_usd": 5000}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["record_type"], item["title"], item["arb_edge_pct"])
```

### Frequently Asked Questions (FAQ) & Disclaimer

- **Do I need an API key for Polymarket or Kalshi, or paid proxies?**
  No. All public orderbook, event, and trade feeds are queried directly from cloud infrastructure with zero extra credentials or proxy fees required.
- **Are cross-venue matches guaranteed risk-free arbitrage?**
  Always inspect exact contract resolution rules on both exchanges before trading—similar headlines can occasionally carry different settlement dates or oracle definitions.

*Legal Notice: Independent market data extraction tool maintained by Enigma Labs. Not affiliated with, endorsed by, or sponsored by Adventure One QSS Inc. (Polymarket) or KalshiEX LLC (Kalshi). Provided strictly for informational and quantitative research purposes, not financial or investment advice.*

# Actor input Schema

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

Select 'all' to emit top Polymarket + Kalshi markets, cross-venue arbitrage pairs, and live whale trades, or focus on a single feed.

## `search_query` (type: `string`):

Filter markets by keyword (e.g., 'Fed', 'Bitcoin', 'Trump', 'AI', 'Election'). Leave empty for highest-volume live markets.

## `max_markets_per_venue` (type: `integer`):

Maximum number of top active markets to fetch from Polymarket and Kalshi.

## `min_whale_usd` (type: `integer`):

Minimum cash notional in USD to flag recent Polymarket whale fills.

## `max_whale_trades` (type: `integer`):

Maximum number of live whale trades to include in the output dataset.

## Actor input object example

```json
{
  "mode": "all",
  "search_query": "Bitcoin",
  "max_markets_per_venue": 15,
  "min_whale_usd": 2500,
  "max_whale_trades": 5
}
```

# Actor output Schema

## `dataset` (type: `string`):

Normalized Polymarket & Kalshi markets, synthetic Dutch-book arbitrage spreads, and whale trade alerts.

# 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 = {
    "mode": "all",
    "search_query": "",
    "max_markets_per_venue": 15,
    "min_whale_usd": 2500,
    "max_whale_trades": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("enigmalabs/polymarket-kalshi-arbitrage-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 = {
    "mode": "all",
    "search_query": "",
    "max_markets_per_venue": 15,
    "min_whale_usd": 2500,
    "max_whale_trades": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("enigmalabs/polymarket-kalshi-arbitrage-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 '{
  "mode": "all",
  "search_query": "",
  "max_markets_per_venue": 15,
  "min_whale_usd": 2500,
  "max_whale_trades": 5
}' |
apify call enigmalabs/polymarket-kalshi-arbitrage-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,enigmalabs/polymarket-kalshi-arbitrage-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/4An41PdyYzNwrf0HY/builds/UP3yFJtmWLYPYDXDZ/openapi.json