# Prediction Market Spread Finder: Kalshi vs Polymarket (`transparent_meteorite/prediction-market-spread-finder`) Actor

Kalshi and Polymarket odds in one table: yes/no price, implied probability, volume, liquidity and close time per market, with the same question matched across both venues and the price spread between them. No login, no API key.

- **URL**: https://apify.com/transparent_meteorite/prediction-market-spread-finder.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Developer tools, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 markets

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

## Prediction Market Spread Finder: Kalshi vs Polymarket odds in one table

Use this to pull live odds from **Kalshi** and **Polymarket** into one dataset, match the same question across both venues, and see where they disagree.

**One clean row per market, from both venues' public APIs, with the cross-venue spread already computed.** Kalshi and Polymarket often list the same question (a Fed decision, a CPI print, an election, a bitcoin price level) with different wording, different units and different prices. This actor reads both, normalizes each market to a common `topic`, pairs markets that ask the same thing (same subject, same month and year, same strike, same direction), and adds the counterpart's price, the `spread` between venues and a `crossVenueEdge` computed from the best asks.

- **What you get:** venue, market id, title, outcome, yes and no price, implied probability, best bid and ask, last price, volume, 24h volume, liquidity, open interest (Kalshi), close time, category, a normalized `topic`, the matched market on the other venue, `spread`, `crossVenueEdge`, market URL and fetch time.
- **Who it is for:** traders and quants comparing venues, research and newsroom desks that chart implied probabilities, data teams that track odds over time, and builders of dashboards, bots and AI agents that need prediction market prices as clean JSON.
- **Price:** $1.00 per 1,000 market rows ($0.001 each) plus $0.00005 per run start. Filtered, invalid or unpriced markets are never charged.
- **No login, no API key:** both venues publish these prices through public, keyless APIs.

### How it works: what this prediction market spread finder does

1. **Reads Kalshi** through the official Trade API v2: open events and their markets, with order-book bid and ask in dollars, volume and open interest.
2. **Reads Polymarket** through the public gamma API (events, markets, outcomes, volume, liquidity) and refreshes prices from the public CLOB order book (best bid and best ask per outcome token).
3. **Normalizes every market to a `topic`.** Wording is folded to one vocabulary: "hike", "raise" and "increase" become `increase`; "25 bps" and "25bps" become `25bps`; ">25bps" and "50+ bps" become `50plusbps`; "$100,000" becomes `100000usd`; "at least" and "≥" become `above`.
4. **Matches the same question across venues.** A pair needs a text similarity of 0.62 or more and the same years, months, numeric strikes and direction words, and close times that agree. Each market is paired at most once (mutual best match), so one Kalshi market never claims three Polymarket markets.
5. **Orders the output usefully:** matched pairs first (both rows next to each other, largest combined volume first), then the remaining markets alternating venues by volume.

### Use cases

- **Cross-venue price checks:** a trader pulls every Fed, CPI and jobs-report market each morning with `onlyMatched` on and sorts by `spread` to see where Kalshi and Polymarket disagree by more than a few points.
- **Research and journalism:** a newsroom pulls implied probabilities for a topic (recession, a candidate, a bitcoin price level) from both venues into one sheet for a chart or a story, with the source link on every row.
- **Odds history:** a data team schedules the actor every hour and appends rows to a warehouse to track how the price of the same question moves on each venue over time, keyed by `topic` or `matchGroupId`.
- **Bots and AI agents:** an agent calls the actor through the Apify API or MCP server to answer "what do prediction markets say about X" with prices from both venues instead of one.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `keyword` | string | `fed` (prefill) | Words that must appear in the market or event title, for example `fed`, `bitcoin`, `cpi`, `election`. Empty = top markets of the chosen categories. |
| `categories` | list | Politics, Elections, Economics, Finance, Crypto | Normalized categories: politics, elections, economics, finance, crypto, sports, tech, science, culture, weather, world, health. |
| `sources` | list | both | `kalshi`, `polymarket`, or both. Matching needs both. |
| `status` | string | `open` | Only open, tradable markets are tracked. |
| `minVolume` | integer | 0 | Skip markets with lower lifetime volume. |
| `closesWithinDays` | integer | empty | Only markets that close within this many days. |
| `maxItems` | integer | 25 | Stop after this many rows (max 2,000). |
| `matchAcrossVenues` | boolean | true | Pair the same question across venues and add spread fields. |
| `onlyMatched` | boolean | false | Return only markets that have a counterpart. |
| `minAbsSpread` | number | 0 | Only matched markets whose yes prices differ by at least this much (0.03 = 3 points). |
| `refreshPolymarketPrices` | boolean | true | Use live CLOB bid and ask for Polymarket instead of the cached gamma price. |

