# Polymarket Kalshi Arbitrage Scanner — Matched Markets & Edge (`tactful_anvil/polymarket-kalshi-arbitrage-scanner`) Actor

Match the same prediction market on Polymarket and Kalshi, compare YES/NO ask prices and get fee-adjusted, risk-free arbitrage edge for every pair. Entity-exact matching (names, strikes, dates) — no false-positive soup. $2/1,000 matched pairs.

- **URL**: https://apify.com/tactful\_anvil/polymarket-kalshi-arbitrage-scanner.md
- **Developed by:** [Mr Zack](https://apify.com/tactful_anvil) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 matched pairs

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

## Polymarket × Kalshi Arbitrage Scanner — Matched Markets & Fee-Adjusted Edge

Find the **same prediction market on Polymarket and Kalshi**, compare live YES/NO ask prices, and get the **fee-adjusted, risk-free arbitrage edge** for every matched pair — in one run, from two public APIs, with no login and no API keys.

Built for **prediction market traders, arbitrageurs and researchers** who are tired of eyeballing two browser tabs: the scanner matches markets by entity (names, numeric strikes, dates), blocks false pairs (negation, above/below direction, mismatched strikes), and computes the exact cost of buying YES on one platform and NO on the other — **including Kalshi's 7% trading fee**.

### Why this scanner instead of eyeballing?

- **Entity-exact matching, not keyword soup.** "Fed rate *be* 1.75%" will never be paired with "Fed rate *above* 2.75%". Numeric strikes must agree, end dates must be close, negations and directions must match.
- **Fee-adjusted edge.** A 1.5% gross gap that dies after Kalshi fees is not an arb. `netEdgePct` already subtracts the fee.
- **Verified arbs first.** Rows are sorted with high-confidence, net-positive arbs on top (`isArb: true`). Edges above 15% are flagged `suspiciousEdge` — cross-platform gaps that big are almost always a market mismatch, so we never charge you optimism.
- **Whole-market coverage.** Scans ~2,000 highest-volume Polymarket binary markets and every open Kalshi market (tens of thousands) per run.

### Output fields

| Field | Description |
| --- | --- |
| `matchScore` / `confidence` | Match similarity (0–1) and `high`/`medium` tier |
| `question`, `polyEventTitle`, `polyUrl` | Polymarket market |
| `polyYesAsk`, `polyNoAsk`, `polyVolumeUsd`, `polyEndDate` | Polymarket prices & volume |
| `kalshiTicker`, `kalshiQuestion`, `kalshiUrl` | Kalshi market |
| `kalshiYesAsk`, `kalshiNoAsk`, `kalshiCloseTime` | Kalshi prices |
| `direction` | Best arb legs, e.g. `YES@Polymarket + NO@Kalshi` |
| `totalCostUsd`, `kalshiFeeUsd` | Combined cost of both legs + fee |
| `grossEdgePct`, `netEdgePct` | Edge before / after Kalshi fees |
| `isArb` | `true` = verified net-positive arb (high confidence, sane edge) |
| `suspiciousEdge` | `true` = edge >15%, verify the pair manually |
| `scannedAt` | UTC timestamp of the scan |

### Pricing

**$0.04 per run + $2.00 per 1,000 matched pairs.** A full scan typically returns 300–600 pairs (≈ $0.6–1.2 per full price-gap table). Set `minNetEdgePct: 0` to receive **only net-positive arbs** — then a run costs $0.04 plus a fraction of a cent per actionable opportunity.

### Run it on a schedule (recommended)

Arbs live for minutes to hours. In Apify Console: **Actors → this actor → Schedules → Create new**, pick every 15–60 minutes, set input `{ "minNetEdgePct": 0 }`, and add an email/Slack/webhook integration that fires when the dataset is non-empty. You'll only pay for rows that are actually actionable.

### Use with AI agents & MCP

This actor works out of the box with the [Apify MCP server](https://mcp.apify.com) — plug it into Claude, ChatGPT, LangGraph or any agent framework and ask things like *"scan for prediction-market arbitrage above 1% and summarize the top 5"*. The output schema is stable and machine-readable, so agents can chain it into alerting, sizing or execution research workflows.

### Related actors

- [Kalshi Weather Markets Scraper](https://apify.com/tactful_anvil/kalshi-weather-markets-scraper) — live Kalshi weather market odds by city.
- [Whop New Launches Monitor](https://apify.com/tactful_anvil/whop-new-launches-monitor) — catch every new Whop product the hour it launches.
- [Ad Budget Signals](https://apify.com/tactful_anvil/ad-budget-signals) — which advertisers are scaling spend right now.
- [Polymarket Top Traders Scraper — Whale Positions & Copy Feed](https://apify.com/tactful_anvil/polymarket-top-traders-scraper) — see what the most profitable Polymarket whales are holding right now.

### Legality & fair use

Both data sources are public, unauthenticated JSON APIs (Polymarket Gamma API, Kalshi trade API v2). The scanner uses polite pacing, no proxies and no credentials. This actor provides market data, not financial advice — always verify prices on-platform before trading.

# Actor input Schema

## `minNetEdgePct` (type: `integer`):

Only emit pairs whose fee-adjusted edge is at least this percent. Leave empty to get ALL matched pairs (full price-gap table). Set to 0 for net-positive arbs only — you pay only for actionable rows.

## `minMatchScore` (type: `string`):

Similarity threshold for pairing markets. Default 0.55. Raise to 0.75 for high-confidence pairs only.

## `minPolyVolumeUsd` (type: `integer`):

Skip thin Polymarket markets below this lifetime volume. Default 5000.

## `keywordFilter` (type: `string`):

Only keep pairs mentioning this text, e.g. "bitcoin", "fed" or "nfl".

## `maxPairs` (type: `integer`):

Cap the number of charged pair rows (1-1000).

## Actor input object example

```json
{
  "minPolyVolumeUsd": 5000,
  "maxPairs": 500
}
```

# Actor output Schema

## `pairs` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("tactful_anvil/polymarket-kalshi-arbitrage-scanner").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("tactful_anvil/polymarket-kalshi-arbitrage-scanner").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 '{}' |
apify call tactful_anvil/polymarket-kalshi-arbitrage-scanner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tactful_anvil/polymarket-kalshi-arbitrage-scanner"
        }
    }
}

```

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/2oLejll9WhHzoigUm/builds/nSSiBvN0K6vW2sD5d/openapi.json