{"id":3657,"date":"2026-08-21T10:00:00","date_gmt":"2026-08-21T10:00:00","guid":{"rendered":"https:\/\/oddspapi.io\/blog\/?p=3657"},"modified":"2026-08-29T14:57:50","modified_gmt":"2026-08-29T14:57:50","slug":"nfl-schedule-api","status":"publish","type":"post","link":"https:\/\/oddspapi.io\/blog\/nfl-schedule-api\/","title":{"rendered":"NFL Schedule API: Pull the Full 2026 Season in Python"},"content":{"rendered":"

The NFL does not publish a schedule API. ESPN’s old public endpoints are undocumented and break without notice, nflverse ships CSV dumps built for R users, and the licensed stats feeds put a sales call in front of a JSON file. None of that helps if you want the 2026 fixture list in your own database this afternoon.<\/p>\n

This guide pulls the whole loaded NFL season out of the OddsPapi \/v4\/fixtures<\/code> endpoint in 21 API calls and 52 seconds, on the free key. Every number below came off the live API on August 12, 2026. All eight code blocks ran end to end before this post went out.<\/p>\n

What you get, and what you do not<\/h2>\n

The endpoint returns fixtures: teams, kickoff times, status, a coverage flag, and a block of third-party IDs for joining to other data. It does not return scores, and it does not return a week number. Both gaps are fixable and this post shows how.<\/p>\n

\n\n\n\n\n\n\n\n\n\n
The old way<\/th>\nOddsPapi \/v4\/fixtures<\/code><\/th>\n<\/tr>\n<\/thead>\n
Scrape ESPN’s undocumented JSON and re-fix the parser every season<\/td>\nOne documented endpoint, stable JSON shape<\/td>\n<\/tr>\n
Download a CSV dump and wait for someone to update it<\/td>\nLive feed, updatedAt<\/code> on every fixture<\/td>\n<\/tr>\n
Sales call before you see a schema<\/td>\nFree key, curl it in 30 seconds<\/td>\n<\/tr>\n
Schedule from one provider, odds from another, IDs that never match<\/td>\nSchedule and odds keyed on the same fixtureId<\/code><\/td>\n<\/tr>\n
No way to join to Betradar or Sofascore<\/td>\nexternalProviders<\/code> on every fixture<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n

Step 1: authenticate<\/h2>\n

The key goes in the query string. It is not a header, and passing it as one gets you a 401.<\/p>\n

import datetime as dt\nimport time\nimport requests\n\nAPI_KEY = \"YOUR_API_KEY\"\nBASE_URL = \"https:\/\/api.oddspapi.io\/v4\"\n\n\ndef fetch(path, **params):\n    \"\"\"GET a v4 endpoint. Returns None when the API says 'nothing here'.\"\"\"\n    params[\"apiKey\"] = API_KEY\n    for attempt in range(6):\n        r = requests.get(f\"{BASE_URL}\/{path}\", params=params, timeout=60)\n        if r.status_code == 429:\n            wait = r.json()[\"error\"].get(\"retryMs\", 1500) \/ 1000\n            time.sleep(wait + 0.3)\n            continue\n        if r.status_code == 404:\n            return None                      # empty window, not an error\n        r.raise_for_status()\n        return r.json()\n    raise RuntimeError(f\"rate limited on \/{path}\")\n\n\nprint(len(fetch(\"sports\")), \"sports\")        # 69<\/code><\/pre>\n
Two things in that function matter more than they look. A 429 response carries a JSON body with retryMs<\/code>, so the API tells you exactly how long to wait rather than making you guess. And a 404 from \/fixtures<\/code> means the window is empty, which happens 11 times in the season loop below. If you let raise_for_status()<\/code> see it, your season pull dies in August.<\/p>\n
The 404 is not an error<\/h3>\n
GET \/v4\/fixtures?sportId=14&tournamentId=31&from=2026-08-12&to=2026-08-22\n\n404\n{\"error\": {\"message\": \"No fixtures found for the specified criteria.\",\n           \"code\": \"FIXTURE_NOT_FOUND\",\n           \"details\": \"Please check your filters and try again.\"}}<\/code><\/pre>\n
The NFL plays no games in late August, so the window is genuinely empty. Treat FIXTURE_NOT_FOUND<\/code> as an empty list and move to the next window.<\/p>\n
Step 2: find the NFL<\/h2>\n
American football is sportId=14<\/code>, and that sport holds 29 tournaments. Six of them have fixtures loaded right now, including the college board with 3,507 of them. Filter on the wrong row and you get a schedule 26 times too big.<\/p>\n
tours = fetch(\"tournaments\", sportId=14)\n\nfor t in tours:\n    if t[\"futureFixtures\"]:\n        print(f\"{t['tournamentId']:>6}  {t['tournamentName']:<28} \"\n              f\"{t['categoryName']:<14} {t['futureFixtures']} future\")<\/code><\/pre>\n
    31  NFL                          USA            132 future\n   233  NFL Preseason                USA             48 future\n   790  CFL                          Canada          43 future\n 27653  NCAA, Regular Season         USA           3507 future\n 51578  EFA                          International    2 future\n 51580  AFLE                         International    8 future<\/code><\/pre>\n
The NFL is tournamentId=31<\/code>. Hardcode it after you have looked it up once. Preseason lives on its own ID (233), so a pull that expects one season list will silently miss August football.<\/p>\n
tournamentId<\/code> works on \/fixtures, and it is worth using<\/h3>\n
The parameter is not in the endpoint docs but it filters server side. The same six-day window returned 324 American football fixtures unfiltered and 15 with tournamentId=31<\/code> attached. That is 20 times less JSON to download and parse.<\/p>\n
Step 3: pull the season<\/h2>\n
\/fixtures<\/code> takes a date range and caps it at 10 days. A season is about 25 weeks, so you loop. Deduplicate on fixtureId<\/code> as you go, because consecutive windows share a boundary day.<\/p>\n
def pull_season(tournament_id, start, end, window=10):\n    fixtures, calls, empty = {}, 0, 0\n    day = dt.date.fromisoformat(start)\n    last = dt.date.fromisoformat(end)\n    while day < last:\n        to = min(day + dt.timedelta(days=window), last)\n        batch = fetch(\"fixtures\", sportId=14, tournamentId=tournament_id,\n                      **{\"from\": day.isoformat(), \"to\": to.isoformat()})\n        calls += 1\n        if batch is None:\n            empty += 1\n        else:\n            for f in batch:\n                fixtures[f[\"fixtureId\"]] = f\n        day = to\n        time.sleep(1.0)                      # per-endpoint cooldown\n    return list(fixtures.values()), calls, empty\n\n\nseason, calls, empty = pull_season(31, \"2026-08-12\", \"2027-03-05\")\nprint(f\"{len(season)} fixtures in {calls} calls ({empty} empty)\")\n# 132 fixtures in 21 calls (11 empty)<\/code><\/pre>\n
That run took 52 seconds, and 21 of those seconds are the deliberate sleep(1.0)<\/code>. The free tier rate-limits per endpoint, and a one-second gap between calls to the same path returns clean 200s every time. Do not thread this. Concurrency at any worker count gets almost everything rejected.<\/p>\n
Set to<\/code> to the day after the last day you want<\/h3>\n
The window is inclusive of both midnight instants, which means to<\/code> behaves as a timestamp rather than a whole day. Asking for one day gets you only the games that kick off at exactly 00:00 UTC:<\/p>\n
\n\n\n\n\n\n\n
Query<\/th>\nFixtures returned<\/th>\n<\/tr>\n<\/thead>\n
from=2026-09-13&to=2026-09-13<\/code><\/td>\n0<\/td>\n<\/tr>\n
from=2026-09-13&to=2026-09-14<\/code><\/td>\n12<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n
Both queries cover the same Sunday slate. The first one makes the NFL look cancelled.<\/p>\n
Step 4: the fixture object<\/h2>\n
Here is one game, unedited:<\/p>\n
{\n  \"fixtureId\": \"id1400003171515752\",\n  \"sportId\": 14,\n  \"tournamentId\": 31,\n  \"tournamentName\": \"NFL\",\n  \"tournamentSlug\": \"nfl\",\n  \"categoryName\": \"USA\",\n  \"seasonId\": null,\n  \"statusId\": 0,\n  \"statusName\": \"Pre-Game\",\n  \"hasOdds\": true,\n  \"startTime\": \"2026-09-10T00:20:00.000Z\",\n  \"trueStartTime\": null,\n  \"trueEndTime\": null,\n  \"updatedAt\": \"2026-08-11T23:10:47.105Z\",\n  \"participant1Id\": 4430,\n  \"participant1Name\": \"Seattle Seahawks\",\n  \"participant1ShortName\": \"Seattle\",\n  \"participant1Abbr\": \"SEA\",\n  \"participant2Id\": 4424,\n  \"participant2Name\": \"New England Patriots\",\n  \"participant2ShortName\": \"New England\",\n  \"participant2Abbr\": \"NE\",\n  \"externalProviders\": {\n    \"betradarId\": 71515752,\n    \"opticoddsId\": \"20260910B2546DE0\",\n    \"sofascoreId\": 16184611,\n    \"betgeniusId\": 13906257,\n    \"flashscoreId\": \"GQtrH2RF\",\n    \"pinnacleId\": 1630865288,\n    \"mollybetId\": null,\n    \"lsportsId\": null,\n    \"txoddsId\": null,\n    \"oddinId\": null\n  }\n}<\/code><\/pre>\n
Three fields will bite you.<\/p>\n
statusName<\/code> is missing, not null, on some fixtures.<\/strong> Sixteen of the 132 NFL games have no statusName<\/code> key at all, and the same 16 have statusId: null<\/code>. Every one of them is a real game with a real kickoff time. Use f.get(\"statusName\", \"Unknown\")<\/code> and your parser survives.<\/p>\n
seasonId<\/code> is null on all 132.<\/strong> Do not build a season key off it.<\/p>\n
There is no week number.<\/strong> The feed gives you a kickoff timestamp and nothing else. Derive the week by anchoring on opening day, since the NFL runs a clean Thursday-to-Wednesday cycle:<\/p>\n
season.sort(key=lambda f: f[\"startTime\"])\n\n\ndef utc(fixture):\n    return dt.datetime.fromisoformat(fixture[\"startTime\"].replace(\"Z\", \"+00:00\"))\n\n\nopening_day = utc(season[0]).date()\n\n\ndef week_of(fixture):\n    return (utc(fixture).date() - opening_day).days \/\/ 7 + 1\n\n\nweeks = {}\nfor f in season:\n    weeks.setdefault(week_of(f), []).append(f)\n\nfor w in sorted(weeks):\n    games = weeks[w]\n    print(f\"Week {w:>2}: {len(games):>2} games, \"\n          f\"{sum(g['hasOdds'] for g in games):>2} with odds\")<\/code><\/pre>\n
Week  1: 16 games, 16 with odds\nWeek  2: 16 games, 16 with odds\nWeek  3: 16 games, 16 with odds\nWeek  4: 16 games, 16 with odds\nWeek  5: 15 games, 15 with odds\nWeek  6: 14 games, 14 with odds\nWeek  7: 14 games, 14 with odds\nWeek  8: 14 games, 14 with odds\nWeek  9:  1 games,  1 with odds\nWeek 10:  1 games,  1 with odds\nWeek 11:  1 games,  0 with odds\nWeek 12:  4 games,  0 with odds\nWeek 16:  4 games,  0 with odds<\/code><\/pre>\n
The 16-game weeks are complete rounds for all 32 teams. Weeks 5 through 8 drop to 14 or 15 because byes start. After Week 8 the feed thins to a handful of marquee dates, and the four Week 12 games are Thanksgiving.<\/p>\n
The season loads in front of you<\/h3>\n
132 fixtures is 48.5% of a 272-game regular season. Weeks 1 through 8 are fully loaded; the back half is not there yet, and no team has all 17 of its games on the feed. Re-run the loop weekly and merge on fixtureId<\/code> rather than treating one pull as the finished article.<\/p>\n
Step 5: kickoff times move a day<\/h2>\n
Every timestamp is UTC, and NFL prime-time kickoffs cross midnight when you convert. Twelve of the 132 games land on a Friday in UTC. None of them are Friday games.<\/p>\n
EASTERN = dt.timezone(dt.timedelta(hours=-4))   # EDT during the season\n\nfor f in season[:5]:\n    local = utc(f).astimezone(EASTERN)\n    print(f\"{local:%a %b %d %H:%M} ET  \"\n          f\"{f['participant1Name']} v {f['participant2Name']}\")<\/code><\/pre>\n
Wed Sep 09 20:20 ET  Seattle Seahawks v New England Patriots\nThu Sep 10 20:35 ET  Los Angeles Rams v San Francisco 49ers\nSun Sep 13 13:00 ET  Indianapolis Colts v Baltimore Ravens\nSun Sep 13 13:00 ET  Detroit Lions v New Orleans Saints\nSun Sep 13 13:00 ET  Pittsburgh Steelers v Atlanta Falcons<\/code><\/pre>\n
Converted to Eastern, the slate structure appears exactly where you expect it: 54 games at Sunday 13:00, 19 at Sunday 16:25, seven Sunday nighters at 20:20, seven Monday nighters at 20:15, and four Sunday morning kickoffs at 09:30 that are the London games. Group by UTC date and you get none of that.<\/p>\n
Step 6: join keys for everything else<\/h2>\n
The feed has no scores and no player stats, so most real pipelines join it to something that does. externalProviders<\/code> is how. Coverage is uneven and worth measuring before you pick a key:<\/p>\n
from collections import Counter\n\ncoverage = Counter()\nfor f in season:\n    for provider, value in (f.get(\"externalProviders\") or {}).items():\n        if value is not None:\n            coverage[provider] += 1\n\nprint({k: f\"{v}\/{len(season)}\" for k, v in coverage.most_common()})<\/code><\/pre>\n
\n\n\n\n\n\n\n\n\n\n\n\n\n
Provider key<\/th>\nPopulated<\/th>\nType<\/th>\n<\/tr>\n<\/thead>\n
betradarId<\/code><\/td>\n132 of 132<\/td>\nint<\/td>\n<\/tr>\n
opticoddsId<\/code><\/td>\n117 of 132<\/td>\nstr<\/td>\n<\/tr>\n
sofascoreId<\/code><\/td>\n30 of 132<\/td>\nint<\/td>\n<\/tr>\n
flashscoreId<\/code><\/td>\n30 of 132<\/td>\nstr<\/td>\n<\/tr>\n
betgeniusId<\/code><\/td>\n16 of 132<\/td>\nint<\/td>\n<\/tr>\n
pinnacleId<\/code><\/td>\n16 of 132<\/td>\nint<\/td>\n<\/tr>\n
lsportsId<\/code><\/td>\n4 of 132<\/td>\nint<\/td>\n<\/tr>\n
mollybetId<\/code><\/td>\n1 of 132<\/td>\nint<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n
Betradar is the only key present on every fixture, so build your join on that and fall back to team names plus kickoff date. Sofascore and Flashscore, the two free scoreboards a hobby project would reach for, cover 23%. The IDs also arrive at different types, so cast before you compare.<\/p>\n
Step 7: hasOdds<\/code> tells you a book exists, not that a market does<\/h2>\n
123 of the 132 fixtures carry hasOdds: true<\/code>, which reads like the whole season is priced four months out. It is not. Measure the board instead of trusting the flag:<\/p>\n
def board_depth(fixture_id):\n    payload = fetch(\"odds\", fixtureId=fixture_id)\n    books = (payload or {}).get(\"bookmakerOdds\") or {}\n    live = {s: b for s, b in books.items() if not b.get(\"suspended\")}\n\n    quotes = {}\n    for slug, book in live.items():\n        ml = book.get(\"markets\", {}).get(\"141\")        # Winner (incl. overtime)\n        if not ml:\n            continue\n        price = tuple(sorted(\n            (oid, round(o[\"players\"][\"0\"][\"price\"], 4))\n            for oid, o in ml[\"outcomes\"].items()\n            if o.get(\"players\", {}).get(\"0\", {}).get(\"active\")))\n        if len(price) == 2:\n            quotes.setdefault(price, []).append(slug)\n\n    markets = sum(len(b.get(\"markets\", {})) for b in live.values())\n    return len(live), len(quotes), markets<\/code><\/pre>\n
Note where active<\/code> lives. An outcome object has exactly one key, players<\/code>. The price, the active<\/code> flag and the limit all sit one level deeper at players[\"0\"]<\/code>, so outcome[\"active\"]<\/code> is always undefined. On game lines the key is the string \"0\"<\/code>; on player props the same dict is keyed by player ID.<\/p>\n
Run it across three fixtures on each of the first three Sunday slates, so the comparison is like for like:<\/p>\n
\n\n\n\n\n\n\n\n
Sunday slate<\/th>\nDays out<\/th>\nhasOdds<\/code><\/th>\nBooks<\/th>\nIndependent quotes<\/th>\nMarkets<\/th>\n<\/tr>\n<\/thead>\n
Week 1, Sep 13<\/td>\n32<\/td>\ntrue<\/td>\n18<\/td>\n13 to 14<\/td>\n167 to 177<\/td>\n<\/tr>\n
Week 2, Sep 20<\/td>\n39<\/td>\ntrue<\/td>\n4<\/td>\n3<\/td>\n20<\/td>\n<\/tr>\n
Week 3, Sep 27<\/td>\n46<\/td>\ntrue<\/td>\n3<\/td>\n2<\/td>\n10 to 11<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n
One week further out costs you four fifths of the board. Week 1 carries Pinnacle, SBOBet, Kalshi, Polymarket, Bet365, Circa and eleven others. Week 3 carries Caesars, William Hill and DraftKings, and Caesars and William Hill are the same feed quoting byte-identical prices. Two independent opinions, both flagged hasOdds: true<\/code>.<\/p>\n
This is how sportsbooks work rather than a gap in the feed. Books hang the opening week first and fill the rest in as it approaches, and one desk carrying season-long placeholder numbers is enough to flip the flag. Prime-time standalone games hold depth longer than the Sunday slate around them: the Week 2 Friday game had 10 books while its Sunday slate had four.<\/p>\n
Rule: a fixture count is not a coverage number.<\/strong> If your pipeline picks games to price, filter on measured depth, not on hasOdds<\/code>.<\/p>\n
What Week 1 looks like when the board is real<\/h3>\n
Seattle at New England, the first game on the feed, carried 174 markets across 18 bookmakers and 72 distinct market IDs. The moneyline, sorted by margin:<\/p>\n
\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Bookmaker<\/th>\nSeattle<\/th>\nNew England<\/th>\nMargin<\/th>\n<\/tr>\n<\/thead>\n
polymarket<\/td>\n1.493<\/td>\n2.941<\/td>\n0.98%<\/td>\n<\/tr>\n
kalshi<\/td>\n1.515<\/td>\n2.778<\/td>\n2.00%<\/td>\n<\/tr>\n
pinnacle<\/td>\n1.490<\/td>\n2.770<\/td>\n3.22%<\/td>\n<\/tr>\n
circasports<\/td>\n1.526<\/td>\n2.650<\/td>\n3.27%<\/td>\n<\/tr>\n
fanduel<\/td>\n1.530<\/td>\n2.600<\/td>\n3.82%<\/td>\n<\/tr>\n
caesars = williamhill<\/td>\n1.508<\/td>\n2.640<\/td>\n4.19%<\/td>\n<\/tr>\n
draftkings<\/td>\n1.521<\/td>\n2.600<\/td>\n4.21%<\/td>\n<\/tr>\n
bet365<\/td>\n1.500<\/td>\n2.650<\/td>\n4.40%<\/td>\n<\/tr>\n
hardrockbet<\/td>\n1.526<\/td>\n2.550<\/td>\n4.75%<\/td>\n<\/tr>\n
sbobet<\/td>\n1.480<\/td>\n2.660<\/td>\n5.16%<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n
Polymarket and Kalshi price the opener tighter than Pinnacle does, which reproduces what the prediction markets have been doing on college football<\/a> and La Liga<\/a> all summer. Read those as best available prices and nothing more; exchange quotes need a depth check on the exchangeMeta<\/code> ladder before you treat them as real.<\/p>\n
Deduplicating the 18 books on the exact price tuple leaves 12 independent quotes. Some of those collapses are known shared feeds (Caesars with William Hill, BetMGM with Borgata, BetParx with BallyBet and FourWinds) and some are coincidence at a round number. Dedupe on the tuple first, then confirm against \/v4\/bookmakers<\/code>, because cloneOf<\/code> does not flag every shared feed.<\/p>\n
Step 8: write it to CSV<\/h2>\n
import csv\n\nwith open(\"nfl_2026_schedule.csv\", \"w\", newline=\"\") as fh:\n    writer = csv.writer(fh)\n    writer.writerow([\"week\", \"kickoff_utc\", \"kickoff_et\", \"home\", \"away\",\n                     \"status\", \"has_odds\", \"fixture_id\", \"betradar_id\"])\n    for f in season:\n        writer.writerow([\n            week_of(f),\n            f[\"startTime\"],\n            utc(f).astimezone(EASTERN).isoformat(),\n            f[\"participant1Name\"],\n            f[\"participant2Name\"],\n            f.get(\"statusName\", \"Unknown\"),\n            f[\"hasOdds\"],\n            f[\"fixtureId\"],\n            (f.get(\"externalProviders\") or {}).get(\"betradarId\"),\n        ])<\/code><\/pre>\n
132 rows, nine columns, ready for pandas or a SQLite table<\/a>. Keep fixtureId<\/code> in the file. It is the key for every odds call you make later, and for the free \/v4\/historical-odds<\/code> endpoint that gives you the full price history of any fixture back to its opening line.<\/p>\n
The same loop, other competitions<\/h2>\n
Nothing in pull_season<\/code> is NFL-specific past the tournament ID. Swap it and the loop works on any of the 69 sports:<\/p>\n
\n\n\n\n\n\n\n\n\n
Competition<\/th>\ntournamentId<\/code><\/th>\nFixtures loaded<\/th>\nWith odds<\/th>\n<\/tr>\n<\/thead>\n
NFL<\/td>\n31<\/td>\n132<\/td>\n123<\/td>\n<\/tr>\n
NFL Preseason<\/td>\n233<\/td>\n48<\/td>\n48<\/td>\n<\/tr>\n
NCAA regular season<\/td>\n27653<\/td>\n3,507 future<\/td>\n97 in the opening 10 days<\/td>\n<\/tr>\n
CFL<\/td>\n790<\/td>\n43<\/td>\nnot measured<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n
College is the interesting one. 3,507 future fixtures sounds like total coverage until you look at the opening window, where 416 games loaded and 97 had a price. The NCAAF board<\/a> also runs 42% active, meaning most quoted outcomes are suspended lines a book posted early and stopped taking.<\/p>\n
What is not in the feed<\/h2>\n
Being straight about the gaps saves you a wasted afternoon.<\/p>\n
    \n
  • No scores or results.<\/strong> statusName<\/code> reaches Finished<\/code> and stops. Join out on betradarId<\/code> or sofascoreId<\/code>, or recover win and loss labels from the way historical prices collapse toward 1.00 after kickoff.<\/li>\n
  • No player stats, no injuries, no venue, no weather.<\/strong> Teams, time, status, IDs.<\/li>\n
  • No week number and no seasonId<\/code>.<\/strong> Derive the week as shown above.<\/li>\n
  • Half the season.<\/strong> 132 of 272 games today, front-loaded on Weeks 1 to 8.<\/li>\n
  • No NFL outrights.<\/strong> The catalogue has no Super Bowl winner or division market. The only futures-shaped NFL market is To Win the Coin Toss.<\/li>\n<\/ul>\n
    Where the schedule pays off<\/h2>\n
    A fixture list on its own is a calendar. Joined to the odds endpoint it becomes the spine of everything else: 350+ bookmakers on one fixtureId<\/code>, free historical price history back to the opening line on the same key, and a WebSocket feed that pushes changes instead of making you poll for them. The Week 1 opener alone carries 72 distinct market IDs, including spreads, totals, team totals and anytime touchdown props keyed by player.<\/p>\n
    Start with the NFL odds guide<\/a> for the market IDs, key numbers<\/a> for what a half point is worth on the spread, and the free sports data API guide<\/a> if you want the same loop pointed at the other 68 sports. New to the API? Make your first call<\/a> first.<\/p>\n
    FAQ<\/h2>\n
    Is there a free NFL schedule API?<\/h3>\n
    Yes. The OddsPapi \/v4\/fixtures<\/code> endpoint returns the NFL schedule as JSON on the free tier. The full loaded 2026 season took 21 calls and 52 seconds on a free key.<\/p>\n
    What is the NFL tournament ID?<\/h3>\n
    31, with slug nfl<\/code> under category USA. Preseason is 233 and the college regular season is 27653. Sport ID 14 covers all of them plus the CFL, XFL and UFL, so filter on the tournament.<\/p>\n
    Why does my date query return nothing?<\/h3>\n
    Two reasons. to<\/code> is a midnight UTC instant, so set it to the day after the last day you want. And an empty window returns HTTP 404 with code FIXTURE_NOT_FOUND<\/code>, which your fetch wrapper should treat as an empty list.<\/p>\n
    Does the API include NFL scores?<\/h3>\n
    No. Fixtures carry teams, kickoff time and status only. Use the externalProviders<\/code> block to join to a scores source. betradarId<\/code> is populated on all 132 fixtures; sofascoreId<\/code> and flashscoreId<\/code> on 30 each.<\/p>\n
    How far ahead are NFL odds available?<\/h3>\n
    Books price the opening week properly and thin out fast after it. Week 1 fixtures carried 18 bookmakers and up to 177 markets; the Week 3 Sunday slate carried three books and 10 markets. Every one of those fixtures reports hasOdds: true<\/code>, so measure the board rather than trusting the flag.<\/p>\n
    Can I get last season’s NFL schedule and odds?<\/h3>\n
    \/v4\/historical-odds<\/code> keeps deep price history per fixture, but 2025 regular-season NFL history has aged out. January 2026 playoff games still return data from retail books, and Super Bowl LX is fully retained.<\/p>\n
    Get your key<\/h2>\n
    The schedule loop above runs on the free tier with no card and no sales call. Grab a free API key<\/a>, point pull_season<\/code> at tournament 31, and have the 2026 fixture list in your database before kickoff.<\/p>\n