# Migrate from The Odds API to GetOdds: endpoints, fields, sport keys and credits

Migrate from The Odds API v4 to GetOdds: same /v4 paths for five books and props, endpoint map, code diffs, keys, price by volume. Checked 16 Nov 2026.

Canonical page: https://getoddsapi.com/migrate/the-odds-api

## Free API key

Get a free GetOdds API key: **1,000 requests per UTC day and 60 per minute, no card**. One key covers REST and the hosted MCP server.

Sign up: https://getoddsapi.com/sign-up?ref=ai-claudebot

## Quickstart

1. Create an account at https://getoddsapi.com/sign-up?ref=ai-claudebot, open https://getoddsapi.com/dashboard and issue a key with the sources you need (draftkings, fanduel, betrivers, prizepicks or underdog). Keep it in a server environment variable named GETODDS_API_KEY.
2. Read current DraftKings NBA spreads with curl:

```bash
curl --fail-with-body "https://getoddsapi.com/api/v1/odds?sport=NBA&market=spread&fresh_only=true&limit=50" \
  -H "Authorization: Bearer $GETODDS_API_KEY"
```

3. The same request in Python (standard library only):

```python
import json, os, urllib.request

req = urllib.request.Request(
    "https://getoddsapi.com/api/v1/odds?sport=NBA&market=spread&fresh_only=true&limit=50",
    headers={"Authorization": "Bearer " + os.environ["GETODDS_API_KEY"]},
)
with urllib.request.urlopen(req) as res:
    rows = json.load(res)["data"]
for row in rows:
    print(row["away"], "at", row["home"], row["side"], row["line"], row["american"], row["observed_at"])
```

4. Check `observed_at`, `age_seconds` and `stale` on every row before using a price. Full reference: https://getoddsapi.com/docs

## Use with Claude (MCP)

```bash
claude mcp add --transport http getodds https://getoddsapi.com/api/mcp \
  --header "Authorization: Bearer $GETODDS_API_KEY"
```

The MCP tools follow the key's source grants and share its allowance. Setup guide: https://getoddsapi.com/use-with-claude

SDKs: `pip install getodds` (PyPI) · `npm install getoddsapi` (npm) · `npx -y getodds-mcp` (local MCP server) · R: `remotes::install_github("getoddsapi/getodds-r")`. Source: https://github.com/getoddsapi · https://getoddsapi.com/docs/sdks

## Pricing

| Plan | Allowance | Price |
| --- | --- | --- |
| Free key | 1,000 requests a day, 60 a minute | $0, no card |
| Starter | 100,000 credits a month, 120 a minute | $5 a month |
| Pro | 750,000 credits a month, 300 a minute | $19 a month |
| Business | 3,000,000 credits a month, 600 a minute | $39 a month |
| Scale | 15,000,000 credits a month, 1,200 a minute | $99 a month |

Free development allowance: 1,000 requests per UTC day and 60 per minute per account, with no payment step. Paid plans from $5 a month for 100,000 credits to $99 for 15 million, self-serve at /pricing.
Details: https://getoddsapi.com/pricing

## Guide


Canonical: https://getoddsapi.com/migrate/the-odds-api
Reviewed: 2026-11-15 UTC

**Answer:** To move from The Odds API to GetOdds, swap each v4 call for the GetOdds endpoint in the map below, move the key from the apiKey query parameter to an Authorization: Bearer header, map sport keys to league codes (basketball_nba becomes NBA) and read one flat row per price instead of event, bookmakers and outcomes; keep The Odds API for books GetOdds does not carry.

Migrate from The Odds API v4 to GetOdds: same /v4 paths for five books and props, endpoint map, code diffs, keys, price by volume. Checked 16 Nov 2026.

| Fact | Value |
| --- | --- |
| Same request shape? | Yes: /v4 odds, per-event odds with props, events, sports and scores |
| Key | Authorization: Bearer header |
| Response | One flat row per price |
| Books | DraftKings, FanDuel, BetRivers, Pinnacle, Novig |
| Free | 1,000 requests a day, no card |
| Checked | 15 November 2026 |

## Before you start

