List every tool group across all providers, which are currently enabled, and each provider's auth requirements (env-var names + required/optional).

On a fresh install (no groups enabled) this is the only functional tool, so the model can guide the user to enable what they want in sportsdata-mcp.yaml.

Discover tools by capability — the unit of cross-provider comparison.

Given a slug like 'sport.event_markets', returns every enabled tool exposing it across providers. Pass no argument for the full capability → tools map.

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 competition by integer id.

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

Auth: none needed.

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

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

Auth: none needed.

List comp seasons within one competition.

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

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 rounds for a comp season (incl. byes, start/end times).

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

Auth: none needed.

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.

List calendar-year season records.

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

Auth: none needed.

Get a single calendar-year season by id.

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

Auth: none needed.

List AFL/AFLW clubs (32).

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

Auth: none needed.

Get a single club by id.

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

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 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 venues (191) incl. location, state, timezone, landOwner.

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

Auth: none needed.

Get a single venue by id.

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

Auth: none needed.

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

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

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.

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.

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

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

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 broadcast regions (26) with timezones.

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

Auth: none needed.

Get a single broadcast region by id.

Returns: {id, name, timezone}

Auth: none needed.

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

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

Auth: none needed.

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

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

Auth: none needed.

Broadcast schedule — one entry per match per channel.

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

Auth: none needed.

Also answers this: espn_core_call, pl_broadcasting_events, pl_broadcast_match_events.

Get a single broadcast event by id.

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

Auth: none needed.

Also answers this: espn_core_call, pl_broadcasting_events, pl_broadcast_match_events.

Broadcast events scoped to one (compseason, round).

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

Auth: none needed.

Also answers this: espn_core_call, pl_broadcasting_events, pl_broadcast_match_events.

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.

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.

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 text article by id.

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

Auth: none needed.

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

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

Auth: none needed.

Get a single video content item by id.

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

Auth: none needed.

List photo content.

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

Auth: none needed.

Get a single photo content item by id.

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

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 promo content item by id.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Also answers this: squiggle_tips, squiggle_ladder.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Cash-out availability for one or more markets.

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

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.

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.

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

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

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.

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.

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.

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

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

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.

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

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

Auth: none needed.

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

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

Auth: none needed.

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

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

Auth: none needed.

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

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

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.

Events + markets for one sport category (competition).

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

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.

Categories that currently have Popular Same Game Multis.

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

Auth: none needed.

Popular Same Game Multi suggestions for one master event.

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

Auth: none needed.

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

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

Auth: none needed.

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

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

Auth: none needed.

All visible promotions (name, description, dates).

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

Auth: none needed.

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

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

Auth: none needed.

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

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

Auth: none needed.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 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.

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.

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 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.

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.

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

