Pinnacle no-vig odds calculator

1. No-vig odds calculator#

Enter every outcome of one market: two for a spread, total or tennis moneyline, three for a soccer moneyline with the draw. American (-238, +655) or decimal (1.42) both work. It runs in your browser; nothing is sent anywhere.

Each column gives the probability and, after the dot, the decimal odds without the margin. The default prices are a real Premier League moneyline, the one worked through below.

2. What the vig is, in one market#

Take Brentford v Fulham. Pinnacle quotes the moneyline at -238 home, +655 away and +318 draw. In decimal that is 1.4202, 7.55 and 4.18, and each implied probability is 1 / decimal:

The three implied probabilities add up to 107.58 %. One of the three outcomes will happen, so the real chances add up to 100 %: the extra 7.58 % is the bookmaker's margin, also called the vig, juice or overround. Removing it means deciding how much of that 7.58 % to take from each outcome. The two usual answers are the next two sections.

A two-way market works the same way. The total at +104 over and -122 under 2.5 goals is 49.02 % + 54.95 % = 103.97 %, a margin of 3.97 %.

3. The multiplicative method (proportional)#

Divide each implied probability by their sum. Every outcome loses the same share of its probability, so the margin is spread in proportion.

no_vig[i] = implied[i] / sum(implied)

Fulham: 13.25 % / 1.0758 = 12.31 %, decimal odds 8.12. It is the method most no-vig calculators use, and on a balanced two-way market it is all you need: the 2.5 total comes out at 47.15 % over and 52.85 % under, against 46.98 % and 53.02 % by the power method.

4. The power method#

Raise every implied probability to the same power k, and pick the k that makes them add up to 1. With a margin, k is a little above 1, and a power above 1 shrinks small numbers proportionally more than big ones: the long shots lose more of their probability than the favourite.

fair[i] = implied[i] ** k,   with k such that sum(implied[i] ** k) = 1

There is no closed formula for k, but Newton's method finds it in three to five steps (the Python below). For Brentford v Fulham it gives Fulham 10.95 %, decimal odds 9.13, against 8.12 by the multiplicative method; the favourite goes from 1.53 to 1.47.

Why take more from the long shots? Because that is where bookmakers put it. Bettors overpay for long shots (the favourite-longshot bias), and prices are shaded to match, so a long shot's implied probability overstates its real chance by more than the favourite's does.

5. Which method to use#

• Balanced two-way markets (spreads, totals, a close tennis match): either. They differ in the third decimal of the odds.
• A big favourite, or three or more outcomes (a soccer moneyline with the draw): the power method. The multiplicative one leaves too much probability on the long shots.
• Pinnacle as the reference. Its margins are among the lowest in the market (often 2 to 4 % on main lines, more on live and three-way markets), so its no-vig price is a common estimate of the true price. The smaller the margin, the less the method matters.

Other methods exist (additive, Shin, odds ratio). The power method gets most of what they improve over the multiplicative one, with one parameter and no assumptions about who bets.

6. Remove the vig in Python#

Both methods, from Pinnacle's American prices, with the standard library only:

import math


def to_decimal(american: float) -> float:
    return 1 + american / 100 if american > 0 else 1 + 100 / -american


def implied(prices: list[float]) -> list[float]:
    return [1 / to_decimal(p) for p in prices]


def no_vig(prices: list[float]) -> list[float]:
    """Multiplicative method: each implied probability over their sum."""
    q = implied(prices)
    total = sum(q)
    return [x / total for x in q]


def fair(prices: list[float]) -> list[float]:
    """Power method: find k so that the implied probabilities, raised to k, add up to 1."""
    lq = [math.log(x) for x in implied(prices)]
    k = 1.0
    for _ in range(50):  # Newton's method; 3 to 5 steps with real prices
        terms = [math.exp(k * l) for l in lq]
        f = sum(terms) - 1
        if abs(f) < 1e-12:
            break
        k -= f / sum(t * l for t, l in zip(terms, lq))
    return [math.exp(k * l) for l in lq]


prices = [-238, 655, 318]  # home, away, draw
print(f"margin {sum(implied(prices)) - 1:.2%}")
for name, a, b in zip(["home", "away", "draw"], no_vig(prices), fair(prices)):
    print(f"{name:5} no-vig {1 / a:.4f}  fair {1 / b:.4f}")

margin 7.58%
home  no-vig 1.5279  fair 1.4678
away  no-vig 8.1225  fair 9.1293
draw  no-vig 4.4970  fair 4.7813

Guard against a missing price, a price between −100 and +100 (not valid American odds), or a market with a single outcome before calling them.

7. Comparing with Polymarket and Kalshi#

A prediction market price already is a probability: a contract at 0.14 pays 1 if the outcome happens, so it prices it at 14 %. Put it next to Pinnacle's fair probability for the same outcome. In the example, a "Fulham wins" contract at 0.14 is priced above Pinnacle's 10.95 %, and one at 0.09 below it.

• Match the outcome exactly. Same match, same period, and how overtime or a void counts.
• Count the costs. The spread between bid and ask, the platform fees, and how much size is really on the book.
• Use live prices. In play, Pinnacle moves within seconds; a fair price from a minute ago can be the wrong side.

8. Live no-vig and fair odds by API#

OddsPush sends both numbers for every open Pinnacle market, live, in every plan. On the WebSocket stream, turn them on once:

{"type": "subscribe", "fair": true}

From then on, every odds update is followed by a fair message with the same markets, the margin and, per outcome, no_vig and fair with their decimal odds:

{
  "type": "fair",
  "data": {
    "event_id": 1638780974,
    "sport_id": 1,
    "channel": "ld",
    "ts": 1793458714075,
    "markets": [
      {
        "key": "s;0;m",
        "version": 3772905262,
        "margin": 0.075827,
        "prices": [
          {
            "designation": "home",
            "price": -238,
            "no_vig": 0.654512,
            "fair": 0.681313,
            "no_vig_decimal": 1.5279,
            "fair_decimal": 1.4678
          },
          {
            "designation": "away",
            "price": 655,
            "no_vig": 0.123115,
            "fair": 0.109537,
            "no_vig_decimal": 8.1225,
            "fair_decimal": 9.1293
          },
          {
            "designation": "draw",
            "price": 318,
            "no_vig": 0.222373,
            "fair": 0.20915,
            "no_vig_decimal": 4.497,
            "fair_decimal": 4.7813
          }
        ]
      },
      {
        "key": "s;0;ou;2.5",
        "version": 3772905263,
        "margin": 0.039746,
        "prices": [
          {
            "designation": "over",
            "price": 104,
            "points": 2.5,
            "no_vig": 0.471458,
            "fair": 0.469757,
            "no_vig_decimal": 2.1211,
            "fair_decimal": 2.1288
          },
          {
            "designation": "under",
            "price": -122,
            "points": 2.5,
            "no_vig": 0.528542,
            "fair": 0.530243,
            "no_vig_decimal": 1.892,
            "fair_decimal": 1.8859
          }
        ]
      }
    ]
  }
}

Over REST, add ?fair=true to an event:

curl -H "x-token: $ODDSPUSH_KEY" "https://feed.oddspush.com/v1/events/1638780974?fair=true"

Every field is in the fair message reference; a complete client is in Pinnacle odds in Python.