Free sports odds API: 20,000 data points a day

TheRundown’s Free plan is a free sports odds API in the plain sense: it costs $0, it is not a trial, and you sign up without a credit card. It returns pre-match moneyline, spread, and total lines from DraftKings, FanDuel, and BetMGM over REST, five minutes delayed, with an allowance of 20,000 data points per UTC day, up to 200,000 per UTC calendar month. Current terms are on API pricing. This guide covers what Free includes and leaves out, how data points are counted (with numbers you can reproduce), a first request in curl and Python, how far 20,000 a day goes, and when a paid plan is worth it.

What the Free plan includes

Here is what Free covers, so you can tell whether it fits your project before you sign up:

• Price: $0, not a trial. No credit card at signup.
• Allowance: 20,000 data points per UTC day, up to 200,000 per UTC calendar month. The first cap you reach pauses requests until that window resets.
• Sportsbooks: DraftKings (affiliate ID 19), BetMGM (22), and FanDuel (23).
• Markets: pre-match, full-game moneyline, spread, and total (market IDs 1, 2, 3) in leagues such as the NFL, NBA, MLB, and NHL. NHL and soccer responses can also include the 3-way regulation moneyline (market 563) unless you pass market_ids=1,2,3.
• Freshness and delivery: prices five minutes delayed, over REST, at up to 1 request per second.
• Also included: schedules, scores and results, and reference data. Reference calls (/sports, /affiliates, /markets) don’t use data points.
• Stats: the stat catalog and a fixed box-score sample. New accounts also get a seven-day, no-card evaluation of current-season stats. That evaluation grants access to current-season stats only — it doesn’t add extra data points. Stats calls during the evaluation count against the same 20,000-a-day and 200,000-a-month allowance as odds calls.

What Free leaves out

• The other 22 books and exchanges, including Pinnacle, Circa Sports, BookMaker, Kalshi, and Polymarket. They start on Starter.
• Player props, alternate lines, halves, quarters, and team totals. Starter and up.
• Live in-game odds. Starter and up.
• Odds history, opening lines, and closing lines. Starter adds 7 days of odds history; opening and closing lines start on Pro.
• WebSocket streaming and futures. Ultra and up.
• Showing odds to users of your product. Free and Starter are licensed for internal business or personal use; commercial end-user display starts on Pro.
• Overage. Free stops at its caps instead of billing for more.

How data points are counted

Free is metered in data points, not requests, so one request can cost 4 points or several hundred depending on what it returns. If you’re comparing free odds APIs, compare what a typical request costs, not only the headline allowance. The rate limits docs give the rule for event responses:

• one data point for each returned price, meaning one sportsbook’s price on one side of one line
• one data point for each returned event, plus one for its score

On a Free key, that works out to data points = 2 × events + prices. Prices a book hasn’t posted aren’t returned and aren’t charged, and every successful response is billed for what it returns, even when no price changed since your last call. Each billed response reports its cost in the X-Datapoints header, and X-Datapoints-Breakdown, when present, splits it into events, odds, and scores.

These counts were checked on October 5, 2026, with the three Free books, main_line=true, and hide_closed=true:

The single-game rows use GET /events/{event_id}; the slate uses the dated events endpoint. To check a slate’s cost yourself:

curl -s -o /dev/null -D - \
  "https://therundown.io/api/v2/sports/2/events/2026-10-11?market_ids=1,2,3&affiliate_ids=19,22,23&main_line=true&hide_closed=true&offset=240" \
  -H "X-TheRundown-Key: $THERUNDOWN_API_KEY" | grep -i -E '^x-datapoints(-breakdown)?:'

On October 5, 2026, it returned:

x-datapoints: 260
x-datapoints-breakdown: events=13,odds=234,scores=13