Returns: {competitions:[{id, name, url, imageUrl, startDateTime, endDateTime, order}], 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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 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.

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 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 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 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 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.

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: none needed.

Featured slider events (homepage hero carousel).

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

Auth: none needed.

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: none needed.

Next races about to jump, grouped per racing category.

Returns: {category_race_map:{}, race_summaries:{:{race_name, meeting_name, advertised_start, race_form}}}

Auth: none needed.

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

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

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

Auth: none needed.

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

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

Auth: none needed.

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

Returns: {status, data:{races:{:{name, advertised_start:{seconds}}}}}

Auth: none needed.

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: none needed.

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

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

Auth: none needed.

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

Returns: {market_rules:{:{id, name, description}}}

Auth: none needed.

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

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

Auth: none needed.

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: none needed.

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

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

Auth: none needed.

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

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

Auth: none needed.

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: none needed.

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: none needed.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Also answers this: fpl_game_rules, sleeper_league, yahoo_league_settings.

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.

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.

Also answers this: fpl_game_rules, sleeper_league, yahoo_league_settings.

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.

Also answers this: fpl_game_rules, sleeper_league, yahoo_league_settings.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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

Auth: none needed.

Homepage quick-link tiles for the racing site.

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

Auth: none needed.

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

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

Auth: none needed.

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

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Also answers this: espnfantasy_rosters, sleeper_league_rosters, yahoo_team_roster.

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.

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.

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.

Also answers this: espnfantasy_rosters, sleeper_league_rosters, yahoo_team_roster.

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.

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.

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 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.

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.

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.

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.

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.

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.

Football competitions with their ids.

Returns: {code:0, data:[{competitionId, name, shortName, logo, type, color}]} — SHAPE FROM VENDOR DOCS. code: 0 means success; anything else is an error delivered with HTTP 200.

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 competition

Auth: needs your own key in ISPORTS_API_KEY.

Football fixtures and results by date.

Returns: {code:0, data:[{matchId, competitionId, homeId, homeName, awayId, awayName, matchTime, status, homeScore, awayScore, halfHomeScore, halfAwayScore}]} — SHAPE FROM VENDOR DOCS. matchTime is a UNIX TIMESTAMP, not an ISO string.

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 ISPORTS_API_KEY.

Asian-handicap odds across companies — the reason to use this provider.

Returns: {code:0, data:{handicap:[[matchId, companyId, initialHandicap, initialHome, initialAway, liveHandicap, liveHome, liveAway, …]], europeOdds:[[…]], overUnder:[[…]]}} — SHAPE FROM VENDOR DOCS. NOTE the payload is ARRAYS OF POSITIONAL ARRAYS, not objects: fields are identified by INDEX. Read the vendor's column order before parsing, and do not assume it matches other providers here.

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: Asian handicap odds

Auth: needs your own key in ISPORTS_API_KEY.

Football matches in play now.

Returns: {code:0, data:[{matchId, status, homeScore, awayScore, homeHalfScore, awayHalfScore, homeRed, awayRed, homeYellow, awayYellow, homeCorner, awayCorner, updateTime}]} — SHAPE FROM VENDOR DOCS. Corners and cards live here rather than in a separate statistics call.

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: In play now

Auth: needs your own key in ISPORTS_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"}

Auth: needs your own key in ISPORTS_API_KEY.

Every F1 season on record (1950 onward).

Returns: {MRData:{total, limit, offset, SeasonTable:{Seasons:[{season, url}]}}}

Example: First page of seasons {"format": "json", "limit": 30}

Auth: none needed.

Drivers — all-time, or the field for one season.

Returns: {MRData:{DriverTable:{season, Drivers:[{driverId, permanentNumber, code, givenName, familyName, dateOfBirth, nationality, url}]}}} — driverId (e.g. 'max_verstappen') is the key every other tool filters on

Example: 2024 field {"season": "2024", "format": "json"}

Auth: none needed.

Constructors (teams) — all-time, or those entered in one season.

Returns: {MRData:{ConstructorTable:{season, Constructors:[{constructorId, name, nationality, url}]}}}

Example: 2024 constructors {"season": "2024", "format": "json"}

Auth: none needed.

Circuits, with location and coordinates.

Returns: {MRData:{CircuitTable:{Circuits:[{circuitId, circuitName, Location:{lat, long, locality, country}, url}]}}}

Example: 2024 circuits {"season": "2024", "format": "json"}

Auth: none needed.

A season's race calendar with dates, circuits and (from 2021) each session's date/time.

Returns: {MRData:{RaceTable:{season, Races:[{season, round, raceName, date, time, url, Circuit:{circuitId, circuitName, Location}, FirstPractice, Qualifying, Sprint}]}}} — round is what the result tools take

Example: 2024 calendar {"season": "2024", "format": "json"}

Auth: none needed.

Race results: finishing order, grid, laps, time/status, points and fastest lap.

Returns: {MRData:{RaceTable:{Races:[{season, round, raceName, Results:[{position, positionText, points, grid, laps, status, Driver:{driverId, code}, Constructor:{constructorId}, Time:{millis, time}, FastestLap:{rank, lap, Time, AverageSpeed}}]}]}}} — all values are STRINGS

Example: 2024 round 1 {"season": "2024", "round": "1", "format": "json"}

Auth: none needed.

Qualifying results with Q1/Q2/Q3 times per driver.

Returns: {MRData:{RaceTable:{Races:[{QualifyingResults:[{position, Driver, Constructor, Q1, Q2, Q3}]}]}}} — Q2/Q3 absent for drivers eliminated earlier

Example: 2024 round 1 qualifying {"season": "2024", "round": "1", "format": "json"}

Auth: none needed.

Sprint race results (weekends that have one — 2021 onward).

Returns: {MRData:{RaceTable:{Races:[{SprintResults:[{position, points, grid, laps, status, Driver, Constructor, Time}]}]}}} — Races is EMPTY for a weekend with no sprint, which is not an error

Example: A 2024 sprint weekend {"season": "2024", "round": "5", "format": "json"}

Auth: none needed.

Lap-by-lap times for every driver in a race. LARGE — page it or narrow to one lap.

Returns: {MRData:{total, RaceTable:{Races:[{Laps:[{number, Timings:[{driverId, position, time}]}]}]}}} — one entry per lap, each holding every driver's timing

Example: First laps of 2024 round 1 {"season": "2024", "round": "1", "format": "json", "limit": 100}

Auth: none needed.

Pit stops for a race: lap, time of day and stationary duration.

Returns: {MRData:{RaceTable:{Races:[{PitStops:[{driverId, lap, stop, time, duration}]}]}}} — duration is stationary time ('23.2'), time is clock time of day

Example: 2024 round 1 pit stops {"season": "2024", "round": "1", "format": "json"}

Auth: none needed.

Drivers' championship standings — after a season, or after a specific round.

Returns: {MRData:{StandingsTable:{season, round, StandingsLists:[{season, round, DriverStandings:[{position, points, wins, Driver:{driverId, code, familyName}, Constructors:[{constructorId, name}]}]}]}}} — note the extra StandingsLists layer

Example: 2024 drivers' championship {"season": "2024", "format": "json"}

Auth: none needed.

Constructors' championship standings.

Returns: {MRData:{StandingsTable:{StandingsLists:[{season, round, ConstructorStandings:[{position, points, wins, Constructor:{constructorId, name, nationality}}]}]}}}

Example: 2024 constructors' championship {"season": "2024", "format": "json"}

Auth: none needed.

Prediction-market catalogue with current quotes — filter by event/series ticker or status. Paginated by cursor.

Returns: {cursor, markets:[{ticker, event_ticker, market_type, title, status, yes_bid_dollars, yes_ask_dollars, no_bid_dollars, no_ask_dollars, last_price_dollars, volume_fp, volume_24h_fp, open_interest_fp, liquidity_dollars, open_time, close_time, expiration_time, rules_primary}]}

Example: First page of open markets {"limit": 5, "status": "open"}

Auth: none needed.

Also answers this: polymarket_markets, polymarket_clob_markets.

One market's full detail by ticker — quotes, volume, rules, strike, timing.

Returns: {market:{ticker, event_ticker, title, yes_sub_title, no_sub_title, status, result, yes_bid_dollars, yes_ask_dollars, last_price_dollars, volume_fp, open_interest_fp, rules_primary, rules_secondary, strike_type, custom_strike, open_time, close_time, expiration_time}}

Auth: none needed.

Also answers this: polymarket_market.

Order book for one market — resting yes/no bids by price level (dollar-denominated).

Returns: {orderbook_fp:{yes_dollars:[[price, size], …], no_dollars:[[price, size], …]}} (empty arrays when nothing is resting)

Auth: none needed.

Recent public trades, optionally for one market ticker. Paginated by cursor.

Returns: {cursor, trades:[{trade_id, ticker, count, yes_price, no_price, taker_side, created_time}]}

Auth: none needed.

Also answers this: polymarket_trades.

OHLC price candlesticks for one market over a time window (1m/1h/1d periods).

Returns: {ticker, candlesticks:[{end_period_ts, yes_bid, yes_ask, price, volume, open_interest}]}

Auth: none needed.

Also answers this: polymarket_price_history.

OHLC candlesticks for MANY markets in one call — pass the tickers as a list.

Returns: {markets:[{market_ticker, candlesticks:[{end_period_ts, price, volume, open_interest}]}]}

Auth: none needed.

Also answers this: polymarket_price_history.

Event catalogue (an event groups related markets) — filter by series or status. Paginated by cursor.

Returns: {cursor, events:[{event_ticker, series_ticker, title, sub_title, category, mutually_exclusive, strike_period}], milestones}

Example: First page of open events {"limit": 5, "status": "open"}

Auth: none needed.

One event by ticker, optionally with its markets embedded.

Returns: {event:{event_ticker, series_ticker, title, category, mutually_exclusive, markets:[…]}, markets}

Auth: none needed.

All series in a category (Sports, Politics, Economics, Financials, Climate and Weather, Entertainment, …) — the top of the id chain.

Returns: {series:[{ticker, title, category, frequency, tags, settlement_sources, contract_url}]}

Example: Every sports series {"category": "Sports"}

Auth: none needed.

One series by ticker — title, category, settlement sources, fee structure.

Returns: {series:{ticker, title, category, frequency, tags, settlement_sources, contract_url, fee_type}}

Auth: none needed.

Milestones — dated catalysts (data releases, games, decisions) linked to the event tickers they resolve.

Returns: {cursor, milestones:[{id, category, details, end_date, primary_event_tickers, related_event_tickers}]}

Auth: none needed.

Multivariate event collections — the parlay-style combo products that many KXMVE* markets belong to (a market's mve_collection_ticker points here).

Returns: {cursor, multivariate_contracts:[{collection_ticker, series_ticker, title, description, is_ordered, is_all_yes, size_min, size_max, associated_event_tickers, open_date, close_date}]}

Auth: none needed.

One multivariate event collection by ticker.

Returns: {multivariate_contract:{collection_ticker, series_ticker, title, description, associated_events, associated_event_tickers}}

Auth: none needed.

Structured targets — Kalshi's entity registry (players, companies, people) that markets resolve against. Paginated by cursor; page size via page_size.

Returns: {cursor, structured_targets:[{id, name, type, details, source_ids, last_updated_ts}]}

Auth: none needed.

One structured target (entity) by id.

Returns: {structured_target:{id, name, type, details, source_ids}}

Auth: none needed.

Is the exchange up and trading right now.

Returns: {exchange_active, trading_active}

Auth: none needed.

Standard trading hours + maintenance windows.

Returns: {schedule:{standard_hours, maintenance_windows}}

Auth: none needed.

Active exchange-wide announcements.

Returns: {announcements:[{type, message, delivery_time, status}]}

Auth: none needed.

All LaLiga competitions (men's/women's, primera/segunda, across history), each with slug, opta_id, name.

Returns: {competitions:[{id, slug, name, opta_id, lde_id, main}]}

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

One competition by SLUG (e.g. primera-division). Numeric id 404s — use the slug.

Returns: {competition:{id, slug, name, opta_id}}

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

Season instances (a 'subscription' = one competition's season), paginated 20/page. Each has slug, competition, year, current_gameweek, date range.

Returns: {total, subscriptions:[{id, name, slug, competition, year, current_gameweek, date_ini, date_end, rounds}]}

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

One season instance by slug — competition, year, season name, current gameweek, rounds, and teams (the authoritative 20 teams in that season — use this, not laliga_teams, for a season roster).

Returns: {subscription:{id, slug, name, competition, season, season_name, year, current_gameweek, teams:[20 season teams], rounds}}

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

Full league table for a season — 20 entries with played/won/drawn/lost/goals_for/goals_against/goal_difference/points/position + full team object (shield, colours).

Returns: {total, standings:[{position, previous_position, played, won, drawn, lost, goals_for, goals_against, goal_difference, points, team:{id, slug, name, shortname, opta_id, shield}}]}

Example: 2025/26 LALIGA EA SPORTS table {"slug": "laliga-easports-2025"}

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

Rounds / matchweeks structure for a season (gameweeks, groups).

Returns: {total, rounds:[{id, slug, name, position, num_gameweeks, gameweeks, has_groups, groups}]}

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

Global team directory across all competitions (~1541), paginated — use it to resolve a team's slug/id/opta_id. NOTE: NOT season-scoped; for the 20 teams in a season read laliga_standing or laliga_subscription (its embedded teams).

Returns: {total, teams:[{id, slug, name, nickname, shortname, boundname, shield, competitions}]} (opta_id present on most; join via it where available)

Example: First page of the team directory {"limit": 20}

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

One team by SLUG — club info, colours, foundation, socials, competitions, venue.

Returns: {team:{id, slug, name, shortname, opta_id, club, color, foundation, competitions, last_main_competition}}

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

A club's CURRENT squad — each entry has person (name, date_of_birth, country, height), photos, position id, shirt_number, opta_id, loan status. (The subscription arg is required by the API but the roster returned is the current one, not season-historical.)

Returns: {total, squads:[{id, opta_id, person:{name, date_of_birth, country, height}, photos, position, shirt_number, role, current, loan}]}

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

EVERY player in a season (≈749) with full Opta stats[] (name/stat pairs) + position + team + opta_id. Page with limit (max 100) + offset.

Returns: {total, player_stats:[{id, name, slug, opta_id, shirt_number, position, country, team, stats:[{name, stat}]}]}

Example: First page of 2025/26 player stats {"slug": "laliga-easports-2025", "limit": 20}

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

One player profile by SLUG — name, firstname/lastname, date_of_birth, country, current team + squad, roles.

Returns: {player:{id, slug, name, firstname, lastname, date_of_birth, country, international, team, squad, roles}}

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

One player's Opta stats[] by SLUG.

Returns: {player_stats:{id, name, slug, opta_id, team, stats:[{name, stat}]}}

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

Matches feed. IMPORTANT: pass competition= to get a competition's matches — subscription= alone returns a mixed bag (incl. World Cup placeholders). competition=primera-division gives the 380 LALIGA EA SPORTS matches; add gameweek= for one matchweek (10).

Returns: {total, matches:[{id, slug, name, opta_id, home_team, away_team, competition, season, gameweek, date, time, venue, status}]} (status FullTime/PreMatch/…)

Example: 2025/26 LALIGA matchweek 1 (10 matches) {"subscription": "laliga-easports-2025", "competition": "primera-division", "gameweek": 1, "limit": 10}

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

One match by SLUG (from laliga_matches; the long temporada-… slug, not the numeric id which 404s). For a played match adds scores + formations.

Returns: {match:{id, slug, name, home_team, away_team, home_score, away_score, home_formation, away_formation, competition, gameweek, date, status, attempt, ball}}

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

A Lichess player: ratings per time control and variant, games played, play time and profile.

Returns: {id, username, title, perfs:{bullet:{rating, games, rd, prog}, blitz:{…}, rapid:{…}, classical:{…}, correspondence:{…}, puzzle:{…}}, createdAt, seenAt, playTime:{total, tv}, count:{all, rated, win, loss, draw}, profile:{…}, patron, streamer} — no single 'rating': read perfs..rating

Example: One player's profile and ratings {"username": "thibault"}

Auth: none needed.

Online/playing status for up to 50 users in one call — who is available right now.

Returns: [{id, name, title, online, playing, streaming, patron}] (top-level array)

Example: Status of two players {"ids": ["thibault", "neio"]}

Auth: none needed.

Top-rated players for one time control or variant.

Returns: {users:[{id, username, title, perfs:{:{rating, progress}}, online}]}

Example: Top 10 blitz players {"count": 10, "perf": "blitz"}

Auth: none needed.

Top 10 for EVERY time control and variant in a single call.

Returns: {bullet:[{id, username, title, perfs}], blitz:[…], rapid:[…], classical:[…], chess960:[…], atomic:[…], …} — one array per perf

Example: Every leaderboard at once

Auth: none needed.

The daily puzzle: the position, the solution line, and the game it came from.

Returns: {game:{id, perf:{key, name}, rated, players:[{name, color, rating}], pgn, clock}, puzzle:{id, rating, plays, solution:[uci moves], themes:[str], initialPly}}

Example: Today's puzzle

Auth: none needed.

Arena tournaments — currently running, finished and upcoming.

Returns: {created:[{id, fullName, startsAt, variant, clock, nbPlayers}], started:[…], finished:[…]} — three lists by state, NOT one

Example: Arena tournaments by state

Auth: none needed.

Sport catalogue — the sportId lookup (1 = Major League Baseball; others are MiLB levels, college, international).

Returns: {sports:[{id, code, name, abbreviation, sortOrder, activeStatus}]}

Auth: none needed.

League catalogue — e.g. American League (103) and National League (104). Pass sportId=1 for MLB.

Returns: {leagues:[{id, name, abbreviation, sport, seasonState, hasWildCard}]}

Auth: none needed.

Division catalogue (AL/NL East, Central, West) with their league + sport links.

Returns: {divisions:[{id, name, nameShort, abbreviation, league, sport}]}

Auth: none needed.

Team catalogue — id, name, abbreviation, location, league/division, home venue. Pass sportId=1 for the 30 MLB clubs.

Returns: {teams:[{id, name, abbreviation, teamName, locationName, league, division, venue, firstYearOfPlay}]}

Auth: none needed.

A team's roster — players with position and jersey number. rosterType selects active / 40-man / full-season / depth chart.

Returns: {roster:[{person:{id, fullName}, jerseyNumber, position:{abbreviation, name}, status}], teamId, rosterType}

Auth: none needed.

Player biographical profile — name, DOB, bats/throws, height/weight, position, debut, current team. One personId.

Returns: {people:[{id, fullName, primaryNumber, birthDate, currentAge, height, weight, primaryPosition, batSide, pitchHand, mlbDebutDate, currentTeam}]}

Auth: none needed.

Find players by name — resolves a name to personId(s) and basic bio.

Returns: {people:[{id, fullName, firstName, lastName, birthDate, primaryPosition}]}

Auth: none needed.

Venue detail for one or more venueIds — name, location, field/roof info.

Returns: {venues:[{id, name, location, fieldInfo, timeZone, active}]}

Auth: none needed.

Season catalogue with key dates (regular-season start/end, postseason, etc.). Pass sportId=1.

Returns: {seasons:[{seasonId, regularSeasonStartDate, regularSeasonEndDate, seasonStartDate, seasonEndDate, preSeasonStartDate, postSeasonEndDate}]}

Auth: none needed.

Every season in MLB history (151+) with key dates — the /seasons/all catalogue. (Plain /seasons only returns the current season; an ?all=true query there is a no-op.)

Returns: {seasons:[{seasonId, regularSeasonStartDate, regularSeasonEndDate, seasonStartDate, seasonEndDate, preSeasonStartDate, qualifierPlateAppearances, hasWildcard}]}

Auth: none needed.

Game schedule — by single date or startDate/endDate range, optionally for one team. Each game carries gamePk, status, teams and score.

Returns: {totalGames, dates:[{date, games:[{gamePk, gameDate, status, teams:{away:{team,score}, home:{team,score}}, venue}]}]}

Auth: none needed.

Full game boxscore — both teams' batting + pitching lines per player, team totals, officials and top performers.

Returns: {teams:{away:{team, teamStats, players:{ID#:{stats:{batting,pitching}, position}}}, home:{...}}, officials, topPerformers}

Auth: none needed.

Game linescore — runs per inning, R/H/E totals, current inning + state, and on-base/defense for live games.

Returns: {currentInning, inningState, isTopInning, innings:[{num, home:{runs,hits,errors}, away:{...}}], teams:{home:{runs,hits,errors}, away:{...}}}

Auth: none needed.

Pitch-by-pitch / play-by-play log — every plate appearance with result, pitches, counts, runners and scoring-play flags.

Returns: {allPlays:[{result, about:{inning,halfInning,isScoringPlay}, matchup:{batter,pitcher}, playEvents:[...], count}], scoringPlays, currentPlay}

Auth: none needed.

The complete live game feed (v1.1) — gameData (teams, players, venue, weather, probables) + liveData (boxscore, linescore, full plays). The firehose; large.

Returns: {gamePk, gameData:{teams, players, venue, weather, probablePitchers}, liveData:{plays, linescore, boxscore, decisions}}

Auth: none needed.

Division standings — per-team W/L, pct, GB, streak, run differential, wild-card and division ranks. Pass leagueId (103=AL, 104=NL).

Returns: {records:[{division, league, teamRecords:[{team, wins, losses, winningPercentage, gamesBack, streak, runDifferential, divisionRank, wildCardRank}]}]}

Auth: none needed.

Season stats query across players — by group (hitting/pitching/fielding) and type (season, career, byDateRange, ...). Sort + limit for top-N tables.

Returns: {stats:[{type, group, splits:[{season, player, team, stat:{...}}]}]}

Auth: none needed.

One player's stats — by type (season / career / yearByYear / gameLog) and group (hitting/pitching/fielding).

Returns: {stats:[{type, group, splits:[{season, stat:{...}, team, league}]}]}

Auth: none needed.

League leaders for one or more categories (homeRuns, battingAverage, era, strikeouts, wins, saves, ...).

Returns: {leagueLeaders:[{leaderCategory, statGroup, season, leaders:[{rank, value, person, team}]}]}

Auth: none needed.

MLB Rule 4 draft results for a year — picks with player, school/team, position and signing info. Filter by round.

Returns: {drafts:{draftYear, rounds:[{round, picks:[{pickNumber, person, team, school, position}]}]}}

Auth: none needed.

Award definitions catalogue — every awardId with name, description and sport (the id lookup for mlb_awards).

Returns: {awards:[{id, name, description, sortOrder, sport, active}]}

Auth: none needed.

Recipients of an award — e.g. MLBHOF (Hall of Fame), ALMVP/NLMVP, ALCY/NLCY (Cy Young), ALROY/NLROY (Rookie of the Year). Discover awardIds with mlb_awards_list.

Returns: {awards:[{id, name, season, player, team, votes}]}

Auth: none needed.

Attendance figures for a team or league/season — per-game and aggregate home/away/total gate.

Returns: {records:[{openings, attendanceTotal, attendanceAverage, team, season}], aggregateTotals}

Auth: none needed.

Single team detail by id — name, league/division, venue, colours, founding.

Returns: {teams:[{id, name, abbreviation, league, division, venue, locationName, firstYearOfPlay}]}

Auth: none needed.

A team's coaching staff — manager, hitting/pitching/bench coaches, etc.

Returns: {roster:[{person, jobId, job, title}], teamId}

Auth: none needed.

Also answers this: espn_core_call.

A team's front-office / non-uniformed personnel.

Returns: {roster:[{person, job, title}], teamId}

Auth: none needed.

Former players (alumni) for a team in a season + group (hitting/pitching/fielding).

Returns: {people:[{id, fullName, primaryPosition, mlbDebutDate}]}

Auth: none needed.

Franchise history (name/league/division changes over time) for one or more teams.

Returns: {teams:[{id, name, season, league, division, locationName, active}]}

Auth: none needed.

A club's affiliated teams across the minor-league levels.

Returns: {teams:[{id, name, sport, league, parentOrgId, parentOrgName}]}

Auth: none needed.

Uniform assets / descriptions for one or more teams.

Returns: {uniforms:[{teamId, uniformAssets:[{uniformAssetText, uniformAssetType, ...}]}]}

Auth: none needed.

Conference catalogue (used by some leagues / amateur levels).

Returns: {conferences:[{id, name, abbreviation, league, hasWildcard}]}

Auth: none needed.

Batch player profiles for a list of personIds (the multi-id form of mlb_player).

Returns: {people:[{id, fullName, primaryNumber, birthDate, primaryPosition, batSide, pitchHand, currentTeam}]}

Auth: none needed.

Player records changed since a timestamp — a polling/sync helper (the people-side sibling of mlb_game_changes).

Returns: {people:[{id, fullName, currentAge, birthDate, active, primaryPosition, batSide, pitchHand}]} (can be large for a wide window)

Auth: none needed.

All players in a sport for a season — the full player catalogue (name → id resolution). sportId=1 for MLB.

Returns: {people:[{id, fullName, firstName, lastName, primaryNumber, birthDate, currentAge}]} (large)

Auth: none needed.

Single season detail by seasonId — key dates and game-count info.

Returns: {seasons:[{seasonId, regularSeasonStartDate, regularSeasonEndDate, postSeasonStartDate, postSeasonEndDate}]}

Auth: none needed.

Postseason schedule — all playoff games (optionally a single season / series type).

Returns: {totalGames, dates:[{date, games:[{gamePk, seriesDescription, teams, status}]}]}

Auth: none needed.

Postseason series view — games grouped by series (e.g. ALDS, NLCS, World Series).

Returns: {series:[{series:{id, gameType}, totalItems, games:[...]}]}

Auth: none needed.

Postseason broadcast 'tune-in' info (where/when to watch playoff games).

Returns: {dates:[{games:[{gamePk, broadcasts:[...]}]}]}

Auth: none needed.

Tie-breaker / tied games for a season.

Returns: {totalGames, dates:[{games:[...]}]}

Auth: none needed.

Win-probability time series for a game — WP after each play, with leverage index.

Returns: [{atBatIndex, homeTeamWinProbability, awayTeamWinProbability, leverageIndex, homeTeamWinProbabilityAdded}] (top-level array)

Auth: none needed.

Also answers this: espn_core_call.

Context metrics for a game — leverage, win-probability and run-expectancy context for the current/most-recent state.

Returns: {game, leverageIndex, homeWinProbability, awayWinProbability}

Auth: none needed.

Editorial / media content for a game — highlights, recap, media, and (when present) the box-score-and-storylines bundle.

Returns: {editorial, media, highlights, summary, gameNotes}

Auth: none needed.

One player's stat line for one specific game (batting/pitching/fielding for that gamePk).

Returns: {stats:[{group, splits:[{stat:{...}, game}]}]}

Auth: none needed.

Games changed since a timestamp — a polling helper to detect updated games.

Returns: {totalItems, dates:[{games:[{gamePk, gameDate}]}]}

Auth: none needed.

Uniforms worn in one or more games.

Returns: {uniforms:[{gamePk, home:{...}, away:{...}}]}

Auth: none needed.

One team's aggregate stats — by season + group (hitting/pitching/fielding) and stat type.

Returns: {stats:[{type, group, splits:[{season, team, stat:{...}}]}]}

Auth: none needed.

Aggregate stats across all teams — league-wide team leaderboard by season + group. Sort + limit for top-N.

Returns: {stats:[{type, group, splits:[{team, stat:{...}}]}]}

Auth: none needed.

A team's statistical leaders for given categories (e.g. homeRuns, era) in a season.

Returns: {teamLeaders:[{leaderCategory, season, leaders:[{rank, value, person}]}]}

Auth: none needed.

Game-pace / tempo metrics for a season (pitches per game, time of game, etc.), optionally by team.

Returns: {sports:[{...pace}], teams:[{team, ...pace}], leagues:[...]}

Auth: none needed.

High / low stat records for an org level — top and bottom performances for a sortStat in a season.

Returns: {highLow:[{statType, splits:[{stat, player|team}]}]}

Auth: none needed.

Roster transactions — signings, trades, call-ups, IL moves, DFA, etc. Filter by team, player, single date or date range.

Returns: {transactions:[{id, person, fromTeam, toTeam, date, typeCode, typeDesc, description]}]}

Auth: none needed.

Free agents for a season — players and their from/to-team signing info.

Returns: {freeAgents:[{player, originalTeam, newTeam, dateSigned, dateDeclared, position]}]}

Auth: none needed.

Draft prospects for a year (the pre-draft prospect board).

Returns: {prospects:[{id, rank, person, school, position}]}

Auth: none needed.

People holding a job type for a season — jobType e.g. UMPR (umpires), SCORER, DATACASTER, BROADCASTER, COACH.

Returns: {roster:[{person, jobType, job}]}

Auth: none needed.

Current umpire crew list.

Returns: {roster:[{person, jobType, job}]}

Auth: none needed.

Datacaster (official scorer-adjacent stringer) assignments.

Returns: {roster:[{person, job}]}

Auth: none needed.

Official scorer assignments.

Returns: {roster:[{person, job}]}

Auth: none needed.

Home Run Derby bracket + results for a derby gamePk.

Returns: {info, status, rounds:[{matchups:[{topSeed, bottomSeed, ...}]}]}

Auth: none needed.

All-Star Game ballot candidates for a league + season.

Returns: {league, candidates:[{position, players:[{person, team}]}]}

Auth: none needed.

All-Star write-in candidates for a league + season.

Returns: {league, writeIns:[{person, team, position}]}

Auth: none needed.

All-Star 'Final Vote' candidates for a league + season.

Returns: {league, candidates:[{person, team, position}]}

Auth: none needed.

Meta lookup — fetch the valid values for a parameter used elsewhere (stat types, positions, game types, pitch codes, etc.). One tool over the API's /{type} endpoint.

Returns: [{...lookup rows}] (shape depends on type; e.g. positions → [{code, name, type, abbrev}])

Auth: none needed.

Every MotoGP season (1949 →) with its uuid — the entry point to everything else.

Returns: [{id (uuid), year, current}] (top-level array, newest first) — id is the seasonUuid every other tool needs; current: true marks the live season

Example: All seasons

Auth: none needed.

The Grand Prix weekends in a season, with circuit, country and dates.

Returns: [{id (uuid), name, short_name:'QAT', sponsored_name, date_start, date_end, circuit:{id, name, nation}, country:{iso, name}, season, event_files}]

Example: Completed rounds of a season {"seasonUuid": "dd12382e-1d9f-46ee-a5f7-c5104db28e43", "isFinished": true}

Auth: none needed.

The classes running at one event — MotoGP, Moto2, Moto3, MotoE.

Returns: [{id (uuid), name:'MotoGP™', legacy_id}] — id is the categoryUuid the session and standings tools need

Example: Classes at one Grand Prix {"eventUuid": "0f4c9f38-3e30-40f4-8a4a-9e05ba0d0daa"}

Auth: none needed.

The sessions for one class at one event — practice, qualifying, sprint and race.

Returns: [{id (uuid), type:'RAC'|'SPR'|'Q1'|'Q2'|'FP1'|'PR', number, date, condition:{track, air, humidity, ground, weather}}] — pick type 'RAC' for the race

Example: Sessions for MotoGP at one round {"eventUuid": "0f4c9f38-3e30-40f4-8a4a-9e05ba0d0daa", "categoryUuid": "e8c110ad-64aa-4e8e-8a86-f2f152f6a942"}

Auth: none needed.

The result of one session: finishing order, rider, team, bike, time/gap and points.

Returns: {classification:[{position, points, total_laps, time, gap:{first, lap}, rider:{id, full_name, number, country}, team:{name}, constructor:{name}, average_speed, top_speed, status}], records, file}

Example: A race result {"sessionUuid": "5b0827b6-7faf-4a1b-a4c2-de630ba1941a"}

Auth: none needed.

Championship standings for one class in one season.

Returns: {classification:[{position, points, rider:{id, full_name, number, country}, team:{name}, constructor:{name}}], file}

Example: MotoGP riders' championship {"seasonUuid": "dd12382e-1d9f-46ee-a5f7-c5104db28e43", "categoryUuid": "e8c110ad-64aa-4e8e-8a86-f2f152f6a942"}

Auth: none needed.

Games for a season in one league, with scores and venue.

Returns: {lastUpdatedOn, games:[{schedule:{id, week, startTime, awayTeam:{id, abbreviation}, homeTeam:{…}, venue, playedStatus}, score:{awayScoreTotal, homeScoreTotal, quarters|periods|innings:[…], currentQuarter, currentIntermission}}]} — SHAPE FROM VENDOR DOCS. NOTE identity lives under schedule and the result under score: a game is TWO nested objects, not one flat one.

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: This NFL season's games {"league": "nfl", "season": "current"}

Auth: needs your own key in MYSPORTSFEEDS_API_KEY.

Full box score for one game, team and player level.

Returns: {game:{…}, scoring:{…}, stats:{away:{teamStats:[…], players:[{player:{id, firstName, lastName, position}, playerStats:[…]}]}, home:{…}}} — SHAPE FROM VENDOR DOCS. The game id may be given as '20240115-LAL-BOS', which is often easier than looking one up.

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 box score {"league": "nba", "season": "current", "game": "20240115-LAL-BOS"}

Auth: needs your own key in MYSPORTSFEEDS_API_KEY.

Per-game statistics for players across a season — the cleanest surface this API has.

Returns: {gamelogs:[{game:{id, startTime, awayTeamAbbreviation, homeTeamAbbreviation}, player:{id, firstName, lastName, position, jerseyNumber}, team:{id, abbreviation}, stats:{…sport-specific groups…}}]} — SHAPE FROM VENDOR DOCS. stats groups differ per sport (passing/rushing for NFL, offense/rebounds for NBA).

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 team's player game logs {"league": "nba", "season": "current", "team": ["LAL"]}

Auth: needs your own key in MYSPORTSFEEDS_API_KEY.

Standings for a league and season.

Returns: {teams:[{team:{id, abbreviation, city, name}, stats:{standings:{wins, losses, winPct, gamesBack}}, divisionRank:{rank, gamesBack}, conferenceRank:{…}, overallRank:{…}}]} — 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: This season's standings {"league": "nba", "season": "current"}

Auth: needs your own key in MYSPORTSFEEDS_API_KEY.

Current injury list for a league.

Returns: {players:[{id, firstName, lastName, position, currentTeam:{abbreviation}, currentInjury:{description, playingProbability}}]} — SHAPE FROM VENDOR DOCS. Note there is NO season segment on this path — injuries are always 'now'.

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: NBA injuries {"league": "nba"}

Auth: needs your own key in MYSPORTSFEEDS_API_KEY.

Also answers this: espn_site_call, espnfantasy_player_info, sportsdataio_nfl_injuries.

Every race in a season across all three series, with winner, track, distance, cautions and lead changes. LARGE (~430 KB).

Returns: {series_1:[{race_id, series_id, race_season, race_name, track_name, track_id, date_scheduled, scheduled_distance, actual_laps, number_of_cautions, number_of_lead_changes, average_speed, margin_of_victory, pole_winner_driver_id, winner_driver_id, attendance}], series_2:[…], series_3:[…]} — series 1=Cup, 2=Xfinity, 3=Truck

Example: 2024 season across all series {"season": 2024}

Auth: none needed.

One race weekend in full: the finishing order with laps led, points and status, plus every practice and qualifying run.

Returns: {weekend_race:[{race_id, race_name, track_name, results:[{finishing_position, starting_position, car_number, driver_fullname, team_name, laps_completed, laps_led, points_earned, status, delta_leader}], caution_segments, race_comments}], weekend_runs:[{run_type, run_name, results:[{finishing_position, driver_name, best_lap_time, best_lap_speed}]}]} — weekend_race is the race, weekend_runs is practice + qualifying. WARNING: results is NOT sorted and INCLUDES non-starters with finishing_position 0 (DNQ/DNS). Verified on the 2024 Daytona 500, where results[0] is a driver who did not qualify. The winner is the row with finishing_position == 1 — never results[0].

Example: One Cup race weekend {"season": 2024, "series": 1, "raceId": 5376}

Auth: none needed.

Today's games from the live CDN scoreboard: matchups, period/clock state, live scores and game ids. The fastest way to get today's gameId values for nba_boxscore / nba_playbyplay.

Returns: {scoreboard:{gameDate, games:[{gameId, gameStatus, gameStatusText, period, gameClock, homeTeam, awayTeam}]}}

Example: Today's NBA scoreboard.

Auth: none needed.

Full league schedule for the current season (every game, date, broadcasters, arena). Large payload (~8 MB) — prefer nba_scoreboard_today for just today.

Returns: {leagueSchedule:{seasonYear, gameDates:[{gameDate, games:[{gameId, homeTeam, awayTeam, ...}]}]}}

Example: Whole-season schedule.

Auth: none needed.

Live/final box score for one game from the CDN: per-player and per-team stat lines, by period. gameId comes from nba_scoreboard_today or nba_schedule.

Returns: {game:{gameId, homeTeam:{teamId, players:[{name, statistics}]}, awayTeam:{...}}}

Example: Box score for one game. {"gameId": "0022300001"}

Auth: none needed.

Event-level play-by-play log for one game from the CDN: every action with clock, score, player and description. gameId from nba_scoreboard_today / nba_schedule.

Returns: {game:{gameId, actions:[{actionNumber, period, clock, scoreHome, scoreAway, description}]}}

Example: Play-by-play for one game. {"gameId": "0022300001"}

Auth: none needed.

Sportsbook odds for today's games from the live CDN odds feed (spread, money line, total per game and book).

Returns: {games:[{gameId, markets:[{name, books:[{name, outcomes:[...]}]}]}]}

Example: Today's game odds.

Auth: none needed.

Projected/confirmed starting lineups for a date's games, from the stats.nba.com JS data feed. date is YYYYMMDD.

Returns: {games:[{gameId, homeTeam, awayTeam, lineups}]} (feed shape varies)

Example: Daily lineups for a date. {"date": "20260101"}

Auth: none needed.

Gateway to the stats.nba.com /stats/ analytics API (138 operations). Supply an operation (the /stats/ path segment, e.g. "leaguedashplayerstats", "shotchartdetail", "boxscoretraditionalv3", "playercareerstats") plus a query_params map; each operation already carries NBA's full default param set, so override only the fields you need (e.g. {Season: "2024-25", PlayerID: "201939"}). Browse every operation, its required params and its defaults in the nba://stats/operations resource. Most responses are column-oriented ({resultSets:[{name, headers, rowSet}]}); zip headers with each row.

Returns: (JSON object)

Auth: none needed.

Every NBL season (~73: NBL27, NBL26, blitz/preseason/tournament variants…), each with id (UUID), name, year (season start year), season_type, the Genius external_id, and start/end dates. The discovery entry point — take a season's id for nbl_stat_leaders, or its year for the year-scoped feeds. Current regular season is the latest year with season_type=regular.

Returns: {type, count, source, data:[{id, name, year, season_type, external_id, start_date, end_date, competition}]}

Auth: none needed.

The current season(s). Convenience shortcut over nbl_seasons; may return empty in the deep off-season (the call still resolves). Use limit to cap rows.

Returns: {type, count, data:[{id, name, year, season_type, external_id, start_date, end_date}]}

Auth: none needed.

The NBL club catalogue (~78 incl. historical/relocated franchises) — each with id (UUID), name, team_code, team_nickname, logos and brand colours. Join team_id from nbl_players / nbl_schedule back to here.

Returns: {type, count, data:[{id, external_id, name, team_code, team_nickname, team_logo, color_primary, color_secondary}]}

Auth: none needed.

The NBL ladder (standings) for one season — 10 clubs with position, played/won/lost, points_percentage, win_percentage, points_for/against, last_5 and current streak. year is the season start year (2025 = current NBL26).

Returns: {type, count, data:[{id, position, played, won, lost, points_percentage, win_percentage, points_for, points_against, last_5, streak, team}]}

Example: Current-season ladder {"year": 2025, "seasonType": "regular"}

Auth: none needed.

Every match for one season — each with start_time, round, match_status (complete/upcoming/live), home/away scores, attendance, match_slug/title, a play_by_play flag, the Genius external_id, and full home_team/away_team objects (name, team_code, logos, colours). seasonType=all for the whole season.

Returns: {type, count, data:[{id, external_id, start_time, round, match_status, home_score, away_score, attendance, match_slug, match_title, play_by_play, home_team:{id, name, team_code, team_logo, color_primary}, away_team:{…}}]}

Example: Full NBL26 schedule + results {"year": 2025, "seasonType": "all"}

Auth: none needed.

Per-team match outcomes (results) for a season — win/loss rows by team, for head-to-head and form analysis.

Returns: {type, count, data:[{team, …per-match outcome rows}]}

Auth: none needed.

Upcoming matches across all NBL teams for a season (empty in the deep off-season). For the full fixture incl. completed games use nbl_schedule.

Returns: {type, count, data:[{id, start_time, round, home_team, away_team}]}

Auth: none needed.

All players for one season (~165) — each with jersey_number, playing_position and embedded player {id, first_name, last_name, …}, team and season objects. The player id (UUID) feeds nbl_player_stats / nbl_player_boxscores.

Returns: {type, count, data:[{jersey_number, playing_position, player:{id, first_name, last_name}, team:{id, name, team_code}, season}]}

Example: All NBL26 players {"year": 2025}

Auth: none needed.

One team's roster for a season. teamId comes from the team objects in nbl_players / nbl_schedule / nbl_ladder.

Returns: {type, count, data:[{jersey_number, playing_position, player:{id, first_name, last_name}, team}]}

Auth: none needed.

Season statistics for one player — points/rebounds/assists/blocks/steals/turnovers and their per-game averages, shooting splits (field goals / three-pointers / free throws made-attempted-percentage), fouls, minutes. playerId is the player UUID from nbl_players.

Returns: {type, count, data:[{points_average, rebounds_total_average, assists_average, blocks_average, steals_average, turnovers_average, field_goals_percentage, three_pointers_percentage, free_throws_percentage, fouls_average, minutes}]}

Auth: none needed.

Game-by-game box scores for one player across a season — per match the points/rebounds/assists/blocks/steals/turnovers and playing position. The score-series / game-log source.

Returns: {type, count, data:[{period, playing_position, points, rebounds, assists, blocks, steals, turnovers}]}

Auth: none needed.

Team statistics for a season — totals and per-game averages across assists, rebounds (offensive/defensive), blocks, steals, turnovers, and shooting (field goals / three-pointers / free throws made-attempted-percentage).

Returns: {type, count, data:[{team, assists, assists_average, defensive_rebounds, blocks, steals, turnovers, field_goals_made, field_goals_attempted, field_goals_percentage, three_pointers_percentage}]}

Example: Team stats, current season {"year": 2025, "seasonType": "regular"}

Auth: none needed.

Season statistical leaders (points/rebounds/assists/etc. averages, per player) for one season — pass the season UUID (seasonId) from nbl_seasons (data[].id), NOT the year. Use limit to cap rows (limit=-1 for all).

Returns: {type, count, data:[{player, team, points_average, rebounds_total_average, assists_average, field_goals_percentage, three_pointers_made_average, …}]}

Example: Top 50 scorers for NBL26 {"seasonId": "1f8e4a79-e98b-457b-85a5-e4b898c6c0bd", "limit": 50, "sort": "-points_average"}

Auth: none needed.

NBL news articles (latest ~200) — each with title, slug, body (HTML), excerpt, sub_headline, byline, published_date, categories/tags, a related_player and match_slug link, and featured_image_url. NOTE: this feed returns a RAW ARRAY (not the {type,count,data} envelope). Use limit to cap rows.

Returns: array of {id, status, title, slug, body, excerpt, sub_headline, byline, published_date, categories, tags, related_player, match_slug, featured_image_url, likes} (RAW ARRAY, not enveloped)

Example: Latest 10 NBL articles {"limit": 10}

Auth: none needed.

Current scoreboard for one college sport and division — games with scores, state and clock.

Returns: {updated_at, games:[{game:{gameID, startDate, startTime, gameState, currentPeriod, contestClock, home:{names:{short, full}, score, winner, conferences}, away:{…}, url, network}}]} — note each entry is a one-key object wrapping game

Example: FBS football scoreboard {"sport": "football", "division": "fbs"}

Auth: none needed.

Conference standings for a college sport and division.

Returns: {sport, title, updated, page, pages, data:[{conference:'ACC', standings:[{School, 'Conference W', 'Conference L', 'Overall W', 'Overall L', 'Overall PF', 'Overall PA', 'Overall HOME', 'Overall AWAY', 'Overall STREAK'}]}]} — GROUPED BY CONFERENCE: data[] is one entry per conference, each holding its own standings list. The inner column names are human-readable strings WITH SPACES and vary by sport; all values are strings.

Example: FBS football standings {"sport": "football", "division": "fbs"}

Auth: none needed.

Poll rankings — AP, coaches and others — for a college sport and division.

Returns: {sport, title, updated, page, pages, data:[{RANK, SCHOOL, POINTS, PREVIOUS, RECORD}]} — keys here are UPPERCASE, unlike standings

Example: AP football poll {"sport": "football", "division": "fbs", "poll": "associated-press"}

Auth: none needed.

Every season the standings API covers, with its start/end dates and which rules applied — call this to get valid season ids.

Returns: {currentDate, seasons:[{id:20242025, standingsStart, standingsEnd, conferencesInUse, divisionsInUse, tiesInUse, wildcardInUse, pointForOTlossInUse}]} — id is the concatenated-year season format every other tool wants

Example: All seasons

Auth: none needed.

A club's full roster for one season, split into forwards / defensemen / goalies with bio, height/weight, shoots-catches and birthplace.

Returns: {forwards:[…], defensemen:[…], goalies:[{id, firstName, lastName, sweaterNumber, positionCode, shootsCatches, heightInInches, weightInPounds, birthDate, birthCity, birthCountry, headshot}]} — three parallel arrays, NOT one players list

Example: Toronto's 2024-25 roster {"team": "TOR", "season": "20242025"}

Auth: none needed.

One player's landing page: bio, draft details, current season splits, career totals and awards.

Returns: {playerId, firstName, lastName, position, sweaterNumber, currentTeamAbbrev, birthDate, birthCity, birthCountry, draftDetails:{year, round, overallPick, teamAbbrev}, featuredStats, careerTotals:{regularSeason, playoffs}, seasonTotals:[…], awards:[{trophy, seasons}]}

Example: Connor McDavid {"playerId": 8478402}

Auth: none needed.

League schedule for the current week (or a given date's week), grouped by day.

Returns: {gameWeek:[{date, dayAbbrev, numberOfGames, games:[{id, startTimeUTC, gameState, gameType, homeTeam:{abbrev, score}, awayTeam:{…}, venue}]}], regularSeasonStartDate, regularSeasonEndDate, playoffEndDate, nextStartDate, previousStartDate}

Example: This week's games {"date": "now"}

Auth: none needed.

One club's entire season schedule with results — the team game log.

Returns: {games:[{id, gameDate, gameType, gameState, homeTeam:{abbrev, score}, awayTeam:{abbrev, score}, gameOutcome:{lastPeriodType}, venue, neutralSite}], currentSeason, previousSeason, nextSeason, clubTimezone} (~200 KB for a full season)

Example: Toronto's full 2024-25 season {"team": "TOR", "season": "20242025"}

Auth: none needed.

Live scoreboard: every game on a date with current score, clock and period.

Returns: {currentDate, prevDate, nextDate, games:[{id, gameState, gameScheduleState, startTimeUTC, homeTeam:{abbrev, score, sog}, awayTeam:{…}, clock:{timeRemaining, running, inIntermission}, periodDescriptor:{number, periodType}, goals:[…]}], gameWeek:[…]}

Example: Today's scores {"date": "now"}

Auth: none needed.

Full box score for one game: both lineups with goals, assists, plus-minus, shots, hits, blocks and time on ice.

Returns: {id, gameDate, gameState, gameOutcome, homeTeam:{abbrev, score, sog}, awayTeam:{…}, playerByGameStats:{homeTeam:{forwards:[{playerId, name, goals, assists, points, plusMinus, sog, hits, blockedShots, toi}], defense:[…], goalies:[…]}, awayTeam:{…}}, clock, periodDescriptor}

Example: One completed game {"gameId": 2024020500}

Auth: none needed.

Game landing page: scoring summary by period, three stars, penalties and team game stats.

Returns: {id, gameDate, gameState, homeTeam, awayTeam, summary:{scoring:[{periodDescriptor, goals:[{timeInPeriod, firstName, lastName, assists, strength}]}], penalties:[…], threeStars:[…], teamGameStats:[…]}, clock}

Example: One completed game {"gameId": 2024020500}

Auth: none needed.

League standings with division/conference/wildcard sequencing and clinch indicators.

Returns: {standings:[{teamName:{default}, teamAbbrev:{default}, conferenceName, divisionName, gamesPlayed, wins, losses, otLosses, points, pointPctg, goalFor, goalAgainst, goalDifferential, divisionSequence, conferenceSequence, wildcardSequence, l10Wins, streakCode, streakCount, clinchIndicator}], wildCardIndicator, standingsDateTimeUtc}

Example: Current standings {"date": "now"}

Auth: none needed.

League leaders among skaters — goals, assists, points, plus-minus, power-play and short-handed goals, penalty minutes, ice time.

Returns: {goals:[{id, firstName:{default}, lastName:{default}, teamAbbrev, position, value, headshot}], assists:[…], points:[…], plusMinus:[…], goalsPp:[…], goalsSh:[…], penaltyMins:[…], toi:[…]} — one array per category

Example: Current season leaders {"season_or_current": "current", "limit": 10}

Auth: none needed.

League leaders among goalies — wins, save percentage, goals-against average and shutouts.

Returns: {wins:[{id, firstName:{default}, lastName:{default}, teamAbbrev, value, headshot}], savePctg:[…], goalsAgainstAverage:[…], shutouts:[…]}

Example: Current goalie leaders {"season_or_current": "current", "limit": 10}

Auth: none needed.

Global Champion Data competition catalogue. Returns every competition id (NRL, State of Origin, plus other Champion Data sports) with its season and round count. Find the NRL competitionId here (e.g. 12999 = 2026 NRL Premiership, 13009 = 2026 State of Origin) to pass to nrl_fixture / nrl_match.

Returns: {competitionDetails:{competition:[{id, name, season, rounds, regulationPeriods, regulationPeriodLength}]}}

Example: All Champion Data competitions (filter client-side for NRL by name/season).

Auth: none needed.

NRL match-centre application config: the current-season competition list (competitionList), stat-grid column layouts (dataGrids), UI components and team/competition image paths. Handy for discovering the active competitionIds and which statistics the official site surfaces.

Returns: {applicationInfo, userInfo, competitionList, components, dataGrids, shellGroups}

Example: Current NRL competition list + stat-grid config.

Auth: none needed.

Full fixture + results for one competition. One entry per match with round, status, kickoff times (local + UTC), home/away squad ids/names/scores and venue. Use it to list a round's games and to resolve the matchId for nrl_match.

Returns: {fixture:{match:[{matchId, roundNumber, matchStatus, utcStartTime, localStartTime, homeSquadId, homeSquadName, homeSquadScore, awaySquadId, awaySquadName, awaySquadScore, venueId, venueName}]}}

Example: Every 2026 NRL Premiership match (round + result). {"competitionId": 12999}

Auth: none needed.

Full match file: per-player match statistics (tries, tackles, runMetres, lineBreaks, tryAssists, offloads, handlingErrors, metresGained, …), per-period player stats, team/player rosters, period durations, sin bins and on-report records. This is the per-player, per-match stat source. Decode stat codes via the nrl://stats/definitions resource.

Returns: {matchStats:{matchInfo, teamInfo:{team[]}, playerInfo:{player[]}, periodInfo:{qtr[]}, playerStats:{player[]}, playerPeriodStats:{player[]}, sinBins:{binned[]}, reports:{onReport[]}, created}, jobId}

Example: Knights v Cowboys, round 1 2026 — full player stat lines. {"competitionId": 12999, "matchId": 129990101}

Auth: none needed.

The 34 sports covered, with the slug every other tool needs. VERIFIED live — works without a key.

Returns: [{name:'Football', slug:'football'}] — VERIFIED live: 34 entries, slugs include football, basketball, tennis, baseball, american-football, ice-hockey, esports, darts, mixed-martial-arts, boxing, handball, volleyball, snooker, table-tennis, rugby, cricket, aussie-rules, gaelic-football, padel, bandy, golf, cycling.

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 sport

Auth: needs your own key in ODDS_API_IO_KEY.

The 274 bookmakers indexed, and whether each is currently active. VERIFIED live — works without a key.

Returns: [{name:'10BET', active:true}] — VERIFIED live: 274 entries, 263 active. Names are the vendor's own spelling and are what the odds calls filter on.

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 bookmaker

Auth: needs your own key in ODDS_API_IO_KEY.

Leagues within a sport. NEEDS A KEY.

Returns: [{id, name, country, sport}] — 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: Football leagues {"sport": "football"}

Auth: needs your own key in ODDS_API_IO_KEY.

Upcoming events for a sport or league, without prices. NEEDS A KEY.

Returns: [{id, sport, league, home, away, starts, status}] — 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: Upcoming football {"sport": "football"}

Auth: needs your own key in ODDS_API_IO_KEY.

Odds for one event across the indexed bookmakers. NEEDS A KEY.

Returns: {id, home, away, starts, bookmakers:{'':{markets…}}} — SHAPE FROM VENDOR DOCS. Reported to key bookmakers by NAME rather than as a list; inspect what you receive before indexing.

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 event's odds {"eventId": ""}

Auth: needs your own key in ODDS_API_IO_KEY.

The hero catalogue — id, name, primary attribute, attack type and roles.

Returns: [{id, name:'npc_dota_hero_antimage', localized_name:'Anti-Mage', primary_attr:'agi', attack_type:'Melee', roles:[str], legs}] (top-level array, ~127 heroes)

Example: All heroes

Auth: none needed.

Per-hero win and pick counts broken down by skill bracket — the hero meta.

Returns: [{id, localized_name, pro_pick, pro_win, pro_ban, 1_pick, 1_win, …, 8_pick, 8_win}] — the numeric prefixes are skill brackets (1=lowest … 8=highest); win rate is _win / _pick, NOT a percentage field

Example: Hero meta across brackets

Auth: none needed.

Professional teams ranked by rating, with win/loss records.

Returns: [{team_id, name, tag, rating, wins, losses, last_match_time, logo_url}] (~250 KB, ordered by rating)

Example: Pro teams by rating

Auth: none needed.

Every Dota 2 league/tournament OpenDota knows. LARGE (~1 MB) — includes years of historical events.

Returns: [{leagueid, name, tier:'premium'|'professional'|'amateur', ticket, banner}] (~1 MB — filter client-side by tier)

Example: All leagues

Auth: none needed.

Recent professional matches with teams, league, duration and result.

Returns: [{match_id, duration, start_time, radiant_team_id, radiant_name, dire_team_id, dire_name, leagueid, league_name, series_id, series_type, radiant_score, dire_score, radiant_win}] — Dota sides are RADIANT and DIRE, not home/away; radiant_win is the result

Example: Latest pro matches

Auth: none needed.

Full detail for one match: every player's hero, items, KDA, gold/XP curves and objectives. LARGE (~250 KB).

Returns: {match_id, duration, radiant_win, radiant_score, dire_score, league, players:[{account_id, hero_id, player_slot, kills, deaths, assists, gold_per_min, xp_per_min, last_hits, hero_damage, items, gold_t:[…], xp_t:[…]}], objectives, picks_bans, teamfights} — player_slot < 128 means Radiant

Example: One professional match {"match_id": 8937822821}

Auth: none needed.

A sample of recent public (non-professional) matches — the ladder meta rather than the pro scene.

Returns: [{match_id, start_time, duration, avg_rank_tier, radiant_win, radiant_team:[hero_id], dire_team:[hero_id]}] — hero ids only, no player identity

Example: Recent public matches

Auth: none needed.

A player's profile with rank tier and estimated MMR.

Returns: {profile:{account_id, personaname, name, avatarfull, steamid, country_code, is_pro}, rank_tier, leaderboard_rank, competitive_rank} — rank_tier is two digits: tens=medal (1 Herald … 8 Immortal), units=star

Example: One player's profile {"account_id": 88367253}

Auth: none needed.

A player's recent matches with hero, result and KDA.

Returns: [{match_id, player_slot, radiant_win, duration, hero_id, kills, deaths, assists, start_time, lane_role}] — you won a match when (player_slot < 128) == radiant_win

Example: Last 20 matches {"account_id": 88367253, "limit": 20}

Auth: none needed.

A player's win/loss totals, with the same filters as their match list.

Returns: {win, lose} — two integers

Example: Career win/loss {"account_id": 88367253}

Auth: none needed.

Which heroes a player uses and how they perform on each.

Returns: [{hero_id, games, win, with_games, with_win, against_games, against_win, last_played}] — ordered by games played; join hero_id via opendota_heroes

Example: Hero pool {"account_id": 88367253}

Auth: none needed.

Grand Prix weekends (meetings). Filter by year/country, or pass meeting_key=latest for the current event.

Returns: [{meeting_key, meeting_name, meeting_official_name, country_name, country_code, circuit_short_name, location, year, date_start}] (top-level array)

Auth: none needed.

F1 sessions (Practice / Qualifying / Sprint / Race). This is the fixtures feed — filter by year, country or session_name to find a session_key.

Returns: [{session_key, session_name, session_type, date_start, date_end, meeting_key, circuit_short_name, country_name, year}] (top-level array)

Auth: none needed.

Drivers entered in a session — number, name, acronym, team and colours. Pass session_key (or 'latest').

Returns: [{driver_number, full_name, name_acronym, broadcast_name, team_name, team_colour, headshot_url, session_key, meeting_key}] (top-level array)

Auth: none needed.

Final classification of a session — per-driver position, laps, points, gap, DNF/DNS/DSQ flags.

Returns: [{position, driver_number, number_of_laps, points, dnf, dns, dsq, duration, gap_to_leader, session_key}] (top-level array)

Auth: none needed.

Race starting grid — per-driver grid position and lap time. (Sparse feed: OpenF1 returns a 404 'No results found' for sessions where no grid is published, which is currently most of them.)

Returns: [{position, driver_number, lap_duration, session_key, meeting_key}] (top-level array)

Auth: none needed.

Drivers' championship standings around a race — points and position before/after the session.

Returns: [{driver_number, position_start, position_current, points_start, points_current, session_key}] (top-level array)

Auth: none needed.

Constructors' championship standings around a race — points and position before/after the session.

Returns: [{team_name, position_start, position_current, points_start, points_current, session_key}] (top-level array)

Auth: none needed.

Overtake events in a race — who passed whom, when, and for which position.

Returns: [{date, overtaking_driver_number, overtaken_driver_number, position, session_key}] (top-level array)

Auth: none needed.

Per-lap timing for a driver — lap + sector durations, speed-trap (i1/i2/st) speeds, mini-sector segment colours, pit-out flag.

Returns: [{driver_number, lap_number, lap_duration, duration_sector_1/2/3, i1_speed, i2_speed, st_speed, is_pit_out_lap, segments_sector_1/2/3, date_start}] (top-level array)

Auth: none needed.

Pit stops — lap, total time in pit lane and stationary stop duration per driver.

Returns: [{date, driver_number, lap_number, pit_duration, lane_duration, stop_duration, session_key}] (top-level array)

Auth: none needed.

Tyre stints — compound and tyre age per driving period (lap_start → lap_end).

Returns: [{stint_number, driver_number, lap_start, lap_end, compound, tyre_age_at_start, session_key}] (top-level array)

Auth: none needed.

Live gap data during a race — each driver's gap to the leader and interval to the car ahead, sampled over time.

Returns: [{date, driver_number, gap_to_leader, interval, session_key}] (top-level array)

Auth: none needed.

Driver track position over time — position changes throughout a session.

Returns: [{date, driver_number, position, session_key, meeting_key}] (top-level array)

Auth: none needed.

Car telemetry at ~3.7 Hz — speed, throttle, brake, gear, RPM, DRS. HIGH VOLUME: always pass session_key + driver_number.

Returns: [{date, driver_number, speed, throttle, brake, n_gear, rpm, drs, session_key}] (top-level array; large — use date>=/date<= operators on the raw API to window it)

Auth: none needed.

Car (x, y, z) track position at ~3.7 Hz. HIGH VOLUME: always pass session_key + driver_number (and ideally a date window on the raw API).

Returns: [{date, driver_number, x, y, z, session_key}] (top-level array; large)

Auth: none needed.

Race-control messages — flags, safety cars, incidents, investigations, penalties — the official message feed.

Returns: [{date, category, flag, scope, sector, lap_number, driver_number, message, session_key}] (top-level array)

Auth: none needed.

Team-radio clips — recording URLs of driver/pit-wall radio exchanges during a session.

Returns: [{date, driver_number, recording_url, session_key, meeting_key}] (top-level array)

Auth: none needed.

Also answers this: afl_live_audio.

Track weather, updated ~once a minute — air/track temperature, humidity, pressure, wind, rainfall.

Returns: [{date, air_temperature, track_temperature, humidity, pressure, wind_speed, wind_direction, rainfall, session_key}] (top-level array)

Auth: none needed.

Every competition + season OpenLigaDB carries — call this to find the league shortcut and season year the other tools need.

Returns: [{leagueId, leagueName, leagueShortcut:'bl1', leagueSeason:'2024', sport:{sportId, sportName}}] (~819 entries, ~120 KB)

Example: All competitions

Auth: none needed.

The clubs contesting one league season.

Returns: [{teamId, teamName, shortName, teamIconUrl, teamGroupName}]

Example: 2024/25 Bundesliga clubs {"league": "bl1", "season": "2024"}

Auth: none needed.

The matchdays ('groups') in a season — OpenLigaDB calls a Spieltag a 'group'.

Returns: [{groupID, groupName:'1. Spieltag', groupOrderID}] — groupOrderID is the matchday number the match tools take

Example: Bundesliga matchdays {"league": "bl1", "season": "2024"}

Auth: none needed.

Which matchday a league is currently on — resolve 'this week' without guessing.

Returns: {groupID, groupName:'1. Spieltag', groupOrderID} — a single object, not a list

Example: Current Bundesliga matchday {"league": "bl1"}

Auth: none needed.

Every match in a league season with results. LARGE (~550 KB for a Bundesliga season) — prefer the matchday tool.

Returns: [{matchID, matchDateTime, matchDateTimeUTC, timeZoneID, leagueName, leagueSeason, group:{groupName, groupOrderID}, team1:{teamId, teamName}, team2:{…}, matchIsFinished, matchResults:[{resultName:'Endergebnis'|'Halbzeit', pointsTeam1, pointsTeam2}], goals:[…], location}]

Example: Whole 2024/25 Bundesliga season {"league": "bl1", "season": "2024"}

Auth: none needed.

One matchday's fixtures and results — the everyday call.

Returns: Same shape as openligadb_season_matches, restricted to one matchday (~9 matches for the Bundesliga)

Example: Matchday 1 of 2024/25 {"league": "bl1", "season": "2024", "matchday": 1}

Auth: none needed.

One match by id, with goals and scorers.

Returns: {matchID, matchDateTime, team1, team2, matchIsFinished, matchResults:[…], goals:[{goalID, scoreTeam1, scoreTeam2, matchMinute, goalGetterName, isPenalty, isOwnGoal}], location}

Example: A single match {"matchId": 66222}

Auth: none needed.

The league table for a season.

Returns: [{teamInfoId, teamName, shortName, points, opponentGoals, goals, matches, won, lost, draw, goalDiff, teamIconUrl}] — ordered top to bottom; goals is scored, opponentGoals is conceded

Example: Bundesliga table {"league": "bl1", "season": "2024"}

Auth: none needed.

The titles PandaScore covers, with the slug every other tool needs. Call this first rather than guessing a slug.

Returns: [{id, name:'Counter-Strike', slug:'cs-go', current_version}] (top-level array) — 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 titles

Auth: needs your own key in PANDASCORE_TOKEN.