#### Example input

```json
{
  "keyword": "fed",
  "maxItems": 30,
  "onlyMatched": false
}
```

### Output

One row per market, 36 flat fields. Main fields:

| Field | Meaning |
|---|---|
| `source` | `kalshi` or `polymarket` |
| `marketId`, `eventId` | Kalshi ticker / Polymarket id |
| `title`, `eventTitle`, `outcome` | The question, its parent event and the outcome `yesPrice` refers to |
| `yesPrice`, `noPrice`, `impliedProbability` | 0-1. Order-book mid when both sides quote, otherwise last trade |
| `yesBid`, `yesAsk`, `noBid`, `noAsk`, `lastPrice` | Top of book and last trade, 0-1 |
| `volume`, `volume24h`, `volumeUnit` | Kalshi: contracts ($1 face value each). Polymarket: USDC |
| `liquidity`, `liquidityBasis` | Polymarket: reported liquidity in USDC. Kalshi: dollars resting at the top of the book |
| `openInterest` | Kalshi open interest in contracts |
| `closeTime` | Scheduled close, ISO 8601 UTC |
| `category`, `topic` | Normalized category and the cross-venue topic key |
| `matchGroupId`, `matchedSource`, `matchedMarketId`, `matchedTitle`, `matchedUrl`, `matchedYesPrice`, `matchScore` | The counterpart on the other venue |
| `spread` | `yesPrice - matchedYesPrice` (positive = this venue prices yes higher) |
| `crossVenueEdge` | `1 - min(yesAsk here + noAsk there, noAsk here + yesAsk there)`, before fees |
| `url`, `priceSource`, `fetchedAt` | Market link, where the price came from, when the row was read |

#### Sample output

Real rows from our test data (keyword `fed`, read 2026-11-05):

| Venue | Market | Yes | Spread | Topic |
|---|---|---|---|---|
| Kalshi | Will the Federal Reserve Hike rates by 25bps at their December 2026 meeting? | 0.645 | +0.010 | fed increase 25bps december 2026 |
| Polymarket | Will the Fed increase interest rates by 25 bps after the December 2026 meeting? | 0.635 | -0.010 | fed increase 25bps december 2026 |
| Kalshi | Will the Federal Reserve Hike rates by 0bps at their December 2026 meeting? | 0.330 | -0.005 | fed nochange december 2026 |
| Polymarket | Will there be no change in Fed interest rates after the December 2026 meeting? | 0.335 | +0.005 | fed nochange december 2026 |
| Kalshi | Will the Federal Reserve Hike rates by 25bps at their January 2027 meeting? | 0.205 | +0.030 | fed increase 25bps january 2027 |
| Polymarket | Will the Fed increase interest rates by 25 bps after the January 2027 meeting? | 0.175 | -0.030 | fed increase 25bps january 2027 |

One row as JSON (shortened):

