No vig odds API: fair odds data

No vig odds API data: implied probabilities from every book with format=probability, so you can remove the margin from any market and get fair odds.

PreciseAPI returns each book’s posted price with the margin left in, so a no vig odds API workflow is format=probability plus a few lines of de-vig code. Over MCP, find_outliers computes fair prices against the market consensus or a sharp book for you.

A no vig odds API gives you prices with the bookmaker's margin taken out, which is the market's own estimate of the true probability. PreciseAPI's REST endpoints return each book's posted price with the margin left in, on purpose, so you choose the de-vig method your product needs. Ask for format=probability and every price arrives as an implied probability, which turns the de-vig into a few lines of code. Over MCP, the find_outliers tool computes fair prices for you. This page covers the math, the methods, the requests and the edge cases.

What the vig is and how to measure it

Convert each side of a market to implied probability (1 / decimal odds) and add them up. A fair coin flip priced at −110 on both sides implies 52.38% twice, or 104.76% in total. The 4.76% above 100% is the overround: the margin the book builds in, also called the vig. Every book carries one, and the size varies by book and market. Sharp books usually run thin margins on main lines, while player props and futures often carry far more. The sportsbook hold entry and measuring sportsbook hold go deeper.

Removing the margin is called de-vigging. What is left is a set of probabilities that add up to exactly 100%, and the prices they imply are the fair or no-vig odds.

De-vig methods

There is no single correct way to split the margin across the sides. Four methods cover nearly everything you will see:

Here is one market, −150 / +130, under three of them. Implied probabilities are 60.00% and 43.48%, an overround of 3.48%:

MethodFavoriteUnderdogFair prices
Multiplicative57.98%42.02%−138 / +138
Additive58.26%41.74%−140 / +140
Power58.40%41.60%−140 / +140

On two-way main lines the methods differ by tenths of a percent. On long futures boards the gap is much wider. The power method fits in a few lines of Python:

def power_devig(implied, tol=1e-10):
    lo, hi = 1.0, 10.0
    while hi - lo > tol:
        k = (lo + hi) / 2
        if sum(p ** k for p in implied) > 1:
            lo = k
        else:
            hi = k
    return [p ** lo for p in implied]

print(power_devig([0.6, 0.4348]))  # [0.584, 0.416]

How to devig odds works through every method, Shin included, and the no vig calculator runs them on any prices you enter.

No vig odds API data: format=probability

Every odds endpoint takes format=probability, which returns each price as the implied probability, margin included, rounded to four decimal places. Lines and points don't change. Use /v1/odds (2 credits, up to 200 events of game lines) for a league, /v1/events/{id}/odds (2 credits) for one game, /v1/props (3 credits) for player props and /v1/futures (2 credits) for futures boards.

curl "https://api.preciseapi.com/v1/odds?league=nfl&markets=spread&books=pinnacle,draftkings&format=probability" \
  -H "Authorization: Bearer $PRECISEAPI_KEY"

A shortened response:

{
  "id": "evt_0iydmltearh",
  "league": "nfl",
  "status": "scheduled",
  "home": { "id": "nfl_mia", "name": "Miami Dolphins", "abbr": "MIA" },
  "away": { "id": "nfl_bal", "name": "Baltimore Ravens", "abbr": "BAL" },
  "bookmakers": [
    {
      "id": "pinnacle", "name": "Pinnacle", "type": "sportsbook",
      "markets": [{ "id": "mkt_19gvfk2ks6p", "key": "spread", "period": "full_game", "line": 2.5,
        "outcomes": [
          { "id": "sel_1d92w0erhd2", "name": "Miami Dolphins", "side": "home", "point": 2.5, "price": 0.5192 },
          { "id": "sel_1lhzilnwepp", "name": "Baltimore Ravens", "side": "away", "point": -2.5, "price": 0.505 }
        ], "suspended": false, "updated_at": "2026-11-11T17:58:40.118Z" }]
    },
    {
      "id": "draftkings", "name": "DraftKings", "type": "sportsbook",
      "markets": [{ "id": "mkt_14ivq762bz0", "key": "spread", "period": "full_game", "line": 2.5,
        "outcomes": [
          { "id": "sel_1d92w0erhd2", "name": "Miami Dolphins", "side": "home", "point": 2.5, "price": 0.5349 },
          { "id": "sel_1lhzilnwepp", "name": "Baltimore Ravens", "side": "away", "point": -2.5, "price": 0.5122 }
        ], "suspended": false, "updated_at": "2026-11-11T17:58:36.774Z" }]
    }
  ]
}

Pinnacle's sides add up to 102.42% and DraftKings' to 104.71%. De-vigged, Pinnacle makes Miami +2.5 a 50.70% chance (about −103) and DraftKings 51.08% (about −104).

De-vig in JavaScript

This loop turns the REST response into a no vig odds API of your own: it prints the overround and the multiplicative fair price for every market at every book.