GetOdds covers fewer books than The Odds API: DraftKings, FanDuel, BetRivers and Pinnacle prices, PrizePicks, Underdog and Pick6 lines, and Kalshi and Polymarket contracts. If your product needs Caesars, BetMGM or other international books, migrate only the US books you read from GetOdds and keep The Odds API for the rest.

- [Every sportsbook GetOdds carries](https://getoddsapi.com/sportsbooks): And the ones it does not.
- [Sports and leagues covered](https://getoddsapi.com/sports): League by league.

## Same request shape: change the host, keep your code

GetOdds answers The Odds API v4 paths for the data it really has. Point your existing client at https://getoddsapi.com and send your GetOdds key as apiKey (or as a bearer header). /v4/sports and /v4/sports/{sport}/events cost 0 credits; /v4/sports/{sport}/odds, the per-event odds route and /scores cost 1 credit per request whatever the number of markets and regions.

What it serves: draftkings, fanduel and betrivers (region us), novig (us_ex) and pinnacle (eu) with h2h, spreads and totals; player_* prop markets on /v4/sports/{sport}/events/{eventId}/odds (those five books plus underdog); and /v4/sports/{sport}/scores. Sports: NFL, NCAAF, NBA, NCAAB, NHL, MLB, EPL, MLS, Champions League, Bundesliga, La Liga, Serie A and Ligue 1. Pregame prices only. Bookmaker and market keys GetOdds does not carry are dropped and listed in x-getodds-unsupported-bookmakers and x-getodds-unsupported-markets. x-requests-used and x-requests-remaining count your GetOdds allowance. Event ids are GetOdds ids, not 32-character hex ids.

```bash
curl "https://getoddsapi.com/v4/sports/basketball_nba/odds?apiKey=$GETODDS_API_KEY&regions=us&markets=h2h,spreads&oddsFormat=american"
```

## Endpoint map: The Odds API v4 to GetOdds

Every GetOdds path is in the OpenAPI contract at /openapi.json.

| The Odds API v4 | GetOdds | What changes |
| --- | --- | --- |
| GET /v4/sports?apiKey=KEY | GET /api/v1/sports | The key moves from apiKey (or x-api-key) to an Authorization: Bearer header. |
| GET /v4/sports/{sport}/events | GET /api/v1/events?sport=NBA | Sport keys become league codes: basketball_nba is NBA, americanfootball_nfl is NFL, icehockey_nhl is NHL. |
| GET /v4/sports/{sport}/odds?regions=us&markets=h2h | GET /api/v1/odds?sport=NBA&market=moneyline | One book per row instead of bookmakers[] per event; no regions parameter. |
| markets=spreads / markets=totals | market=spread / market=total | point becomes line. |
| GET /v4/sports/{sport}/events/{eventId}/odds | GET /api/v1/odds?event_id=ID | Several events at once: /api/v1/odds/multi?event_ids=ID1,ID2. |
| bookmakers=draftkings,fanduel | PUT /api/v1/bookmakers/selected/select?bookmakers=draftkings,fanduel,betrivers | Selected once per account; FanDuel and BetRivers also have their own endpoints. |
| GET /v4/sports/{sport}/scores | Same path on GetOdds, or GET /api/v1/events/ID/result | Same shape from the ESPN scoreboard; the native route adds verified final-result evidence. |
| GET /v4/historical/sports/{sport}/odds?date= | GET /api/v1/history?event_id=ID and /api/v1/historical/closing-lines?event_id=ID | Seven days of changes and closing lines; no snapshots before November 2026. |
| Player prop markets on event odds | GET /api/v1/betrivers/markets (priced) and /api/v1/markets?source=prizepicks (pick’em lines) | Pick’em lines are thresholds, not prices. |
| x-requests-remaining header | 1,000 requests a day, 60 a minute; 429 with Retry-After | One credit per successful page of up to 200 rows. |

## Field map

The Odds API nests outcomes under bookmakers and markets per event. GetOdds returns one row per price, each with its own capture time.

| The Odds API field | GetOdds field |
| --- | --- |
| id | event_id |
| sport_key | sport |
| commence_time | starts_at |
| home_team, away_team | home, away |
| bookmakers[].markets[].key | market (moneyline, spread, total) |
| outcomes[].name | side (home, away, draw, over, under) |
| outcomes[].price | american and decimal (both on every row) |
| outcomes[].point | line |
| last_update | observed_at, plus age_seconds and stale |

## Sport keys to league codes

GetOdds uses short league codes in the sport parameter.

| The Odds API sport key | GetOdds sport |
| --- | --- |
| americanfootball_nfl | NFL |
| basketball_nba | NBA |
| icehockey_nhl | NHL |
| americanfootball_ncaaf | NCAAF |
| basketball_ncaab | NCAAB |
| soccer_epl | EPL |
| soccer_usa_mls | MLS |
| baseball_mlb, tennis_*, golf_*, mma_* | Not covered by GetOdds |

## Bookmaker keys

Bookmaker keys from The Odds API bookmaker list, checked 15 November 2026.

| The Odds API bookmaker key | GetOdds equivalent |
| --- | --- |
| draftkings | draftkings, same key on /v4 (native: /api/v1/odds) |
| fanduel | fanduel, same key on /v4 (native: /api/v1/sportsbook/markets) |
| betrivers | betrivers, same key on /v4 (native: /api/v1/betrivers/markets) |
| novig (us_ex region) | novig, same key on /v4, the exchange ask (native: /api/v1/novig/markets with bid and fair) |
| prizepicks, underdog, pick6 (us_dfs region) | underdog on the /v4 per-event route where Underdog posts a price; all three lines on /api/v1/props and /api/v1/markets |
| kalshi, polymarket (us_ex region) | /api/v1/prediction-markets?source=kalshi or polymarket |
| pinnacle (eu region) | pinnacle, same key on /v4 (native: /api/v1/pinnacle/markets; read through, no history) |
| player_* prop markets on /v4/sports/{sport}/events/{id}/odds | Same path and keys on GetOdds (FanDuel, DraftKings, BetRivers, Pinnacle, Novig, Underdog); merged per player with history on /api/v1/props |
| williamhill_us, betmgm, fanatics, espnbet and others | Not carried; keep The Odds API for these |

## Credits: what the same workload costs

One credit is not the same unit on both. A credit on The Odds API covers every book in a region for one market; a GetOdds credit reads one source, every market, one page of up to 100 or 200 rows depending on the endpoint. Plans from both pricing pages on 15 November 2026.

|  | The Odds API | GetOdds |
| --- | --- | --- |
| Unit | 1 market x 1 region per request, all books in the region | 1 successful request to one source, one page of rows |
| Free | 500 credits a month | 1,000 credits per UTC day (about 30,000 a month) |
| Example: NBA moneyline, spread and total for DraftKings, FanDuel and BetRivers every 60 seconds | 3 credits a minute (3 markets, 1 region): about 129,600 a month | 3 requests a minute (one per book, all markets): about 129,600 a month |
| Cheapest plan that fits the example | $59 a month (100,000 credits) is too small; the next is $119 for 5M | $19 a month (750,000 credits) |
| Historical odds | 10 credits per region per market, snapshots back to 2020 | Seven days of changes and closing lines included; no data before November 2026 |

## The same request on both

Both calls return current NBA moneylines.

```bash
# The Odds API v4
curl "https://api.the-odds-api.com/v4/sports/basketball_nba/odds?apiKey=$THE_ODDS_API_KEY&regions=us&markets=h2h&oddsFormat=american"

# GetOdds: the same NBA moneylines, key in the header
curl --fail-with-body \
  -H "Authorization: Bearer $GETODDS_API_KEY" \
  "https://getoddsapi.com/api/v1/odds?sport=NBA&market=moneyline&fresh_only=true&limit=200"
```

## Code diff: Python

Lines starting with - are your current code; lines starting with + replace them. Step 1 keeps your parser; step 2 moves to flat rows when you are ready.

```diff
# Before: The Odds API
-import os, requests
-r = requests.get(
-    "https://api.the-odds-api.com/v4/sports/basketball_nba/odds",
-    params={"apiKey": os.environ["ODDS_API_KEY"], "regions": "us",
-            "markets": "h2h", "oddsFormat": "american"},
-    timeout=20)
-events = r.json()  # event > bookmakers > markets > outcomes

# After, step 1: same v4 path and parsing, GetOdds host and bearer key (DraftKings, FanDuel, BetRivers, Novig, Pinnacle)
+import os, requests
+r = requests.get(
+    "https://getoddsapi.com/v4/sports/basketball_nba/odds",
+    params={"regions": "us", "markets": "h2h", "oddsFormat": "american"},
+    headers={"Authorization": "Bearer " + os.environ["GETODDS_API_KEY"]},
+    timeout=20)
+events = r.json()  # same nesting as before

# After, step 2: native rows with capture times (pip install getodds)
+from getodds import GetOdds
+rows = GetOdds().odds(sport="NBA", market="moneyline", fresh_only=True, limit=200)["data"]
```

## Code diff: JavaScript

Node 18 or later with the built-in fetch. Keep the key on the server.

```diff
// Before: The Odds API
-const url = new URL('https://api.the-odds-api.com/v4/sports/basketball_nba/odds');
-url.search = new URLSearchParams({apiKey: process.env.ODDS_API_KEY, regions: 'us', markets: 'h2h'});
-const events = await (await fetch(url)).json();

// After, step 1: same v4 path, GetOdds host and bearer key
+const url = new URL('https://getoddsapi.com/v4/sports/basketball_nba/odds');
+url.search = new URLSearchParams({regions: 'us', markets: 'h2h'});
+const events = await (await fetch(url, {headers: {Authorization: `Bearer ${process.env.GETODDS_API_KEY}`}})).json();

// After, step 2: native client (npm install getoddsapi)
+import {GetOdds} from 'getoddsapi';
+const {data: rows} = await new GetOdds().odds({sport: 'NBA', market: 'moneyline', fresh_only: true, limit: 200});
```

## Code diff: curl

The v4 path serves DraftKings, FanDuel, BetRivers, Novig and Pinnacle; the native routes add capture times and history per price.

```diff
# Before: The Odds API
-curl "https://api.the-odds-api.com/v4/sports/basketball_nba/odds?apiKey=$ODDS_API_KEY&regions=us&markets=h2h,spreads"

# After: same path on GetOdds (apiKey in the query also works)
+curl "https://getoddsapi.com/v4/sports/basketball_nba/odds?regions=us&markets=h2h,spreads" \
+  -H "Authorization: Bearer $GETODDS_API_KEY"

# FanDuel, BetRivers and Pinnacle use native routes
+curl "https://getoddsapi.com/api/v1/sportsbook/markets?league=NBA&limit=100" -H "Authorization: Bearer $GETODDS_API_KEY"
+curl "https://getoddsapi.com/api/v1/betrivers/markets?league=NBA&limit=100" -H "Authorization: Bearer $GETODDS_API_KEY"
+curl "https://getoddsapi.com/api/v1/pinnacle/markets?league=NBA" -H "Authorization: Bearer $GETODDS_API_KEY"
```

## Price by monthly request volume

Cheapest plan that covers each monthly volume, assuming one market in one region per The Odds API call (1 credit) and one book per GetOdds call (1 credit). The Odds API credit covers every book in the region, so if you read three books on GetOdds, multiply your GetOdds requests by three before you read the table. Prices from both pricing pages on 15 November 2026.

| Credits a month | The Odds API | GetOdds |
| --- | --- | --- |
| 500 | Free (500) | Free (1,000 a day) |
| 20,000 | $30 (20K) | Free, if under 1,000 a day |
| 100,000 | $59 (100K) | $5 (100K) |
| 750,000 | $119 (5M) | $19 (750K) |
| 3,000,000 | $119 (5M) | $39 (3M) |
| 5,000,000 | $119 (5M) | $99 (15M) |
| 15,000,000 | $249 (15M) | $99 (15M) |

## Keep your parsing code during the switch

This helper builds The Odds API event, bookmakers, markets, outcomes shape from GetOdds rows, so you can change the data source first and refactor later.

```python
# Group GetOdds rows into The Odds API's event -> bookmakers -> outcomes shape,
# so existing code that reads that shape keeps working during a migration.
from collections import defaultdict

def to_the_odds_api_shape(rows, bookmaker="draftkings"):
    names = {"moneyline": "h2h", "spread": "spreads", "total": "totals"}
    events = {}
    outcomes = defaultdict(list)
    for r in rows:
        events.setdefault(r["event_id"], {
            "id": r["event_id"], "sport_key": r["sport"], "commence_time": r["starts_at"],
            "home_team": r["home"], "away_team": r["away"],
        })
        name = r["home"] if r["side"] == "home" else r["away"] if r["side"] == "away" else r["side"].title()
        outcomes[(r["event_id"], r["market"])].append(
            {"name": name, "price": r["american"], **({"point": r["line"]} if r["line"] is not None else {})})
    for (event_id, market), outs in outcomes.items():
        books = events[event_id].setdefault("bookmakers", [{"key": bookmaker, "markets": []}])
        books[0]["markets"].append({"key": names[market], "outcomes": outs})
    return list(events.values())
```

## Migrate in three steps

Run both feeds side by side for a day and compare line, price and capture time per game before you move production traffic.

```bash
# 1. Create a free GetOdds key (no card) at https://getoddsapi.com/sign-up
export GETODDS_API_KEY=go_live_...

# 2. Select the books you read (DraftKings is on by default)
curl --fail-with-body -X PUT \
  "https://getoddsapi.com/api/v1/bookmakers/selected/select?bookmakers=draftkings,fanduel,betrivers" \
  -H "Authorization: Bearer $GETODDS_API_KEY"

# 3. Replace each v4 call using the map above, then diff a few games against your current feed
curl --fail-with-body "https://getoddsapi.com/api/v1/odds?sport=NBA&fresh_only=true&limit=200" \
  -H "Authorization: Bearer $GETODDS_API_KEY"
```

## Questions

### Is GetOdds a drop-in replacement for The Odds API?

For the books it carries, yes: the /v4 odds, per-event odds (with player props), events, sports and scores routes take the same parameters and return the same shape. GetOdds covers fewer books and no historical snapshots before November 2026.

### Do I lose historical odds when I migrate?

GetOdds keeps every change and closing line since November 2026 and has no data before that. If you backtest on older seasons, keep The Odds API historical endpoints for that.

### Is GetOdds cheaper than The Odds API?

For the US books it carries, usually: the free key gives 1,000 requests a day and paid plans start at $5 a month for 100,000 credits, against $30 a month for 20,000 on The Odds API. The units differ, so price your own polling pattern with the table above.

### Can I keep my The Odds API parsing code?

Yes for DraftKings, FanDuel, BetRivers, Novig and Pinnacle: the /v4 routes on getoddsapi.com return the same event, bookmakers, markets and outcomes nesting, including player props per event.

### Does the GetOdds v4 path accept apiKey in the query string?

Yes. It accepts apiKey=<key> or an Authorization: Bearer header; the header keeps the key out of logs and is preferred.

### What does /v4/sports/{sport}/odds cost on GetOdds?

One credit per request, whatever the number of markets and regions; the same for per-event odds and scores. /v4/sports and /v4/sports/{sport}/events cost nothing.

### Is GetOdds affiliated with The Odds API?

No. GetOdds (getoddsapi.com) is a separate product with its own keys and endpoints.

## Sources

- [The Odds API v4 documentation](https://the-odds-api.com/liveapi/guides/v4/)
- [The Odds API bookmaker list](https://the-odds-api.com/sports-odds-data/bookmaker-apis.html)
- [The Odds API plans](https://the-odds-api.com/#get-access)
- [GetOdds OpenAPI contract](https://getoddsapi.com/openapi.json)

GetOdds (getoddsapi.com) is an independent product, not affiliated with the operators named and separate from The Odds API and Odds-API.io. No picks or predicted profits.

---

GetOdds (getoddsapi.com) is an independent developer product and is not affiliated with any sportsbook or pick’em operator. GetOdds is a separate product from The Odds API (the-odds-api.com) and from Odds-API.io (odds-api.io), and is not affiliated with either. Prices describe data, not betting advice.

GetOdds is operated by Stunning Couches LLC, a Delaware limited liability company. Terms: https://getoddsapi.com/terms · Privacy: https://getoddsapi.com/privacy