The arithmetic: 13 games × 3 markets × 2 sides × 3 books = 234 prices, plus 13 events and 13 scores, is 260. offset=240 sets the date boundary to US Eastern time (the offset is in minutes) during daylight saving time; Eastern reverts to UTC-5 (offset=300) once daylight saving time ends in early November, so adjust the value seasonally. Here it puts the Sunday night game, which starts after midnight UTC, in the same response. Without it, dates follow UTC and that game lands on October 12. Those are maximums, and your own run will usually come in lower: books post, move, and pull lines through the week, and once a game starts a Free key no longer gets its prices.

Your first free request

Get a key on the odds API page: sign up with an email and password (no card), confirm your email if asked, and copy the key from your account dashboard. Keep it in an environment variable (THERUNDOWN_API_KEY below) rather than in source control. Every request sends it in the X-TheRundown-Key header to https://therundown.io/api/v2.

Step 1: find the next game date

For the NFL, pass the regular season, preseason, and playoffs together (2,25,26), and add exclude_canceled=true so a date with only canceled events is skipped:

curl -s "https://therundown.io/api/v2/sports/dates?sport_ids=2,25,26&format=epoch&exclude_canceled=true" \
  -H "X-TheRundown-Key: $THERUNDOWN_API_KEY"

Each value is a Unix timestamp in UTC for the first start on that date. Convert it to a YYYY-MM-DD date for the next call, for example with date -u -d @<timestamp> +%F (on macOS, date -u -r <timestamp> +%F).

Step 2: pull free NFL odds from three books

Request that date’s events with the moneyline, spread, and total (market_ids=1,2,3) from the three Free books (affiliate_ids=19,22,23), main lines only:

curl -s "https://therundown.io/api/v2/sports/2/events/2026-10-11?market_ids=1,2,3&affiliate_ids=19,22,23&main_line=true&hide_closed=true" \
  -H "X-TheRundown-Key: $THERUNDOWN_API_KEY"

Replace 2026-10-11 with the converted date. The response nests each event’s markets, participants, lines, and prices by book; the developer guide walks through that data model.

Doing it in Python

The same two calls with requests, printing the request’s cost and each line with the three books’ prices side by side. The pause before Step 2 respects Free’s 1-request-per-second limit:

import os
import time
from datetime import datetime, timezone

import requests

api = "https://therundown.io/api/v2"
headers = {"X-TheRundown-Key": os.environ["THERUNDOWN_API_KEY"]}
FREE_BOOKS = {"19": "DraftKings", "22": "BetMGM", "23": "FanDuel"}

# Step 1: the next NFL game date (regular season, preseason, or playoffs)
dates_resp = requests.get(
    f"{api}/sports/dates",
    params={"sport_ids": "2,25,26", "format": "epoch", "exclude_canceled": "true"},
    headers=headers,
    timeout=30,
)
dates_resp.raise_for_status()
dates = dates_resp.json()
# Each value is the first start time on a UTC date. Skipping dates whose
# first game has started keeps every returned game pre-match, which is
# what a Free key prices.
now = datetime.now(timezone.utc).timestamp()
upcoming = [
    (sport_id, stamp)
    for sport_id, body in dates.items()
    for stamp in body.get("dates") or []
    if stamp > now
]
sport_id, stamp = min(upcoming, key=lambda row: row[1], default=("2", now))
date = datetime.fromtimestamp(stamp, timezone.utc).date().isoformat()

# Step 2: pre-match moneyline, spread, and total from the three Free books
# Free allows 1 request per second, so pause before the next call
time.sleep(1.1)
slate = requests.get(
    f"{api}/sports/{sport_id}/events/{date}",
    params={
        "market_ids": "1,2,3",
        "affiliate_ids": ",".join(FREE_BOOKS),
        "main_line": "true",
        "hide_closed": "true",
    },
    headers=headers,
    timeout=30,
)
slate.raise_for_status()
events = slate.json().get("events") or []
used = int(slate.headers.get("X-Datapoints", "0"))
print(f"{len(events)} game(s), {used} data points;",
      f"{20_000 // used:,} requests this size fit in a 20,000-point day" if used
      else "no billable rows returned for this date")

