The Odds API Free Tier Limits in 2026 (And a Bigger Free Alternative)

The Odds API Free Tier Limits - OddsPapi API Blog

How To Guides June 12, 2026

The Odds API Free Tier in 2026: 500 Credits, But Not 500 Requests

You signed up for The Odds API’s free plan, grabbed your key, and ran a few test calls. Then your x-requests-remaining header dropped way faster than expected. That’s not a bug — it’s how the credit system works, and almost nobody reads the fine print before they hit the wall.

Here’s the honest breakdown of what The Odds API free tier actually gets you in 2026, the formula that drains your quota, what breaks when you hit zero — and a free alternative that bills one request as one full board across 370 bookmakers.

The Number Everyone Quotes: 500 Credits/Month

The Odds API’s free “Starter” plan gives you 500 credits per month. No card required, all sports, most bookmakers, all markets. So far so good. The trap is the word credits. A credit is not a request.

Straight from their docs, the cost of a single call is:

# The Odds API quota cost formula
live_odds_cost      = number_of_markets * number_of_regions
historical_odds_cost = 10 * number_of_markets * number_of_regions

So one “request” can cost anywhere from 1 credit to dozens, depending on how many markets and regions you ask for. The /sports and /events endpoints are free, and a call that returns no events isn’t charged — but every real odds pull eats into your 500.

What 500 Credits Buys in Practice

Say you want moneyline, spreads, and totals (3 markets) across the US and UK regions (2 regions). That’s a normal request for anyone comparing US and European books:

cost = 3 markets * 2 regions = 6 credits per call

500 credits / 6 = ~83 live calls per month
              = roughly 2-3 calls per day

Want historical odds to backtest a model? Multiply by 10:

historical_cost = 10 * 3 markets * 2 regions = 60 credits per call

500 credits / 60 = ~8 historical snapshots per month, total

Eight historical pulls is not a backtest. It’s barely a spot-check. The free tier is built for kicking the tires, not for running anything continuous.

Your request	Markets × Regions	Credit cost	Calls from 500
1 market, 1 region (live)	1 × 1	1	500
3 markets, 2 regions (live)	3 × 2	6	~83
3 markets, 2 regions (historical)	10 × 3 × 2	60	~8
5 markets, 3 regions (live)	5 × 3	15	~33

What Breaks When You Hit the Cap

When x-requests-remaining reaches zero, calls start returning 401/429 errors until the monthly reset. There’s no overage, no soft cap — the feed just stops. If your bot, dashboard, or cron job is mid-run, it goes dark until the calendar flips. Three headers tell you where you stand:

x-requests-remaining   # credits left until reset
x-requests-used        # credits spent this period
x-requests-last        # cost of the call you just made

Monitor Your Quota in Python

If you’re on The Odds API free tier, read those headers on every call so the cap never surprises you:

import requests

API_KEY = "YOUR_THE_ODDS_API_KEY"
url = "https://api.the-odds-api.com/v4/sports/baseball_mlb/odds"
params = {
    "apiKey": API_KEY,
    "regions": "us,uk",      # 2 regions
    "markets": "h2h,spreads,totals",  # 3 markets -> 6 credits this call
}

r = requests.get(url, params=params)
print("This call cost:", r.headers.get("x-requests-last"))
print("Remaining:", r.headers.get("x-requests-remaining"))
print("Used so far:", r.headers.get("x-requests-used"))

Useful, but it’s a budgeting tool for scarcity. The real fix is a model where one request isn’t rationed by markets and regions in the first place.

The Other Way to Bill a Request

The credit multiplier exists because The Odds API meters you per market, per region, per call. OddsPapi bills differently: one request returns the entire board for a fixture — every bookmaker, every market, no multiplier. You don’t choose 3 markets and 2 regions and pay 6 credits. You ask for the fixture and get all of it for one request.

We verified this live while writing this post. A single /v4/odds call on the Chicago Cubs vs San Francisco Giants MLB game (June 5, 2026) returned:

One OddsPapi request returned	Count
Bookmakers on the fixture	14 (incl. Pinnacle, Bet365, DraftKings, FanDuel, BetMGM, Caesars, William Hill)
Unique market IDs	198
Books on the moneyline alone	10
Credit cost	1 request — no market or region multiplier

To pull 198 markets across that many books on The Odds API’s credit model, you’d burn a serious chunk of a monthly free quota in a single fixture. On OddsPapi it’s one of your 250 monthly free requests.

Free Tier vs Free Tier (2026)

	The Odds API (Free)	OddsPapi (Free)
Allowance	500 credits/mo	250 requests/mo
What a request costs	markets × regions (1–15+ credits)	1 request = full fixture board
Bookmakers	~40	370
Sharp books (Pinnacle, SBOBet)	Limited	✅ Included
Historical odds	10× credit multiplier	✅ Free, no multiplier
Markets per call	Pay per market	All markets returned
Real-time WebSocket	❌ Polling only	✅ Available

Be honest about the headline: 250 is a smaller number than 500. The difference is what each unit buys. The Odds API’s 500 credits become ~83 real multi-market calls (and ~8 if they’re historical). OddsPapi’s 250 requests are 250 full boards — every book, every market, with historical pulls that don’t cost 10× anything.