const res = await fetch(
  'https://api.preciseapi.com/v1/odds?league=nfl&markets=moneyline,spread,total&books=pinnacle,circa,draftkings&format=probability',
  { headers: { Authorization: `Bearer ${process.env.PRECISEAPI_KEY}` } },
);
const { data } = await res.json();
const toAmerican = (p) => (p >= 0.5 ? -Math.round((100 * p) / (1 - p)) : Math.round((100 * (1 - p)) / p));

for (const event of data) {
  for (const book of event.bookmakers) {
    for (const m of book.markets) {
      const implied = m.outcomes.map((o) => o.price);
      if (implied.length < 2 || implied.some((p) => !p)) continue;
      const total = implied.reduce((a, b) => a + b, 0);
      const fair = implied.map((p) => p / total);
      const sides = m.outcomes.map((o, i) => `${o.name} ${o.point ?? ''} ${(fair[i] * 100).toFixed(2)}% (${toAmerican(fair[i])})`);
      console.log(event.id, book.id, m.key, `overround ${((total - 1) * 100).toFixed(2)}%`, sides.join(' | '));
    }
  }
}

Using it as a fair odds API: sharp book or consensus

A fair price is only as good as the market behind it, so the next choice is which market to de-vig. The usual reference is a sharp book: Pinnacle, Circa and BookMaker carry the sharp tag in our catalog. The Pinnacle odds API page explains why Pinnacle is the common pick. The alternative is a consensus: de-vig every book at the same line, take the median for each side, and rescale so the sides add up to 100%.

Either way, compare identical lines only. Spreads and totals often differ between books, and a fair price at −3 says nothing exact about −3.5. Group by market key, period and line before you combine anything. The sharp sportsbook entry covers why sharp prices make the better anchor.

The devig API route over MCP

REST never returns fair prices. If you connect Claude, ChatGPT, Cursor or another AI client to the PreciseAPI MCP server, find_outliers does the de-vig server-side: multiplicative, against the consensus (the median of every book's no-vig price at the same line) or one reference book such as pinnacle. Each result includes fair_price and fair_probability_pct next to the book's price and the edge between them, and a call costs 3 credits.

It is built to find prices that beat the fair line, so it lists outliers, not a fair price for every market. min_edge_pct takes values from −10 to 50, so a negative threshold also shows prices just under fair. For a complete fair board, compute it from REST as above. The odds API MCP guide covers setup.

Edge cases

Where no-vig fair odds data is used

No-vig fair odds data is the input to most betting analytics. Expected value compares a price with the fair probability, which the positive EV API page covers. Closing line value compares the price you took with the fair closing price, covered by the line movement API. Model calibration and hold comparisons start from the same numbers.

Plans and credit costs

Every paid plan returns format=probability on every odds endpoint. Edge ($49.99 a month) includes 150,000 credits; Sharp ($199.99) and Syndicate ($249.99) are unlimited, and Syndicate adds in-play odds and the WebSocket stream. find_outliers works on all three. The free Sandbox has 50 credits for the dashboard chat but no API or MCP access, so a no vig odds API setup starts on Edge. See odds API pricing.

Frequently asked questions

Does the no vig odds API return fair odds directly?

Not over REST. Every REST price is the book's posted price, and format=probability gives implied probabilities with the margin included, so the de-vig runs in your code. Over MCP, find_outliers returns a fair price and fair probability for each outlier it reports.

Which de-vig method should I use?

Multiplicative is the common default and is what PreciseAPI's MCP tools use. On two-way main lines the methods agree within tenths of a percent; on futures and other long boards, power or Shin usually fit better.

Can I get fair odds for player props?

Yes, from any book that posts both an over and an under at the same line. Request /v1/props with format=probability and de-vig each pair, or run find_outliers with markets set to props.

Is there a free way to try it?

The Sandbox is free, with 50 credits for the dashboard chat and no card, but it has no API access. API keys work from Edge at $49.99 a month.

From implied probability to fair odds

Request any odds endpoint with format=probability and each price arrives as an implied probability, margin included, to four decimal places. Add a market’s sides to measure its overround, then divide each side by the total for multiplicative fair probabilities, or use the additive, power or Shin method. Group by market key, period and line first, because only identical lines compare. A /v1/odds call costs 2 credits and covers up to 200 events of game lines.

Which market to de-vig

A fair price is only as good as the market behind it. Pinnacle, Circa and BookMaker are tagged as sharp books, and many tools de-vig one of them. Others take the median no-vig probability across every book at the same line. Three-way soccer markets must be de-vigged with the draw included, and futures boards carry large margins where the method matters more. Over MCP, find_outliers returns a fair price for each outlier it reports.

Example request

GET /v1/odds?league=nfl&markets=moneyline,spread,total&books=pinnacle,circa,draftkings&format=probability

Endpoint

What teams build with it

Related reading

More products

Responses use the same event, market and outcome ids as every other endpoint. Prices are American odds by default, with format=decimal and format=probability for the other two, and a market whose source has stopped reporting is flagged suspended instead of being shown as live.

Every source and league is on the coverage page, and what each request costs is on the pricing page.