for event in events:
    for market in event["markets"]:
        for participant in market["participants"]:
            for line in participant["lines"]:
                books = "  ".join(
                    f"{FREE_BOOKS[book]} {price['price']}"
                    for book, price in sorted(line["prices"].items())
                    if book in FREE_BOOKS
                )
                print(event["event_date"], market["name"], participant["name"],
                      line.get("value", ""), books)

Run at 23:28 UTC on October 5, 2026, it found Monday night’s Falcons at Saints game. The output below came from that exact request; on a Free key the response has the same shape and cost, with prices five minutes delayed.

1 game(s), 20 data points; 1,000 requests this size fit in a 20,000-point day
2026-10-06T00:15:00Z moneyline Atlanta Falcons  DraftKings -105  BetMGM 100  FanDuel -102
2026-10-06T00:15:00Z moneyline New Orleans Saints  DraftKings -115  BetMGM -118  FanDuel -116
2026-10-06T00:15:00Z handicap Atlanta Falcons +1.5 DraftKings -120  BetMGM -118  FanDuel -110
2026-10-06T00:15:00Z handicap New Orleans Saints -1.5 DraftKings 100  BetMGM -110  FanDuel -110
2026-10-06T00:15:00Z totals Over 47.5 DraftKings -112  BetMGM -108  FanDuel -110
2026-10-06T00:15:00Z totals Under 47.5 DraftKings -108  BetMGM -110  FanDuel -110

Here all three books posted the same spread and total, so each line carries three prices. When books post different numbers, each number is its own line object with its own prices, and you’d see one row per number.

How far 20,000 a day goes

Free has two caps, and which one matters depends on how steadily you poll. The monthly 200,000 is ten days at the full daily 20,000, or about 6,700 a day spread over a 30-day month. On a busy game day the daily cap is the limit; on steady, every-day use it’s the monthly one.

Cadence is the other half. Free prices trail the market by five minutes, and every response is billed for its rows whether or not anything moved. Polling faster than every five minutes shows a change a little sooner, but never closer than five minutes to the market, so a cadence of five minutes or slower gets the most from each data point.

Using the costs above:

The weekly row is three dated requests with offset=240 (October 8, 11, and 12: 20 + 260 + 20 points; use offset=300 once daylight saving time ends). Space them at least a second apart, since Free allows 1 request per second.

A few habits stretch the allowance further:

• Ask only for what you use. Name market_ids and affiliate_ids and keep main_line=true; every extra book or market adds rows.
• Poll single games by ID. If you track a handful of games, GET /events/{event_id} costs 20 points per game instead of the whole slate.
• Watch the usage headers. Alongside X-Datapoints, the rate limits docs list X-Datapoints-Remaining for the current UTC day and X-Datapoints-Monthly-Remaining for the month on Free keys.
• Back off on 429. A billing-cap 429 carries Retry-After with the time until the window reopens; retrying sooner won’t help.

When to upgrade, and to which plan

Free suits prototypes, personal projects, and learning the data model. The signs you’ve outgrown it map onto specific plans:

• You need a book beyond the free three, such as Pinnacle, Circa Sports, BookMaker, Kalshi, or Polymarket: Starter.
• You need player props, alternates, periods, or team totals: Starter.
• You need live in-game odds, or prices fresher than five minutes: Starter (60 seconds), Pro (30 seconds), or Ultra (real-time).
• You regularly hit 20,000 a day or 200,000 a month: Starter’s 25,000,000 a month is 125 times Free’s monthly cap.
• You need opening and closing lines, or will show odds to users of a commercial product: Pro.
• You need WebSocket push or futures: Ultra.

Prices and limits below are current as of October 2026; see API pricing for the live numbers.

Annual billing lowers Starter to $39 a month, Pro to $119, and Ultra to $319. Monthly and annual paid plans stop at their included data points by default, and overage applies only if you turn it on. Self-serve paid plans are also offered with weekly billing for short projects such as one postseason; weekly plans start with automatic metered overage, so check the terms on API pricing first. Above Ultra, the Super ($649/month), Mega ($999/month), and Max ($2,499/month) tiers add more WebSocket connections and longer history, and Enterprise is custom-priced.

