List broadcast channels (272) with media types (VIDEO/AUDIO/TEXT).

Returns: {pageInfo, content:[{id, name, abbreviation, broadcaster, channelTypes:[{name, mediaType}]}]}

Auth: none needed.

List broadcasters (49: Foxtel, Channel 7, BBC, ESPN, …).

Returns: {pageInfo, content:[{id, name, abbreviation, logo, restrictedCountries}]}

Auth: none needed.

Get a single broadcast event by id.

Returns: {id, name, startDateTime, channels:[...], contentReference}

Auth: none needed.

Broadcast schedule — one entry per match per channel.

Returns: {pageInfo, content:[{id, name, startDateTime, channels:[...], contentReference:{id, type}}]}

Auth: none needed.

Broadcast events scoped to one (compseason, round).

Returns: {pageInfo, content:[{id, name, startDateTime, channels}]}

Auth: none needed.

Get a single broadcast region by id.

Returns: {id, name, timezone}

Auth: none needed.

List broadcast regions (26) with timezones.

Returns: {pageInfo, content:[{id, name, timezone}]}

Auth: none needed.

Call any of the AFL CFS premium operations (api.afl.com.au/cfs/afl/...). Requires the anonymous x-media-mis-token (minted automatically). Path params use provider IDs (CD_M*/CD_R*/CD_S*/CD_I*/CD_T*) — map integer ids via the idmap endpoints/resources. Read afl://cfs/operations for the full op list.

Returns: (JSON object)

Auth: none needed.

Get a single club by id.

Returns: {clubs:[{id, providerId, name}]}

Auth: none needed.

List AFL/AFLW clubs (32).

Returns: {clubs:[{id, providerId, name, abbreviation, nickname}]}

Auth: none needed.

List comp seasons within one competition.

Returns: {meta, compSeasons:[...]}

Auth: none needed.

Get a single competition by integer id.

Returns: {meta, competitions:[{id, providerId, code, name}]}

Auth: none needed.

List all AFL competitions (AFL, AFLW, VFL, SANFL, …).

Returns: {meta:{pagination}, competitions:[{id, providerId, code, name}]}

Example: All 16 competitions {"pageSize": 50}

Auth: none needed.

Get a single comp season (embeds its full rounds array + currentRoundNumber).

Returns: {meta, compSeasons:[{id, providerId, name, shortName, season, rounds:[...], currentRoundNumber}]}

Auth: none needed.

List comp seasons across all competitions (2012–present).

Returns: {meta:{pagination}, compSeasons:[{id, providerId, name, competition, season}]}

Auth: none needed.

Get a single photo content item by id.

Returns: {id, type:'photo', title}

Auth: none needed.

List photo content.

Returns: {pageInfo, content:[{id, type:'photo', title, leadMedia}]}

Auth: none needed.

Get a single promo content item by id.

Returns: {id, type:'promo', title, links:[...]}

Auth: none needed.

List promo / marketing cards (each embeds a links[] of CTAs).

Returns: {pageInfo, content:[{id, type:'promo', title, links:[{promoUrl, linkText}]}]}

Auth: none needed.

Get a single text article by id.

Returns: {id, type:'text', title, body, author, references, tags}

Auth: none needed.

List text articles (news) with reference/tag filters.

Returns: {pageInfo, content:[{id, type:'text', title, date, tags, references, body, author}]}

Example: AFL+AFLW news index {"referenceExpression": "(AFL_COMPETITION:1) or (AFL_COMPETITION:3)", "tagExpression": "("News")", "limit": 17}

Auth: none needed.

Get a single video content item by id.

Returns: {id, type:'video', title, duration, onDemandUrl}

Auth: none needed.

List video content (highlights, replays, press conferences).

Returns: {pageInfo, content:[{id, type:'video', title, duration, onDemandUrl, additionalInfo}]}

Auth: none needed.

Sign an AFL HLS video URL for playback (returns a token-signed CDN URL).

Returns: {signedUrl} (anonymous tokens may return {code: KEYSERVER001, status: 401})

Auth: none needed.

Also answers this: cricketaustralia_streams, entain_video_channels, pointsbet_inplay_streaming.

Competition ladder up to a comp season's current round.

Returns: {compSeason, round, ladders:[{entries:[{position, team, played, thisSeasonRecord}]}]}

Example: 2026 AFL ladder {"compSeasonId": 85}

Auth: none needed.

Live AFL audio streams (empty when no game is live).

Returns: {pageInfo, content:[{id, name, channels:[...]}]}

Auth: none needed.

Also answers this: openf1_team_radio.

Live AFL video streams (empty when no game is live).

Returns: {pageInfo, content:[{id, name, channels:[{streamUrl, type:'LIVE'}]}]}

Auth: none needed.

Also answers this: cricketaustralia_streams, entain_video_channels, pointsbet_inplay_streaming.

Map every match providerId (CD_M*) to its integer id (~48 KB).

Returns: {entityType:'match', idMapResponse:{ids:{'CD_M20260141201':8139, ...}}}

Auth: none needed.

List matches with filters (competition, season, round, team, status, date).

Returns: {meta:{pagination}, matches:[{id, providerId, round, home, away, venue, utcStartTime, status}]}

Example: Live + upcoming AFL matches from a date {"status": "L,U", "startDate": "", "competitionId": "1"}

Auth: none needed.

Get a single match by integer id (teams, venue, time, score when started).

Returns: {meta, matches:[{id, providerId, home, away, venue, utcStartTime, status, score?}]}

Auth: none needed.

Get a single player by id (bio, draft, height/weight).

Returns: {players:[{id, providerId, firstName, surname, draftYear, debutYear, recruitedFrom}]}

Auth: none needed.

Map every player providerId (CD_I*) to its integer id (~98 KB, 17k+).

Returns: {entityType:'player', idMapResponse:{ids:{...}}}

Auth: none needed.

List players (17k+ all-time catalogue).

Returns: {players:[{id, providerId, firstName, surname, dateOfBirth, draftYear, heightInCm}]}

Auth: none needed.

List rounds for a comp season (incl. byes, start/end times).

Returns: {rounds:[{id, providerId, roundNumber, abbreviation, byes, utcStartTime, utcEndTime}]}

Auth: none needed.

Get a single calendar-year season by id.

Returns: {meta, seasons:[{id, year}]}

Auth: none needed.

List calendar-year season records.

Returns: {meta, seasons:[{id, year}]}

Auth: none needed.

Call any of the AFL StatsPro operations (api.afl.com.au/statspro/...). Requires the anonymous x-media-mis-token (minted automatically). Path params use provider IDs (CD_S*/CD_R*/CD_I*). Read afl://statspro/operations for the list.

Returns: (JSON object)

Auth: none needed.

Get a single team by id (incl. social/home-venue metadata).

Returns: {teams:[{id, providerId, name, club, teamType, metadata}]}

Auth: none needed.

Map CD_T* team providerIds to integer aflapi ids (and vice versa).

Returns: {entityType:'team', idMapResponse:{ids:{'CD_T10':1, ...}}}

Auth: none needed.

List teams (150 incl. AFL men, AFLW, state leagues, historical).

Returns: {teams:[{id, providerId, name, abbreviation, nickname, club, teamType, metadata}]}

Auth: none needed.

Get a single venue by id.

Returns: {venues:[{id, providerId, name, location, state, timezone}]}

Auth: none needed.

List venues (191) incl. location, state, timezone, landOwner.

Returns: {venues:[{id, providerId, name, location, state, timezone, landOwner}]}

Auth: none needed.

Baseball games (MLB, NPB, KBO and others) by date or league.

Returns: {response:[{id, date, status, league, teams, scores:{home:{hits, errors, innings:{'1','2',…, extra}, total}, away:{…}}}]} — SHAPE FROM VENDOR DOCS. Innings are keyed by NUMBER-AS-STRING. For MLB itself, the keyless official mlb provider is deeper.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A day's games {"date": "2024-07-04"}

Auth: needs your own key in API_SPORTS_KEY.

Basketball games worldwide (NBA, EuroLeague, NBL and many more) by date or league.

Returns: {response:[{id, date, status:{long, short}, league:{id, name, season}, teams:{home, away}, scores:{home:{quarter_1, quarter_2, quarter_3, quarter_4, over_time, total}, away:{…}}}]} — SHAPE FROM VENDOR DOCS. Note season is a '2023-2024' STRING here; the football host uses an integer year.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A day's games {"date": "2024-01-15"}

Auth: needs your own key in API_SPORTS_KEY.

Basketball standings for a league and season.

Returns: {response:[[{position, team, league, group:{name}, games:{played, win:{total, percentage}, lose:{…}}, points:{for, against}, form}]]} — SHAPE FROM VENDOR DOCS. Double-nested like football's.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A league table {"league": 12, "season": "2023-2024"}

Auth: needs your own key in API_SPORTS_KEY.

Football fixtures and results by date, league or team. Give at least one filter.

Returns: {results, response:[{fixture:{id, date, timestamp, venue:{name, city}, status:{long, short, elapsed}}, league:{id, name, country, season, round}, teams:{home:{id, name, winner}, away:{…}}, goals:{home, away}, score:{halftime, fulltime, extratime, penalty}}]} — SHAPE FROM VENDOR DOCS. goals is the 90-minute score; score.penalty decides a shootout, so a cup tie needs both.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A day's fixtures {"date": "2024-08-17"}

Auth: needs your own key in API_SPORTS_KEY.

Team match statistics for one fixture — shots, possession, corners, and expected goals where covered.

Returns: {response:[{team:{id, name}, statistics:[{type:'Shots on Goal'|'Ball Possession'|'expected_goals'|…, value}]}]} — SHAPE FROM VENDOR DOCS. NOTE this is LONG format keyed by a HUMAN-READABLE type string, and value is sometimes a string with a percent sign ('54%'). Do not assume a numeric type.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: One fixture's team stats {"fixture": 1035037}

Auth: needs your own key in API_SPORTS_KEY.

Every past meeting between two clubs.

Returns: {response:[{fixture, league, teams, goals, score}]} — same fixture shape as apisports_football_fixtures. SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Two clubs' history {"h2h": "33-34", "last": 10}

Auth: needs your own key in API_SPORTS_KEY.

Football leagues and cups worldwide, with the seasons available on your plan.

Returns: {response:[{league:{id, name, type:'League'|'Cup', logo}, country:{name, code, flag}, seasons:[{year, start, end, current, coverage:{fixtures:{events, lineups, statistics_fixtures}, standings, players, odds, predictions}}]}]} — SHAPE FROM VENDOR DOCS. coverage matters: it tells you which of the tools below will actually return anything for that league.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: English competitions {"country": "England"}

Auth: needs your own key in API_SPORTS_KEY.

Pre-match odds from many bookmakers for a fixture or league.

Returns: {response:[{fixture, league, update, bookmakers:[{id, name, bets:[{id, name:'Match Winner', values:[{value:'Home', odd:'1.85'}]}]}]}]} — SHAPE FROM VENDOR DOCS. ODDS ARE STRINGS, not numbers. For AU markets the direct providers here (sportsbet, tab, pointsbet) are deeper and live.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: One fixture's odds {"fixture": 1035037}

Auth: needs your own key in API_SPORTS_KEY.

Player season statistics for a team or league. season is required.

Returns: {paging:{current, total}, response:[{player:{id, name, age, nationality, height, weight, injured, photo}, statistics:[{team, league, games:{appearences, lineups, minutes, position, rating}, goals:{total, assists, conceded, saves}, shots, passes, tackles, duels, dribbles, fouls, cards, penalty}]}]} — SHAPE FROM VENDOR DOCS. statistics is a LIST — one entry per competition — so a player in a league and a cup has two.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A club's squad statistics {"team": 42, "season": 2023}

Auth: needs your own key in API_SPORTS_KEY.

The vendor's own model prediction for a fixture, with the comparison data behind it.

Returns: {response:[{predictions:{winner:{id, name, comment}, win_or_draw, under_over, goals:{home, away}, advice, percent:{home, draw, away}}, league, teams, comparison:{form, att, def, poisson_distribution, h2h, goals, total}, h2h:[…]}]} — SHAPE FROM VENDOR DOCS. percent values are STRINGS with a % sign. This is a vendor model, not a market price: compare it against squiggle-style model output, not against a bookmaker's line.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A fixture's prediction {"fixture": 1035037}

Auth: needs your own key in API_SPORTS_KEY.

League table. Both league and season are required.

Returns: {response:[{league:{id, name, standings:[[{rank, team:{id, name}, points, goalsDiff, group, form, status, description, all:{played, win, draw, lose, goals:{for, against}}, home:{…}, away:{…}}]]}}]} — SHAPE FROM VENDOR DOCS. NOTE the DOUBLE nesting: standings is a list OF TABLES (one per group in a group stage), each a list of rows.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Premier League table {"league": 39, "season": 2023}

Auth: needs your own key in API_SPORTS_KEY.

Clubs, by league/season, country, or name search.

Returns: {response:[{team:{id, name, code, country, founded, national, logo}, venue:{id, name, address, city, capacity, surface}}]} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Search a club {"search": "Arsenal"}

Auth: needs your own key in API_SPORTS_KEY.

Formula 1 races and sessions for a season.

Returns: {response:[{id, competition:{id, name, location}, circuit:{id, name}, season, type, laps:{current, total}, distance, timezone, date, status}]} — SHAPE FROM VENDOR DOCS. jolpicaf1 (keyless) covers F1 history back to 1950 and openf1 (keyless) covers live telemetry — prefer those unless you need this one key to span sports.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A season's races {"season": 2023}

Auth: needs your own key in API_SPORTS_KEY.

Handball games (EHF Champions League, Bundesliga, LNH and others) by date or league.

