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

Get a single competition by integer id.

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

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

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

List comp seasons within one competition.

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

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

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

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

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

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

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

Example: 2026 AFL ladder

List calendar-year season records.

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

Get a single calendar-year season by id.

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

List AFL/AFLW clubs (32).

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

Get a single club by id.

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

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

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

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

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

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

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

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

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

Get a single venue by id.

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

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

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

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

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

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

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

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

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

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

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

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

List broadcast regions (26) with timezones.

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

Get a single broadcast region by id.

Returns: {id, name, timezone}

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

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

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

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

Broadcast schedule — one entry per match per channel.

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

Get a single broadcast event by id.

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

Broadcast events scoped to one (compseason, round).

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

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

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

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

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

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

Get a single text article by id.

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

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

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

Get a single video content item by id.

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

List photo content.

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

Get a single photo content item by id.

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

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

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

Get a single promo content item by id.

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

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

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

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)

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)

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

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}]}]}]}]}

Cash-out availability for one or more markets.

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

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

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

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

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)

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

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

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)

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

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

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}]}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Example: Basketball competitions

Events + markets for one sport category (competition).

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

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}]}

Categories that currently have Popular Same Game Multis.

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

Popular Same Game Multi suggestions for one master event.

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

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

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

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

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

All visible promotions (name, description, dates).

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

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

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

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

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

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}

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

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

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}]}

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}

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

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

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}

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}

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}

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}]}

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)

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, ...}]}

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, ...}]}

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}]}}

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)

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}]}

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

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

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)

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}]}

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}]}

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}]}

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:[...]}

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, ...}]}

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}]}

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}]}

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}]}

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, ...}]}

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}]}