Where to go next

• Get a free key on the odds API page, then follow the quickstart.
• Compare plans on API pricing.
• Learn the full data model and ID tables in how to pull sports betting odds from an API.
• Need Pinnacle’s prices (Starter and up)? Read the Pinnacle API alternative guide.
• League guides: the free NFL odds API, NBA odds API, MLB odds API, and NHL odds API.
• The three Free books: the DraftKings odds API, FanDuel odds API, and BetMGM odds API.

Questions

Is there a free sports odds API?

Yes. TheRundown’s Free plan is a free sports betting odds API: it returns pre-match moneylines, spreads, and totals from DraftKings, FanDuel, and BetMGM for leagues including the NFL, NBA, MLB, and NHL, five minutes delayed, up to 20,000 data points a day and 200,000 a month. Free is a $0 plan, not a trial. No credit card.

Is TheRundown’s free plan a trial?

No. Free is a $0 plan, not a trial, and signing up takes no credit card. Its allowance resets every UTC day and every UTC calendar month, and you move to a paid plan only if you choose to. TheRundown does not offer a free trial of its paid API plans. The only time-limited part of Free is a seven-day, no-card evaluation of current-season stats for new accounts; the stats catalog and fixed box-score sample stay available on Free after that window.

How many requests does TheRundown’s free plan include per day and per month?

Free is metered in data points, not a fixed number of requests: 20,000 per UTC day, up to 200,000 per UTC calendar month, at up to 1 request per second. An odds request costs one point per returned price plus two per returned event (one for the event, one for its score), so one NFL game with moneyline, spread, and total from all three free books costs up to 20 data points, and a 13-game Sunday slate up to 260. At 20 points for that single-game request, TheRundown’s free plan supports up to 1,000 such requests a day and 10,000 a month.

Which sportsbooks are included in the free plan?

DraftKings (affiliate ID 19), BetMGM (22), and FanDuel (23). The other 22 of the 25 sportsbooks and exchanges in the API, including Pinnacle, Kalshi, and Polymarket, start on Starter ($49 a month).

Does the free plan include player props, live odds, or WebSocket?

No. Free covers pre-match, full-game moneyline, spread, and total over REST. Player props, alternate lines, and live in-game odds start on Starter ($49 a month). WebSocket streaming starts on Ultra ($399 a month).

Can I use the free plan commercially?

You can use Free data for internal business or personal purposes, the same license as Starter. Showing odds to end users of your own product requires a Commercial Plan, which starts on Pro ($149 a month). See the Terms and API pricing.

What happens when I hit the free limit?

Requests return HTTP 429 until the window resets: “Daily data point limit reached” at 20,000 in a UTC day, or “Monthly data point limit reached” at 200,000 in a UTC calendar month. The Retry-After header says when to try again. Free has no overage, so nothing is charged. Sending more than 1 request per second returns a separate, short 429.

What does upgrading from the free plan add?

Starter ($49 a month, or $39 a month on annual billing) adds live in-game odds, every published book and market except futures, a 60-second delay in place of five minutes, 7-day odds history, and 25,000,000 data points a month. Pro ($149) adds opening and closing lines and commercial display. Ultra ($399) adds real-time WebSocket delivery and futures.

Start free. Upgrade when you outgrow it.

A free key returns DraftKings, FanDuel, and BetMGM pre-match game lines, 20,000 data points a day, no credit card. Starter ($49 a month) adds every book, props, and live odds, and cuts the delay to 60 seconds.

Get a free API keyCompare plans

Keep reading

• Developer guide

  How to pull sports betting odds from an API

  A developer's guide to TheRundown's odds API: the events-to-prices data model, first requests in curl and Python, and the free vs. paid plans.

  October 5, 2026
• Developer guide

  Pinnacle API alternative after the 2025 closure

  Pinnacle closed its public API on July 23, 2025. A Pinnacle API alternative: Pinnacle odds, max stakes, and closing lines beside 24 other books.

  October 5, 2026