Returns: {response:[{id, date, time, status, league, teams, scores:{home, away}, periods:{first, second}}]} — SHAPE FROM VENDOR DOCS. Handball scores run to 25-35 per side; a value under 10 usually means the match is still in the first half, not a low-scoring game.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A day's games {"date": ""}

Auth: needs your own key in API_SPORTS_KEY.

Ice-hockey games (NHL, KHL, SHL and others) by date or league.

Returns: {response:[{id, date, status, league, teams, scores:{home, away}, periods:{first, second, third, overtime, penalties}}]} — SHAPE FROM VENDOR DOCS. For the NHL itself the keyless official nhl provider is deeper and live.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A day's games {"date": "2024-01-15"}

Auth: needs your own key in API_SPORTS_KEY.

MMA fights (UFC and others) by date or season.

Returns: {response:[{id, date, slug, category, status, is_main, fighters:{first:{id, name, winner}, second:{…}}}]} — SHAPE FROM VENDOR DOCS. winner is null until the fight is resulted, and BOTH may be false on a draw or no-contest — do not infer the loser from one flag.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A card {"date": "2024-03-09"}

Auth: needs your own key in API_SPORTS_KEY.

American-football games (NFL, NCAA) by date, season or team.

Returns: {response:[{game:{id, stage, week, date:{date, time, timezone}, status}, league, teams, scores:{home:{quarter_1,…, total}, away:{…}}}]} — SHAPE FROM VENDOR DOCS. NOTE this host wraps the identity under game, unlike the basketball and hockey hosts.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A week of NFL {"league": 1, "season": 2023}

Auth: needs your own key in API_SPORTS_KEY.

Rugby games (Six Nations, Super Rugby, NRL, Premiership) by date or league. The catalogue's only rugby-union coverage.

Returns: {response:[{id, date, time, status, league, teams, scores:{home, away}, periods:{first, second, overtime}}]} — SHAPE FROM VENDOR DOCS. For the NRL specifically, the keyless nrl provider is official and deeper.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A day's games {"date": "2024-03-09"}

Auth: needs your own key in API_SPORTS_KEY.

Your subscription and how much of today's quota is left. Costs no quota — call it first when something returns empty.

Returns: {response:{account:{firstname, lastname, email}, subscription:{plan, end, active}, requests:{current, limit_day}}} — SHAPE FROM VENDOR DOCS. requests.current vs limit_day is the check worth making before blaming the data.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Quota check

Auth: needs your own key in API_SPORTS_KEY.

Volleyball games (Italian SuperLega, Polish PlusLiga, CEV and others) by date or league.

Returns: {response:[{id, date, status, league, teams, scores:{home, away}, periods:{first, second, third, fourth, fifth}}]} — SHAPE FROM VENDOR DOCS. scores is SETS WON (best of 5), not points; the per-set point totals are in periods. Reading scores as points is the usual mistake.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A day's games {"date": ""}

Auth: needs your own key in API_SPORTS_KEY.

Event types the API covers (ATP singles, WTA doubles, ITF, …).

Returns: {success:1, result:[{event_type_key, event_type_type:'Atp Singles'}]} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Event types {"method": "get_events"}

Auth: needs your own key in API_TENNIS_KEY.

Matches in a date range, with scores and set-by-set detail once played.

Returns: {success:1, result:[{event_key, event_date, event_time, event_first_player, first_player_key, event_second_player, second_player_key, event_final_result:'2 - 0', event_status, tournament_name, tournament_round, scores:[{score_first, score_second, score_set}], pointbypoint:[…]}]} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A day's matches {"method": "get_fixtures", "date_start": "2025-01-20", "date_stop": "2025-01-20"}

Auth: needs your own key in API_TENNIS_KEY.

Head-to-head history between two players, plus each one's recent form.

Returns: {success:1, result:{H2H:[{event_key, event_date, event_first_player, event_second_player, event_final_result, tournament_name}], firstPlayerResults:[…], secondPlayerResults:[…]}} — SHAPE FROM VENDOR DOCS. Note result here is an OBJECT, not a list like the other methods.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Two players' H2H {"method": "get_H2H", "first_player_key": 1905, "second_player_key": 1903}

Auth: needs your own key in API_TENNIS_KEY.

Matches in progress right now, with live scores.

Returns: {success:1, result:[{event_key, event_first_player, event_second_player, event_game_result, event_serve, event_status, scores:[…]}]} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Live matches {"method": "get_livescore"}

Auth: needs your own key in API_TENNIS_KEY.

One player's profile and recent results.

Returns: {success:1, result:[{player_key, player_name, player_country, player_bday, player_logo, stats:[{season, type, rank, titles, matches_won, matches_lost, hard_won, clay_won, grass_won}]}]} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: One player {"method": "get_players", "player_key": 1905}

Auth: needs your own key in API_TENNIS_KEY.

ATP or WTA rankings.

Returns: {success:1, result:[{place, player, player_key, league, movement, country, points}]} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: ATP rankings {"method": "get_standings", "event_type": "ATP"}

Auth: needs your own key in API_TENNIS_KEY.

Tournaments, optionally for one event type.

Returns: {success:1, result:[{tournament_key, tournament_name, event_type_key, event_type_type}]} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: All tournaments {"method": "get_tournaments"}

Auth: needs your own key in API_TENNIS_KEY.

Premier League fixtures and results.

Returns: {data:[{id, week, kickoff, home_team, away_team, home_score, away_score, status, ground}], meta:{next_cursor}} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A season's fixtures {"season": 2023}

Auth: needs your own key in BALLDONTLIE_API_KEY.

Premier League clubs for a season.

Returns: {data:[{id, name, short_name, abbr, city, stadium}]} — SHAPE FROM VENDOR DOCS. The keyless official premierleague provider is deeper for the EPL.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: EPL clubs {"season": 2023}

Auth: needs your own key in BALLDONTLIE_API_KEY.

MLB games by date, season or team. (For MLB alone, the keyless official mlb provider is far deeper.)

Returns: {data:[{id, date, season, postseason, home_team_score, away_team_score, home_team, away_team, venue, status}], meta:{next_cursor}} — SHAPE FROM VENDOR DOCS. NOTE: away_team here, but visitor_team on the NBA and NFL paths. The shape is NOT uniform across sports.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: One date's games {"dates": ["2024-07-04"]}

Auth: needs your own key in BALLDONTLIE_API_KEY.

NBA games by date, season or team.

Returns: {data:[{id, date, season, status, period, time, postseason, home_team_score, visitor_team_score, home_team:{…}, visitor_team:{…}}], meta:{next_cursor}} — SHAPE FROM VENDOR DOCS. Note the away side is visitor_team, not away_team.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: One date's games {"dates": ["2024-01-15"]}

Auth: needs your own key in BALLDONTLIE_API_KEY.

NBA players, searchable by name.

Returns: {data:[{id, first_name, last_name, position, height, weight, jersey_number, college, country, draft_year, draft_round, draft_number, team:{…}}], meta:{next_cursor, per_page}} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Search a player {"search": "curry"}

Auth: needs your own key in BALLDONTLIE_API_KEY.

Season averages for specific NBA players.

Returns: {data:[{player_id, season, games_played, min, pts, reb, ast, stl, blk, turnover, fg_pct, fg3_pct, ft_pct}]} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A player's season {"season": 2023, "player_ids": ["115"]}

Auth: needs your own key in BALLDONTLIE_API_KEY.

NBA standings for a season.

Returns: {data:[{team:{…}, conference_record, conference_rank, division_record, division_rank, wins, losses, home_record, road_record, season}]} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A season's standings {"season": 2023}

Auth: needs your own key in BALLDONTLIE_API_KEY.

Per-player, per-game NBA box-score lines.

Returns: {data:[{id, min:'34:12', fgm, fga, fg_pct, fg3m, fg3a, ftm, fta, oreb, dreb, reb, ast, stl, blk, turnover, pf, pts, player:{…}, team:{…}, game:{…}}], meta:{next_cursor}} — SHAPE FROM VENDOR DOCS. min is a 'MM:SS' STRING, not a number.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A player's game lines {"player_ids": ["115"], "seasons": ["2023"]}

Auth: needs your own key in BALLDONTLIE_API_KEY.

All 30 NBA franchises with conference and division.

Returns: {data:[{id, conference, division, city, name, full_name, abbreviation}]} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Every NBA team

Auth: needs your own key in BALLDONTLIE_API_KEY.

NFL games by season, week or team.

Returns: {data:[{id, visitor_team_score, home_team_score, season, postseason, status, date, week, home_team, visitor_team}], meta:{next_cursor}} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A season's games {"seasons": ["2023"]}

Auth: needs your own key in BALLDONTLIE_API_KEY.

Cash-out availability for one or more markets.

Returns: [{marketId, cashout, partial}] (top-level array)

Auth: none needed.

In-play event details (event name, competition, primary market, runners, start time) for one or more events.

Returns: [{eventId, eventTypeId, marketId, marketName, eventName, competitionName, numberOfRunners, countryCode, startTime}] (top-level array)

Auth: none needed.

Live timeline + running score/state for one in-play event.

Returns: {eventId, eventTypeId, score:{home:{name, score, numberOfYellowCards, ...}, away:{...}}, timeElapsed, ...}

Auth: none needed.

Live timelines + running scores for several in-play events at once (batch).

Returns: [{eventId, eventTypeId, score:{home:{name, score, halfTimeScore, fullTimeScore}, away:{...}}}] (top-level array)

Auth: none needed.

Exchange back/lay prices + state for one or more markets (the core odds feed).

Returns: {currencyCode, eventTypes:[{eventTypeId, eventNodes:[{eventId, event:{eventName, countryCode, openDate}, marketNodes:[{marketId, state:{inplay, status}, description, runners:[{...prices: back/lay}]}]}]}]}

Example: Price two markets {"marketIds": "1.258654642,1.258653584"}

Auth: none needed.

Market STRUCTURE for an event (market ids, names, runners) — probed live 2026-07-06: this route STRIPS exchange prices (runners come back without the exchange block) and 400s on multi-id batches. For prices, feed the market ids into betfair_market_prices; for bulk market-id discovery, betfair_navigation with attachments=MENU,EVENT,MARKET returns 1000+ MARKET nodes per event type in one call.

Returns: {currencyCode, eventTypes:[{eventNodes:[{eventId, event:{eventName}, marketNodes:[{marketId, description:{marketType}, state, runners:[{...prices}]}]}]}]}

Auth: none needed.

Navigation graph by node — traverse sport → group → event → market. Feed market ids into betfair_market_prices.

Returns: {nodes:[{nodeId, name, nodeType: EVENT_TYPE|MENU|EVENT|MARKET, navInfo, ...}]}

Example: Top of the Horse Racing tree {"nodeIds": "EVENT_TYPE:7"}

Auth: none needed.

Live scores for one or more in-play events (per-sport score detail).

Returns: [{eventId, eventTypeId, score:{home:{name, score, ...}, away:{...}}}] (top-level array)

Auth: none needed.

Live scores plus broadcast/streaming availability for one or more events.

Returns: [{eventId, startTime, state:{score:{...}}, broadcast:{...}}] (top-level array)

Auth: none needed.

All visible promotions (name, description, dates).

Returns: {Promotions:[{Id, PromotionId, Name, Description, PromotionStartDate}]}

Auth: none needed.

All event types (sports + racing) with event counts and SGM availability.

Returns: {Items:[{EventTypeId, EventTypeDesc, EventCount, HasSameGameMulti, MasterEventTypeId}]}

Auth: none needed.

Featured 'Fav 4' upcoming races for a race-type filter.

Returns: {Items:[{EventId, MasterEventId, Venue, RaceNumber, BettingCloseTimeUtc, TimeToJump}]}

Auth: none needed.

Editorially featured racing events (carousel order, promo titles).

Returns: {ContentfulFeaturedEvent:[{EventOrder, EventID, EventName, PromotionTitle}]}

Auth: none needed.

All meetings + their races for a day offset, grouped by code.

Returns: {Thoroughbred:[[{EventId, Venue, CountryCode, RaceNumber, AdvertisedStartTime, HasFixedMarkets}]], Greyhounds:[...], Trots:[...]}

Example: Today's meetings {"DaysToRace": 0}

Auth: none needed.

Racing market movers — runners whose fixed prices are shortening/drifting.

Returns: {Items:[{EventId, EventName, Venue, RaceNumber, SecondsToJump, AdvertisedStartTime}]}

Auth: none needed.

Master categories (competitions) for one event type, optionally with levelled markets.

Returns: {EventTypeDesc, EventTypeId, MasterCategories:[{MasterCategoryId, MasterCategory, Categories:[{CategoryId, CategoryName}]}]}

Example: Basketball competitions {"EventTypeId": 107}

Auth: none needed.

One sport match's markets by master event id — a market GROUP per call (Events[].Outcomes[] with prices; GroupLinks names the other groups: totals, lines, race-to, periods).

Returns: {MasterEvent:{MasterEventId, MasterEventName, CategoryId, MinAdvertisedStartTime, IsLive, IsOpenForBetting}, Events:[{EventId, EventName, Outcomes:[{OutcomeName, Price, MarketTypeCode, MarketDesc, Points}]}], GroupLinks:[{GroupTypeCode, GroupName}]}

Auth: none needed.

Next races about to jump, with time-to-jump, for a race-type + country filter.

Returns: {Items:[{Race:{EventId, Venue, RaceNo, AdvertisedStartTime, StateCode}, TimeToJump, SecondsToJump, EventType}]}

Auth: none needed.

Popular Same Game Multi suggestions for one master event.

Returns: {PopSGMBetItems:[{legs:[{selectionName, price}], price}]}

Auth: none needed.

Categories that currently have Popular Same Game Multis.

Returns: {PopSGMCategoryItems:[{EventTypeId, MasterCategoryName, CategoryId, CategoryName}]}

