Every sportsbook in the world publishes odds, but they do not all speak the same language. A line that reads -150 in New York shows up as 1.67 in Melbourne and 2/3 in London. If you are building an app that pulls data from a sports betting API, you need to understand all three formats, know how to convert between them, and be able to extract the implied probability from any line. This guide breaks down American, Decimal, and Fractional odds with clear formulas, worked examples, and a Python script you can drop into any project.
What Are Betting Odds?
Betting odds represent the probability of an outcome and determine how much a bettor wins relative to their stake. Bookmakers set odds based on statistical models, market activity, and their own margin. The same underlying probability gets expressed differently depending on which region or platform you are looking at.
Understanding odds is the foundation for working with any odds API. Whether you are comparing prices across bookmakers with an odds comparison tool or calculating expected value in a prediction model, everything starts with reading and interpreting odds correctly.
How It Works: Data Flow from Bookmakers to Your App
Bookmakers employ teams of traders and quantitative analysts who set opening lines for each event. Those lines move based on betting volume, injury news, weather, and other factors. Odds API providers aggregate these prices from dozens of sportsbooks and expose them through REST endpoints. When your app makes a request, it receives structured data containing the bookmaker name, market type, and odds in your chosen format (American, Decimal, or Fractional). Most providers let you specify which format you want in the API call, and some return all three simultaneously.
Who Uses It: Developers, Bettors, and Data Analysts
Developers building betting dashboards or comparison tools need to parse and display odds in whatever format their users prefer. Bettors shopping for the best line across sportsbooks need to compare odds that may arrive in different formats. Data analysts and quant modelers convert everything to implied probability so they can compare bookmaker prices against their own models. All three groups benefit from understanding the math behind each format.
Key Features and Data Points
Odds Formats: American, Decimal, Fractional
American odds (also called moneyline odds) are the standard in the United States. They use a positive or negative number anchored around $100. Negative odds like -150 tell you how much you need to risk to win $100. In this case, a $150 bet returns $100 profit plus your $150 stake. Positive odds like +200 tell you how much you win on a $100 bet. A $100 stake at +200 returns $200 profit plus your $100 back. The dividing line is even money, which shows as -100 or +100.
Decimal odds are dominant in Europe, Canada, and Australia. They represent the total payout per unit staked, including the original stake. Decimal odds of 2.50 mean that a $1 bet returns $2.50 total ($1.50 profit plus the $1 stake). Decimal odds are always greater than 1.00 because any value at or below 1.00 would mean the bettor loses money even when they win. The even money equivalent is 2.00.
Fractional odds are the traditional format in the United Kingdom and Ireland. They express profit relative to stake as a ratio. Odds of 5/1 (spoken as “five to one”) mean you win $5 for every $1 staked. Odds of 2/5 mean you win $2 for every $5 staked. The numerator is the potential profit and the denominator is the stake required. Even money is 1/1 (also written as “evens”).
Here is how the same probability looks across all three formats:
- Even money: +100 / 2.00 / 1/1
- Moderate favorite: -150 / 1.67 / 2/3
- Strong favorite: -300 / 1.33 / 1/3
- Slight underdog: +130 / 2.30 / 13/10
- Big underdog: +400 / 5.00 / 4/1
Markets Covered: Moneyline, Spreads, Totals, Props
Odds formats apply across every betting market. Moneyline (or match result) odds tell you who wins. Spread odds add a point handicap so both sides are closer to even money. Totals (over/under) set a combined score line and let you bet on which side of it the game lands. Player props set a line on individual performance like points scored, yards thrown, or goals assisted. Each of these markets returns odds in whichever format you request from the API.
Update Frequency and Latency
Odds change constantly. Pre-match lines move as bookmakers react to sharp bettors and news. Live in-play odds shift after every significant event during a game. Most odds APIs update pre-match data every 1 to 15 minutes and live data every few seconds. If you are converting between formats in real time, your conversion functions need to handle thousands of calculations per minute without becoming a bottleneck. The Python code in this guide runs in microseconds per conversion, so performance is not a concern at typical API polling rates.
Common Use Cases
Building a Betting App or Dashboard
A betting dashboard needs to display odds in the format that matches each user’s region. US users expect American odds. European users expect Decimal. UK users expect Fractional. Rather than making separate API calls for each format, pull data in one format and convert client-side or server-side using the formulas below. This also lets you display all three formats simultaneously in a comparison table.
Odds Comparison and Arbitrage Detection
An odds comparison tool pulls the same market from multiple bookmakers and finds the best price. Since different bookmakers may return odds in different formats, you need to normalize everything to a single format (usually Decimal or implied probability) before comparing. Arbitrage detection takes this further: if the combined implied probability across all outcomes is less than 100% when you pick the best price from different books for each outcome, an arbitrage opportunity exists.
Sports Analytics and Prediction Models
Quantitative models output a probability estimate for each outcome. To determine if a bet has positive expected value, you compare your model’s probability against the implied probability from the bookmaker’s odds. This requires converting from American, Decimal, or Fractional odds into a probability percentage. The formulas in the next section cover exactly that.
How to Get Started
Choosing an API Provider
Your choice depends on what data you need beyond odds. The Odds API covers 70+ sports with odds from 40+ bookmakers and offers a free tier of 500 credits per month. API-Sports provides odds alongside deep statistical data for multiple sports starting with a free 100 requests/day plan. SportMonks tracks odds movement from opening line to kickoff across 145+ bookmakers. For a full comparison, see our sports betting API guide.
Authentication and API Keys
Most odds APIs use key-based authentication. Sign up on the provider’s website, get your API key, and pass it as a query parameter or header with each request. Keep your key in an environment variable rather than hardcoding it. Here is a minimal setup:
import os
import requests
API_KEY = os.environ.get("ODDS_API_KEY")
BASE_URL = "https://api.the-odds-api.com/v4"Making Your First Request
This example fetches upcoming NFL odds in American format:
url = f"{BASE_URL}/sports/americanfootball_nfl/odds"
params = {
"apiKey": API_KEY,
"regions": "us",
"markets": "h2h,spreads,totals",
"oddsFormat": "american"
}
response = requests.get(url, params=params)
games = response.json()
for game in games:
print(f"{game['away_team']} @ {game['home_team']}")
for book in game["bookmakers"]:
for market in book["markets"]:
if market["key"] == "h2h":
for outcome in market["outcomes"]:
print(f" {book['title']}: {outcome['name']} {outcome['price']}")Change the oddsFormat parameter to decimal to receive decimal odds instead. The response structure stays the same; only the price values change.
Conversion Formulas and Python Code
Here are the complete conversion formulas between all three formats, plus implied probability calculations.
American to Decimal:
- Positive odds: Decimal = (American / 100) + 1
- Negative odds: Decimal = (100 / abs(American)) + 1
Decimal to American:
- Decimal >= 2.00 (underdog): American = (Decimal - 1) x 100
- Decimal < 2.00 (favorite): American = -100 / (Decimal - 1)
Fractional to Decimal:
- Decimal = (Numerator / Denominator) + 1
Decimal to Fractional:
- Fraction = (Decimal - 1) / 1, then simplify
Implied Probability from American:
- Positive odds: Probability = 100 / (American + 100)
- Negative odds: Probability = abs(American) / (abs(American) + 100)
Implied Probability from Decimal:
- Probability = 1 / Decimal
Implied Probability from Fractional:
- Probability = Denominator / (Numerator + Denominator)
Here is a complete Python module that handles all conversions:
from fractions import Fraction
def american_to_decimal(american: int) -> float:
if american > 0:
return (american / 100) + 1
else:
return (100 / abs(american)) + 1
def decimal_to_american(decimal_odds: float) -> int:
if decimal_odds >= 2.0:
return round((decimal_odds - 1) * 100)
else:
return round(-100 / (decimal_odds - 1))
def fractional_to_decimal(numerator: int, denominator: int) -> float:
return (numerator / denominator) + 1
def decimal_to_fractional(decimal_odds: float) -> str:
frac = Fraction(decimal_odds - 1).limit_denominator(100)
return f"{frac.numerator}/{frac.denominator}"
def implied_probability(decimal_odds: float) -> float:
return 1 / decimal_odds
# Example conversions
examples = [
("Heavy favorite", -300),
("Moderate favorite", -150),
("Even money", +100),
("Slight underdog", +130),
("Big underdog", +400),
]
print(f"{'Line':<20} {'American':>10} {'Decimal':>10} {'Fractional':>12} {'Implied %':>10}")
print("-" * 65)
for label, american in examples:
dec = american_to_decimal(american)
frac = decimal_to_fractional(dec)
prob = implied_probability(dec) * 100
print(f"{label:<20} {american:>+10} {dec:>10.2f} {frac:>12} {prob:>9.1f}%")Running this produces:
Line American Decimal Fractional Implied %
-----------------------------------------------------------------
Heavy favorite -300 1.33 1/3 75.0%
Moderate favorite -150 1.67 2/3 60.0%
Even money +100 2.00 1/1 50.0%
Slight underdog +130 2.30 13/10 43.5%
Big underdog +400 5.00 4/1 20.0%The implied_probability function returns the raw bookmaker probability, which includes the vig (the bookmaker’s margin). When you add up the implied probabilities for all outcomes in a market, they typically total more than 100%. The amount over 100% is the vig. For example, if a two-outcome market has implied probabilities of 52.4% and 52.4%, the vig is 4.8%.
Pricing and Free Tier Options
Most odds API providers include format conversion as a built-in feature at no extra cost. You choose your format in the API request and the provider handles the math. Here is how the major providers compare:
- The Odds API: 500 free credits/month, all formats supported via
oddsFormatparameter. Paid plans from $30/month. - API-Sports: 100 free requests/day, returns decimal odds by default. Paid plans from $15/month.
- SportMonks: Free tier with selected leagues. European plans from EUR 39/month. Odds in decimal format with 145+ bookmakers.
- SportsData.io: Free tier with scrambled demo data. Paid plans from $99/month with American and decimal formats.
If your provider only returns one format, use the conversion functions above to derive the others. The computation is trivial and adds no meaningful overhead.
FAQ
What is the difference between American and decimal odds?
American odds use positive and negative numbers anchored around $100. Negative odds (-150) show how much you risk to win $100. Positive odds (+200) show how much you win on a $100 bet. Decimal odds show the total return per unit staked, including the original stake. Decimal 2.50 means a $1 bet returns $2.50 total. The key difference is that decimal odds already include your stake in the number, while American odds show only the profit relationship. Decimal odds are simpler to calculate with: multiply your stake by the decimal odds to get your total payout.
How do I convert American odds to decimal?
For positive American odds, divide by 100 and add 1. For example, +200 becomes (200 / 100) + 1 = 3.00. For negative American odds, divide 100 by the absolute value of the odds and add 1. For example, -150 becomes (100 / 150) + 1 = 1.67. In Python: decimal = (american / 100) + 1 if american > 0 else (100 / abs(american)) + 1.
How often does odds data update?
Pre-match odds update every 1 to 15 minutes depending on the provider and plan tier. Live in-play odds update every few seconds through REST polling or in real time through WebSocket feeds. Odds movement accelerates around game start times and after significant in-game events like goals, touchdowns, or injuries. Higher-tier API plans generally offer faster update rates.