No-Vig Fair Odds Explained: What They Are and How to Use Them in Your App

What Are No-Vig Fair Odds?

Every time a sportsbook posts a line, it embeds a margin — commonly called the 'vig' or 'juice' — into the prices. This margin ensures the book profits regardless of which side wins. For example, a perfectly even coin-flip game might be priced at -110 on both sides rather than +100. That gap is the vig, and it shifts the implied probability above 100% when you add both sides together.

No-vig fair odds are the prices you would see if that margin were removed entirely. They represent the market's true implied probability for each outcome, expressed as American odds (or decimal/fractional equivalents). If one side of a two-outcome market is priced at -110/-110, removing the vig produces +100/+100 — a clean 50/50 split with no house edge baked in.

Fair odds matter enormously to bettors and developers building analytics tools because they serve as a neutral benchmark. Any line offered by a bookmaker can be compared against the fair price to determine whether the bettor is getting value. If a book offers you -105 on an outcome whose fair price is +100, you are getting a better-than-fair deal — a positive expected value (+EV) bet. If you are offered -120 on that same outcome, you are paying extra vig.

Understanding the math behind no-vig odds is the first step toward building any serious betting analytics product, whether that is a line-shopping tool, a +EV scanner, or an arbitrage detector.

How to Calculate No-Vig Fair Odds Step by Step

The calculation involves three steps: convert American odds to implied probabilities, normalize those probabilities to sum to 100%, then convert back to odds. Here is a concrete example.

Step 1 — Convert to implied probability. For negative American odds, the formula is: implied probability = |odds| / (|odds| + 100). For positive American odds: implied probability = 100 / (odds + 100). Take a game priced at Team A -130 and Team B +110. Team A implied probability = 130 / (130 + 100) = 0.5652 (56.52%). Team B implied probability = 100 / (110 + 100) = 0.4762 (47.62%). Total = 104.14% — that 4.14% excess is the vig.

Step 2 — Normalize. Divide each side's implied probability by the total: Team A fair probability = 0.5652 / 1.0414 = 0.5428 (54.28%). Team B fair probability = 0.4762 / 1.0414 = 0.4572 (45.72%). These now sum to exactly 100%.

Step 3 — Convert back to American odds. For probabilities above 50%: fair odds = -(probability / (1 - probability)) × 100. For probabilities below 50%: fair odds = ((1 - probability) / probability) × 100. Team A fair odds = -(0.5428 / 0.4572) × 100 ≈ -118.7. Team B fair odds = (0.4572 / 0.5428) × 100 ≈ +84.2. These are the no-vig fair prices for this market.

This same logic extends to three-way markets (soccer draw markets, for instance) and to player props with over/under lines. The principle is always the same: remove the juice to find the true probability the market is implying.

How MoneyLine API Exposes fairOdds in Its Response

MoneyLine's betting odds API does this heavy lifting for you automatically. Every market summary returned by the API includes a fairOdds field alongside bestOdds and avgOdds, so you never have to run the vig-stripping math yourself in production code.

When you call GET /v1/odds with your league and event filters, the response for each event includes a moneyline, spread, and total array. Each element in those arrays is an object with the shape: { name, point?, fairOdds, bestOdds, avgOdds }. The fairOdds value is the no-vig price computed across all bookmakers tracked for that market. The bestOdds value is the highest (most favorable) actual price available at any book. By comparing bestOdds to fairOdds, you can instantly see whether the market offers value.

Here is an example of what a moneyline array element might look like in a real response: { "name": "Kansas City Chiefs", "fairOdds": -118, "bestOdds": -110, "avgOdds": -115 } In this case, bestOdds (-110) is better than fairOdds (-118), meaning at least one bookmaker is offering this side at a price above fair value — a +EV situation worth flagging in your application.

The bookmakers array on each event goes one level deeper. Each entry has a bookmakerId, bookmakerName, sourceType, and a markets array. Each market object holds a marketType (e.g., 'moneyline', 'spread', 'total') and an outcomes array of { name, point?, price }. This is the raw, vig-inclusive price from that specific book. By comparing any individual outcome's price to the corresponding fairOdds from the summary, you can tell your users exactly how much edge (or lack thereof) a particular book is offering on that outcome.

