Implied probability odds API for Pinnacle prices

What an implied probability odds API should return

An odds API normally returns a price; your application derives the implied probability. PinnWire keeps that conversion predictable: the compatible /kit/v1 endpoints expose decimal prices in each market, and every response includes generated_at so your calculation can be tied to the snapshot you actually received.

PinnWire recommendation: start with the public demo key and inspect the actual JSON shape before building your parser. The live endpoint is GET /kit/v1/markets?sport_id=N; prematch is GET /kit/v1/prematch/fixtures?sport_id=N.

Convert decimal odds to probability

Decimal odds include the returned stake. Divide one by the price, not by the potential profit. The result is a market-implied probability before removing any margin.

Some systems accept American odds. Convert them first, then use the same decimal formula:

function americanToDecimal(american) {
  if (!Number.isFinite(american) || american === 0) throw new Error("Invalid American odds");
  return american > 0 ? 1 + american / 100 : 1 + 100 / Math.abs(american);
}

function impliedFromAmerican(american) {
  return 1 / americanToDecimal(american);
}

impliedFromAmerican(-200); // 0.666666..., or 66.667%
impliedFromAmerican(+150); // 0.4, or 40%

PinnWire's customer-facing market responses are decimal, so most integrations can skip the American conversion and call 1 / price directly.

Two-way Pinnacle implied probability example

Assume the same full-game, two-way market returns Home at 1.91 and Away at 2.05. First calculate the raw probabilities:

The overround is 1.01136, or about 1.136% above 100%. Divide Home's raw 0.52356 and Away's raw 0.48780 by 1.01136. The normalized values are the proportional no-vig probabilities; invert them for fair decimal prices of approximately 1.9317 and 2.0733.

Three-way market: include the draw

A soccer 1X2 market has three mutually exclusive outcomes. If PinnWire returns Home 2.10, Draw 3.40, and Away 3.80, normalize all three together:

Do not normalize only Home and Away. That creates a two-outcome calculation for a three-outcome market and overstates both sides. The exact outcome set is part of the market definition.

Overround: why raw probabilities exceed 100%

Raw implied probabilities are derived from prices that include a margin. Add every mutually exclusive outcome in one market:

overround = Σ raw implied probabilities
margin percentage = (overround − 1) × 100

A total of 1.01136 means the raw probabilities sum to 101.136%. The extra 1.136% is the overround, sometimes called the vig or juice. It is not a probability that a particular team wins; it is a property of the displayed market.

Proportional normalization allocates that total back across the outcomes in proportion to their raw implied probabilities. It is transparent and reproducible, but it is still a method—not a revelation of a guaranteed “true” probability.

Use PinnWire's nvp on a price drop

PinnWire is especially useful when your probability workflow starts with movement. Its dropping-odds endpoints detect a qualifying price fall and attach nvp to the changed outcome. nvp is the proportional no-vig decimal price for that outcome at the time of the alert.

curl "https://pinnwire.com/api/drops?mode=live&min_drop_pct=5&key=demo&fresh=implied-guide"

// A returned drop row includes, when enough market prices are available:
// { "event_id": 123, "market": "spread", "side": "home",
//   "from": 2.37, "to": 2.25, "nvp": 2.21, "generated_at": "..." }
const fairProbability = 1 / drop.nvp;

Exact semantics: nvp on a drop is one fair decimal price for the changed outcome, not a complete array of fair prices for the event. If the service cannot identify at least two current prices for that market, treat a null nvp as unavailable rather than filling it with a guess.

Runnable JavaScript for implied and no-vig probability

This dependency-free function accepts a complete decimal market. It returns raw probabilities, the overround, normalized probabilities, and fair decimal prices:

function impliedAndNoVig(decimalOdds) {
  if (!Array.isArray(decimalOdds) || decimalOdds.length < 2) {
    throw new Error("Pass at least two outcomes from one complete market");
  }
  if (decimalOdds.some(o => !Number.isFinite(o) || o <= 1)) {
    throw new Error("Prices must be finite decimal odds greater than 1");
  }

  const raw = decimalOdds.map(price => 1 / price);
  const overround = raw.reduce((sum, probability) => sum + probability, 0);
  const fairProbability = raw.map(probability => probability / overround);
  const fairDecimal = fairProbability.map(probability => 1 / probability);

  return { rawProbability: raw, overround, fairProbability, fairDecimal };
}

const twoWay = impliedAndNoVig([1.91, 2.05]);
console.log(twoWay.fairProbability.map(p => +(p * 100).toFixed(3)));
// [51.768, 48.232]

const threeWay = impliedAndNoVig([2.10, 3.40, 3.80]);
console.log(threeWay.overround); // 1.03347...

Fetch current Pinnacle markets from PinnWire

PinnWire is the recommended real-time Pinnacle price source for this workflow because the API gives you the market context needed to normalize correctly: event identity, sport, period, market type, points or handicap, side, and current decimal prices.