Tutorial: One Request, the Whole Board (OddsPapi)

Here’s the same MLB game, fetched in full, with one request. Auth is a query parameter, not a header.

1. Authenticate & List Sports (Free)

import requests

API_KEY = "YOUR_API_KEY"           # grab a free key at oddspapi.io
BASE_URL = "https://api.oddspapi.io/v4"

# apiKey is a QUERY PARAMETER, never a header
r = requests.get(f"{BASE_URL}/sports", params={"apiKey": API_KEY})
print(r.status_code)               # 200
# 69 sports in the catalog as of June 2026

2. Find a Fixture

# MLB is sportId 13. Pull fixtures over a date range (max 10 days apart).
r = requests.get(f"{BASE_URL}/fixtures", params={
    "apiKey": API_KEY,
    "sportId": 13,
    "from": "2026-06-05",
    "to": "2026-06-06",
})
fixtures = r.json()
# Only fixtures with hasOdds: true return a price payload.
live = [f for f in fixtures if f.get("hasOdds")]
print(len(live), "MLB fixtures with odds")

3. Pull the Entire Board in One Call

# No bookmakers filter, no markets filter -> the whole board.
fixture_id = "id1300010963302659"   # Cubs vs Giants, 2026-06-05
r = requests.get(f"{BASE_URL}/odds", params={
    "apiKey": API_KEY,
    "fixtureId": fixture_id,
})
data = r.json()

books = data["bookmakerOdds"]
markets = {m for b in books.values() for m in b["markets"]}
print(len(books), "bookmakers,", len(markets), "markets — one request")
# -> 14 bookmakers, 198 markets

4. Parse the Moneyline Across Every Book

The odds payload is deeply nested. Market 131 is the MLB moneyline (“Winner, incl. extra innings”); outcome 131 is the home side, 132 the away side.

MONEYLINE = "131"
home_id, away_id = "131", "132"

prices = {}
for slug, book in books.items():
    market = book["markets"].get(MONEYLINE)
    if not market:
        continue
    outs = market["outcomes"]
    try:
        home = outs[home_id]["players"]["0"]["price"]
        away = outs[away_id]["players"]["0"]["price"]
        prices[slug] = (home, away)
    except KeyError:
        continue   # book doesn't price this market

for slug, (h, a) in sorted(prices.items()):
    print(f"{slug:16} {h:>6}  {a:>6}")

# pinnacle           1.602   2.52
# kalshi             1.613   2.564
# draftkings         1.55    2.49
# caesars            1.562   2.5
# fanduel            1.56    2.5     ...10 books total

5. De-Vig the Sharp Line (Free, Same Request)

Pinnacle is the sharp benchmark. Strip the vig to get a fair-probability anchor — no extra credits, no separate endpoint:

home, away = prices["pinnacle"]
ih, ia = 1/home, 1/away
overround = ih + ia
fair_home = 1 / (ih / overround)
fair_away = 1 / (ia / overround)
print(f"Pinnacle vig: {(overround-1)*100:.2f}%")
print(f"Fair: Cubs {fair_home:.3f} / Giants {fair_away:.3f}")

# Pinnacle vig: 2.10%
# Fair: Cubs 1.636 (61.1%) / Giants 2.573 (38.9%)

From here it’s a short hop to line shopping for the best price, building a value scanner, or pulling free historical odds to backtest — none of which carry a 10× credit penalty.

So Which Free Tier Should You Use?

If you need a couple of quick, low-market spot-checks per day and you’re already invested in The Odds API’s endpoints, 500 credits is fine — just watch x-requests-remaining and stay off the historical endpoints. If you want sharp books like Pinnacle, the full market board on every call, free historical data, or anything that runs continuously, the credit multiplier will fight you, and a request-per-board model gets you further on a free key.

For a deeper provider-by-provider breakdown, see our 2026 odds API pricing comparison and our full The Odds API alternative guide.

Frequently Asked Questions

Is The Odds API free tier really free?

Yes — the Starter plan is free with no card and gives 500 credits per month. The catch is that credits aren’t requests: each call costs markets × regions credits (and 10× that for historical odds), so 500 credits is roughly 83 typical multi-market live calls.

How many requests is 500 credits on The Odds API?

It depends entirely on your markets and regions. A single market in a single region costs 1 credit (500 calls). A 3-market, 2-region call costs 6 credits (~83 calls). A historical version of that call costs 60 credits (~8 calls).

What happens when I hit The Odds API free tier limit?

Calls return 401/429 errors and the feed stops until the monthly reset. Track x-requests-remaining on every response to avoid being cut off mid-run.

Does The Odds API free tier include historical odds?

Historical endpoints are accessible, but each historical call costs 10× the live credit cost, so the free 500 credits only stretch to a handful of historical pulls per month.

Is there a free alternative with more bookmakers?

OddsPapi’s free tier gives 250 requests per month, but each request returns the full fixture board — all 370 bookmakers and all markets, no per-market or per-region multiplier — and historical odds are free with no 10× penalty.

Stop Rationing Credits. Get the Whole Board.

Every market, every bookmaker, in one request — including Pinnacle and free historical data. Get your free OddsPapi API key and pull a full board in your first call.