Authentication is handled via the x-api-key header. MoneyLine offers a free tier suitable for both personal projects and commercial applications, so you can start pulling fairOdds data immediately without a paid subscription.

Building a +EV Scanner Using fairOdds

The most common developer use case for no-vig fair odds is building a positive expected value (+EV) scanner. The core logic is simple: for every outcome across all books and markets, check whether the book's offered price (price from the outcomes array) is better than the fair price (fairOdds from the summary). If it is, calculate the implied edge.

A straightforward approach in JavaScript might look like this: async function scanForEV(leagueId) { const res = await fetch( `https://api.moneyline.com/v1/odds?leagueId=${leagueId}`, { headers: { 'x-api-key': process.env.MONEYLINE_API_KEY } } ); const data = await res.json(); const evBets = []; for (const event of data.events) { for (const side of event.moneyline) { const fairImplied = americanToImplied(side.fairOdds); for (const book of event.bookmakers) { const ml = book.markets.find(m => m.marketType === 'moneyline'); if (!ml) continue; const outcome = ml.outcomes.find(o => o.name === side.name); if (!outcome) continue; const bookImplied = americanToImplied(outcome.price); const edge = fairImplied - bookImplied; if (edge > 0) { evBets.push({ eventId: event.eventId, team: side.name, book: book.bookmakerName, fairOdds: side.fairOdds, offeredOdds: outcome.price, edgePct: (edge * 100).toFixed(2) }); } } } } return evBets; }

MoneyLine also provides a dedicated /v1/edge endpoint that returns pre-computed +EV opportunities across all markets and books. This is useful when you want server-side filtering rather than scanning the full odds payload yourself. The /v1/best-bets endpoint surfaces the highest-edge opportunities ranked for quick consumption. Both endpoints use the same fairOdds methodology under the hood.

For player props, the same fairOdds field is present in the /v1/player-props response. Each player's prop markets include fairOdds for the over and under so you can run identical EV checks on rushing yards, passing touchdowns, points scored, hits, and any other prop market the API covers. Player props are often softer markets with more frequent mispricing, making them particularly rewarding to scan with a fairOdds-based filter.

Once you have a working scanner, you can enrich the output by querying /v1/events to pull in the eventId and leagueId for display, linking each flagged bet back to its game context. You can also pipe the raw findings into the /v1/ai/chat endpoint to generate natural-language summaries of the best opportunities for end users who prefer prose over raw numbers.

Common Pitfalls When Working with No-Vig Odds

One frequent mistake is treating fairOdds as a guaranteed predictor of outcomes. Fair odds represent the consensus market probability after removing the bookmaker margin — they reflect collective market opinion, not ground truth. Sharp markets on high-volume games (NFL Sunday, NBA playoffs) tend to have tight, efficient fairOdds. Softer markets on lower-volume props or early-week lines may have wider spreads and noisier fair prices.

Another pitfall is ignoring the sourceType field on each bookmaker object. MoneyLine distinguishes between sharp books (whose lines are more informative for setting fair odds) and square or recreational books. If you are computing your own fair odds from raw prices rather than using the pre-computed fairOdds field, weighting sharp-book prices more heavily will produce a more accurate benchmark.

Stale data is also a concern. Odds move constantly, especially in the hours leading up to a game, during injury news, or after significant betting volume hits one side. Always store the timestamp of your API response and display freshness indicators in your UI. For real-time line movement monitoring, poll /v1/odds at regular intervals and track changes in both fairOdds and bestOdds over time to detect when the market is moving.

Finally, keep in mind that not every book will have odds for every outcome at every moment. The bestOdds in the summary reflects the best currently available price, but if a book limits or removes a market, that price disappears. Your application should handle missing outcomes gracefully and clearly communicate when a specific book-side combination is unavailable.