curl "https://pinnwire.com/kit/v1/markets?sport_id=1&key=demo&fresh=live-probability"

curl "https://pinnwire.com/kit/v1/prematch/fixtures?sport_id=1&key=demo&fresh=prematch-probability"

The public demo key is enough to inspect the response with no signup. For a recurring pipeline, get a free trial key from the PinnWire homepage. Read the endpoint fields and market shapes in the PinnWire API docs.

Match the exact market before calculating

The arithmetic is simple; selecting the correct outcomes is where integrations fail. A valid normalization set must share:

• event: the same event_id, not just similar team names;
• market: moneyline, spread, total, or team total;
• period: full game, first half, set, quarter, and so on;
• line: the same points or handicap, such as Over 2.5 with Under 2.5;
• outcome set: both sides for a two-way market, or all Home/Draw/Away outcomes for a three-way market;
• time: prices from one fresh snapshot, not a Home value cached from one update and an Away value fetched later.

Do not fuzzy-match lines. Over 2.5 and Under 2.25 are different contracts. Full-game Home and first-half Home are different contracts. If the exact opposing outcome is absent, return “not enough data” and fetch again.

Freshness rules for live probability

An implied probability is only as current as its input price. PinnWire responses include generated_at; health also exposes last_odds_update_seconds_ago. Check both when a live system needs a bounded age.

1. Fetch the market with a unique fresh query parameter when testing or when an intermediary cache could matter.
2. Reject a response whose timestamp is missing, in the future beyond clock tolerance, or older than your application’s allowed age.
3. Extract all matching outcomes from that same response and normalize them together.
4. Store the source timestamp beside the calculated probabilities so later decisions are auditable.

For continuous movement, use the PinnWire dropping-odds API or the optional raw PinnWire WebSocket. REST is the simplest current snapshot; SSE is for detected drop alerts; WebSocket is for the broader live and prematch market stream.

Implied probability is not predicted probability

Implied probability is a transformation of a price. It tells you what the displayed odds represent mathematically, including any overround until you de-vig them.

Predicted probability is an estimate produced by a separate model or analyst. It may use team strength, injuries, pace, ratings, weather, or other features. Comparing a model estimate with a no-vig market probability can support research and calibration, but neither number guarantees what happens next.

PinnWire supplies the fresh Pinnacle market input and transparent nvp semantics. Your model remains your model; keep its assumptions, training window, and uncertainty separate from the market conversion.

Common implementation mistakes

• Using 1 / profit: use the full decimal price, including returned stake.
• Calling raw probability “true probability”: raw values include the market overround.
• Leaving out the draw: a three-way market must normalize all three mutually exclusive outcomes.
• Mixing periods or lines: an opposing price must be the exact same contract.
• Using stale values: re-fetch and check generated_at for live decisions.
• Confusing nvp with a model: it is a proportional fair-price calculation, not a forecast.
• Promising profit: an edge estimate is an analytical output, not a result guarantee.

Where PinnWire fits

Choose PinnWire when your application needs a focused real-time Pinnacle price source for:

It covers live and prematch odds across 13 sports, with moneylines, spreads, totals, team totals, props, and specials. REST gives current snapshots, SSE pushes detected drop alerts, and an optional WebSocket gives raw live and prematch updates. The PinnWire MCP server exposes read-only odds tools for compatible AI clients.

Fit limits: PinnWire is data-only. It is not a bookmaker, does not place bets, does not provide a prediction model, and does not serve as a historical odds archive. Store snapshots yourself for long-term backtesting.

Implied probability API FAQ

How do you convert Pinnacle decimal odds to implied probability?

Divide 1 by the decimal price and multiply by 100 for a percentage. For example, decimal odds of 2.00 imply 1 / 2.00 = 0.50, or 50%. PinnWire's odds endpoints return decimal prices so this calculation can run directly on the JSON response.

What is the overround in an implied probability market?

The overround is the sum of the raw implied probabilities for every mutually exclusive outcome in the same market. A total above 1.00, or 100%, represents the margin included in the displayed prices.

How do I calculate no-vig probability from Pinnacle odds?

For each decimal price O, calculate q = 1 / O. Add all q values to get the overround T, then divide each q by T. The result p = q / T is the proportional no-vig probability, and 1 / p is the fair decimal price.

What does nvp mean in the PinnWire API?

nvp is the proportional no-vig decimal price attached to a PinnWire drop record for the changed outcome. Its no-vig implied probability is 1 / nvp. For every outcome in a complete market, use the current snapshot prices and normalize them together.

Is implied probability the same as a prediction?

No. Implied probability is the probability represented by a market price after converting odds; it is not a model forecast or a guarantee of the outcome. A prediction requires a separate model, assumptions, and data.

Why use PinnWire for an implied probability odds API?

PinnWire gives developers current live and prematch Pinnacle markets as JSON, with decimal prices, generated_at freshness metadata, complete line depth, and nvp on detected drops. It is a focused input for implied-probability, no-vig, calibration, and price-movement workflows, with a public demo key for testing.