# Polymarket & Kalshi Odds vs Pinnacle Fair Probability (MCP) (`sharplinelabs/polymarket-kalshi-odds-mcp`) Actor

Sports odds API and MCP server for AI agents. Get the Pinnacle no-vig fair probability for any game, live Polymarket and Kalshi prices, and the true edge after fees at your size. NFL, NBA, NHL, MLB, college football, EPL, Champions League, La Liga, ATP/WTA tennis and more. Pay per call.

- **URL**: https://apify.com/sharplinelabs/polymarket-kalshi-odds-mcp.md
- **Developed by:** [SharpLine Labs](https://apify.com/sharplinelabs) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 fair probabilities

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Polymarket & Kalshi Odds vs Pinnacle Fair Probability (MCP + API)

**Sports odds API and MCP server for AI agents.** Name a game and get the **Pinnacle no-vig fair probability**, the **live Polymarket and Kalshi prices** for the same game, and the **true edge after fees at your trade size**. One call, no API keys to manage, pay per result.

Use it as a prediction-market odds API, a sharp-line reference for trading bots, or a "is this price fair?" tool inside Claude, ChatGPT, Cursor or any MCP client.

### What it answers

- *"What's the real chance Arsenal beat Forest?"* or *"…Sinner beats Alcaraz?"* → `fair_probability`
- *"Is the Polymarket price for the Heat fair, and what would $250 cost me after fees?"* → `compare_venues`
- *"Where are Polymarket or Kalshi cheaper than the sharp line in the NBA tonight?"* → `scan_mispricings`
- *"Does this market settle on 90 minutes or include extra time?"* → `resolution_check`

### Coverage

- **Soccer** (3-way home/draw/away, 90 minutes + stoppage): Premier League (`epl`), Champions League (`ucl`), Europa League (`uel`), La Liga (`laliga`), Serie A (`seriea`), Bundesliga (`bundesliga`), Ligue 1 (`ligue1`), EFL Championship (`championship`), MLS (`mls`), Liga MX (`ligamx`), Brasileirão Série A (`brasileirao`), Saudi Pro League (`saudipl`).
- **US sports** (winner incl. OT): NBA (`nba`), NFL (`nfl`), College Football (`ncaaf`), NHL (`nhl`), MLB (`mlb`).
- **Tennis** (match winner, main-tour singles): ATP (`atp`), WTA (`wta`).

Pre-match; in-play answers are flagged as indicative. Live check on 2026-10-17: 98% of Pinnacle games in these leagues matched on Polymarket and 99% on Kalshi (287 games).

### How it works

1. Pinnacle (the sharpest book) prices are fetched live, and the bookmaker margin is removed (multiplicative).
2. The same game is found on Polymarket and Kalshi (names and kickoff time are matched automatically).
3. `compare_venues` walks each order book for your size and adds taker fees (Polymarket sports 0.05·p·(1−p) per share; Kalshi 0.07·C·p·(1−p) rounded up per order). It then reports all-in cost, expected value per share, ROI and a verdict.

Most of the time the honest answer is **no edge**. That's the point: a calibrated reference price, not hype.

### Tools and pricing (pay per successful result; errors are free)

| Tool | Price |
|---|---|
| `fair_probability(league, team, date?)` | $0.01 |
| `compare_venues(league, team, date?, size_usd=100, min_edge=0.01)` | $0.03 |
| `scan_mispricings(league, min_edge=0.02)` | $0.10 |
| `resolution_check(league, team, date?)` | $0.02 |

### Connect (MCP)

```json
{ "mcpServers": { "polymarket-kalshi-odds": {
  "url": "https://sharplinelabs--polymarket-kalshi-odds-mcp.apify.actor/mcp",
  "headers": { "Authorization": "Bearer <APIFY_API_TOKEN>" } } } }
```

Or run it as a normal Actor with input `{"tool": "fair_probability", "league": "epl", "team": "Arsenal"}`.

### Example output (fair_probability, live run 2026-10-16)

```json
{"ok": true, "league": "epl",
 "game": {"home": "Nottingham Forest", "away": "Arsenal", "start_utc": "2026-10-18T15:30:00Z"},
 "fair_probability": {"home": 0.1639, "away": 0.5783, "draw": 0.2577},
 "pinnacle": {"margin": 0.0374, "max_stake_usd": 4500, "source": "direct"},
 "venues": {"polymarket": {"matched": true, "prices": {"away": {"bid": 0.59, "ask": 0.60, "mid": 0.595, "gap_vs_fair": 0.0167}}},
            "kalshi": {"matched": true, "prices": {"away": {"bid": 0.59, "ask": 0.60, "mid": 0.595, "gap_vs_fair": 0.0167}}}},
 "warnings": [], "disclaimer": "Informational only. Not betting or investment advice."}
```

### FAQ

**Is there a Polymarket or Kalshi odds API with fair value built in?** Yes, that's this Actor. It returns venue prices next to the Pinnacle no-vig probability, so you see the gap directly.

**What is a no-vig (fair) probability?** The bookmaker's implied probabilities minus its margin. Pinnacle is the sharpest, highest-limit book, so its de-vigged line is the standard reference for "true" odds.

**Does it include fees?** Yes. `compare_venues` walks the real order book for your size and adds Polymarket and Kalshi taker fees before computing edge and ROI.

**Can my AI agent use it?** Yes. Connect the MCP URL above (Claude Desktop, Claude Code, Cursor, ChatGPT connectors, n8n, LangChain). Tool descriptions list every league code, and errors return suggestions instead of failing silently.

**Is it real-time?** Every call fetches live data (cached up to 30 seconds). Pre-match is the main use; in-play answers are flagged as indicative.

**Which sports?** NFL, NBA, NHL, MLB, college football, 12 soccer leagues (EPL, Champions League, Europa League, La Liga, Serie A, Bundesliga, Ligue 1, Championship, MLS, Liga MX, Brasileirão, Saudi Pro League) and ATP/WTA tennis.

### Notes

Data comes from public endpoints of Pinnacle, Polymarket and Kalshi. If Pinnacle is unreachable, the Actor falls back to the `lergassy/pinnacle-odds-api` Actor, billed to you at its own price. Informational only. Not betting or investment advice. Check your local laws.

# Actor input Schema

## `tool` (type: `string`):

fair_probability: Pinnacle no-vig probability vs Polymarket/Kalshi prices. compare_venues: order-book fill, fees and edge at your size. scan_mispricings: all upcoming games in the league. resolution_check: how each venue settles.

## `league` (type: `string`):

League code.

## `team` (type: `string`):

One team or player in the game, any common spelling (e.g. 'Arsenal', 'Man Utd', 'Heat', 'Sinner'). Not needed for scan_mispricings.

## `date` (type: `string`):

Optional, YYYY-MM-DD (UTC). Defaults to the team's next game.

## `sizeUsd` (type: `integer`):

compare_venues only: dollars to fill against each order book.

## `minEdgePercent` (type: `integer`):

Edge threshold in probability points. 2 = 2%.

## Actor input object example

```json
{
  "tool": "fair_probability",
  "league": "epl",
  "team": "Arsenal",
  "sizeUsd": 100,
  "minEdgePercent": 2
}
```

# Actor output Schema

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

The tool result item(s) in the default dataset.

# 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 = {
    "team": "Arsenal"
};

// Run the Actor and wait for it to finish
const run = await client.actor("sharplinelabs/polymarket-kalshi-odds-mcp").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 = { "team": "Arsenal" }

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

```

## MCP server setup

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

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/d4aNEiKeKpKwqWrzi/builds/cl1Ee6KigKfwdBCls/openapi.json