SDKs & Libraries

import { ForbiddenError, isPriceRunner } from 'odds-api-io';

try {
  const tournaments = await client.getOutrights({ sport: 'golf', league: 'pga-tour' });
  const odds = await client.getOutrightOdds({
    id: tournaments[0].id,
    bookmakers: ['DraftKings', 'Betfair Exchange'],
  });

  for (const market of odds.bookmakers['DraftKings'] ?? []) {
    for (const runner of market.odds.slice(0, 3)) {
      if (isPriceRunner(runner)) console.log(market.name, runner.label, runner.odds);
      else console.log(market.name, runner.label, runner.yes, runner.no); // Make Cut
    }
  }

  const results = await client.getOutrightResults(tournaments[0].id);
  console.log(results.winners['Top 10 (Incl. Ties)']);
} catch (err) {
  if (err instanceof ForbiddenError && err.isAddOnRequired) console.log(err.message);
  else throw err;
}

from odds_api import AddOnRequiredError, OddsAPIClient

client = OddsAPIClient(api_key="YOUR_API_KEY")
try:
    tournaments = client.get_outrights(sport="golf", league="pga-tour")
except AddOnRequiredError as e:
    print(e)  # the server's message, with the link to add the Outrights add-on
else:
    odds = client.get_outright_odds(tournaments[0]["id"], ["DraftKings", "Betfair Exchange"])
    for bookmaker, markets in odds["bookmakers"].items():
        for market in markets:  # Winner, Top 5, Top 5 (Incl. Ties), ..., Make Cut
            favourite = market["odds"][0]
            print(bookmaker, market["name"], favourite["label"], favourite.get("odds") or favourite.get("yes"))

    results = client.get_outright_results(tournaments[0]["id"])
    print(results["winners"].get("Top 10"))

golf <- oa_outrights("golf", league = "pga-tour")
prices <- oa_outright_odds(golf$id[1], c("DraftKings", "Betfair Exchange"))
head(prices)

results <- oa_outright_results(golf$id[1])

for await (const event of client.iterateClosingLines({
  sport: 'football',
  leagues: ['england-premier-league', 'spain-laliga'],
  from: '2026-08-01T00:00:00Z',
  to: '2026-10-31T23:59:59Z',
  markets: ['ML', 'Totals'],
  bookmakers: ['Bet365', 'SingBet'],
})) {
  console.log(event.id, event.bookmakers['Bet365']?.[0]?.odds[0]);
}

from odds_api import OddsAPIClient
from odds_api.dataframes import closing_lines_to_dataframe  # pip install "odds-api-io[pandas]"

client = OddsAPIClient(api_key="YOUR_API_KEY")
rows = client.iter_closing_lines(
    sport="football",
    leagues=["england-premier-league", "spain-laliga"],
    from_="2026-08-01T00:00:00Z",
    to="2026-10-31T23:59:59Z",
    markets=["ML", "Totals"],
    bookmakers=["Bet365", "SingBet"],
)
df = closing_lines_to_dataframe(list(rows))
print(df[["date", "home_team", "away_team", "bookmaker", "market", "hdp", "home", "away", "over", "under"]])

cl <- oa_closing_lines("football", "england-premier-league",
                       from = "2025-08-01T00:00:00Z",
                       to = "2026-05-31T23:59:59Z",
                       markets = "ML", bookmakers = c("Bet365", "SingBet"))
head(cl)

import { OddsAPIError, RateLimitError, ForbiddenError } from 'odds-api-io';

try {
  await client.getEvents({ sport: 'basketball' });
} catch (err) {
  if (err instanceof RateLimitError) console.log(`retry in ${err.retryAfter}s`);
  else if (err instanceof ForbiddenError) console.log(err.message); // plan, bookmaker or add-on
  else if (err instanceof OddsAPIError) console.log(err.status, err.message);
}

from odds_api import OddsAPIClient, ForbiddenError, RateLimitError

client = OddsAPIClient(api_key="YOUR_API_KEY", max_retries=3)  # retries 429, 5xx and network errors
try:
    client.get_events(sport="basketball")
except RateLimitError as e:
    print(f"Rate limited, retry in {e.retry_after:.0f}s: {e}")
except ForbiddenError as e:
    print(e)  # plan, bookmaker or add-on

import { OddsAPIClient, OddsWebSocket } from 'odds-api-io'; // npm install ws

const store = new Map();
const { data, seq } = await client.getOddsSnapshot({ eventIds, bookmakers: ['Bet365'], markets: ['ML', 'Totals'] });
for (const event of data) {
  for (const [bookie, markets] of Object.entries(event.bookmakers)) store.set(`${event.id}:${bookie}`, markets);
}

const feed = new OddsWebSocket({ apiKey, markets: ['ML', 'Totals'], eventIds, lastSeq: seq ?? undefined });
for await (const msg of feed) {
  if (msg.type === 'created' || msg.type === 'updated') store.set(`${msg.id}:${msg.bookie}`, msg.markets); // replace, do not merge
  if (msg.type === 'deleted' || msg.type === 'no_markets') store.delete(`${msg.id}:${msg.bookie}`);
}

import asyncio
from odds_api import OddsAPIClient
from odds_api.ws import OddsStream  # pip install "odds-api-io[ws]"

client = OddsAPIClient(api_key="YOUR_API_KEY")
event_ids = [123456, 123457]

store = {}
snapshot = client.get_odds_for_multiple_events(event_ids, ["Bet365"], markets=["ML", "Totals"], include_seq=True)
for event in snapshot:
    for bookie, markets in event["bookmakers"].items():
        store[(str(event["id"]), bookie)] = markets
seq = next((v for k, v in client.last_response_headers.items() if k.lower() == "x-oddsapi-seq"), None)

async def main():
    stream = OddsStream("YOUR_API_KEY", markets=["ML", "Totals"], event_ids=event_ids,
                        last_seq=int(seq) if seq else None)
    async for message in stream:
        key = (str(message.get("id")), message.get("bookie"))
        if message["type"] in ("created", "updated"):
            store[key] = message["markets"]  # replace, do not merge
        elif message["type"] in ("deleted", "no_markets"):
            store.pop(key, None)

asyncio.run(main())