Polymarket & Kalshi Odds vs Pinnacle Fair Probability

npx add-mcp 'https://sharplinelabs--polymarket-kalshi-odds-mcp.apify.actor/mcp'

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 (community)
• Stats: 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
• User rating: 5.00 out of 5 stars

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 section below.

Each client library has reference documentation the quickstart does not restate: JavaScript/TypeScript (npm install apify-client) and Python (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).
• Fights (winner): UFC (ufc), Boxing (boxing).

Markets

Pass market (default winner). Lines are compared only when Polymarket/Kalshi list the exact same line as Pinnacle (half lines like 2.5; quarter lines are skipped).

market	Sports	Example
winner	all	Arsenal to win
first_half_winner	soccer	Arsenal leading at half-time
total, first_half_total	soccer, US sports	Over/Under 2.5 goals, 47.5 points
spread, first_half_spread	soccer, US sports	Arsenal -1.5; pass line from the queried team's view
team_total	soccer, US sports	the queried team's goals/points O/U
btts	soccer	both teams to score
set_winner (+ set_number)	tennis	Sinner wins set 1
total_games, spread_games	tennis	Over 21.5 games, -3.5 games

line is optional: without it you get Pinnacle's main line plus lines_available (every line also listed on a venue). scan_mispricings also takes market="all", a date (one day, UTC) and sort_by (edge or kickoff). It lists every matched price vs fair in lines, flags the ones above min_edge as opportunities, and in a normal Actor run writes one dataset row per price (see the League scan tab).

De-vig methods

devig_method chooses how Pinnacle's margin is removed:

• shin (default): puts more of the margin on longshots and draws, which is how books actually price. Most accurate in published studies.
• multiplicative: removes the margin in proportion to each price. Tends to leave longshots and draws a little too high.
• power: the harshest on longshots; the most conservative fair price for underdogs.
• none: raw Pinnacle prices with the margin left in. This inflates the fair price, so it is the most lenient setting; use it only for comparison.

Every opportunity carries robust: true only when the edge holds under all four methods.

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?, market?, line?, set_number?, devig_method?)	$0.01
compare_venues(league, team, date?, size_usd=100, min_edge=0.01, market?, line?, set_number?, devig_method?)	$0.03
scan_mispricings(league, min_edge=0.02, market?, date?, sort_by?, devig_method?)	$0.10
resolution_check(league, team, date?, market?, set_number?)	$0.02

Connect (MCP)

{ "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)

{"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.

Which markets are covered? Match winner everywhere, plus totals, spreads, team totals and first-half markets (soccer and US sports), both teams to score (soccer), set winner / total games / games spread (tennis), and UFC and boxing fight winners.

Which de-vig method should I use? Keep the default shin. Use power for a stricter test, and look at robust to see whether an edge depends on the method (it must hold under all four).

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):

Scan a whole league: every upcoming game, every venue price vs the Pinnacle fair price, best edge first. Fair probability: one game's no-vig price vs Polymarket/Kalshi. Compare venues: order-book fill, fees and edge at your size. How each venue settles: resolution rules.

league (type: string):

Sport and competition. Only games listed on Pinnacle and on Polymarket or Kalshi are compared.

team (type: string):

One team or player in the game, any common spelling ('Arsenal', 'Man Utd', 'Heat', 'Sinner'). Required for single-game tools; ignored by the league scan.

market (type: string):

Which bet to price. The label shows the sports it exists for. 'All markets' works only with the league scan.

line (type: string):

Optional. Total line (2.5) or spread from the queried team's view (-1.5). Empty = Pinnacle's main line.

setNumber (type: integer):

Tennis set_winner only. Default 1.

date (type: string):

Optional. Pick a day (UTC), or a relative day like 'today', '+1 day'. Single-game tools: the team's game on that day (default: next game). League scan: only games on that day (default: all upcoming).

sortBy (type: string):

League scan only. Biggest edge first, or by kickoff time (games grouped together).

sizeUsd (type: integer):

compare_venues only: dollars to fill against each order book.

minEdgePercent (type: integer):

Optional edge threshold in probability points (2 = 2%). Default 0: every price at or above fair is flagged. The scan always lists every price either way.

devigMethod (type: string):

How Pinnacle's margin is removed. Shin (default): most accurate, removes more margin from longshots and draws. Multiplicative: proportional. Power: harshest on longshots. None: raw Pinnacle prices with the margin left in, which inflates fair prices (most lenient, for comparison only).

Actor input object example

{
  "tool": "fair_probability",
  "league": "epl",
  "team": "Arsenal",
  "market": "winner",
  "sortBy": "edge",
  "sizeUsd": 100,
  "minEdgePercent": 0,
  "devigMethod": "shin"
}

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

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

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

echo '{
  "team": "Arsenal"
}' |
apify call sharplinelabs/polymarket-kalshi-odds-mcp --silent --output-dataset

MCP server setup

{
    "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/aNOUY8yYvjCCHK14o/openapi.json