```json
{
  "source": "kalshi",
  "marketId": "KXFEDDECISION-26DEC-H25",
  "title": "Will the Federal Reserve Hike rates by 25bps at their December 2026 meeting?",
  "yesPrice": 0.645,
  "impliedProbability": 0.645,
  "volumeUnit": "contracts ($1 face value each)",
  "closeTime": "2026-12-09T18:59:00Z",
  "topic": "fed increase 25bps december 2026",
  "matchedSource": "polymarket",
  "matchedYesPrice": 0.635,
  "spread": 0.01,
  "url": "https://kalshi.com/markets/kxfeddecision",
  "priceSource": "kalshi_orderbook",
  "fetchedAt": "2026-11-05T18:00:00.000Z"
}
```

### Pricing

Pay per event, no monthly rental:

| Event | Price | When |
|---|---|---|
| `market-row` | $0.001 ($1.00 per 1,000) | Each market row written to your dataset |
| `apify-actor-start` | $0.00005 | Once per run |

**Worked example:** the example input (`fed`, 30 rows) costs 30 x $0.001 + $0.00005 = **$0.03005**. An hourly check of 50 matched markets costs about $0.05 per run, about $1.20 per day. A run can never cost more than $0.00005 + `maxItems` x $0.001, and the actor stops cleanly at your "Maximum cost per run" setting. A run that finds nothing costs only the start event.

### How to run it

- **Apify Console:** set a keyword or a category, press Start, and open the Markets table, or export JSON, CSV or Excel.
- **API and clients:** call `transparent_meteorite/prediction-market-spread-finder` from the Apify REST API or the JavaScript and Python clients.
- **Schedules, webhooks, n8n, Make, Zapier and AI agents:** every row has a stable `marketId`, a `fetchedAt` date and numeric prices, so it drops into a sheet, a database or a workflow without reshaping.

### Limitations

- **Text matching, not resolution matching.** Two markets with the same topic can still resolve on different sources or rules. Read both venues' rules before treating a spread or `crossVenueEdge` as tradable. Edge is computed from best asks and is before fees, slippage and position limits.
- **Best on economics, politics and crypto price levels**, where questions share dates, strikes and direction. Sports markets are listed but team-name aliases are not resolved, so fewer sports markets pair up.
- **Units differ by venue:** Kalshi volume is in contracts and Kalshi liquidity is the top of the book only; Polymarket reports USDC.
- **Open markets only.** No order-book depth beyond the best bid and ask, no trade history, no account data.
- **Kalshi links open the market's series page** on kalshi.com. Very broad keywords scan Kalshi's open events within a time budget; a category or a narrower keyword returns faster.

### Data source and license

Prices come from Kalshi's public Trade API v2 and Polymarket's public gamma and CLOB APIs, which both venues publish for read access without an account. The actor only reads public market data. It does not trade, place orders or log in.

### Related actors