Auth: none needed.

Popular market quick-links (specials, featured competitions) for navigation.

Returns: {Items:[{PopularMarketName, EventTypeId, EventType, MasterEventId, CategoryId}]}

Auth: none needed.

Active promotions with metadata (title, end date, linked master events).

Returns: {MetaData:[{PromotionId, Title, PromotionEndDate, MasterEventId:[...]}]}

Auth: none needed.

Full racecard for one race: runners, prices, allowed bet types, results once run.

Returns: {EventId, EventName, AllowedWinBetTypes:[{MarketTypeCode, DividendTypeCode}], ...runners + prices}

Auth: none needed.

Price fluctuation history per runner for one race (fixed-odds movements).

Returns: {Items:[{OutcomeId, Flucs:[{Offset, Price}]}]}

Auth: none needed.

Detailed form guide for one race (runner history, comments, ratings).

Returns: {RaceFormV2:{RaceNo, RaceName, NumberOfRunners, Distance, Course, RaceComment, Runners:[...]}}

Auth: none needed.

Also answers this: pointsbet_racing_form, tab_racing_race_form.

PRICE A SAME GAME MULTI you choose — give it two or more selections from one BetR match, get the correlation-adjusted combined price. Prices combinations BetR has not pre-built (for the ones it has, see betr_pop_sgm_bet_data).

Returns: {Price: 2.2, ErrorNo: 0} — that is the WHOLE body on success; there is no echo of the legs. VERIFIED live 2026-08-27 against AFL Western Bulldogs v Collingwood (MasterEventId 2255977), unauthenticated.

THE PRICE IS NOT THE PRODUCT OF THE LEGS. Measured on that fixture, BetR's adjustment ran from -9.7% to +4.9% and went BOTH ways: Bulldogs (1.95) with Under 139.5 (6.25) priced 11.00 against a naive 12.19, while the same 1.95 with Under 201.5 (1.10) priced 2.25 against a naive 2.145. Never multiply the legs.

DO NOT SEND FixedWin. The site does, and the server treats the value you send as a FLOOR on the answer: send 99.0 on any leg and the response is {Price: 99.0, ErrorNo: 0} — a fabricated quote reported as a clean success. Omitting it returned the true price in every case tested, so the field is pure downside.

BETR REFUSES A REDUNDANT LEG INSTEAD OF DROPPING IT (ErrorNo 4527), which is the safe behaviour and the opposite of TAB's and PointsBet's — you cannot end up holding a shorter bet than you asked for. But 4527 IS A CATCH-ALL and its wording names only one of its three causes: a leg that another leg implies, the SAME leg twice, and legs from DIFFERENT matches all come back as 'redundant leg in bet'.

Other codes seen live: 4500 = fewer than two legs (unlike Sportsbet and PointsBet, BetR will not price a single one), 4526 = impossible combination (Over 139.5 with Under 139.5), 4503 = a leg could not be resolved, usually a missing EventId or OutcomeId. All arrive as HTTP 200; the engine raises them rather than passing Price: 0 off as a quote.

Example: Price Bulldogs to win with over 139.5 total points {"MasterEventID": 2255977, "Markets": [{"EventId": 91686300, "OutcomeId": 1, "MarketType": "WIN"}, {"EventId": 91712212, "OutcomeId": 13910, "MarketType": "WIN"}]}

Auth: none needed.

Events + markets for one sport category (competition).

Returns: {EventTypeDesc, EventTypeId, MasterCategories:[{Categories:[{CategoryId, CategoryName, Events:[...]}]}]}

Auth: none needed.

Statwars master events (head-to-head stats promo events).

Returns: {Items:[{EventTypeId, EventTypeDesc, MasterEventId, MasterEventName, MinAdvertisedStart}]}

Auth: none needed.

Today's races grouped by code (Thoroughbred / Greyhound / Harness), for the homepage.

Returns: {Throughbred:[{VenueId, Venue, Race1:{EventId, RaceNumber, AdvertisedStartTime, SecondsToJump}}], Greyhound:[...], Harness:[...]}

Auth: none needed.

Advanced box score for one game: success rate, explosiveness, PPA and field position.

Returns: {gameId, teams:{ppa:[…], cumulativePpa:[…], successRates:[…], explosiveness:[…], rushing:[…], havoc:[…], scoringOpportunities:[…], fieldPosition:[…]}} — SHAPE FROM VENDOR DOCS. PPA is CFBD's expected-points-added metric.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: One game's advanced box {"id": 401520165}

Auth: needs your own key in CFBD_API_KEY.

Historical betting lines per game from multiple books — spread, over/under and moneyline. The college-football backtesting dataset.

Returns: [{id, season, week, homeTeam, homeScore, awayTeam, awayScore, lines:[{provider:'consensus'|'Bovada'|…, spread, formattedSpread, spreadOpen, overUnder, overUnderOpen, homeMoneyline, awayMoneyline}]}] — SHAPE FROM VENDOR DOCS. lines is per BOOK; *Open vs the closing value is what a CLV comparison uses.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: 2024 week 1 lines {"year": 2024, "week": 1}

Auth: needs your own key in CFBD_API_KEY.

Games for a season with scores, venue and attendance. year is required.

Returns: [{id, season, week, season_type, start_date, neutral_site, conference_game, venue, home_team, home_points, home_line_scores:[…], away_team, away_points, excitement_index, home_post_win_prob}] — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: 2024 week 1 {"year": 2024, "week": 1}

Auth: needs your own key in CFBD_API_KEY.

Transfer-portal moves for a season — origin, destination and rating.

Returns: [{season, firstName, lastName, position, origin, destination, transferDate, rating, stars, eligibility}] — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: 2024 portal {"year": 2024}

Auth: needs your own key in CFBD_API_KEY.

Weekly poll rankings (AP, Coaches, Playoff Committee).

Returns: [{season, seasonType, week, polls:[{poll:'AP Top 25', ranks:[{rank, school, conference, firstPlaceVotes, points}]}]}] — SHAPE FROM VENDOR DOCS. Note polls are NESTED inside each week entry.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: 2024 week 10 polls {"year": 2024, "week": 10}

Auth: needs your own key in CFBD_API_KEY.

Elo ratings by team and week.

Returns: [{year, team, conference, elo}] — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: 2024 Elo {"year": 2024}

Auth: needs your own key in CFBD_API_KEY.

SP+ ratings — the headline predictive rating for college football, split by offence and defence.

Returns: [{year, team, conference, rating, ranking, offense:{ranking, rating, success, explosiveness}, defense:{…}, specialTeams:{rating}}] — SHAPE FROM VENDOR DOCS. Defensive ratings are better when LOWER.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: 2024 SP+ {"year": 2024}

Auth: needs your own key in CFBD_API_KEY.

Recruiting classes: individual commits with stars, ratings and positions.

Returns: [{id, athleteId, recruitType, year, ranking, name, school, committedTo, position, height, weight, stars, rating, city, stateProvince, hometownInfo}] — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: 2024 recruits {"year": 2024}

Auth: needs your own key in CFBD_API_KEY.

FBS/FCS programmes with conference, venue and colours.

Returns: [{id, school, mascot, abbreviation, conference, division, color, alt_color, logos:[url], location:{venue_id, name, city, state, capacity, grass, dome}}] — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: SEC programmes {"conference": "SEC"}

Auth: needs your own key in CFBD_API_KEY.

Season totals per team across every tracked stat category.

Returns: [{season, team, conference, statName, statValue}] — SHAPE FROM VENDOR DOCS. NOTE this is LONG format: one row PER STAT per team, not one row per team.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: 2024 team stats {"year": 2024}

Auth: needs your own key in CFBD_API_KEY.

The list of monthly game archives available for a player — call this before asking for a month's games.

Returns: {archives:[url]} — URLs ending /games/YYYY/MM; take the year and month from the last entry to fetch the most recent games

Example: Which months a player has games for {"username": "hikaru"}

Auth: none needed.

A Chess.com club: description, membership count, admins and average rating.

Returns: {'@id', name, club_id, country, average_daily_rating, members_count, created, last_activity, admin:[url], description, url}

Example: The developer community club {"club_id": "chess-com-developer-community"}

Auth: none needed.

Chess.com's leaderboards for every category — live blitz/bullet/rapid, daily, variants and tactics. LARGE (~290 KB).

Returns: {live_blitz:[{player_id, username, score, rank, title, country}], live_bullet:[…], live_rapid:[…], daily:[…], daily960:[…], tactics:[…], battle:[…]} — one array per category

Example: All leaderboards

Auth: none needed.

Every game a player finished in one month, with PGN, result, ratings and opening ECO.

Returns: {games:[{url, pgn, time_control, time_class, rules, end_time, rated, eco, white:{username, rating, result}, black:{…}}]} — end_time is UNIX SECONDS; a prolific player's month can be several MB

Example: One player-month {"username": "hikaru", "year": "2025", "month": "01"}

Auth: none needed.

A Chess.com player's profile: name, title, country, league, followers and status.

Returns: {player_id, '@id', url, username, name, title, followers, country, location, joined, last_online, status, league, avatar} — joined/last_online are UNIX SECONDS; country is a URL, not a code

Example: One player's profile {"username": "hikaru"}

Auth: none needed.

A player's ratings and records per game type — blitz, bullet, rapid, daily, plus tactics and puzzle rush.

Returns: {chess_blitz:{last:{rating, date, rd}, best:{rating, date, game}, record:{win, loss, draw}}, chess_bullet:{…}, chess_rapid:{…}, chess_daily:{…}, tactics:{highest, lowest}, puzzle_rush:{best}, fide} — a key is ABSENT if the player has never played that format

Example: Ratings across formats {"username": "hikaru"}

Auth: none needed.

Every player holding a given FIDE title — usernames only.

Returns: {players:[username]} — a flat list of USERNAME STRINGS, not objects; feed one to chesscom_player for detail

Example: All grandmasters {"title": "GM"}

Auth: none needed.

Competition catalogue — series / tournaments with id, name, dates and artwork.

Returns: {competitions:[{id, name, url, imageUrl, startDateTime, endDateTime, order}], responseError}

Auth: none needed.

Pulselive CMS content list by type — VIDEO (highlights/replays), TEXT (articles), AUDIO, or PLAYLIST (curated collections). Paginated.

Returns: {pageInfo:{page, pageSize, numPages, numEntries}, content:[{id, type, title, description, date, ...}]}

Auth: none needed.

Match list (the /matches feed) — fixtures with teams, venue, competition, status, toss and result. Filter by competition, completed/live, etc.

Returns: {fixtures:[{id, name, startDateTime, gameType, isLive, isCompleted, resultText, competitionId, venueId, homeTeamId, awayTeamId, tossResult, tossDecision}], responseError}

Auth: none needed.

Player profiles for a batch of player ids — name, DOB, birthplace, batting/bowling hand + type, height, image. Pass a list of playerIds.

Returns: {players:[{id, displayName, firstName, lastName, dob, birthPlace, battingHand, bowlingHand, bowlingType, height, imageUrl}], responseError}

Auth: none needed.