- [SEC EDGAR Filings Monitor](https://apify.com/transparent_meteorite/sec-edgar-filings-monitor): new SEC filings by company or form type, for event-driven research next to market odds.
- [Federal Register Rules and Notices Monitor](https://apify.com/transparent_meteorite/federal-register-rules-notices-monitor): new US federal rules and notices, useful for policy and regulation markets.
- [DeFi Protocol TVL and Yields Monitor](https://apify.com/transparent_meteorite/defi-protocol-tvl-yields-monitor): on-chain protocol TVL and yields, for crypto research alongside crypto price markets.

### Use with the API, n8n, Make, Zapier or AI agents

**API** (one call, returns the rows as JSON):

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~prediction-market-spread-finder/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keyword":"fed","maxItems":30}'
```

The call waits up to 5 minutes. For bigger inputs, start the run with `/runs` instead and read the dataset when it finishes.

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/prediction-market-spread-finder").call(run_input={"keyword": "fed", "maxItems": 30})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row)
```

- **n8n, Make, Zapier:** use the Apify app's "Run Actor" step with actor `transparent_meteorite/prediction-market-spread-finder`, paste the input JSON, then map the dataset items to your sheet or CRM.
- **Clay:** add an HTTP API column that calls the run-sync endpoint above.
- **Schedules:** in Apify Console, Schedules, run it daily or weekly with the same input for a steady feed.
- **AI agents (MCP):** connect the Apify MCP server at `https://mcp.apify.com?tools=transparent_meteorite/prediction-market-spread-finder` to Claude, Cursor or any MCP client, and your agent can run Prediction Market Spread Finder on request.

### FAQ

**Do I need a Kalshi or Polymarket account or API key?**
No. Both venues publish these prices through public, keyless APIs. You only need an Apify account.

**How does it decide two markets are the same question?**
Each title is folded to a normalized topic (subject, direction, strike, month, year). A pair needs a similarity of 0.62 or more, identical strikes, direction and dates, and close times that agree. `matchScore` shows the similarity on every pair.

**What is the difference between `spread` and `crossVenueEdge`?**
`spread` compares mid prices (yes here minus yes there). `crossVenueEdge` uses the asks you would actually pay: buying yes on one venue and no on the other. A positive edge means the two asks sum to less than $1 before fees.

**Why is Kalshi volume so much larger than Polymarket volume on the same market?**
Kalshi counts contracts with $1 face value; Polymarket counts USDC traded. Use `volumeUnit` before comparing them.

**Can I get only one venue?**
Yes. Set `sources` to `["kalshi"]` or `["polymarket"]`. Matching and spread fields are then empty.

**How fresh are the prices?**
Prices are read at run time. Polymarket prices are refreshed from the CLOB order book by default, and every row carries `fetchedAt`.

**How much does a typical run cost?**
$0.001 per market row. 30 rows cost about $0.03, 1,000 rows about $1.00.

# Actor input Schema

## `keyword` (type: `string`):

Words that must appear in the market or event title, for example fed, bitcoin, election, cpi, recession. Leave empty to list the highest-volume open markets of the chosen categories.

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

Normalized topic categories, mapped to Kalshi categories and Polymarket tags. Empty = Politics, Elections, Economics, Finance and Crypto when no keyword is set; all categories when a keyword is set.

## `sources` (type: `array`):

Which venues to read. Cross-venue matching and spreads need both.

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

Only open (tradable) markets are tracked.

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

Skip markets with lower lifetime volume. Kalshi volume is in contracts ($1 face value each); Polymarket volume is in USDC. 0 = no minimum.

## `closesWithinDays` (type: `integer`):

Only markets that close within this many days. Empty = any close date.

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

Stop after this many market rows (you are charged per row delivered).

## `matchAcrossVenues` (type: `boolean`):

Pair each Kalshi market with the Polymarket market asking the same question (same subject, date, strike and direction) and add matchedYesPrice, spread and crossVenueEdge.

## `onlyMatched` (type: `boolean`):

Return only markets that have a counterpart on the other venue.

## `minAbsSpread` (type: `number`):

Only return matched markets whose yes-price difference between venues is at least this much, as a decimal (0.03 = 3 points). 0 = off.

## `refreshPolymarketPrices` (type: `boolean`):

Read live best bid/ask for Polymarket markets from the public CLOB order book instead of the cached gamma price.

## Actor input object example

```json
{
  "keyword": "fed",
  "sources": [
    "kalshi",
    "polymarket"
  ],
  "status": "open",
  "minVolume": 0,
  "maxItems": 25,
  "matchAcrossVenues": true,
  "onlyMatched": false,
  "minAbsSpread": 0,
  "refreshPolymarketPrices": true
}
```

# Actor output Schema

## `overview` (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 = {
    "keyword": "fed",
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/prediction-market-spread-finder").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 = {
    "keyword": "fed",
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/prediction-market-spread-finder").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 '{
  "keyword": "fed",
  "maxItems": 25
}' |
apify call transparent_meteorite/prediction-market-spread-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/prediction-market-spread-finder"
        }
    }
}
```

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/cCoUavHLk4amEVgO7/builds/EZws52eTyeoyR1t0b/openapi.json