A single Pulselive playlist by id — a curated collection of videos (e.g. a match's highlights playlist).

Returns: {id, type, title, description, date, content:[{id, type, title, ...}]}

Auth: none needed.

Run-progression (worm/manhattan) data per innings for a fixture — the series behind cricket.com.au's run graphs.

Returns: {innings:[{inningNumber, battingTeamId, bowlingTeamId, overs, overnightRuns, overnightWickets, byesRuns, legByesRuns, noBalls}]}

Auth: none needed.

Full match scorecard — per-innings batting, bowling and fall-of-wickets, plus the players[] lookup for the fixture.

Returns: {fixture:{id, name, innings:[{inningNumber, battingTeamId, bowlingTeamId, batsmen:[...], bowlers:[...], wickets:[...]}]}, fixtureTitle, players:[{id, displayName}], dataSupport, responseError}

Auth: none needed.

Competition ladder — per-team played/won/lost/drawn/tied/no-result, points, net run rate. Needs competitionId (empty for competitions without a points table).

Returns: {standings:[{competitionId, teamId, groupName, played, won, lost, drawn, matchTied, noResult, points, netRunRate, deductions}], responseError}

Auth: none needed.

Live video stream entries for a fixture (populated during live matches; empty array otherwise).

Returns: {streams:[{...stream urls/metadata}], responseError} (streams empty when the match isn't live)

Auth: none needed.

Team catalogue — id, name, short name, colours, logo/badge URLs across all CA competitions.

Returns: {teams:[{id, name, shortName, teamColor, logoUrl, teambadgeImageUrl, isActive}], responseError}

Auth: none needed.

Tours / series with status flags — each tour groups its competitions and is flagged upcoming / in-progress / completed. The feed behind the site's series navigation.

Returns: {tours:[{competitionId, name, startDateTime, endDateTime, isUpComing, isInProgress, isCompleted, competitions:[...], bannerUrl, logoUrl}]}

Auth: none needed.

Venue detail for one venueId — name, city, country, state, coordinates. Resolve a fixture's venueId (one venue per call).

Returns: {venue:{id, name, city, state, countryName, latitude, longitude}, responseError}

Auth: none needed.

Matches in progress or starting soon, with live scores.

Returns: {status:'success', data:[{id, name, matchType:'t20'|'odi'|'test', status, venue, date, dateTimeGMT, teams:[str], teamInfo:[{name, shortname, img}], score:[{r, w, o, inning}], series_id, matchStarted, matchEnded}], info:{hitsToday, hitsLimit}} — SHAPE FROM VENDOR DOCS. Score fields are terse: r runs, w wickets, o overs.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Live and upcoming matches

Auth: needs your own key in CRICKETDATA_API_KEY.

All matches, paginated — recent and upcoming across every series.

Returns: {status, data:[{id, name, matchType, status, venue, date, teams, teamInfo, series_id, matchStarted, matchEnded}], info:{hitsToday, hitsLimit}} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Recent matches

Auth: needs your own key in CRICKETDATA_API_KEY.

One match: toss, venue, teams and result.

Returns: {status, data:{id, name, matchType, status, venue, date, dateTimeGMT, teams, teamInfo, score:[{r, w, o, inning}], tossWinner, tossChoice, matchWinner, matchStarted, matchEnded}} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: One match {"id": ""}

Auth: needs your own key in CRICKETDATA_API_KEY.

One player's profile and career batting/bowling statistics.

Returns: {status, data:{id, name, dateOfBirth, role, battingStyle, bowlingStyle, placeOfBirth, country, playerImg, stats:[{fn:'batting'|'bowling', matchtype:'test'|'odi'|'t20i', stat:'m'|'runs'|'avg', value}]}} — SHAPE FROM VENDOR DOCS. NOTE stats is LONG format: one row per (function, format, statistic), not a nested object.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: One player's career {"id": ""}

Auth: needs your own key in CRICKETDATA_API_KEY.

Search the player catalogue by name.

Returns: {status, data:[{id, name, country}], info:{hitsToday, hitsLimit}} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Search players {"search": "Kohli"}

Auth: needs your own key in CRICKETDATA_API_KEY.

Full scorecard: batting and bowling figures per innings.

Returns: {status, data:{id, name, scorecard:[{inning, batting:[{batsman:{id, name}, r, b, '4s', '6s', sr, 'dismissal-text'}], bowling:[{bowler:{id, name}, o, m, r, w, eco}], extras, totals}]}} — SHAPE FROM VENDOR DOCS. Cricket abbreviations: r runs, b balls, sr strike rate, o overs, m maidens, w wickets, eco economy.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: One match's scorecard {"id": ""}

Auth: needs your own key in CRICKETDATA_API_KEY.

Series (tours and tournaments) with their match counts and dates.

Returns: {status, data:[{id, name, startDate, endDate, odi, t20, test, squads, matches}], info:{hitsToday, hitsLimit}} — SHAPE FROM VENDOR DOCS. The format counts (odi/t20/test) are how many matches of each type the series holds.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: All series

Auth: needs your own key in CRICKETDATA_API_KEY.

One series with its full match list.

Returns: {status, data:{info:{id, name, startdate, enddate, odi, t20, test, squads, matches}, matchList:[{id, name, matchType, status, venue, date, teams}]}} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: One series {"id": ""}

Auth: needs your own key in CRICKETDATA_API_KEY.

Every currently-bettable competition across all sports (~318) — the discovery entry point. Pick any one's id and pass it to dabble_competition_fixtures. Each carries name, sportName, country and a featured flag. Pass sportId to filter to one sport's active competitions.

Returns: {status, data:{activeCompetitions:[{id, name, sportName, country, featured, location, sportId}]}}

Auth: none needed.

All fixtures for ONE competition, each embedding its markets + prices (decimal odds) + selections + teams. Get the competitionId from dabble_active_competitions / dabble_competitions (AFL Matches = ad4c78ec-e39d-45ee-8cec-ff5d485a3205, NRL = c709772d-d5d0-4252-af89-be8a163706dc). For the FULL book of one fixture use dabble_fixture_details.

Returns: {data:[{id, name, displayName, competitionId, competitionName, advertisedStart, status, inplayAvailable, teams:[{id, name, abbreviation}], markets:[{id, name, resultingType, product, isHandicap, isTotal, isSgmAllowed, status}], selections:[{id, name, marketId, isScratched}], prices:[{marketId, selectionId, price}]}]} (product is engine-derived from resultingType — see dabble_fixture_details.)

Example: AFL fixtures with markets + odds {"competitionId": "ad4c78ec-e39d-45ee-8cec-ff5d485a3205"}

Auth: none needed.

Look up competitions by EXACT name (name, case-sensitive; e.g. 'NRL', 'Premier League', 'AFL Matches' — note 'AFL' alone returns nothing) OR list EVERY competition for a sport (sportId, including ones not currently active — ~20 for AFL). Pass at least one filter: bare /competitions is the ~38 MB / 142k-row firehose (deliberately avoid). For browsing currently-bettable comps, prefer dabble_active_competitions.

Returns: {status, data:[{id, name, sportId, country}]} (filtered by name or sportId — empty if the exact name isn't found)

Auth: none needed.

The FULL book for one fixture — every market (hundreds), all selections + prices, the marketGroups (SGM grouping) and the Pick'em playerProps product. LARGE (~1 MB+ for a major match); fetch one fixture at a time. fixtureId comes from dabble_competition_fixtures. Each market gets an engine-derived product: SGM legs by Dabble's capability flags (isSgmAllowed && !isSingleAllowed) so it's robust to the SGM vendor (SportCast today) changing; Pick'em by the pickem token (e.g. odds_on_pickem_goals) and racing by the Racing* resultingType — both first-party naming. RACING resultingTypes: RacingFixed*/RacingSP*=win/place, RacingDD*=exotics, RacingSrm*=Same-Race-Multi (no Pick'em in racing).

Returns: {sportFixtureDetail:{id, name, competitionName, sportName, status, teams, markets:[{id, name, resultingType, product, isSgmAllowed, isSingleAllowed}], selections:[{id, name, marketId}], prices:[{marketId, selectionId, price}], marketGroups, marketGroupMappings, playerProps:[{playerName, stats, value, lineType}]}} (LARGE — markets/selections/prices number in the hundreds-to-thousands. Each market carries an engine-derived product ∈ {single, sgm, pickem, srm, racing}: RacingSrm*→srm, Racing*→racing, resultingType-contains-pickem→pickem, else isSingleAllowed→single, else isSgmAllowed→sgm, else→single. Use product ∈ {single, sgm} for like-for-like price comparison; NEVER blend pickem multipliers into fixed-odds value/arb.)

Auth: none needed.

The 24 sports Dabble offers (Rugby League, Australian Rules, Football, Basketball, Cricket, Tennis, Horse Racing, …), each with id + name. Join sportId from a competition back to its sport here.

Returns: {status, data:[{id, name, isRacing, isHidden}]}

Auth: none needed.

Detailed approach-play skill per player across yardage/lie buckets — SG per shot, proximity, GIR, good-shot and poor-shot-avoidance rates.

Returns: {last_updated, time_period, data:[{dg_id, player_name, ...per-bucket sg/proximity/gir fields}]}

Auth: needs your own key in DATAGOLF_KEY.

DFS fantasy-points projections + salaries/ownership for a site + slate.

Returns: {event_name, last_updated, projections:[{dg_id, player_name, proj_points, salary, proj_ownership}]}

Auth: needs your own key in DATAGOLF_KEY.

Current event field — players entered, tee times, withdrawals, current round.

Returns: {event_name, event_id, course_name, current_round, date_start, date_end, field:[{dg_id, player_name, ...tee times}]}

Auth: needs your own key in DATAGOLF_KEY.

List of historical events with DFS salary/ownership/points data for a site.

Returns: [{event_id, event_name, calendar_year, date, dk_salaries, dk_ownerships}] (top-level array)

Auth: needs your own key in DATAGOLF_KEY.

Historical DFS points + salary + ownership per player for a past event.

Returns: {event_id, event_name, event_completed, season, dfs_points:[{dg_id, player_name, fin_text, finish_pts, total_pts, salary, ownership}]}

Auth: needs your own key in DATAGOLF_KEY.

List of historical events that have raw round-level data available (event_id + year to pass to the rounds feed).

Returns: [{event_id, event_name, tour, calendar_year, date, sg_categories}] (top-level array)

Auth: needs your own key in DATAGOLF_KEY.

Historical matchup / 3-ball odds for a past event from one sportsbook.

Returns: {book, event_id, event_name, event_completed, matchups:[{p1_player_name, p2_player_name, open_odds, close_odds, ...}]}

Auth: needs your own key in DATAGOLF_KEY.

List of historical events that have archived bookmaker odds available.

Returns: [{event_id, event_name, calendar_year, archived_preds, ...}] (top-level array)

Auth: needs your own key in DATAGOLF_KEY.

Historical opening/closing outright odds for a past event from one sportsbook.

Returns: {book, event_id, event_name, event_completed, outrights:[{dg_id, player_name, open_odds, close_odds, ...}]}

Auth: needs your own key in DATAGOLF_KEY.

Historical event-level results for a past tournament — finish position, earnings, FedExCup points and DG Points per player.

Returns: {event_id, event_name, year, season, event_completed, event_stats:[{dg_id, player_name, fin_text, earnings, fec_points, dg_points}]}

Auth: needs your own key in DATAGOLF_KEY.

List of tournaments with historical event-level results data (finishes/earnings/points) — the id lookup for datagolf_hist_results.

Returns: [{event_id, event_name, calendar_year, date}] (top-level array)

Auth: needs your own key in DATAGOLF_KEY.

Historical round-by-round scoring + strokes-gained for every player in a past event.

Returns: {event_id, event_name, event_completed, scores:[{dg_id, player_name, fin_text, rounds:[{round_num, score, sg_total, sg_putt, ...}]}]}

Auth: needs your own key in DATAGOLF_KEY.

Live (in-play) model predictions during a tournament — current position/score + updated win probabilities.

Returns: {data:[{dg_id, player_name, current_pos, current_score, R1, R2, R3, R4, make_cut, win, ...}]}

Auth: needs your own key in DATAGOLF_KEY.

Live per-hole scoring distributions for the in-progress event (avg score, birdie/bogey rates by hole, AM/PM wave).

Returns: {courses:[{course_code, course_key, rounds:[{round_num, holes:[{hole, par, avg_score, afternoon_wave:{...}, morning_wave:{...}}]}]}]}

Auth: needs your own key in DATAGOLF_KEY.

Live strokes-gained breakdown for every player during PGA Tour events (raw, or relative to the model's pre-round expectations).

Returns: {event_name, current_round, last_update, strokes_gained_values, data:[{dg_id, player_name, pos, score, thru, today, R1:{...sg}, R2, R3, R4}]}

Auth: needs your own key in DATAGOLF_KEY.

Live per-player tournament stats (strokes-gained by category, accuracy, etc.) for the requested round.

Returns: {event_name, course_name, last_updated, live_stats:[{dg_id, player_name, sg_total, sg_ott, sg_app, ...}]}

Auth: needs your own key in DATAGOLF_KEY.

Tournament / round / 3-ball matchup odds across sportsbooks, plus Data Golf's model line.

Returns: {event_name, market, last_updated, match_list:[{p1_player_name, p2_player_name, odds:{datagolf, bet365, pinnacle, ...}}]}

Auth: needs your own key in DATAGOLF_KEY.

All possible tournament matchup pairings for the current event with Data Golf's model odds (every player-vs-player price).

Returns: {event_name, last_update, pairings:[{p1_player_name, p2_player_name, p3_player_name, ...model odds}]}

Auth: needs your own key in DATAGOLF_KEY.

Outright (win / top-N / make-cut) odds for the current event across ~13 sportsbooks, plus Data Golf's model line.

Returns: {event_name, last_updated, books_offering:[...], odds:[{dg_id, player_name, datagolf:{...}, bet365, pinnacle, draftkings, fanduel, ...}]}

Auth: needs your own key in DATAGOLF_KEY.

Per-player skill decomposition for the current event — how each skill (driving, approach, putting, course-fit) contributes to the prediction.

Returns: {event_name, course_name, players:[{dg_id, player_name, ...skill/course-fit components}]}

Auth: needs your own key in DATAGOLF_KEY.

Full player list with Data Golf ids (dg_id), name, country, amateur flag.

Returns: [{dg_id, player_name, country, country_code, amateur}] (top-level array)

Auth: needs your own key in DATAGOLF_KEY.

Pre-tournament model predictions — win / top-5/10/20 / make-cut probabilities per player.

Returns: {baseline:[{dg_id, player_name, win, top_5, top_10, top_20, make_cut}], baseline_history_fit:[...]}

Auth: needs your own key in DATAGOLF_KEY.

Also answers this: apisports_football_predictions, squiggle_tips, squiggle_ladder.

Archived pre-tournament predictions for a past event (what the model said beforehand).

Returns: {baseline:[{dg_id, player_name, fin_text, win, make_cut, first_round_leader, top_10}]}

Auth: needs your own key in DATAGOLF_KEY.

Also answers this: apisports_football_predictions, squiggle_tips, squiggle_ladder.

Data Golf player rankings (top ~500) with skill estimate and OWGR rank.

Returns: {last_updated, rankings:[{datagolf_rank, owgr_rank, dg_id, player_name, dg_skill_estimate, country}]}

Auth: needs your own key in DATAGOLF_KEY.

Tour schedule — the season's events with dates, courses and locations.

Returns: {schedule:[{event_id, event_name, course, course_key, location, country, latitude, longitude, start_date}]}

Auth: needs your own key in DATAGOLF_KEY.

Player skill ratings — strokes-gained components (off-tee, approach, around-green, putting) + driving acc/dist.

Returns: {last_updated, players:[{dg_id, player_name, sg_total, sg_ott, sg_app, sg_arg, sg_putt, driving_acc, driving_dist}]}

Auth: needs your own key in DATAGOLF_KEY.

Contentful CMS entries (promotions, major-event nav) via the www CDN proxy.

Returns: {sys, total, skip, limit, items:[{sys, fields}], includes:{}}

Example: Active promotions {"content_type": "promotions", "limit": 20}

Auth: works without a key; ENTAIN_REFRESH_TOKEN unlocks more if set.

Settlement rules for every named market, indexed by rule id.

Returns: {market_rules:{<rule_id>:{id, name, description}}}

Auth: works without a key; ENTAIN_REFRESH_TOKEN unlocks more if set.

Join table between market types and market-type groups (dedup by pair).

Returns: {market_type_group_map:[{market_type_id, market_type_group_id, priority}]}

Auth: works without a key; ENTAIN_REFRESH_TOKEN unlocks more if set.

Market-tab group definitions for a sport category (lower priority renders first).

Returns: {market_type_group:[{id, category_id, name, priority, type}]}

Auth: works without a key; ENTAIN_REFRESH_TOKEN unlocks more if set.

Featured slider events (homepage hero carousel).

Returns: {items:[{id, title, url, event_id, event:{competition_id, event_start}}]}

Auth: works without a key; ENTAIN_REFRESH_TOKEN unlocks more if set.

Call any of Entain's 127 persisted GraphQL operations against api.ladbrokes.com.au/gql/router by name + variables. Hashes are managed server-side; a PERSISTED_QUERY_NOT_FOUND (gateway APQ-cache eviction) is self-healed automatically by re-POSTing the stored query document. If it still surfaces, run sportsdata-mcp refresh-hashes entain. GraphQL IDs are type-prefixed (RacingRace:, SportingEvent:): variable type ID! wants the prefixed form, UUID! wants the bare uuid. Read entain://graphql/operations for the full op list + variable signatures.

Returns: (JSON object)

Auth: works without a key; ENTAIN_REFRESH_TOKEN unlocks more if set.

SEO metadata (page title) for a given URL path.

Returns: {metadata:{title, url}} (empty {} when no override)

Auth: works without a key; ENTAIN_REFRESH_TOKEN unlocks more if set.

Navigation quick-links (racing/sports nav tiles).

Returns: {quick_links:[{id, root_category_id, category_id, url, title, icon, priority}]}

Example: Racing quick-links {"filter": {"type": "Racing"}}

Auth: works without a key; ENTAIN_REFRESH_TOKEN unlocks more if set.

Legacy v1 racing RPC selector (future-markets races feed).

Returns: {status, data:{races:{<race_id>:{name, advertised_start:{seconds}}}}}

Auth: works without a key; ENTAIN_REFRESH_TOKEN unlocks more if set.

All race meetings + races for one date (normalised UUID-keyed tables).

Returns: {compounds, domestic_countries, meetings:{}, races:{}, venues:{}}

Example: Melbourne card for a given day {"date": "", "timezone": "Australia/Melbourne"}

Auth: works without a key; ENTAIN_REFRESH_TOKEN unlocks more if set.

Next races about to jump, grouped per racing category.

Returns: {category_race_map:{}, race_summaries:{<race_id>:{race_name, meeting_name, advertised_start, race_form}}}

Auth: works without a key; ENTAIN_REFRESH_TOKEN unlocks more if set.

Full priced racecard for one race — entrants, fixed-odds fluctuations, form.

Returns: {status, data:{races:{}, markets:{}, prices:{}, entrants:{}, price_fluctuations:{<entrant_id>:[floats — LAST is the live fixed win price]}, meetings:{}}}

Example: One priced racecard {"id": "7f553143-1ed4-4ef8-a622-46c7563e6c83"}

Auth: works without a key; ENTAIN_REFRESH_TOKEN unlocks more if set.

Racing search facets (barrier/country/jockey/trainer buckets); optional full-text.

Returns: {facets:{barrier:{buckets}, country:{buckets}, jockey:{buckets}, trainer:{buckets}}}

Auth: works without a key; ENTAIN_REFRESH_TOKEN unlocks more if set.

PRICE A SAME GAME MULTI you choose — give it selections from one Entain (Ladbrokes/Neds) event, get the correlation-adjusted combined price. Prices combinations the book has not pre-built (for those, see entain_graphql_call SportingEventPopularSameGameMultis). Several events can be priced in one call.

Returns: {prices:{:{available: true, odds:{numerator: 27, denominator: 10}}}} — keyed by event id, one entry per event you asked about. VERIFIED live 2026-08-27 against AFL Melbourne v Carlton (event eccdc4f5-e01e-4aca-afab-570869b53702), unauthenticated.

ODDS ARE FRACTIONAL AND DECIMAL = numerator/denominator + 1. 27/10 is 3.70 — not 2.7, and not 27. Confirmed against the site's own displayed prices on the same event: Melbourne showed 2.15 and returns 23/20, Over showed 1.88 and returns 22/25. Every price in entain_sport_event_card is the same shape, so the conversion is the provider's convention rather than this endpoint's quirk. FORGETTING THE +1 UNDERSTATES EVERY PRICE.

THE PRICE IS NOT THE PRODUCT OF THE LEGS. Melbourne (2.15) with Over 173.5 (1.88) prices 3.70, against a naive 4.042.

IT SILENTLY COLLAPSES A REDUNDANT LEG AND STILL SAYS available: true. Melbourne to win plus Melbourne on the line returned 23/20 — 2.15, the SINGLE-LEG price — with no echo of the legs and nothing marking the drop. Repeating one selection twice does the same. There is no leg list in the response, so RESTATE THE SELECTIONS YOU SENT whenever you report a price, and treat a price equal to a shorter combination's as a collapse.

SOME IMPOSSIBLE COMBINATIONS ARE QUOTED RATHER THAN REFUSED, AT BIG PRICES. The conflict detector is good but not complete. Every exactly-two-entrant SGM-available market on the verified event was tested (41 of them): 35 correctly refused their mutually exclusive pair, and FIVE priced it — Match Betting, both teams to win, at 146.51, plus each of the four Quarter Match Betting markets at 70-82. The failing set is the WIN-MARKET FAMILY with two entrants and an implicit draw; the three-entrant version that lists Tie as an entrant (1st Half Betting) is refused correctly.

TWO CLIENT-SIDE DEFENCES, because nothing in the payload marks exclusivity. FIRST, honour same_game_multi_available from entain_sport_event_card — THE PRICER IGNORES ITS OWN FLAG (12 of 14 markets marked unavailable were priced anyway, including the two worst impossible quotes, Highest Scoring Half at 143.65 and 1st Half Match Betting at 110.18). SECOND, do not combine two legs from the SAME market_id unless you know that market permits it: every hole found is a same-market pair. Legitimate same-market pairs do exist — nested Alternate Handicaps/Totals lines, and multi-winner props like Anytime Goal Kicker — so a blanket rule costs a little coverage and removes the whole class.

DO NOT USE num_winners FOR THIS. It was tried and it does not mean exclusivity in either direction: Melbourne Alternate Handicaps is num_winners 1 with 96 nested lines that legitimately combine, while Race To 15 is num_winners 3 with two mutually exclusive entrants.

A bet that cannot win, quoted at 146.51, looks exactly like a longshot with enormous edge, which is what an automated screener selects for. Never trust available: true as proof a combination is coherent.

WHEN IT DOES DETECT A CLASH IT IS THE BEST DIAGNOSTIC OF ANY BOOK HERE: {available: false, conflicting_selections:[{market_id, entrant_id}, …]} names the exact pair. It correctly refused Over with Under, both line sides, two margin bands, and cross-market impossibilities like Melbourne to win with Carlton by 1-39.

available: false WITH NO odds KEY is also what an unknown event returns, quietly and alongside the events that did price. Unlike the other Australian books there is no fake zero to guard against — a refusal simply has no number — but a missing odds must never be read as 0.

Malformed requests are real HTTP 400s naming the problem: a selection missing market_id or entrant_id, and event id must match key when the map key and the inner event_id disagree.

Example: Price Melbourne to win with over 173.5 points {"same_game_multies": {"eccdc4f5-e01e-4aca-afab-570869b53702": {"event_id": "eccdc4f5-e01e-4aca-afab-570869b53702", "selections": [{"market_id": "c73591e5-b00e-4c92-abfb-b3737acbdd30", "entrant_id": "49475673-c7b8-4b49-8c87-e14637ebfa5c"}, {"market_id": "2bc6b298-4fce-4545-93cd-ed232a9c69a0", "entrant_id": "8ada7d51-2a67-4bcb-9593-f9fcbbbd5188"}]}}}

Auth: works without a key; ENTAIN_REFRESH_TOKEN unlocks more if set.

Complete event card — every market, selection and price for one sport event.

Returns: {entrants:{}, events:{}, markets:{}, prices:{}, regions:{}, market_type_groups:{}}

Example: One NBA event card {"id": "339e26d0-72a8-49bc-a85f-a2d02c0a1a70"}

Auth: works without a key; ENTAIN_REFRESH_TOKEN unlocks more if set.

Bulk events + markets + prices for one or more sport categories.

Returns: {events:{}, markets:{}, prices:{}, entrants:{}, next_events:[], regions:{}}

Auth: works without a key; ENTAIN_REFRESH_TOKEN unlocks more if set.

Racing live-video channels (HLS .m3u8 URLs; verify token expires within minutes).

Returns: {channels:[{id, name, url}]}

Auth: works without a key; ENTAIN_REFRESH_TOKEN unlocks more if set.

Competitions and tours.

Returns: {status:'ok', response:{items:[{cid, title, abbr, category, game_format, status, season, datestart, dateend, total_matches, total_teams}], total_pages}} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Live competitions {"status": "live"}

Auth: needs your own key in ENTITYSPORT_TOKEN.

Ball-by-ball commentary for an innings — the reason to choose this provider over cricketdata.

Returns: {status:'ok', response:{commentaries:[{event:'ball'|'overend'|'wicket', over, ball, batsman_id, bowler_id, score, run_str, commentary, noball, wide, byes, legbyes, six, four}]}} — SHAPE FROM VENDOR DOCS. Rows include NON-BALL events ('overend'), so filter on event before counting deliveries.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: An innings' commentary {"matchId": 12345, "inningsId": 1}

Auth: needs your own key in ENTITYSPORT_TOKEN.

Cricket matches — live, upcoming and completed.

Returns: {status:'ok', response:{items:[{match_id, title, short_title, subtitle, format_str:'T20'|'ODI'|'Test', status, status_str, game_state_str, teama:{team_id, name, short_name, scores_full, scores, overs}, teamb:{…}, date_start, venue, toss:{text, winner, decision}}], total_items, total_pages}} — SHAPE FROM VENDOR DOCS. scores_full is the display string ('187/4 (20)') and scores the bare runs — do not parse the first when you want the second.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Live matches {"status": 3}

Auth: needs your own key in ENTITYSPORT_TOKEN.

One match with squads, toss and current state.

Returns: {status:'ok', response:{match_id, title, format_str, status_str, teama, teamb, venue, toss, umpires, referee, players:[…], equation, live}} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: One match {"matchId": 12345}

Auth: needs your own key in ENTITYSPORT_TOKEN.

Full innings-by-innings scorecard.

Returns: {status:'ok', response:{innings:[{iid, number, name, batsmen:[{name, batsman_id, runs, balls_faced, fours, sixes, strike_rate, how_out}], bowlers:[{name, overs, maidens, runs, wickets, econ}], extras, equations:{runs, wickets, overs, runrate}, fows:[…], did_not_bat:[…]}]}} — SHAPE FROM VENDOR DOCS. fows is the fall-of-wickets list.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: One match's scorecard {"matchId": 12345}

Auth: needs your own key in ENTITYSPORT_TOKEN.

Gateway to the ESPN CDN core live feed (cdn.espn.com). Fast, lightly-cached scoreboard/game/boxscore/playbyplay JSON. The path slug is the LEAGUE, not the sport (nfl, nba, mlb, college-football, mens-college-basketball) — for soccer use the competition slug directly (eng.1, esp.1, uefa.champions). The CDN covers ESPN's front-page leagues only (no nhl). gameId comes from the scoreboard op. Every request carries ?xhr=1 (added by default). Browse espn://cdn/operations.

Returns: (JSON object)

Auth: none needed.

Gateway to the ESPN core data model (sports.core.api.espn.com). The deepest, most canonical surface: athletes + statistics + career logs, per-event odds / win-probabilities / plays / situation / broadcasts / predictor / power-index, per-competitor line-scores + statistics, season teams/coaches/draft/futures, venues, leaders, rankings, franchises and coaches. NOTE the path uses leagues/{league} (plural). Supply operation + path_params (sport, league, plus eventId/competitionId/athleteId/year as needed). Most responses use ESPN's $ref-linked envelope ({count, items:[{$ref}]}); follow the refs for detail. Browse every operation in the espn://core/operations resource.

Returns: (JSON object)

Auth: none needed.

Week box scores — each matchup with both lineups, per-player actual and projected points. The start/sit post-mortem view.

Returns: {schedule:[{matchupPeriodId, home:{teamId, totalPoints, tiebreak, pointsByScoringPeriod, rosterForCurrentScoringPeriod:{entries:[{playerId, lineupSlotId, playerPoolEntry:{player:{fullName, stats:[{appliedTotal, appliedAverage, statSourceId, statSplitTypeId}]}}}]}}, away:{…}}]}

Example: Week-3 box scores {"game": "ffl", "seasonId": 2018, "leagueId": 1234, "scoringPeriodId": 3}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

League message board / activity feed (chat topics, trade chatter, activity posts). 404s when the league has no communication group.

Returns: {topics:[{id, type, date, author, messages:[{id, messageTypeId, to, for, content}]}]} — HTTP 404 'This Communication Group does not exist.' when the league never used the board

Example: Recent league activity {"game": "ffl", "seasonId": 2018, "leagueId": 1234}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

Draft results — every pick in order with round, team, player, keeper flag and auction bid.

Returns: {draftDetail:{drafted, inProgress, completeDate, picks:[{id, overallPickNumber, roundId, roundPickNumber, playerId, teamId, owningTeamIds, keeper, reservedForKeeper, bidAmount, autoDraftTypeId, lineupSlotId, memberId}]}}

Example: Full draft board {"game": "ffl", "seasonId": 2018, "leagueId": 1234}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

UNDOCUMENTED mega-view (allon): settings + teams + rosters + schedule + draft + the whole player pool in ONE response. VERY LARGE (multi-MB) — prefer a targeted tool unless you genuinely need everything.

Returns: {settings, status, teams, members, schedule, draftDetail, players, playersHighlighted, creationInfo, lastUpdateInfo, lastAccessInfo} (~4 MB on a 10-team league)

Example: Everything about a league in one shot {"game": "ffl", "seasonId": 2018, "leagueId": 1234}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

All five ESPN fantasy games with each one's CURRENT season id and scoring period — call this first to resolve seasonId/scoringPeriodId.

Returns: [{abbrev:'FFL', id, name, proSportAbbrev, currentSeasonId, currentSeason:{id, currentScoringPeriod:{id}, startDate, endDate}}] (top-level array of 5)

Example: Resolve the current NFL fantasy season + week

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

Raw league read with ANY combination of views — the escape hatch when no dedicated tool below fits, or to fetch several views in one round trip.

Returns: {id, seasonId, scoringPeriodId, settings, status, teams:[…], members:[…]} plus whatever the requested views add (schedule, draftDetail, players, …)

Example: Teams + rosters + settings in one call {"game": "ffl", "seasonId": 2018, "leagueId": 1234, "view": ["mTeam", "mRoster", "mSettings"]}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

ESPN's stock league templates (scoring/roster presets) by scoring-type id — the defaults a new league starts from.

Returns: {gameId, id, seasonId, scoringPeriodId, settings:{name:'FFL PPR Scoring', ...}, status:{...}}

Example: The PPR football preset {"game": "ffl", "seasonId": 2025, "scoringTypeId": 3}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

Pre-2018 seasons and cross-season history via the leagueHistory path. Only works for leagues that HAVE history — check espnfantasy_status.status.previousSeasons first; an empty list there means this returns 404. Returns a single-element ARRAY, not an object.

Returns: [{id, seasonId, settings, teams, status, …}] — ARRAY wrapper; index [0] for a single seasonId. 404 when the league has no leagueHistory record (verified: public league 1234 reports status.previousSeasons == [] and 404s here) — fall back to the seasons path.

Example: A 2017 season for a long-running league {"game": "ffl", "leagueId": 1234, "seasonId": 2017}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

League rules: name, size, scoring items, roster slots, schedule/playoff format, waiver + keeper + trade settings.

Returns: {settings:{name, size, isPublic, draftSettings, rosterSettings:{lineupSlotCounts}, scoringSettings:{scoringItems:[{statId, points}]}, scheduleSettings, tradeSettings, acquisitionSettings}, status}

Example: Scoring + roster rules for a league {"game": "ffl", "seasonId": 2018, "leagueId": 1234}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

Live in-progress scoring for the current period — points so far and how many roster spots have yet to play.

Returns: {schedule:[{matchupPeriodId, home:{teamId, totalPoints, totalPointsLive, gamesPlayed}, away:{…}}]} — the *Live fields only populate while pro games are in progress

Example: Live scores right now {"game": "ffl", "seasonId": 2018, "leagueId": 1234}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

Full season schedule of head-to-head fantasy matchups with each side's total and per-period points.

Returns: {schedule:[{id, matchupPeriodId, winner:'HOME'|'AWAY'|'UNDECIDED', home:{teamId, totalPoints, gamesPlayed, pointsByScoringPeriod:{'1':98.4}}, away:{…}}]}

Example: Every matchup in the season {"game": "ffl", "seasonId": 2018, "leagueId": 1234}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

Also answers this: sleeper_matchups, sleeper_playoff_bracket.

Compact matchup scores for the season — totals only, no lineups. Much smaller than the box score.

Returns: {schedule:[{id, matchupPeriodId, winner, home:{teamId, totalPoints, gamesPlayed}, away:{…}}]}

Example: All matchup results {"game": "ffl", "seasonId": 2018, "leagueId": 1234}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

Also answers this: sleeper_matchups, sleeper_playoff_bracket.

Lightweight nav payload — league name, size and the current user's team, for cheap orientation before a heavy call.

Returns: {id, settings:{name, size}, status:{…}, teams:[{id, abbrev}], members:[…]}

Example: Cheap league header {"game": "ffl", "seasonId": 2018, "leagueId": 1234}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

Pending/unprocessed transactions — waiver claims and trade offers awaiting processing (needs the private cookie in most leagues).

Returns: {pendingTransactions:[…]} when any are pending; the key is ABSENT (not an empty list) when there are none.

Example: Outstanding waiver claims / trade offers {"game": "ffl", "seasonId": 2018, "leagueId": 1234, "scoringPeriodId": 3}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

Deep card for specific players — full season + per-period stat splits and projections, as the site's player popup shows.

Returns: {players:[{id, player:{fullName, stats:[{id, seasonId, scoringPeriodId, statSourceId:0|1, statSplitTypeId, appliedTotal, appliedAverage, stats:{…}}]}}]} — statSourceId 0=actual, 1=projected

Example: Season + projection splits for one player {"game": "ffl", "seasonId": 2018, "leagueId": 1234, "fantasy_filter": {"players": {"filterIds": {"value": [15825]}, "filterStatsForTopScoringPeriodIds": {"value": 16, "additionalValue": ["002018", "102018"]}}}}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

The league's player pool with ownership %, ratings, projections and injury status — pass a status filter for FREE AGENTS / WAIVERS (the waiver-wire tool).

Returns: {players:[{id, onTeamId, status:'FREEAGENT'|'ONTEAM'|'WAIVERS', keeperValue, draftAuctionValue, ratings, player:{fullName, defaultPositionId, eligibleSlots, injured, injuryStatus, proTeamId, ownership:{percentOwned, percentChange, percentStarted}, stats:[{appliedTotal, statSourceId, statSplitTypeId}]}}]}

Example: Top available free agents by ownership {"game": "ffl", "seasonId": 2018, "leagueId": 1234, "scoringPeriodId": 3, "fantasy_filter": {"players": {"filterStatus": {"value": ["FREEAGENT", "WAIVERS"]}, "limit": 25, "sortPercOwned": {"sortPriority": 1, "sortAsc": false}}}}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

Recent fantasy news items for one player (injury/usage blurbs that drive start-sit calls).

Returns: {news:{feed:[{id, headline, description, published, lastModified, playerId, links, images}], resultsCount, resultsLimit, timestamp}}

Example: News for one player {"game": "ffl", "playerId": 3139477}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

The player universe for a season (id, name, position, pro team, % owned). Defaults to 50 players — pass fantasy_filter to widen or filter.

Returns: [{id, fullName, firstName, lastName, defaultPositionId, eligibleSlots:[int], proTeamId, droppable, universeId, ownership:{percentOwned}}] (top-level array)

Example: Default slice (50 players) {"game": "ffl", "seasonId": 2025}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

Positional ratings — average fantasy points allowed by each pro defence to each position (the strength-of-matchup table).

Returns: {positionAgainstOpponent:{positionalRatings:{'1':{average, total, ratingsByOpponent:{'proTeamId':{average, rank}}}}}} (keys are position ids). IN-SEASON ONLY: verified 2026-07-02 that completed/old seasons return 200 with the whole positionAgainstOpponent block ABSENT — that is upstream behaviour, not an error.

Example: Which defences are soft against each position {"game": "ffl", "seasonId": 2018, "leagueId": 1234, "scoringPeriodId": 3}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

Pro (real-world) teams for a fantasy season: ids, abbreviations, BYE weeks, and each team's games keyed by scoring period.

Returns: {settings:{proTeams:[{id, abbrev, location, name, byeWeek, universeId, proGamesByScoringPeriod:{'1':[{...game}]}}]}} — 33 entries for NFL (id 0 = free-agent/none)

Example: NFL teams + bye weeks + week-by-week pro schedule {"game": "ffl", "seasonId": 2025}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

Every fantasy team's roster — who each manager holds, their lineup slot, acquisition type and player stats. LARGE (hundreds of KB).

Returns: {teams:[{id, roster:{entries:[{playerId, lineupSlotId, acquisitionType, playerPoolEntry:{player:{fullName, defaultPositionId, eligibleSlots, injuryStatus, stats:[…]}}}]}}]}

Example: All rosters, week 3 {"game": "ffl", "seasonId": 2018, "leagueId": 1234, "scoringPeriodId": 3}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

Scoreboard for a scoring period — matchup totals plus the pro-game state behind each fantasy team.

Returns: {schedule:[{matchupPeriodId, home:{teamId, totalPoints, rosterForCurrentScoringPeriod, cumulativeScore:{wins,losses,ties}}, away:{…}}]}

Example: This week's scoreboard {"game": "ffl", "seasonId": 2018, "leagueId": 1234, "scoringPeriodId": 3}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

One game-season's status: current scoring period, start/end dates, whether it is active.

Returns: {abbrev:'FFL 2025', id:2025, gameId, name, active, display, startDate, endDate, currentScoringPeriod:{id}}

Example: 2025 fantasy football season status {"game": "ffl", "seasonId": 2025}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

League standings — records, points for/against, division and playoff seeding.

Returns: {teams:[{id, name, playoffSeed, rankCalculatedFinal, record:{overall:{wins,losses,ties,percentage,pointsFor,pointsAgainst}, division:{...}, home:{...}, away:{...}}}], schedule:[…]}

Example: Final standings {"game": "ffl", "seasonId": 2018, "leagueId": 1234}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

League lifecycle status — current matchup period, latest scoring period, whether the season is active, waiver process dates.

Returns: {status:{currentMatchupPeriod, latestScoringPeriod, finalScoringPeriod, isActive, previousSeasons:[int], teamsJoined, waiverProcessStatus:{…}}}

Example: Where the league is up to {"game": "ffl", "seasonId": 2018, "leagueId": 1234}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

Fantasy teams with records, points for/against, playoff seed and projected rank.

Returns: {teams:[{id, abbrev, name, owners, primaryOwner, divisionId, playoffSeed, points, pointsAdjusted, currentProjectedRank, rankCalculatedFinal, record:{overall:{wins,losses,ties,pointsFor,pointsAgainst}}, transactionCounter, waiverRank}], members:[{id, displayName, firstName, lastName}]}

Example: All fantasy teams + records {"game": "ffl", "seasonId": 2018, "leagueId": 1234}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

Completed transactions (adds, drops, trades, waiver claims) for a scoring period.

Returns: {transactions:[{id, type, status, teamId, memberId, scoringPeriodId, proposedDate, bidAmount, items:[{type:'ADD'|'DROP', playerId, fromTeamId, toTeamId}]}]}

Example: Week-3 transactions {"game": "ffl", "seasonId": 2018, "leagueId": 1234, "scoringPeriodId": 3}

Auth: works without a key; ESPN_FANTASY_COOKIE unlocks more if set.

Full summary for one game: box score, scoring plays, drives/play-by-play, leaders, win-probability and odds. event is an id from espn_scoreboard. No example here on purpose — it needs a live event id, so the doctor probes espn_scoreboard instead.

Returns: {boxscore:{teams, players}, plays:[...], scoringPlays:[...], leaders:[...], winprobability:[...]}

Auth: none needed.

League news feed: recent articles (headline, description, links, images, related athletes/teams) for one league.

Returns: {header, articles:[{headline, description, published, links, categories}]}

Example: Latest NFL news. {"sport": "football", "league": "nfl"}

Auth: none needed.

Scoreboard for one league: today's (or a given date's) games with status, clock, live scores and event ids. The fastest way to get the event ids that espn_game_summary / espn_core_call (event_*) need. sport+league are slugs, e.g. football/nfl, basketball/nba, soccer/eng.1.

Returns: {leagues:[...], events:[{id, name, status, competitions:[{competitors:[{team, score}]}]}]}

Example: Today's NFL scoreboard. {"sport": "football", "league": "nfl"}

Auth: none needed.

Gateway to the ESPN site API resource families (site.api.espn.com). Supply an operation plus a path_params map containing at least sport + league (slugs like football/nfl, basketball/nba) and any id the op needs (teamId, athleteId), then optional query_params. Covers team detail/rosters/schedules/ injuries/depth-charts/transactions/history, athlete news, conference/division groups and poll rankings. For athlete profiles/game-logs/splits use espn_web_call (or espn_core_call for the canonical model). Browse every operation in the espn://site/operations resource.

Returns: (JSON object)

Auth: none needed.

League standings / ladder: per-team wins, losses, win %, conference/division groupings for the current (or a given) season.

Returns: {name, children:[{standings:{entries:[{team, stats:[{name, value}]}]}}]} (children = conferences/divisions)

Example: Current NBA standings. {"sport": "basketball", "league": "nba"}

Auth: none needed.

Team catalogue for one league: every team with id, name, abbreviation, colours and logos. Use the team ids with espn_site_call (team_roster, team_schedule, …).

Returns: {sports:[{leagues:[{teams:[{team:{id, displayName, abbreviation}}]}]}]}

Example: All 32 NFL teams. {"sport": "football", "league": "nfl"}

Auth: none needed.

Gateway to the ESPN web API (site.web.api.espn.com): site-wide search across teams/athletes/leagues, plus the common/v3 athlete views (overview, stats, gamelog, splits) that power player profile pages, and statistics-by-athlete. search needs only query_params {query, limit}; the athlete_* ops need path_params {sport, league, athleteId}. Browse the espn://web/operations resource.

Returns: (JSON object)

Auth: none needed.

The clubs in one season, with city, country and venue detail.

Returns: {total, data:[{code, name, abbreviatedName, editorialName, city, country:{code, name}, address, images, isVirtual}]} — code (e.g. 'MAD') is the club key used elsewhere

Example: 2024-25 EuroLeague clubs {"competition": "E", "season": "E2024"}

Auth: none needed.

One game's detail by its per-season game code.

Returns: {id, gameCode, identifier, date, played, gameStatus, local:{club, score}, road:{club, score}, group, phaseType, referee1..4, audience} — a single object, NOT wrapped in {data}

Example: Game 1 of the season {"competition": "E", "season": "E2024", "gameCode": 1}

Auth: none needed.

Games in a season with scores, venue and officials. Unpaged this is ~800 KB — pass a limit or filter by round.

Returns: {total, data:[{id (uuid), gameCode, identifier:'E2024_330', date, localDate, played, gameStatus, group, phaseType, local:{club, score}, road:{club, score}, isNeutralVenue, referee1..4, audience}]} — HOME/AWAY are local/road; use gameCode (an int) for the per-game tools, not the uuid

Example: First 50 games of the season {"competition": "E", "season": "E2024", "limit": 50}

Auth: none needed.

Box score for one game: both teams' player lines plus team totals and coach.

Returns: {local:{team, coach, total:{…team totals…}, players:[{player:{person, dorsal, position, club}, stats:{timePlayed, valuation, points, fieldGoalsMade2/3, freeThrowsMade, offensiveRebounds, defensiveRebounds, assistances, steals, turnovers, plusMinus, foulsCommited}}]}, road:{…}} — a player line is NESTED as {player, stats}: identity under player, numbers under stats. valuation is EuroLeague's PIR efficiency metric. timePlayed is SECONDS as a float (1088.0 = 18:08), not a MM:SS string.

Example: Box score for game 1 {"competition": "E", "season": "E2024", "gameCode": 1}

Auth: none needed.

Players and coaches registered for a season. LARGE (~600 KB) — page it.

Returns: {total, data:[{code, name, alias, height, birthDate, country, position, club}]}

Example: First page of registered people {"competition": "E", "season": "E2024", "limit": 100}

Auth: none needed.

The rounds (matchdays) in a season, with their date windows.

Returns: {total, data:[{round, name, seasonCode, phaseTypeCode, minGameStartDate, maxGameStartDate}]}

Example: EuroLeague rounds {"competition": "E", "season": "E2024"}

Auth: none needed.

Seasons for a competition — call this to get valid season codes like E2024.

Returns: {total, data:[{code:'E2024', name:'EuroLeague 2024-25', alias:'2024-25', year, startDate, endDate, competitionCode, winner}]}

Example: EuroLeague seasons {"competition": "E"}

Auth: none needed.

Call any FanDuel Racing (TVG) GraphQL operation by name + variables against api.racing.fanduel.com/cosmo/v1/graphql. The full query text lives server-side and the boilerplate variables (brand/product/device/profile) default automatically, so most calls need no variables. Read fanduel://racing/operations for the operation list + variable signatures.

Returns: (JSON object)

Auth: none needed.

Site message strings (disclaimers, informational copy) for a namespace.

Returns: {response:{:{: }}}

Auth: none needed.

Structured racing promotions / placements (POST; empty body returns all).

Returns: {success, promoPlacements:[{...}]}

Auth: none needed.

Homepage quick-link tiles for the racing site.

Returns: {quickLinks:[{label, url, ...}]}

Auth: none needed.

Fetch a FanDuel Sportsbook (US, NJ) REST resource by operation name. Carries the static public _ak web key + the sportsbook Origin/region headers, so the caller supplies only the variable query params (eventId, customPageId, dataEntries, eventIds, …). Read fanduel://sportsbook/operations for the list.

Returns: (JSON object)

Auth: none needed.

Live score + period state for one sportsbook event (NJ).

Returns: {openDate, homeTeam:{shortName, abbreviation, score}, awayTeam:{...}, comp, mediaTypes}

Auth: none needed.

PRICE A SAME GAME PARLAY you choose — give it two or more selections from one FanDuel event and get the correlation-adjusted combined price. Read the entry with isSGM: true; the SINGLEs alongside it are the individual leg prices, not the parlay.

Returns: {respCode: 'SUCCESS', betCombinations:[{betType, isSGM, features, winAvgOdds:{trueOdds:{decimalOdds:{decimalOdds}}, americanDisplayOdds}, legCombinations:[…]}], betFailures:[…]} — VERIFIED live 2026-08-27 against NBA Boston Celtics @ Detroit Pistons (event 35928218).

READ THE isSGM: true ENTRY — IT IS THE ONLY ONE THAT IS A SAME GAME PARLAY. The response prices EVERY combination it can make from your legs, so a two-leg request comes back with two SINGLEs and one DOUBLE. The SINGLEs are the individual leg prices, not the parlay; taking the first betCombination gives you a single bet.

THE PRICE IS NOT THE PRODUCT OF THE LEGS. Verified: 2.02 and 1.87 as singles, and the SGP DOUBLE prices 3.4128 against a naive 3.7765 — a 9.6% correlation charge.

USE winAvgOdds.trueOdds.decimalOdds.decimalOdds, NOT averageOdds. The latter is a DISPLAY rounding: the same bet reads 3.41 there and 3.41275716 in trueOdds. Rounded odds compared against another book's exact ones manufacture edge that is not there.

betFailures: INVALID_COMBINATION IS USUALLY NOT ABOUT YOUR PARLAY. It says the legs cannot form an ORDINARY multi because they are from the same game — which is the whole point of an SGP. It appears alongside a perfectly good isSGM entry, so never treat its presence as failure; check for the isSGM entry instead.

NO isSGM ENTRY MEANS FANDUEL WILL NOT COMBINE THOSE LEGS. Seen live on legs whose markets were sgmMarket: true in fanduel_sb_call(event_page), so that flag is necessary and not sufficient. A leg whose runner is suspended reports RUNNER_SUSPENDED instead.

THE UPSTREAM RETURNS A betReference PLACEMENT TOKEN ON EVERY COMBINATION. It is PROJECTED AWAY here and never reaches you — this tool prices and cannot place. The stake ceilings, bonus-wallet and promotion fields are dropped with it.

Example: Price a two-leg same game parlay {"betLegs": [{"legType": "SIMPLE_SELECTION", "betRunners": [{"runner": {"marketId": "734.180521459", "selectionId": 60427}}]}, {"legType": "SIMPLE_SELECTION", "betRunners": [{"runner": {"marketId": "734.180522215", "selectionId": 7017823}}]}]}

Auth: none needed.

Countries and regions, used to filter competitions. VERIFIED live — works without a key.

Returns: {count, filters, areas:[{id, name, countryCode, flag, parentAreaId, parentArea}]} — VERIFIED (272 areas)

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: All areas

Auth: needs your own key in FOOTBALL_DATA_ORG_KEY.

One competition with its current season and available seasons. NEEDS A KEY (403 without).

Returns: {id, name, code, type, emblem, area, currentSeason:{id, startDate, endDate, currentMatchday, winner}, seasons:[…]} — SHAPE FROM VENDOR DOCS, not probed.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Premier League {"competition": "PL"}

Auth: needs your own key in FOOTBALL_DATA_ORG_KEY.

All matches in one competition. NEEDS A KEY (403 without).

Returns: {filters, resultSet, competition, matches:[{id, utcDate, status, matchday, homeTeam, awayTeam, score:{winner, fullTime:{home, away}, halfTime}}]} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A Premier League matchday {"competition": "PL", "matchday": 1}

Auth: needs your own key in FOOTBALL_DATA_ORG_KEY.

Every competition the API covers, with its code and current season. VERIFIED live — works without a key.

Returns: {count, filters, competitions:[{id, name, code:'PL', type:'LEAGUE'|'CUP', emblem, plan:'TIER_ONE'…, area:{id, name, code, flag}, currentSeason:{id, startDate, endDate, currentMatchday}, numberOfAvailableSeasons, lastUpdated}]} — VERIFIED (189 competitions). plan tells you which tier a competition needs; the free key covers TIER_ONE only.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: All competitions

Auth: needs your own key in FOOTBALL_DATA_ORG_KEY.

One match with lineups, goals, bookings and head-to-head. NEEDS A KEY (403 without).

Returns: {id, utcDate, status, competition, homeTeam:{id, name, lineup:[…], bench:[…]}, awayTeam:{…}, score, goals:[{minute, scorer, assist}], bookings:[…], substitutions:[…], referees:[…], head2head:{…}} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: One match {"matchId": 419516}

Auth: needs your own key in FOOTBALL_DATA_ORG_KEY.

Matches across every competition your key can see, for a date range. VERIFIED live — the envelope works without a key (though a keyless call sees no competitions).

Returns: {filters, resultSet:{count, first, last, played}, matches:[{id, utcDate, status, matchday, stage, competition:{id, name, code}, homeTeam:{id, name, shortName, tla, crest}, awayTeam:{…}, score:{winner, duration, fullTime:{home, away}, halfTime:{…}}}]} — envelope VERIFIED; the match object shape is from the vendor's docs. Note the score lives in score.fullTime, not on the match.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Matches in a date window {"dateFrom": "", "dateTo": "<today+2>"}

Auth: needs your own key in FOOTBALL_DATA_ORG_KEY.

Top scorers in a competition. NEEDS A KEY (403 without).

Returns: {count, filters, competition, season, scorers:[{player:{id, name, nationality, position}, team:{id, name}, goals, assists, penalties, playedMatches}]} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Premier League top scorers {"competition": "PL", "limit": 10}

Auth: needs your own key in FOOTBALL_DATA_ORG_KEY.

League table for a competition. NEEDS A KEY (403 without).

Returns: {filters, competition, season, standings:[{stage, type:'TOTAL'|'HOME'|'AWAY', group, table:[{position, team:{id, name, crest}, playedGames, won, draw, lost, points, goalsFor, goalsAgainst, goalDifference, form}]}]} — SHAPE FROM VENDOR DOCS. Note standings is a LIST of tables (TOTAL/HOME/AWAY); pick type == 'TOTAL' for the normal ladder.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Premier League table {"competition": "PL"}

Auth: needs your own key in FOOTBALL_DATA_ORG_KEY.

One club with its squad and running competitions. NEEDS A KEY (403 without).

Returns: {id, name, shortName, tla, crest, address, website, founded, clubColors, venue, runningCompetitions:[…], coach:{id, name, nationality, contract}, squad:[{id, name, position, dateOfBirth, nationality}]} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: One club {"teamId": 57}

Auth: needs your own key in FOOTBALL_DATA_ORG_KEY.

The clubs in a competition. NEEDS A KEY (403 without).

Returns: {count, filters, competition, season, teams:[{id, name, shortName, tla, crest, address, website, founded, clubColors, venue, coach, squad:[…]}]} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Premier League clubs {"competition": "PL"}

Auth: needs your own key in FOOTBALL_DATA_ORG_KEY.

One league season: every match with full/half-time score, shots, cards, and CLOSING ODDS from ~10 bookmakers. The backtesting dataset.

Returns: [{Div, Date:'16/08/2024', Time, HomeTeam, AwayTeam, FTHG, FTAG, FTR:'H'|'D'|'A', HTHG, HTAG, HTR, Referee, HS, AS, HST, AST, HF, AF, HC, AC, HY, AY, HR, AR, B365H, B365D, B365A, PSH, PSD, PSA, WHH, WHD, WHA, MaxH, AvgH, B365CH…}] (one row per match; ~380 rows for a 20-team season). ALL VALUES ARE STRINGS — cast before arithmetic. Dates are DD/MM/YYYY. A C in an odds column means CLOSING (B365CH = Bet365 closing home).

Example: Premier League 2024/25 with closing odds {"season": "2425", "division": "E0"}

Auth: none needed.

Every Formula E season ('championship') with its uuid — call this first, everything else needs the id.

Returns: {championships:[{id (uuid), name:'SEASON 2024-2025', status:'Past'|'Live'|'Future', lastFinishedRound, series:{id, name}}]}

Example: All seasons

Auth: none needed.

Drivers' championship standings for one season.

Returns: [{driverPosition, driverFirstName, driverLastName, driverTLA:'ROW', driverPoints, driverTeamName, driverTeamId, driverId, driverCountry}] — a TOP-LEVEL ARRAY, not wrapped

Example: Drivers' championship {"championshipId": "4e287a6d-e2da-471a-9c8a-01141d6a1819"}

Auth: none needed.

One race's detail: circuit, city, date and whether results exist.

Returns: {id, name, sequence, date, city, country, circuit, championship, hasRaceResults, hasSessionResults, metadata} — a single object; there is no results payload on this host (see the docs)

Example: One E-Prix {"raceId": "c1dd1f8a-5112-4864-8d2d-cfcc8951d197"}

Auth: none needed.

The race calendar — all seasons, or one championship's rounds.

Returns: {pageInfo:{…}, races:[{id (uuid), name:'Beijing E-Prix', sequence, date, city, country, circuit, championship, hasRaceResults, hasSessionResults}]} — WRAPPED, unlike standings

Example: One season's calendar {"championshipId": "4e287a6d-e2da-471a-9c8a-01141d6a1819"}

Auth: none needed.

Teams' championship standings, including each team's points race by race.

Returns: [{teamPosition, teamName, teamId, teamPoints, teamRaceStandings:[{raceSequence, raceCountry, racePoints}]}] — top-level array. teamRaceStandings is the per-race points breakdown, and the closest thing to race results this host exposes.

Example: Teams' championship {"championshipId": "4e287a6d-e2da-471a-9c8a-01141d6a1819"}

Auth: none needed.

Classic (total-points) league standings, paginated.

Returns: {league:{id, name, created, closed, admin_entry, start_event, league_type, scoring}, new_entries:{has_next, page, results}, standings:{has_next, page, results:[{id, entry, entry_name, player_name, rank, last_rank, rank_sort, total, event_total}]}} — entry is the manager id for fpl_manager; rank vs last_rank gives movement. Big leagues page at 50.

Example: A league table {"leagueId": 314}

Auth: works without a key; FPL_SESSION_COOKIE unlocks more if set.

The highest-scoring XI of a completed gameweek.

Returns: {top_player:{id, points}, team:[{element, position, points}]} — 404s until the gameweek is finished.

Example: A gameweek's best XI {"gameweek": 1}

Auth: works without a key; FPL_SESSION_COOKIE unlocks more if set.

Whether bonus points and league tables have been finalised for the current gameweek.

Returns: {status:[{bonus_added, date, event, points:'r'|'p'|'l'}], leagues:'Updated'|''} — this is how you know scores are FINAL. bonus_added: false means bonus points are still provisional, so a score read now may change.

Example: Is this gameweek settled?

Auth: works without a key; FPL_SESSION_COOKIE unlocks more if set.

Fixtures with FPL difficulty ratings, and goal/assist/bonus breakdowns once played.

Returns: [{id, code, event, team_h, team_a, team_h_score, team_a_score, kickoff_time, started, finished, finished_provisional, minutes, team_h_difficulty:1-5, team_a_difficulty:1-5, stats:[{identifier:'goals_scored'|'assists'|'bonus'|'bps'|'saves'|…, h:[{element, value}], a:[{element, value}]}]}] — stats is EMPTY until the match is played, then carries per-player contributions keyed by player id. The two difficulty ratings are from each side's perspective. finished_provisional goes true before finished: bonus points are not final until finished.

Example: One gameweek's fixtures {"event": 1}

Auth: works without a key; FPL_SESSION_COOKIE unlocks more if set.

Positions, chips, phases and scoring settings — the lookup tables the other tools' ids refer to.

Returns: {element_types:[{id:1-4, singular_name:'Goalkeeper', plural_name, squad_select, squad_min_play, squad_max_play, element_count}], chips:[{id, name:'wildcard'|'freehit'|'bboost'|'3xc', number, start_event, stop_event}], phases:[{id, name:'Overall'|'August', start_event, stop_event}], game_settings:{squad_squadplay, squad_total_spend, transfers_cost, transfers_limit, …}, element_stats:[{label:'Goals scored', name:'goals_scored'}], total_players:4085510} — element_types resolves the element_type id on every player (1 GK, 2 DEF, 3 MID, 4 FWD). total_players is how many squads exist worldwide, which is what an overall rank is out of.

Example: The lookup tables

Auth: works without a key; FPL_SESSION_COOKIE unlocks more if set.

All 38 gameweeks: deadlines, average scores, highest score, chip usage, and which one is current.

Returns: {events:[{id:1-38, name:'Gameweek 1', deadline_time:'2026-08-15T17:30:00Z', deadline_time_epoch, finished, data_checked, is_previous, is_current, is_next, average_entry_score, highest_score, highest_scoring_entry, most_selected, most_transferred_in, most_captained, most_vice_captained, top_element, transfers_made, chip_plays:[{chip_name, num_played}]}]} — deadline_time is THE thing an agent needs: transfers and lineup changes lock at it. is_current/is_next are how you find where the season is without doing date arithmetic.

Example: The full gameweek calendar

Auth: works without a key; FPL_SESSION_COOKIE unlocks more if set.

Head-to-head league standings with win/draw/loss records.

Returns: {league:{id, name, league_type, scoring:'h'}, standings:{has_next, page, results:[{id, entry, entry_name, player_name, rank, last_rank, total, matches_played, matches_won, matches_drawn, matches_lost, points_for}]}} — total is H2H league points (3 a win), points_for the FPL points scored. Ranking is on total, so a high scorer can sit mid-table.

Example: An H2H table {"leagueId": 1}

Auth: works without a key; FPL_SESSION_COOKIE unlocks more if set.

Live per-player scoring for a gameweek — points as they are being earned.

Returns: {elements:[{id, stats:{minutes, goals_scored, assists, clean_sheets, goals_conceded, saves, bonus, bps, total_points, expected_goals, …}, explain:[{fixture, stats:[{identifier, points, value}]}]}]} — explain breaks a player's points down by WHY they were awarded, which is the only way to reconcile a score. Returns {elements: []} for a gameweek that has not started — empty is normal pre-season, not a failure.

Example: Live scoring for a gameweek {"gameweek": 1}

Auth: works without a key; FPL_SESSION_COOKIE unlocks more if set.

A manager's squad summary: overall rank, points, and every league they are in.

Returns: {id, name:'Squad Name', player_first_name, player_last_name, player_region_name, summary_overall_points, summary_overall_rank, summary_event_points, summary_event_rank, current_event, started_event, last_deadline_bank, last_deadline_value, last_deadline_total_transfers, leagues:{classic:[{id, name, entry_rank, entry_last_rank}], h2h:[…], cup:{…}}} — last_deadline_value and last_deadline_bank are in TENTHS of a million, like player prices.

Example: A manager's summary {"managerId": 1}

Auth: works without a key; FPL_SESSION_COOKIE unlocks more if set.

A manager's gameweek-by-gameweek history, past seasons, and chips already used.

Returns: {current:[{event, points, total_points, rank, overall_rank, bank, value, event_transfers, event_transfers_cost, points_on_bench}], past:[{season_name:'2024/25', total_points, rank}], chips:[{name:'wildcard', time, event}]} — chips is what has ALREADY been played, which is how you know what is still available. current is empty before gameweek 1.

Example: A manager's season {"managerId": 1}

Auth: works without a key; FPL_SESSION_COOKIE unlocks more if set.

The exact XI, bench order, captain and chip a manager used in a gameweek.

Returns: {active_chip, automatic_subs:[{element_in, element_out}], entry_history:{event, points, total_points, rank, bank, value, event_transfers, event_transfers_cost, points_on_bench}, picks:[{element, position:1-15, multiplier:0|1|2|3, is_captain, is_vice_captain}]} — position 1-11 is the XI and 12-15 the bench IN ORDER. multiplier 2 is the captain, 3 a triple-captain chip, and 0 means they did not play (benched).

Example: A manager's gameweek team {"managerId": 1, "gameweek": 1}

Auth: works without a key; FPL_SESSION_COOKIE unlocks more if set.

YOUR current squad including picks not yet visible to others, plus bank, free transfers and chip availability. Needs your FPL session cookie.

Returns: {picks:[{element, position:1-15, multiplier:0|1|2|3, is_captain, is_vice_captain, element_type:1-4, selling_price, purchase_price}], picks_last_updated, chips:[{id, status_for_entry:'available'|'played'|'unavailable', played_by_entry:[], name:'bboost'|'3xc'|'wildcard'|'freehit', number, start_event, stop_event, chip_type:'team'|'transfer', is_pending}], transfers:{cost, status:'unlimited'|'limited', limit, made, bank, value}} — VERIFIED against a live squad. The ONE place selling_price and purchase_price appear: FPL sells a risen player back at half the gain, so selling_price is often below now_cost and that difference decides whether a transfer is affordable.

TWO FIELDS THAT CHANGE THE ANSWER: transfers.status is 'unlimited' BEFORE the first deadline — unlimited free changes, so cost and limit do not apply and limit is null. And chips[].chip_type splits how a chip is played: 'team' chips (bboost, 3xc) ride POST /api/my-team/, 'transfer' chips (wildcard, freehit) ride POST /api/transfers/.

Returns 403 {'detail':'Authentication credentials were not provided.'} without FPL_SESSION_COOKIE.

Example: Your own squad {"managerId": 1}

Auth: works without a key; FPL_SESSION_COOKIE unlocks more if set.

One player in full: every gameweek this season, past seasons, and upcoming fixtures with difficulty.

Returns: {fixtures:[{id, event, team_h, team_a, is_home, difficulty:1-5, kickoff_time}], history:[{element, fixture, round, total_points, minutes, goals_scored, assists, clean_sheets, bonus, bps, expected_goals, value, transfers_balance, selected, was_home, opponent_team}], history_past:[{season_name:'2024/25', total_points, minutes, goals_scored, end_cost, start_cost}]} — difficulty is FPL's own 1 (easiest) to 5 (hardest) rating, and it drives most fixture-run analysis. value in history is the price AT THAT GAMEWEEK, so you can see price movement.

Example: One player's full record {"playerId": 1}

Auth: works without a key; FPL_SESSION_COOKIE unlocks more if set.

Every FPL player with price, form, ownership, expected goals and availability. LARGE — ~65k tokens for all 581 players; use fpl_player_detail for one player's depth.

Returns: {elements:[{id, web_name:'Salah', team:11, element_type:3, now_cost:145, total_points, points_per_game:'6.2', form:'5.4', selected_by_percent:'42.1', status:'a'|'i'|'d'|'s'|'u', news:'Knock - 75% chance of playing', chance_of_playing_next_round, minutes, goals_scored, assists, clean_sheets, bonus, expected_goals:'0.54', expected_assists, defensive_contribution, ict_index, ep_next:'6.1'}]} — now_cost is TENTHS of a million (145 = £14.5m). status: a available, i injured, d doubtful, s suspended, u unavailable. Trimmed from 105 fields per player to 22; the upstream blob is ~362k tokens, which no context window holds.

Example: Every player, key fields

Auth: works without a key; FPL_SESSION_COOKIE unlocks more if set.

Official set-piece taker notes per club — who takes penalties, corners and free kicks.

Returns: {last_updated, teams:[{id, notes:[{external_link, info_message:'Penalties: Haaland, then Alvarez', source_link}]}]} — genuinely useful for FPL and priced-market work alike: penalty duty is worth several points a season and moves with injuries.

Example: Who takes the penalties

Auth: works without a key; FPL_SESSION_COOKIE unlocks more if set.

The 20 Premier League clubs with FPL's attack/defence strength ratings.

Returns: {teams:[{id:1-20, name:'Arsenal', short_name:'ARS', code, strength:1-5, strength_overall_home, strength_overall_away, strength_attack_home, strength_attack_away, strength_defence_home, strength_defence_away, played, win, draw, loss, points, position, form}]} — id is FPL's own alphabetical 1-20, NOT the Premier League's official team id; join to the premierleague provider by name. The strength_* numbers are FPL's internal ratings (~1000-1400) and are what fixture-difficulty is derived from.

Example: All 20 clubs

Auth: works without a key; FPL_SESSION_COOKIE unlocks more if set.

One course in full: every tee box with per-hole par, yardage and stroke index.

Returns: {course:{id, club_name, course_name, location:{…}, tees:{male:[{tee_name, course_rating, slope_rating, par_total, total_yards, number_of_holes, holes:[{par, yardage, handicap}]}], female:[…]}}} — SHAPE FROM VENDOR DOCS. NOTE tees is split by MALE/FEMALE tee sets, each a LIST of tee boxes, each with its own 18-hole array — three levels before a hole. handicap here is the hole's stroke index (1 = hardest), not a player handicap.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: One course in full {"id": 1}

Auth: needs your own key in GOLFCOURSE_API_KEY.

Search the course catalogue by name or club.

Returns: {courses:[{id, club_name, course_name, location:{address, city, state, country, latitude, longitude}}]} — SHAPE FROM VENDOR DOCS. Search returns the summary only; per-hole data needs golfcourseapi_course.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Find a course {"search_query": "Pebble Beach"}

Auth: needs your own key in GOLFCOURSE_API_KEY.

Baseball highlight clips.

Returns: {data:[{id, title, url, embedUrl, imgUrl, match:{…}}], pagination} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A day's baseball highlights {"date": "2024-07-04"}

Auth: needs your own key in HIGHLIGHTLY_API_KEY.

Basketball highlight clips (NBA, EuroLeague and others).

Returns: {data:[{id, title, url, embedUrl, imgUrl, match:{…}}], pagination} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A day's basketball highlights {"date": "2024-01-15"}

Auth: needs your own key in HIGHLIGHTLY_API_KEY.

Ice-hockey highlight clips.

Returns: {data:[{id, title, url, embedUrl, imgUrl, match:{…}}], pagination} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A day's hockey highlights {"date": "2024-01-15"}

Auth: needs your own key in HIGHLIGHTLY_API_KEY.

American-football highlight clips.

Returns: {data:[{id, title, url, embedUrl, imgUrl, match:{…}}], pagination} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A day's NFL highlights {"date": "2024-01-15"}

Auth: needs your own key in HIGHLIGHTLY_API_KEY.

Football highlight clips, by match, league or date. The main tool here.

Returns: {data:[{id, title, type, url, imgUrl, embedUrl, channel, source, match:{id, date, league, homeTeam, awayTeam}}], pagination:{totalCount, limit, offset}} — SHAPE FROM VENDOR DOCS. url is a page link and embedUrl an iframe source; they are not interchangeable.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A day's football highlights {"date": "2024-08-17"}

Auth: needs your own key in HIGHLIGHTLY_API_KEY.

Football competitions covered, with the leagueId filters.

Returns: {data:[{id, name, logo, country:{code, name, logo}, seasons:[…]}], pagination} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: Competitions covered

Auth: needs your own key in HIGHLIGHTLY_API_KEY.

Football matches, to find the matchId a highlight lookup needs.

Returns: {data:[{id, date, country, league:{id, name, logo}, homeTeam:{id, name, logo}, awayTeam:{…}, state:{description, score:{current, penalties}}}], pagination} — SHAPE FROM VENDOR DOCS. The score is nested under state, not on the match.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A day's matches {"date": "2024-08-17"}

Auth: needs your own key in HIGHLIGHTLY_API_KEY.

Basketball fixtures and results by date.

Returns: {code:0, data:[{matchId, leagueId, homeName, awayName, matchTime, status, homeScore, awayScore, quarterScores}]} — SHAPE FROM VENDOR DOCS.

NOTE: this shape is from the vendor's documentation and has NOT been verified against a live response (we hold no key for this provider). Treat it as approximate — inspect the actual payload before relying on a field name.

Example: A day's games {"date": "2024-01-15"}