Reference

Data reference

234 entries, folded

Objects

Every object the API returns, field by field — generated from the same schemas the API validates its output against (also published as OpenAPI 3.1). Every field is always present: null when the source has no value, never absent (fields marked ? appear only in WebSocket patches). Units are in the field name or shown next to it; instants are ISO-8601 UTC, dates YYYY-MM-DD.

FixtureA match. The same object on every endpoint and in WebSocket snapshots.36 fields

Field	Type	Meaning
id	`integer`	Our fixture id.
sport	`string`	Sport slug (as in /v2/sports).
status	`Status`	Match status.
startTime	`string (ISO-8601 UTC) \| null`	Start time: the scheduled start, replaced by the recorded kick-off once the source records it (the live feed sends it a few minutes after the start). The same value on every endpoint and in WebSocket deltas.
league	`LeagueRef \| null`	The competition. null when the source files the fixture under a competition it has no league for — seen on minor regional football (South Africa’s National Second Division, 2026-10-23); season and round are then null too.
season	`Season \| null`	The season.
round	`Round \| null`	The round, when the competition has rounds.
home	`TeamRef \| null`	Home side; null while the side is not decided yet (the source’s placeholder such as "WQF1", winner of quarter-final 1).
away	`TeamRef \| null`	Away side; null while the side is not decided yet (the source’s placeholder such as "WQF1").
homeScore	`ScoreSide`	One side’s score.
awayScore	`ScoreSide`	One side’s score.
winner	`Winner \| null`	Null until status.type is finished, and for a fight ruled a no contest (`fightResult.method` noContest). A match finished on penalties: the shoot-out winner, whatever the source says (on a second leg the source names the side that won the 90 minutes). Named from the score when the source leaves it out, or calls a match draw in a sport that cannot draw (regular time or overtime finishes; not cricket).
venue	`Venue \| null`	Venue, when known (often null in lower tiers). Filled on /fixtures/{id} and, when the source lists it, in date lists; the source’s round, team, player and live lists carry no venue, so null there means "not included", not "unknown" — read /fixtures/{id} for it.
clock	`Clock \| null`	Match clock; null when the source has none for the fixture and once it is over.
firstToServe	`Side \| null`	Deprecated (2026-10-23): the same value as `serving`. The source updates this field every game / leg, so it is the side serving (throwing) NOW, not who served first — read `serving`.
serving	`Side \| null`	Tennis / darts / other serve sports: the side serving (throwing) now, as the source updates it every game / leg. Null when the source does not say.
homeSeed	`string \| null`	Seeded competitions — tennis draws, playoff seeding (basketball, …): the home side’s seed ("1", "12") or entry status ("WC" wild card, "Q" qualifier, "LL" lucky loser, "PR" protected ranking, …), as the draw prints it. Null when unseeded.
awaySeed	`string \| null`	The away side’s seed or entry status, like homeSeed.
note	`string \| null`	Cricket: the source’s match note — the result line once finished ("Pakistan beat Sri Lanka by 37 runs"). Display only.
battingSide	`Side \| null`	Cricket: the side batting now. Null when no innings is in progress and for other sports.
fightResult	`FightResult \| null`	MMA / boxing: method, round and time of the finish. Null until status.type is finished, and when the source has no method.
fightDiscipline	`FightDiscipline \| null`	Combat sports (sport `mma`, which also carries boxing, kickboxing and Muay Thai cards): the discipline of this fight, when the source tags it. The source tags only some cards (ONE, Queensbury, some OKTAGON fights; not UFC or PFL), so null does not mean MMA.
referee	`Referee \| null`	The referee, when the source names one (football and some other sports; cricket: the match referee). Filled on /fixtures/{id}; lists carry null (not included).
homeManager	`ManagerRef \| null`	The home side’s manager / head coach for this fixture, when the source names one. Filled on /fixtures/{id}; lists carry null.
awayManager	`ManagerRef \| null`	The away side’s manager / head coach, like homeManager.
surface	`Surface \| null`	Tennis: the court surface. Filled on /fixtures/{id} and live lists; null for other sports.
toss	`CricketToss \| null`	Cricket: the toss, once made. Filled on /fixtures/{id}; null for other sports.
umpires	`string[] \| null`	Cricket: the on-field umpires as the source names them (often with a country code: "Asif Yaqoob (PAK)"); null when not listed and for other sports.
tvUmpire	`string \| null`	Cricket: the TV (third) umpire, like umpires.
previousLegFixtureId	`integer \| null`	Two-legged ties and playoff series: our id of the previous leg / game of the tie, when the source links it. Read /fixtures/{id} of it for the first-leg score.
aggregateWinner	`Side \| null`	Second leg of a two-legged tie: the side that went through, once finished — the source’s verdict, else read from `aggregated` (higher wins) or, level on aggregate, the shoot-out. Null otherwise, and on a level aggregate the source does not settle (an away-goals rule). `winner` is this match’s winner: on a second leg decided on penalties both name the shoot-out winner; otherwise the two can differ (a side can win the second leg and go out). Filled on /fixtures/{id}; lists and live snapshots may carry null (not included).
fightCard	`FightCard \| null`	MMA / boxing: card section, order and weight class of the bout, when the source lists them.
attendance	`integer \| null`	Spectators, when the source reports it (seen on NBA and MLB games, often only once the game is under way). Filled on /fixtures/{id}; lists carry null (not included).
matchFormat	`MatchFormat \| null`	Darts and esports: the match format (best of N sets / legs / games), when the source gives it; null for other sports.
inningState	`InningState \| null`	Baseball: the game state in play (inning, half, balls, strikes, outs, runners on base). Null unless the game is in progress (or interrupted), and for other sports. Live: in WebSocket deltas.
timeouts	`Timeouts \| null`	Basketball: timeouts left per side. Null unless the game is in progress (or interrupted), and when the source does not track them. Live: in WebSocket deltas.

StatusMatch status.6 fields

Field	Type	Meaning
type	`StatusType`	Coarse state: derived from `phase` (see the StatusPhase table).
phase	`StatusPhase`	Fine state, derived from `code`.
code	`integer \| null`	The source’s status code — the full table is in the data dictionary. `phase`, `period` and `finish` already decode it.
description	`string \| null`	English label for display, from our status table (the data dictionary’s status codes), sport-aware: e.g. "2nd half", "Halftime", "After extra time" (football), "After overtime" (basketball, ice hockey, …), "After extra innings" (baseball), "After penalties", "1st innings" (cricket), "Coverage canceled". The source’s own text only for a code we do not know. Do not branch on it.
period	`PeriodKey \| null`	The period in play (or, during a break, the one just played). Null before the start and once over.
finish	`FinishType \| null`	How the match was decided; null unless `type` is finished.

ScoreSideOne side’s score.12 fields

Field	Type	Meaning
current	`number \| null`	The score as a scoreboard shows it: goals, points, sets won (tennis / volleyball), runs (cricket, baseball), extra time / overtime included. A penalty shoot-out is NOT included — it is in `penalties` — except in ice hockey, whose scoring credits the shoot-out winner with one goal (3-3 after overtime → 3-4). Null before the start, and on a fixture whose coverage was canceled.
periods	`Record<PeriodKey, number>`	Score per period, keyed by PeriodKey: goals per half / quarter / period, games per set (tennis), points per set (volleyball, table tennis), runs per inning (baseball). Extra time is here too: `extra1` / `extra2` (football, futsal), `overtime` (basketball, ice hockey, handball, American football, water polo, …), `period10`… (baseball extra innings; `overtime` only when the source gives the extra-innings runs as a total). The values add up to `current` when the source’s breakdown is complete (it sometimes is not: some baseball leagues send no innings, a few futsal matches miss a half) — ice hockey after a shoot-out is one goal short by design (see `current`). Esports: one key per game (map), and what the source counts there depends on the title — Counter-Strike 1 for the side that won map N and 0 otherwise (maps not played 0, up to period5 in a best of 3), League of Legends the side’s kills in game N (so they do not add up to `current`, which counts games won); read /fixtures/{id}/games for each game’s winner and score. Empty when the source has none.
tieBreaks	`Record<PeriodKey, number>`	Tennis: tie-break points of a set, keyed like `periods` (e.g. { "period2": 7 }).
normalTime	`number \| null`	Score at the end of regulation time, when the source gives it.
penalties	`number \| null`	Penalty shoot-out score (goals scored in the shoot-out). Ice hockey: 1 for the shoot-out winner and 0 for the loser — the goal `current` credits.
aggregated	`number \| null`	Aggregate over a two-legged tie.
series	`number \| null`	Playoff series: games won in the series so far (basketball, baseball, ice hockey, water polo).
point	`string \| null`	Tennis: the current game score, "0" \| "15" \| "30" \| "40" \| "A" (tie-break points as numbers, "0"–"N"). Null unless play is in progress or interrupted.
redCards	`integer \| null`	Football: red cards shown to the side (second yellows included).
innings	`Record<PeriodKey, CricketInnings>`	Cricket: the side’s innings, keyed inning1…N. Empty for other sports.
hits	`integer \| null`	Baseball: hits (the H of the R/H/E line).
errors	`integer \| null`	Baseball: errors (the E of the R/H/E line).

CricketInningsOne innings of a side in cricket.5 fields

Field	Type	Meaning
runs	`integer \| null`	Runs scored.
wickets	`integer \| null`	Wickets lost.
overs	`number \| null`	Overs bowled, cricket notation (49.5 = 49 overs and 5 balls).
runRate	`number \| null`	Runs per over.
targetRunRate	`number \| null`	Required run rate to reach the target (chasing side).

ClockThe match clock. Running clock (football, rugby, …): elapsed = periodOffsetSeconds + (now − periodStartedAt); minute = floor(elapsed / 60) + 1; past periodEndSeconds show periodEndSeconds / 60 + "+" + the extra minutes. Only while status.phase is inprogress. Stop clock (basketball, handball, ice hockey, …): playedSeconds as of playedAt, ticking only while `running` is true. Set / map sports (tennis, table tennis, badminton, esports): only `periodStartedAt` (when the current set or map started), when the source sends it — often the whole clock is null. Every field is null when the source does not supply it for the sport; the whole clock is null when there is none and once the match is over. Lists other than /fixtures/{id} may carry fewer clock fields (the static ones such as periodLengthSeconds can be null there).12 fields

Field	Type	Meaning
periodStartedAt	`string (ISO-8601 UTC) \| null`	When the current period’s clock started.
periodOffsetSeconds	`number \| null`	Running clock: clock seconds already elapsed when the period started (football 2nd half: 2700).seconds
periodEndSeconds	`number \| null`	Running clock: the clock second at which the period’s regulation time ends (football 1st half: 2700).seconds
maxExtraSeconds	`number \| null`	Running clock: the most added time the source’s display allows beyond periodEndSeconds.seconds
injuryTimeMinutes	`number \| null`	Added time announced for the period in play.minutes
playedSeconds	`number \| null`	Stop clock: seconds played, as of `playedAt`.seconds
playedAt	`string (ISO-8601 UTC) \| null`	When `playedSeconds` was read.
running	`boolean \| null`	Stop clock: whether the game clock is running.
runningUpdatedAt	`string (ISO-8601 UTC) \| null`	When `running` was last updated.
periodLengthSeconds	`number \| null`	Stop clock: regulation length of one period.seconds
overtimeLengthSeconds	`number \| null`	Length of one overtime period.seconds
periodCount	`integer \| null`	Number of regulation periods (combat sports: scheduled rounds).

FightResultMMA / boxing: how a finished fight was decided.3 fields

Field	Type	Meaning
method	`FightMethod`	How it was won.
round	`integer \| null`	The round it ended in.
roundTimeSeconds	`integer \| null`	Time into that round when the fight was stopped (KO, TKO, submission, disqualification, …), when the source has it. Null for a decision (unanimous, split, majority, technical — draws by decision included): the fight was not stopped, and the source’s figure for it is unreliable.seconds

RefereeThe match referee (cricket: the match referee), with the career totals the source keeps — divide by `games` for a per-match rate.9 fields

Field	Type	Meaning
id	`integer`	Our referee id.
name	`string`	Referee name.
slug	`string \| null`	URL slug.
country	`Country \| null`	The referee’s country, when the source gives it.
games	`integer \| null`	Matches the source has recorded the referee in charge of (career, all competitions).
yellowCards	`integer \| null`	Yellow cards shown over those matches; null in sports without cards (cricket).
redCards	`integer \| null`	Straight red cards shown over those matches; null in sports without cards.
yellowRedCards	`integer \| null`	Second-yellow sending-offs over those matches; null in sports without cards.
image	`string (URL) \| null`	Photo on our CDN; null when the referee has no image (or it is not uploaded yet). Since 2026-11-04.

SurfaceTennis: the court the match is played on.3 fields

Field	Type	Meaning
type	`SurfaceType`	A tennis court surface.
indoor	`boolean \| null`	True indoors, false outdoors; null when the source does not say.
name	`string`	The source’s text, e.g. "Hardcourt outdoor". Display only.

CricketTossCricket: the toss.2 fields

Field	Type	Meaning
winner	`Side \| null`	The side that won the toss; null when the source’s team name matches neither side.
decision	`TossDecision \| null`	What it chose.

FightCardMMA / boxing: where a bout sits on its card.3 fields

Field	Type	Meaning
section	`FightCardSection \| null`	Main card, prelims, …, when the source says.
order	`integer \| null`	The bout’s place on the card as the source numbers it (higher = later; the main event has the highest number).
weightClass	`string \| null`	The bout’s weight class as the source names it ("light", "bantam", "feather", …).

FixturePatchThe `changes` of a WebSocket delta: a partial Fixture with the same names and nesting. Deep-merge it onto the Fixture you hold — objects merge key by key, any other value (null included) replaces. Only these fields are ever sent.13 fields

Field	Type	Meaning
status?	`{ type?: StatusType; phase?: StatusPhase; code?: integer \| null; description?: string \| null; period?: PeriodKey \| null; finish?: FinishType \| null }`	The status fields that changed (a status change always re-sends type, phase, finish and, when known, period).
startTime?	`string (ISO-8601 UTC) \| null`	New start time: a reschedule, or the recorded kick-off once the source records it (see Fixture.startTime).
winner?	`Winner \| null`	Set when the match finishes.
homeScore?	`ScoreSidePatch`	The changed part of a ScoreSide.
awayScore?	`ScoreSidePatch`	The changed part of a ScoreSide.
clock?	`{ periodStartedAt?: string (ISO-8601 UTC) \| null; periodOffsetSeconds?: number \| null; periodEndSeconds?: number \| null; maxExtraSeconds?: number \| null; injuryTimeMinutes?: number \| null; playedSeconds?: number \| null; playedAt?: string (ISO-8601 UTC) \| null; running?: boolean \| null; runningUpdatedAt?: string (ISO-8601 UTC) \| null; periodLengthSeconds?: number \| null; overtimeLengthSeconds?: number \| null; periodCount?: integer \| null } \| null`	null = the match is over: drop the clock.
firstToServe?	`Side \| null`	Deprecated: the same value as `serving`.
serving?	`Side \| null`	The side serving (throwing) now.
note?	`string \| null`	Cricket: new match note.
battingSide?	`Side \| null`	Cricket: the side now batting (null = none).
inningState?	`InningState \| null`	Baseball: the new game state, always sent whole; null = no longer in play.
timeouts?	`{ homeRemaining?: integer \| null; awayRemaining?: integer \| null; perTeam?: integer \| null } \| null`	Basketball: the timeout counts that changed; null = no longer in play.
fightResult?	`FightResult \| null`	MMA / boxing: the method, round and time of the finish, sent whole once the source has it — usually in a delta after the finishing one (the source publishes it ~20–60 s after the winner).

ScoreSidePatchThe changed part of a ScoreSide.12 fields

Field	Type	Meaning
current?	`number \| null`	The score as a scoreboard shows it: goals, points, sets won (tennis / volleyball), runs (cricket, baseball), extra time / overtime included. A penalty shoot-out is NOT included — it is in `penalties` — except in ice hockey, whose scoring credits the shoot-out winner with one goal (3-3 after overtime → 3-4). Null before the start, and on a fixture whose coverage was canceled.
normalTime?	`number \| null`	Score at the end of regulation time, when the source gives it.
penalties?	`number \| null`	Penalty shoot-out score (goals scored in the shoot-out). Ice hockey: 1 for the shoot-out winner and 0 for the loser — the goal `current` credits.
aggregated?	`number \| null`	Aggregate over a two-legged tie.
series?	`number \| null`	Playoff series: games won in the series so far (basketball, baseball, ice hockey, water polo).
point?	`string \| null`	Tennis: the current game score, "0" \| "15" \| "30" \| "40" \| "A" (tie-break points as numbers, "0"–"N"). Null unless play is in progress or interrupted.
redCards?	`integer \| null`	Football: red cards shown to the side (second yellows included).
hits?	`integer \| null`	Baseball: hits (the H of the R/H/E line).
errors?	`integer \| null`	Baseball: errors (the E of the R/H/E line).
periods?	`Record<PeriodKey, number \| null>`	Only the periods that changed; null = the period was removed upstream (delete it).
tieBreaks?	`Record<PeriodKey, number \| null>`	Only the tie-breaks that changed; null = removed.
innings?	`Record<PeriodKey, CricketInnings>`	Only the innings that changed; merge key by key (like periods) — an innings not named is unchanged.

TeamRefA team as referenced from any other object (fixtures, standings, players, leaders).6 fields

Field	Type	Meaning
id	`integer`	Our team id.
name	`string`	Team name. In individual sports (tennis, table tennis, darts, MMA, …) a competitor is a team too: the player, or the pair in doubles.
slug	`string \| null`	URL slug.
shortName	`string \| null`	Short display name, when the source has one.
code	`string \| null`	Scoreboard abbreviation, 1–4 characters (e.g. "ARS", "LA"); synthetic in individual sports.
image	`string (URL) \| null`	Logo on our CDN; null when the team has no image.

TeamDetailA team profile.16 fields

Field	Type	Meaning
id	`integer`	Our team id.
name	`string`	Team name. In individual sports (tennis, table tennis, darts, MMA, …) a competitor is a team too: the player, or the pair in doubles.
slug	`string \| null`	URL slug.
shortName	`string \| null`	Short display name, when the source has one.
code	`string \| null`	Scoreboard abbreviation, 1–4 characters (e.g. "ARS", "LA"); synthetic in individual sports.
image	`string (URL) \| null`	Logo on our CDN; null when the team has no image.
sport	`string \| null`	Sport slug.
country	`Country \| null`	Country the team represents / is based in.
venue	`Venue \| null`	Home venue.
colors	`{ primary: string \| null; secondary: string \| null; text: string \| null } \| null`	Kit colours as #rrggbb; null when the source has none of its own (it sends a placeholder blue for most minor teams and every individual competitor).
gender	`TeamGender \| null`	Men’s, women’s or mixed; null when the source does not say.
national	`boolean \| null`	True for a national side, false for a club; null when the source does not say.
kind	`TeamKind \| null`	A team, one competitor of an individual sport, or a doubles pair; null when the source does not say.
manager	`ManagerRef \| null`	The current manager / head coach, when the source names one.
person	`Person \| null`	Individual competitors: date of birth, height, weight, … where the source profiles them (tennis, MMA); null otherwise.
record	`FighterRecord \| null`	MMA / boxing fighters: the career win-draw-loss record and the last fights’ methods; null for everyone else.

PersonThe person behind an individual competitor (`kind: individual`), where the source profiles one (tennis players, MMA fighters). Same names and units as Player.12 fields

Field	Type	Meaning
dateOfBirth	`string (YYYY-MM-DD) \| null`	Date of birth.
heightCm	`integer \| null`	Height.cm
weightKg	`number \| null`	Weight in kilograms (MMA: the fighter’s listed weight).
reachCm	`integer \| null`	Reach (MMA).cm
nickname	`string \| null`	Ring name / nickname (MMA), e.g. "Storm".
weightClass	`string \| null`	Weight class as the source names it (MMA: "feather", "light", "bantam", …).
birthplace	`string \| null`	Where they were born, as the source writes it ("San Candido, Italy").
residence	`string \| null`	Where they live, as the source writes it ("Monte Carlo, Monaco").
handedness	`Handedness \| null`	Tennis: the playing hand.
turnedPro	`integer \| null`	Tennis: the year they turned professional.
prizeMoneySeason	`Money \| null`	Tennis: prize money won this season.
prizeMoneyCareer	`Money \| null`	Tennis: career prize money.

LeagueRefA league / competition (also the shape of /v2/leagues/{id} and of every league list).7 fields

Field	Type	Meaning
id	`integer`	Our league id.
name	`string`	League / competition name.
slug	`string \| null`	URL slug.
sport	`string \| null`	Sport slug (as in /v2/sports).
category	`string \| null`	The source’s grouping of the league: a country ("England"), a region ("International", "North America", "World"), a tour ("ATP", "WTA") or a game (esports: "Counter Strike"). Not always a country — see `country`.
country	`Country \| null`	The league’s country, when its category is one; null for regions, tours and games.
image	`string (URL) \| null`	Logo on our CDN; null when the league has no image.

CountryA country.2 fields

Field	Type	Meaning
code	`string \| null`	Two-letter code as the source gives it (ISO 3166-1 alpha-2, except the UK home nations: EN England, SX Scotland, WA Wales, NI Northern Ireland). Null when unknown.
name	`string`	English country name.

SeasonA season of a league.5 fields

Field	Type	Meaning
id	`integer`	Our season id.
name	`string \| null`	Season name, e.g. "Premier League 26/27".
year	`string \| null`	Season label as the source writes it, for display: "26/27" or "2026/2027" for a season across two years, "2026" for a calendar-year one. Sort and filter by startYear / endYear.
startYear	`integer \| null`	The year the season starts (2026 for "26/27" and for "2026"); null when the label cannot be read.
endYear	`integer \| null`	The year the season ends (2027 for "26/27"; the same as startYear for a calendar-year season); null when the label cannot be read.

RoundA round of a league season.4 fields

Field	Type	Meaning
number	`integer`	The source’s round number. An opaque key, not a sequence: cups use the number of remaining entrants (tennis "Round of 64" = 32) and playoff rounds large numbers (636). Pass it to /v2/leagues/{id}/fixtures. Some competitions are not organized in rounds at the source (NBA and NHL regular seasons, NCAA, single tennis / MMA events): a fixture there may still carry a round, while /rounds is empty and the round filter returns no fixtures — list them by date instead.
name	`string \| null`	Round name, when the round has one ("Quarterfinals", "Playoff round").
slug	`string \| null`	Disambiguates rounds that reuse a number across phases; pass it to /fixtures when set.
prefix	`string \| null`	Second disambiguator (e.g. "Qualification"); pass it to /fixtures together with slug.

RoundsThe rounds of a season and the current one. Empty (`current: null`, `rounds: []`) for a competition the source does not organize in rounds — see Round.number.2 fields

Field	Type	Meaning
current	`Round \| null`
rounds	`Round[]`

VenueWhere a fixture is played or a team plays its home games.5 fields

Field	Type	Meaning
id	`integer \| null`	Our venue id; null when the source gives the venue without one.
name	`string \| null`	Stadium / arena name.
city	`string \| null`	City.
country	`Country \| null`	Country of the venue.
capacity	`integer \| null`	Seating capacity.

PlayerRefA player as referenced from any other object.5 fields

Field	Type	Meaning
id	`integer`	Our player id.
name	`string`	Player name.
slug	`string \| null`	URL slug.
shortName	`string \| null`	Short display name, e.g. "B. Saka", when the source has one.
image	`string (URL) \| null`	Photo on our CDN; null when the player has no image.

ManagerRefA team’s manager (head coach) as referenced from another object.5 fields

Field	Type	Meaning
id	`integer`	Our manager id.
name	`string`	Manager / head coach name.
slug	`string \| null`	URL slug.
shortName	`string \| null`	Short name, e.g. "F. Hurzeler".
image	`string (URL) \| null`	Photo on our CDN; null when the manager has no image (or it is not uploaded yet). Since 2026-11-04.

PlayerA player profile.17 fields

Field	Type	Meaning
id	`integer`	Our player id.
name	`string`	Full name.
slug	`string \| null`	URL slug.
shortName	`string \| null`	Short name, e.g. "B. Saka".
position	`Position \| null`	Main position.
positionCode	`string \| null`	The source’s position code.
jerseyNumber	`string \| null`	Shirt number (a string: "0" and "00" are real numbers in basketball and American football); null when unknown — rugby squads list "0" as a placeholder, which is dropped.
heightCm	`integer \| null`	Height.cm
preferredFoot	`"left" \| "right" \| "both" \| null`	Football: left, right or both.
dateOfBirth	`string (YYYY-MM-DD) \| null`	Date of birth.
country	`Country \| null`	Nationality.
marketValue	`Money \| null`	Estimated transfer market value; null when unknown.
contractUntil	`string (YYYY-MM-DD) \| null`	Contract end; null when unknown.
image	`string (URL) \| null`	Photo on our CDN.
injury	`Injury \| null`	The current injury, when the source lists one (football, mostly covered leagues); null = none listed.
detailedPositions	`DetailedPosition[]`	Football: the detailed positions the player plays, main one first (e.g. ["striker"], ["rightWinger", "attackingMidfielder"]); [] where the source has none (other sports, minor leagues). `position` stays the broad line.
team	`TeamRef \| null`	Current team.

InjuryA player’s current injury.5 fields

Field	Type	Meaning
description	`string \| null`	The injury, e.g. "Hamstring Injury".
status	`InjuryStatus \| null`	Out, day to day, …
since	`string (YYYY-MM-DD) \| null`	When it started (UTC day).
expectedReturn	`string (YYYY-MM-DD) \| null`	Expected return (UTC day), when the source estimates one.
updatedAt	`string (ISO-8601 UTC) \| null`	When the source last updated it.

SquadPlayerA squad member: a Player without `team` (it is the squad’s team).16 fields

Field	Type	Meaning
id	`integer`	Our player id.
name	`string`	Full name.
slug	`string \| null`	URL slug.
shortName	`string \| null`	Short name, e.g. "B. Saka".
position	`Position \| null`	Main position.
positionCode	`string \| null`	The source’s position code.
jerseyNumber	`string \| null`	Shirt number (a string: "0" and "00" are real numbers in basketball and American football); null when unknown — rugby squads list "0" as a placeholder, which is dropped.
heightCm	`integer \| null`	Height.cm
preferredFoot	`"left" \| "right" \| "both" \| null`	Football: left, right or both.
dateOfBirth	`string (YYYY-MM-DD) \| null`	Date of birth.
country	`Country \| null`	Nationality.
marketValue	`Money \| null`	Estimated transfer market value; null when unknown.
contractUntil	`string (YYYY-MM-DD) \| null`	Contract end; null when unknown.
image	`string (URL) \| null`	Photo on our CDN.
injury	`Injury \| null`	The current injury, when the source lists one (football, mostly covered leagues); null = none listed.
detailedPositions	`DetailedPosition[]`	Football: the detailed positions the player plays, main one first (e.g. ["striker"], ["rightWinger", "attackingMidfielder"]); [] where the source has none (other sports, minor leagues). `position` stays the broad line.

TransferOne move of a player between teams — a transfer, a loan, a signing, a trade, a release, … No id: a move is identified by player + type + date.10 fields

Field	Type	Meaning
player	`PlayerRef`	The player who moved.
type	`TransferType`	What kind of move a transfer is.
date	`string (YYYY-MM-DD) \| null`	When it took effect (UTC day); null when the source has no date.
from	`TeamRef \| null`	The team he left; null for a free agent, or a side the source does not list as a team (see `fromName`).
fromName	`string \| null`	The source’s name of the team he left — set even when `from` is null (e.g. "Bryne FK Yth.").
to	`TeamRef \| null`	The team he joined; null when waived, released or retired, or a side the source does not list (see `toName`).
toName	`string \| null`	The source’s name of the team he joined, as for `fromName`.
fee	`Money \| null`	The fee, when the source states one; null for a free, undisclosed or unknown fee and for every non-transfer move.
freeTransfer	`boolean`	True when the source records the move as free (no fee was paid).
draft	`{ round: integer \| null; pick: integer \| null } \| null`	type draft: the round and pick, when listed; null otherwise.

TeamTransfersA team’s recent moves in and out, as the source lists them (about the last year).2 fields

Field	Type	Meaning
arrivals	`Transfer[]`	Moves INTO the team, newest first.
departures	`Transfer[]`	Moves OUT of the team, newest first.

MoneyAn amount of money.2 fields

Field	Type	Meaning
amount	`number`	Amount in `currency` units.
currency	`string`	ISO 4217 currency code, e.g. "EUR".

LineupsLineups of both sides.3 fields

Field	Type	Meaning
confirmed	`boolean`	True once the official lineups are out (false = predicted / not yet published).
home	`TeamLineup`	One side’s lineup.
away	`TeamLineup`	One side’s lineup.

TeamLineupOne side’s lineup.3 fields

Field	Type	Meaning
formation	`string \| null`	Formation, e.g. "4-2-3-1" (football).
players	`LineupPlayer[]`
missing	`MissingPlayer[]`

LineupPlayerOne player of a lineup.12 fields

Field	Type	Meaning
player	`PlayerRef \| null`	The player.
position	`Position \| null`	Position in this lineup.
positionCode	`string \| null`	The source’s position code, as a lineup card prints it ("G", "LW", "QB", "1B").
jerseyNumber	`string \| null`	Shirt number — a string ("00" exists).
substitute	`boolean`	On the bench at the start.
captain	`boolean`	Team captain.
rating	`number \| null`	Match rating (e.g. 7.4), rounded to 2 decimals; null when the player has none.
avgRating	`number \| null`	Football: the player’s average match rating this season, rounded to 2 decimals, when the source lists it with the lineup (usually before and around kick-off).
ratingVersions	`{ original: number \| null; alternative: number \| null } \| null`	Football: the original rating and the source’s alternative model’s rating.
star	`1 \| 2 \| 3 \| null`	Ice hockey: the game’s first, second or third star.
battingOrder	`integer \| null`	Baseball: place in the batting order.
statistics	`Record<string, number> \| null`	Per-player match statistics, sport-specific camelCase keys in the same vocabulary as the team statistics — a key that counts the same quantity as a team StatItem has the team key (football minutesPlayed, passes, accuratePasses, shotsOnGoal, expectedGoals …; basketball points, fieldGoalsMade, fieldGoalsAttempted, secondsPlayed …; ice hockey goals, shotsOnGoal, penalties, plusMinus, savePercentage …). Every …Percentage is a 0–100 share (ice-hockey save percentages included: 94.1, not 0.941). Seconds where the key says so. Null when the player has none.

MissingPlayerA player missing a fixture.5 fields

Field	Type	Meaning
player	`PlayerRef \| null`	The player.
availability	`Availability \| null`	Ruled out or doubtful.
reason	`MissingReason \| null`	Why.
description	`string \| null`	The source’s detail, e.g. "Hamstring Injury", "Red card suspension".
expectedReturnAt	`string (ISO-8601 UTC) \| null`	Expected return, when known.

StatisticsMatch statistics, per period.1 field

Field	Type	Meaning
periods	`({ period: "all" \| PeriodKey; groups: StatGroup[] })[]`	One entry per period the source has statistics for, "all" first.

StatGroupA group of statistics.3 fields

Field	Type	Meaning
key	`string`	Stable group key from a table per sport (not derived from the display name), e.g. "matchOverview", "attack", "other".
name	`string \| null`	Group display name, e.g. "Match overview".
items	`StatItem[]`

StatItemOne match statistic for both sides.6 fields

Field	Type	Meaning
key	`string`	Stable camelCase key; the same key always means the same quantity, in every sport and in lineup player statistics (it can appear in two groups). A ratio key names the success its `value` counts (`aerialDuelsWon`, `fieldGoalsMade`, `accurateCrosses`, `firstServesIn`, `powerPlayConversion`) — never `…Percentage`; `…Percentage` is a `value` that is itself a 0–100 share (`duelsWonPercentage`, `corsiPercentage`). `blocks` = attempts this side blocked, `shotsBlocked` = this side’s own shots that were blocked. Catalogue per sport in the data dictionary.
name	`string \| null`	The source’s English display name.
kind	`StatKind`	How to read a statistic’s value and total.
higherIs	`HigherIs \| null`	Whether more is better — use it to highlight the leading side.
home	`StatSide`	One side of a statistic.
away	`StatSide`	One side of a statistic.

StatSideOne side of a statistic.3 fields

Field	Type	Meaning
display	`string \| null`	What to print, e.g. "57%", "33/53 (62%)", "1:22".
value	`number \| null`	The number behind it — see the item’s `kind`.
total	`number \| null`	kind ratio: attempts; kind time: seconds available; null otherwise.

IncidentA match event. Lists are oldest first (chronological), like every timeline list.23 fields

Field	Type	Meaning
type	`IncidentType`	What happened.
detail	`IncidentDetail \| null`	Kind within the type; null for period and injuryTime rows.
side	`Side \| null`	The side the incident counts for (an own goal counts for the side credited with it); null for period / injuryTime rows.
minute	`integer \| null`	Match minute. Null off the clock: before kick-off, at half-time, after full time, on the bench, in a shoot-out.minutes
addedMinute	`integer \| null`	Minutes into added time (90+3 → minute 90, addedMinute 3). injuryTime rows: the minutes announced.minutes
second	`integer \| null`	Match clock in seconds, when the source gives it: on every row in ice hockey, basketball, handball and rugby; football only on period rows.seconds
period	`PeriodKey \| null`	The period it happened in. Period rows: the period that ended (football FT → period2, basketball FT → period4, ET → extra2, PEN → penalties). Other rows: the period between the period rows around it (the source’s own value when it gives one); shoot-out kicks: penalties. Null only when it cannot be told (no period row yet and the sport’s period length unknown).
player	`PlayerRef \| null`	The player: scorer, booked player, penalised player, VAR subject, shoot-out taker.
playerName	`string \| null`	The player’s name — also set when the source gives a name but no player record (some own goals).
assists	`PlayerRef[]`	Goal assists in order (ice hockey has up to two).
playerIn	`PlayerRef \| null`	substitution: the player coming on.
playerOut	`PlayerRef \| null`	substitution: the player going off.
drawnBy	`PlayerRef \| null`	suspension (ice hockey): the player who drew the penalty.
homeScore	`number \| null`	Running home score after the incident (goals, period rows, shoot-out kicks). Set sports’ period rows (volleyball, table tennis, badminton): sets won so far — the set’s own points are in the fixture’s `periods` and in /points.
awayScore	`number \| null`	Running away score after the incident (sets won on set sports’ period rows).
text	`string \| null`	period rows: the scoreboard label ("HT", "FT", "Q4", "3rd period", "Overtime", "PEN"). Display only.
reason	`string \| null`	card: the reason ("Foul", "Violent conduct"); suspension: the infraction ("Holding"); missed penalty: how ("Goalkeeper save", "Off target").
rescinded	`boolean \| null`	card: the card was rescinded later.
confirmed	`boolean \| null`	varDecision: true = the original decision stood.
shootoutSequence	`integer \| null`	shootoutPenalty: overall kick order, both sides counted (1 = the first kick of the shoot-out).
shootoutRound	`integer \| null`	shootoutPenalty: the round — the taker’s side’s 1st, 2nd, … kick.
durationSeconds	`integer \| null`	suspension: length of the exclusion.seconds
buildUp	`BuildUpStep[]`	football goal: the passes and shots that led to it, in order, the goal last (covered leagues; empty otherwise and for every other incident).

KeyedIncidentAn incident with its stable key (events frames).2 fields

Field	Type	Meaning
key	`string`	Stable key of the incident within its fixture: `type:side:minute:addedMinute` ("goal:home:34:0", "-" for a null side or minute), with `#2`, `#3` for further incidents in the same slot, in list order. Not the player: a corrected scorer or goal type keeps the key (an update). A corrected minute is a new key (the old one is removed).
incident	`Incident`	A match event. Lists are oldest first (chronological), like every timeline list.

IncidentChangesWhat an events frame changed against the previous one.3 fields

Field	Type	Meaning
added	`string[]`	Keys of incidents that are new since the previous events frame (or since the copy the server held).
updated	`string[]`	Keys of incidents whose content changed (scorer, assist, build-up, card rescinded, …).
removed	`KeyedIncident[]`	Incidents the source no longer lists, with their last content — e.g. a goal chalked off by VAR (the score goes back in a delta; the goal is removed here once REST confirms it).

BuildUpStepOne action of a goal’s build-up, as the source maps it (football, covered leagues).11 fields

Field	Type	Meaning
action	`BuildUpAction`	What one step of a goal’s build-up was.
side	`Side \| null`	The side of the player who made it (an own goal’s last step is the defending side).
player	`PlayerRef \| null`	Who made it.
minute	`integer \| null`	Match minute.minutes
position	`PitchSpot \| null`	Where the action started.
endPosition	`PitchSpot \| null`	pass / cross: where the ball went; null otherwise.
assist	`boolean`	The pass credited as the assist.
bodyPart	`BodyPart \| null`	goal: what it was struck with.
expectedGoals	`number \| null`	goal / savedShot: expected goals of the chance, 0–1, when the source has it.
expectedGoalsOnTarget	`number \| null`	goal / savedShot: expected goals on target (xGOT), when it has it.
goalMouthLocation	`GoalMouthLocation \| null`	goal: zone of the goal mouth.

PitchSpotA spot on a football pitch.2 fields

Field	Type	Meaning
x	`number`	Along the pitch, 0–100 in the SCORING side’s direction of attack (100 = the goal the goal went into, own goals included). Away goals come rotated from the source’s frame, where the home side always attacks towards 100 (fixed 2026-10-23).percent
y	`number`	Across the pitch, 0–100, rotated with x (the scoring side’s view).percent

H2HHead-to-head record of the two teams (the endpoint returns null when they have none).4 fields

Field	Type	Meaning
homeWins	`integer`	Wins of this fixture’s home team in their meetings.
awayWins	`integer`	Wins of this fixture’s away team.
draws	`integer`	Draws.
managerDuel	`ManagerDuel \| null`	The managers’ own record against each other (football and other sports with managers); null when they never met or the source has none.

ManagerDuelHead-to-head record of the two managers, across every team they managed.5 fields

Field	Type	Meaning
homeManager	`ManagerRef \| null`	The home team’s manager for this fixture.
awayManager	`ManagerRef \| null`	The away team’s manager.
homeWins	`integer`	Wins of the home manager’s teams against the away manager’s.
awayWins	`integer`	Wins of the away manager’s teams.
draws	`integer`	Draws.

PregameFormBoth sides’ form before a fixture. A side is null when the source has none.2 fields

Field	Type	Meaning
home	`TeamForm \| null`
away	`TeamForm \| null`

TeamFormOne side’s form going into a fixture.7 fields

Field	Type	Meaning
results	`FormResult[]`	The side’s last results in this competition before this fixture (up to five), oldest first, most recent last.
position	`integer \| null`	League position going into the fixture.
points	`integer \| null`	Table points going into the fixture, where the competition’s table counts points (football, ice hockey, handball, rugby, …); else null.
wins	`integer \| null`	Wins going into the fixture, where the table counts wins and losses instead of points (basketball, baseball: W-L; MMA: W-D-L); else null. MMA: the source’s figure for the event’s competition (Volkanovski 8-0-3 before UFC 333, while his career record is 28-0-4) — NOT the career record, which is TeamDetail.record on /v2/teams/{id}.
draws	`integer \| null`	Draws, where the record has them (MMA W-D-L); else null.
losses	`integer \| null`	Losses, with `wins`; else null.
avgRating	`number \| null`	The side’s average player rating over its recent matches, rounded to 2 decimals.

StreaksTeam streaks before a fixture.2 fields

Field	Type	Meaning
general	`Streak[]`	Each side’s streaks over its recent matches in all competitions, up to this fixture (a finished fixture still shows the streaks it was played with).
headToHead	`Streak[]`	Streaks over the two sides’ meetings.

StreakA team streak worth a headline before a fixture.8 fields

Field	Type	Meaning
name	`string`	The streak in English, e.g. "Wins", "No losses", "More than 2.5 goals". Display text — the source has no stable key for it.
kind	`StreakKind`	What a streak’s figure is: a run in a row, x of the last y, or an average.
value	`string`	As the source prints it: "5" (five in a row), "7/8" (seven of the last eight) or "83" (an average).
count	`integer \| null`	The number of matches the streak holds for (the 5 of "5", the 7 of "7/8"); null for an average.
outOf	`integer \| null`	For an "x of the last y" streak: y; null for a run in a row and for an average.
average	`number \| null`	kind average: the figure (83 points a game); else null.
side	`StreakSide`	Whose streak it is.
continued	`boolean \| null`	Whether the streak is still running.

BestPlayersThe best performers of each side.3 fields

Field	Type	Meaning
playerOfTheMatch	`BestPlayer \| null`	Player of the match, where the sport has one.
home	`BestPlayer[]`
away	`BestPlayer[]`

BestPlayerA top performer of the match.4 fields

Field	Type	Meaning
player	`PlayerRef \| null`	The player.
value	`number \| null`	The ranking value (a rating, points, goals, yards).
label	`BestPlayerLabel \| null`	What `value` is.
statistics	`Record<string, number> \| null`	Basketball: the player’s line, in the lineup-statistics vocabulary (points, rebounds, assists, steals, blocks, rating). Null in sports whose source lists none.

MomentumMomentum graph: per minute (football, basketball, handball, ice hockey, …) or per game (tennis).6 fields

Field	Type	Meaning
points	`{ minute: number; value: number }[]`	One point per minute.
periodLengthMinutes	`number \| null`	Regulation length of one period (football 45, basketball 10, ice hockey 20).minutes
periodCount	`integer \| null`	Regulation periods.
overtimeLengthMinutes	`number \| null`	Length of one overtime period.minutes
overtimeCount	`integer \| null`	Overtime periods played, when the source says.
games	`{ period: PeriodKey; game: integer; value: number; breakOfServe: boolean }[]`	Tennis: one value per game, in order (the minute points are empty). Empty for other sports.

ShotOne shot (football, ice hockey, basketball field goals). Lists are oldest first (chronological; shoot-out kicks last, in kick order) — except basketball, where the source gives no time: home shots then away shots, in the source’s order, with only side, outcome and position set.21 fields

Field	Type	Meaning
side	`Side \| null`	The shooting side.
player	`PlayerRef \| null`	The shooter.
goalkeeper	`PlayerRef \| null`	Football: the goalkeeper faced.
outcome	`ShotOutcome \| null`	What came of it.
technique	`ShotTechnique \| null`	Ice hockey: the shot type.
goalType	`ShotGoalType \| null`	For goals: regular, ownGoal or penalty.
situation	`ShotSituation \| null`	Football: the play it came from.
bodyPart	`BodyPart \| null`	Football: what it was struck with.
strength	`ShotStrength \| null`	Ice hockey: manpower situation.
expectedGoals	`number \| null`	Expected goals (xG) of the chance, 0–1.
expectedGoalsOnTarget	`number \| null`	Football: expected goals on target (xGOT, post-shot), when on target.
minute	`integer \| null`	Match minute.minutes
addedMinute	`integer \| null`	Minutes into added time.minutes
second	`integer \| null`	Match clock in seconds.seconds
period	`PeriodKey \| null`	The period. Football: read from the minute (45+2 → period1, 92 → extra1; shoot-out kicks: penalties); basketball: null (no time).
position	`Point \| null`	Shot origin. Football: 0–100 pitch percentages, x from the goal line being attacked, y across the pitch. Ice hockey: rink units as the source gives them (x ≈ 0–240 along the rink — each side attacks one end, y 0–100 across). Basketball: tenths of a foot from the basket attacked — x across the court (−250…250, sidelines), y out from the basket (0 at the rim; the NBA three-point arc is 237.5).
goalMouth	`Point \| null`	Football: where it crossed the goal line (y across the mouth 0–100, z height).
goalMouthLocation	`GoalMouthLocation \| null`	Football: zone of the goal mouth (or near miss).
blockPosition	`Point \| null`	Football: where a blocked / saved shot was stopped.
shootoutSequence	`integer \| null`	Football shoot-out kicks: overall kick order, both sides counted (as on the shoot-out incidents).
shootoutRound	`integer \| null`	Football shoot-out kicks: the round — the shooting side’s 1st, 2nd, … kick.

PointA coordinate (see Shot for the system per sport).3 fields

Field	Type	Meaning
x	`number \| null`
y	`number \| null`
z	`number \| null`

HeatmapWhere one player was active during a fixture (football, covered leagues).1 field

Field	Type	Meaning
points	`HeatPoint[]`	Every sample; render them as a density. Empty (200, not 404) when the source has no heatmap for the player in this fixture — also for sports that never have one (only football is covered).

HeatPointOne touch / position sample of a heatmap.2 fields

Field	Type	Meaning
x	`number`	Along the pitch, 0–100, in the player’s direction of attack (100 = the goal attacked).percent
y	`number`	Across the pitch, 0–100.percent

AveragePositionsAverage positions of each side’s players (football, covered leagues).2 fields

Field	Type	Meaning
home	`AveragePosition[]`
away	`AveragePosition[]`

AveragePositionA player’s average position in a fixture.7 fields

Field	Type	Meaning
player	`PlayerRef \| null`	The player.
jerseyNumber	`string \| null`	Shirt number.
position	`Position \| null`	Playing position, as on lineups (from `positionCode`).
positionCode	`string \| null`	The source’s position letter ("G", "D", "M", "F").
x	`number \| null`	Average position along the pitch, 0–100 in the team’s direction of attack.percent
y	`number \| null`	Average position across the pitch, 0–100.percent
pointsCount	`integer \| null`	How many position samples the average is over.

PointsA fixture point by point: tennis (sets → games → points), rally sports (sets → rallies), cricket (innings → overs → balls), baseball (at-bats), darts (sets → legs → visits).5 fields

Field	Type	Meaning
format	`PointsFormat \| null`	Which of `sets` / `innings` / `atBats` / `darts` is filled; null when none is available yet — and for sports that never have point by point (200 with empty lists, not 404).
sets	`PointSet[]`	Tennis and rally sports: one entry per set, in order.
innings	`InningsBalls[]`	Cricket: one entry per innings, in order.
atBats	`AtBat[]`	Baseball: every plate appearance in order, oldest first.
darts	`DartsSet[]`	Darts: sets → legs → visits, in order.

PointSetOne set, point by point.5 fields

Field	Type	Meaning
period	`PeriodKey`	The set: period1, period2, …
homeScore	`integer \| null`	Home games (tennis) or points (rally sports) in the set — the last score listed. A tennis match tie-break counts its points (10-8), as the fixture’s period score does.
awayScore	`integer \| null`	Away games / points in the set.
games	`TennisGame[]`	Tennis: the games in order. Empty for rally sports.
points	`RallyPoint[]`	Rally sports: the rallies in order, as the source recorded them — lower-tier coverage can miss a rally (the running score shows the gap). Empty for tennis.

TennisGameOne game of a tennis set.6 fields

Field	Type	Meaning
number	`integer`	Game number in the set (13 = the tie-break; a match tie-break played instead of a deciding set is game 1 of that set, its points counted to 10).
server	`Side \| null`	Who served. In a tie-break the source names the server of its LAST point, not its first (checked on real tie-breaks 2026-10-19).
winner	`Side \| null`	Who won the game (winner ≠ server = a break of serve). A finished tie-break’s winner is read from its last point (the source’s game winner was wrong on 3 of 8 match tie-breaks checked 2026-10-19).
homeGames	`integer \| null`	Home games in the set after this game.
awayGames	`integer \| null`	Away games in the set after this game.
points	`TennisPoint[]`	The points in order. In a game that is over the last point is the one that won it (`winner` = the game’s winner); in a game still in play, the points so far.

TennisPointOne point of a tennis game.6 fields

Field	Type	Meaning
homeScore	`string \| null`	Home game score after the point: "0", "15", "30", "40", "A" (tie-break: points as numbers). Text because of "A". Null on the point that won a regular game — the game is over, there is no score after it.
awayScore	`string \| null`	Away game score after the point (null as for `homeScore`).
winner	`Side \| null`	Who won the point, read from the score change; null when it cannot be read.
description	`TennisPointDescription \| null`	Ace or double fault; null for any other point, and on the appended game-winning point (the source does not list it, so an ace that won a game is not marked).
homeType	`TennisPointType \| null`	What the point meant for the home side (won it, now has a break / set point, a tie-break mini-break). Null on the appended game-winning point.
awayType	`TennisPointType \| null`	The same for the away side.

RallyPointOne rally of a set (volleyball, table tennis, badminton).3 fields

Field	Type	Meaning
winner	`Side \| null`	Who won the rally.
homeScore	`integer \| null`	Home points in the set after the rally.
awayScore	`integer \| null`	Away points in the set after the rally.

InningsBallsOne cricket innings, ball by ball.3 fields

Field	Type	Meaning
inning	`PeriodKey`	inning1, inning2, … — the same keys as ScoreSide.innings.
battingSide	`Side \| null`	The side batting in this innings.
overs	`Over[]`	The overs in order.

OverOne over.2 fields

Field	Type	Meaning
number	`integer`	The over, counted from 1 (the first over is 1; in cricket notation the 3rd ball of over 46 is "45.3").
balls	`Ball[]`	The deliveries in order.

BallOne cricket delivery.13 fields

Field	Type	Meaning
sequence	`integer \| null`	The source’s running delivery number in the match (orders deliveries across overs).
ball	`integer \| null`	Delivery number within the over (extras push it past 6).
outcome	`BallOutcome`	What a cricket delivery produced.
runs	`integer \| null`	Runs off the bat.
totalRuns	`integer \| null`	Every run the delivery added, extras included.
wicket	`boolean`	A wicket fell on this delivery.
dismissal	`Dismissal \| null`	How, when a wicket fell.
batter	`PlayerRef \| null`	The batter on strike.
bowler	`PlayerRef \| null`	The bowler.
fielder	`PlayerRef \| null`	The fielder involved in a dismissal (catch, run-out, stumping).
dismissedBatter	`PlayerRef \| null`	The batter out (not always the striker: run-outs).
scoreRuns	`integer \| null`	The batting side’s total after the delivery.
scoreWickets	`integer \| null`	Wickets down after the delivery.

AtBatOne baseball plate appearance. The source gives no outcome (hit, out, walk) for it.8 fields

Field	Type	Meaning
inning	`integer`	The inning (10, 11, … = extra innings).
half	`"top" \| "bottom"`	top: the away side bats; bottom: the home side bats.
battingSide	`Side`	The side batting (from the half).
batter	`PlayerRef \| null`	The batter.
pitcher	`PlayerRef \| null`	The pitcher.
homeWinProbabilityBefore	`number \| null`	The SOURCE’s home win probability before the at-bat, 0–100 (not our model; no bookmaker odds).percent
homeWinProbabilityAfter	`number \| null`	The source’s home win probability after it, 0–100 (away = 100 − home).percent
at	`string (ISO-8601 UTC) \| null`	When it was recorded.

DartsSetOne darts set (a legs match has a single set).5 fields

Field	Type	Meaning
number	`integer`	Set number (1 for a legs match).
winner	`Side \| null`	Who won the set; null in a legs match and while the set is in play.
homeSets	`integer \| null`	Home sets won after this set; null in a legs match.
awaySets	`integer \| null`	Away sets won after this set; null in a legs match.
legs	`DartsLeg[]`	The legs in order.

DartsLegOne darts leg, visit by visit.8 fields

Field	Type	Meaning
number	`integer`	Leg number within the set (a legs match is one set).
startScore	`integer \| null`	The score each player starts the leg from (501), as the source lists it.
throwingFirst	`Side \| null`	Who threw first in the leg, as the source says (the throw alternates leg by leg). The visit list can start with the other player — seen once on a first leg.
winner	`Side \| null`	Who won the leg; null while it is in play.
homeLegs	`integer \| null`	Home legs won in the set after this leg.
awayLegs	`integer \| null`	Away legs won in the set after this leg.
checkout	`integer \| null`	The winning visit’s score (the checkout); null while in play, or when the last visit is not listed.
visits	`DartsVisit[]`	The visits in order.

DartsVisitOne darts visit (up to three darts). The source gives no darts-thrown count.5 fields

Field	Type	Meaning
side	`Side`	Who threw.
scored	`integer \| null`	Points the visit scored: the thrower’s remaining score before − after. 0 = nothing scored or a bust (the source does not tell them apart). Null when the drop is not a possible visit (more than 180 — the source skipped a visit).
homeRemaining	`integer`	Home’s remaining score after the visit.
awayRemaining	`integer`	Away’s remaining score after the visit.
checkout	`boolean`	The visit won the leg (the thrower reached 0); its `scored` is the checkout.

BasesBaseball: which bases are occupied.3 fields

Field	Type	Meaning
first	`boolean`	A runner is on first base.
second	`boolean`	A runner is on second base.
third	`boolean`	A runner is on third base.

InningStateBaseball: the game state in play — inning, half, count, outs, runners. The source gives no batter or pitcher with it (the current at-bat’s are in /points `atBats`). Its live feed re-sends the state about once a minute, not after every pitch, so the count can lag the game by up to a minute.7 fields

Field	Type	Meaning
inning	`integer`	The inning in play (10, 11, … = extra innings).
half	`"top" \| "bottom"`	top: the away side bats; bottom: the home side bats.
battingSide	`Side`	The side batting (from the half).
balls	`integer \| null`	Balls in the current count.
strikes	`integer \| null`	Strikes in the current count.
outs	`integer \| null`	Outs in the half-inning (3 = the half just ended).
bases	`Bases`	Baseball: which bases are occupied.

TimeoutsBasketball: timeouts left per side, as the source tracks them.3 fields

Field	Type	Meaning
homeRemaining	`integer \| null`	Timeouts the home side has left.
awayRemaining	`integer \| null`	Timeouts the away side has left.
perTeam	`integer \| null`	Timeouts each side has for the game (NBA: 7).

MatchFormatHow many sets / legs / games the match is played over, when the source says.3 fields

Field	Type	Meaning
bestOfSets	`integer \| null`	Darts: sets in the match format ("best of 5 sets"); 1 = a legs match with no sets.
bestOfLegs	`integer \| null`	Darts: legs per set when `bestOfSets` > 1, else legs in the match ("best of 7 legs").
bestOfGames	`integer \| null`	Esports: games (maps) in the series ("best of 3").

UmpiresBaseball: the game’s umpire crew.1 field

Field	Type	Meaning
umpires	`Umpire[]`	The crew, home plate first, as the source lists it; empty when it has none, and for other sports.

UmpireOne umpire of a baseball game.3 fields

Field	Type	Meaning
name	`string`	Full name as the source writes it.
position	`UmpirePosition`	Where the umpire works this game.
experienceYears	`integer \| null`	Years of experience, as the source counts them.

WeatherBaseball: the weather at the ballpark (the source reports it for baseball only; other sports answer an empty list). Metric units — the source’s figures are converted from °F and mph (14.44 °C = 58 °F, 8.05 km/h = 5 mph). A roofed stadium reports the outside weather too.1 field

Field	Type	Meaning
observations	`WeatherObservation[]`	Observations and forecasts, as the source lists them (observation first); empty when it has none, and for other sports.

WeatherObservationThe weather at a venue at one time.10 fields

Field	Type	Meaning
at	`string (ISO-8601 UTC) \| null`	When it was observed (or, for a forecast, the time it was issued).
forecast	`boolean`	True for a forecast, false for an observation.
condition	`WeatherCondition`	The weather, grouped.
description	`string \| null`	The source’s own words ("Overcast"). Display only.
temperatureC	`number \| null`	Air temperature in °C.celsius
dewPointC	`number \| null`	Dew point in °C.celsius
humidityPercent	`number \| null`	Relative humidity, 0–100.percent
cloudCoverPercent	`number \| null`	Cloud cover, 0–100.percent
windSpeedKmh	`number \| null`	Wind speed in km/h.kilometersPerHour
windDirection	`string \| null`	Where the wind comes from, as a compass point ("SE", "SSE").

EsportsGamesEsports: an esports fixture game by game — map, winner, score, lineups with K/D/A, bans, objectives.1 field

Field	Type	Meaning
games	`EsportsGame[]`	The games in order; empty before the first game, and for other sports.

EsportsGameOne game (map) of an esports series.8 fields

Field	Type	Meaning
number	`integer`	Game number in the series (1, 2, …).
status	`"notstarted" \| "inprogress" \| "interrupted" \| "willcontinue" \| "postponed" \| "canceled" \| "finished"`	The game’s status type (finished, inprogress, notstarted, …).
map	`string \| null`	The map ("Dust2"); null for titles with one map (League of Legends).
startedAt	`string (ISO-8601 UTC) \| null`	When the game started.
durationSeconds	`integer \| null`	Game length.seconds
winner	`Side \| null`	Who won the game; null until it is over.
home	`EsportsGameSide`	One side of one esports game.
away	`EsportsGameSide`	One side of one esports game.

EsportsGameSideOne side of one esports game.5 fields

Field	Type	Meaning
score	`number \| null`	The side’s score in the game: rounds (Counter-Strike), kills (League of Legends, Dota 2).
periods	`Record<PeriodKey, number>`	Counter-Strike: rounds per half (period1, period2) and the overtime rounds together under `overtime`, so they add up to the game score. Empty when the source has none.
players	`EsportsGamePlayer[]`	The side’s players; empty when the source has no lineup.
bans	`EsportsCharacter[]`	Characters the side banned, in order; empty when none are listed.
statistics	`EsportsTeamStats \| null`	Objectives; null when the source has none.

EsportsGamePlayerOne player’s line in one esports game. Each title fills its own fields and leaves the others null: League of Legends gold / creepScore / level; Dota 2 creepScore (last hits) / level / denies / netWorth / goldPerMinute / experiencePerMinute; Counter-Strike averageDamagePerRound / headshotKills / kastPercentage / killDeathDifference / firstKillDifference / flashAssists.19 fields

Field	Type	Meaning
player	`PlayerRef \| null`	The player.
role	`EsportsRole`	The player’s role in this game.
character	`EsportsCharacter \| null`	The champion / hero played.
kills	`integer \| null`	Kills.
deaths	`integer \| null`	Deaths.
assists	`integer \| null`	Assists.
gold	`integer \| null`	League of Legends: gold earned.
creepScore	`integer \| null`	Creeps killed: minions and monsters (League of Legends), last hits (Dota 2).
level	`integer \| null`	Champion / hero level at the end (League of Legends, Dota 2).
denies	`integer \| null`	Dota 2: own creeps denied (last-hit by the player so the opponent gets no gold).
netWorth	`integer \| null`	Dota 2: net worth at the end (gold held + items), in gold.
goldPerMinute	`number \| null`	Dota 2: gold earned per minute of the game.
experiencePerMinute	`number \| null`	Dota 2: experience earned per minute of the game.
averageDamagePerRound	`number \| null`	Counter-Strike: average damage dealt per round (ADR), in hit points.
headshotKills	`integer \| null`	Counter-Strike: kills made with a headshot (a count, at most `kills` — not a percentage).
kastPercentage	`number \| null`	Counter-Strike: KAST — share of rounds in which the player got a kill or an assist, survived or was traded, 0–100.percent
killDeathDifference	`integer \| null`	Counter-Strike: kills − deaths (negative when the player died more).
firstKillDifference	`integer \| null`	Counter-Strike: opening kills − opening deaths (the first kill of a round, for or against the player); the players of a map add up to 0.
flashAssists	`integer \| null`	Counter-Strike: kills by a teammate on an opponent the player had flashed.

EsportsCharacterA champion / hero / agent picked or banned.2 fields

Field	Type	Meaning
name	`string`	Name ("Viktor").
slug	`string \| null`	URL slug.

EsportsTeamStatsOne side’s objectives in one game — League of Legends and Dota 2 (kills, towers; Dota 2 barracks and first blood); a field the title has not is null. Counter-Strike has none (null object).10 fields

Field	Type	Meaning
kills	`integer \| null`	Kills.
gold	`integer \| null`	Gold earned.
towers	`integer \| null`	Enemy towers destroyed (Dota 2: the towers the opponent lost).
inhibitors	`integer \| null`	Inhibitors destroyed.
dragons	`integer \| null`	Dragons (drakes) slain, as the source counts them (`elderDragons` apart).
elderDragons	`integer \| null`	Elder dragons slain.
barons	`integer \| null`	Barons (Nashor) slain.
heraldTaken	`boolean \| null`	Whether the side took the Rift Herald.
barracks	`integer \| null`	Dota 2: enemy barracks destroyed (the barracks the opponent lost).
firstBlood	`boolean \| null`	Dota 2: whether the side drew first blood (the game’s first kill).

ScorecardA cricket fixture’s full scorecard. Other sports: 200 with `{ innings: [], current: null }`, not 404.2 fields

Field	Type	Meaning
innings	`ScorecardInnings[]`	The innings in match order; empty before the first ball and for other sports.
current	`CricketState \| null`	The innings in play: striker, non-striker, bowler, over and ball. Null when no innings is in progress (not started, between innings, finished) and for other sports.

CricketStateWho is at the crease in a live innings — DERIVED by us from the ball-by-ball (the last ball’s batter, swapped on an odd number of runs run and at the end of an over; a wicket brings in the new batter), not the source’s own current-batsman field. Checked against the next ball on 3,000+ deliveries.7 fields

Field	Type	Meaning
inning	`PeriodKey`	The innings in play (inning1, inning2, …).
battingSide	`Side \| null`	The side batting.
striker	`PlayerRef \| null`	The batter who will face the next ball. Null when it cannot be told right now (no ball bowled in the innings yet, or the ball-by-ball and the scorecard briefly disagree after a delivery).
nonStriker	`PlayerRef \| null`	The other batter at the crease. Null when unknown, as for striker.
bowler	`PlayerRef \| null`	The bowler of the over in play; null between overs — the next bowler is known only once he bowls.
over	`integer`	The over in play, 1-based like Points (the next over once one is complete).
ball	`integer`	Legal balls bowled in that over so far (0–5; wides and no-balls do not count).

ScorecardInningsOne cricket innings: totals, batting and bowling cards, falls of wicket, partnerships.12 fields

Field	Type	Meaning
inning	`PeriodKey`	inning1, inning2, … in match order (the match’s second innings is inning2, whoever bats) — the same keys as Points.innings.
battingSide	`Side \| null`	The side batting.
battingTeam	`TeamRef \| null`	The team batting.
bowlingTeam	`TeamRef \| null`	The team bowling.
runs	`integer \| null`	Total: the batters’ runs plus extras.
wickets	`integer \| null`	Wickets down (a batter retired hurt who cannot return counts).
overs	`number \| null`	Overs faced, cricket notation (19.3 = 19 overs and 3 balls).
extras	`Extras`	Runs not scored off the bat.
batting	`ScorecardBatter[]`	The batting card in batting order, did-not-bat lines included.
bowling	`ScorecardBowler[]`	The bowling card in bowling order.
fallOfWickets	`FallOfWicket[]`	Falls of wicket in order (a retirement is not a fall).
partnerships	`Partnership[]`	Partnerships in order.

ScorecardBatterOne line of a batting card, in batting order.11 fields

Field	Type	Meaning
batter	`PlayerRef \| null`	The batter.
state	`BatterState`	Where a batter’s innings stands.
dismissal	`Dismissal \| null`	How the batter was out; null unless `state` is out.
description	`string \| null`	The source’s wording of the state ("Caught & Bowled", "LBW", "Not out", "Did not bat"). Display only.
bowler	`PlayerRef \| null`	The bowler of the dismissal (credited with the wicket, except for a run out). The source also names him on a retired-hurt line.
fielder	`PlayerRef \| null`	The fielder in the dismissal: the catcher (the bowler on caught & bowled), the keeper on a stumping, the fielder on a run out.
runs	`integer \| null`	Runs scored.
balls	`integer \| null`	Balls faced.
fours	`integer \| null`	Fours hit.
sixes	`integer \| null`	Sixes hit.
strikeRate	`number \| null`	Runs per 100 balls, 2 decimals; null before the first ball faced.

ScorecardBowlerOne line of a bowling card, in bowling order.8 fields

Field	Type	Meaning
bowler	`PlayerRef \| null`	The bowler.
overs	`number \| null`	Overs bowled, cricket notation (3.4 = 3 overs and 4 balls).
maidens	`integer \| null`	Maiden overs.
runs	`integer \| null`	Runs conceded (wides and no-balls included, byes and leg byes not).
wickets	`integer \| null`	Wickets credited (run outs and retirements are not).
wides	`integer \| null`	Wides bowled.
noBalls	`integer \| null`	No-balls bowled.
economy	`number \| null`	Runs per over (6 balls), 2 decimals; null before the first ball.

FallOfWicketOne fall of wicket.4 fields

Field	Type	Meaning
wicket	`integer`	Which wicket: 1 = the first to fall.
runs	`integer \| null`	The batting side’s total when it fell.
overs	`number \| null`	When it fell, cricket notation (4.2 = the 2nd ball of the 5th over; the 6th ball of the 5th over is 5, never 4.6).
batter	`PlayerRef \| null`	The batter out.

PartnershipOne batting partnership. The source lists them for limited-overs matches; multi-day matches often have none.4 fields

Field	Type	Meaning
batter1	`PlayerRef \| null`	One batter of the partnership.
batter2	`PlayerRef \| null`	The other batter.
runs	`integer \| null`	Runs added together.
balls	`integer \| null`	Balls it lasted.

ExtrasRuns not scored off the bat.6 fields

Field	Type	Meaning
total	`integer \| null`	All extras: wides + noBalls + byes + legByes + penalties.
wides	`integer \| null`	Wides.
noBalls	`integer \| null`	No-balls.
byes	`integer \| null`	Byes.
legByes	`integer \| null`	Leg byes.
penalties	`integer \| null`	Penalty runs.

StandingsGroupOne table of a season (a conference, a division, a group, or the overall table).6 fields

Field	Type	Meaning
name	`string \| null`	Table name, e.g. "Eastern Conference", "Group A", "NHL".
primary	`boolean`	True for the table /standings returns by default — exactly one per season: the overall table when there is one, else the largest (the first group of a group stage).
overall	`boolean`	True when the table holds every team of the season (a league table); false for a conference, a division or one group of a group stage.
tieBreakRule	`string \| null`	The source’s explanation of the tie-break order.
scoreUnit	`StandingsScoreUnit \| null`	What scoresFor / scoresAgainst count in this table; null when the table has no score columns (cricket).
rows	`StandingsRow[]`

StandingsRowOne row of a standings table. Columns that do not apply to the sport are null.17 fields

Field	Type	Meaning
position	`integer \| null`	Rank in this table, 1..n. Where the source’s positions are not 1..n (its NBA tables early in a season) the rows are ranked by us: win share, wins, fewer losses — or points, score difference, scores for.
team	`TeamRef \| null`	The team.
played	`integer \| null`	Games played.
wins	`integer \| null`	Wins (all wins, overtime ones included).
draws	`integer \| null`	Draws. Null in sports whose tables cannot hold a draw (basketball, ice hockey, baseball, volleyball, esports, water polo, …) — "no draws column", not "none yet"; a number in football, futsal, handball, rugby, American football and cricket.
losses	`integer \| null`	Losses (all, overtime losses included).
overtimeWins	`integer \| null`	Ice hockey: overtime wins as the source counts them — overtime only where it also counts shoot-outs apart (the KHL, the NHL’s league table), overtime + shoot-out otherwise; null where it lists none.
overtimeLosses	`integer \| null`	Ice hockey: overtime + shoot-out losses (the NHL’s OTL, a point each) in every NHL table — league, conference, division and computed home / away; elsewhere the source’s overtime-loss count (the KHL lists overtime only).
scoresFor	`number \| null`	Scored, in the table’s `scoreUnit` (goals, points, runs, sets, …).
scoresAgainst	`number \| null`	Conceded, in the table’s `scoreUnit`.
scoreDifference	`number \| null`	scoresFor − scoresAgainst.
points	`number \| null`	Table points; null where the table ranks by win percentage (NBA).
winPercentage	`number \| null`	Basketball / baseball / American football: share of games won, 0–1, as the league computes it (the NFL counts a tie as half a win).ratio
gamesBehind	`number \| null`	Basketball / baseball: games behind the table’s leader (best wins − losses): ((leader wins − wins) + (losses − leader losses)) / 2. The source prints 0 on every row of its EuroLeague tables; computed NBA home / away tables compute it per table.
streak	`integer \| null`	Current run of results in this competition: +3 = three straight wins, −2 = two straight losses. Set where the source’s table carries it (NBA, EuroLeague, Liga ACB, …); null elsewhere and on home / away tables.
zone	`string \| null`	The qualification / relegation zone the row is in, e.g. "Champions League", "Playoffs", "Relegation".
form	`FormResult[] \| null`	The team’s last results in this competition season (up to five), oldest first, most recent last — on a home / away table its last home / away results. Null when the source has no form for the table (computed tables, older stored rows, a failed read).

CupTreeA knockout bracket of a league season (cup knockout stage, playoffs, a tennis draw).3 fields

Field	Type	Meaning
name	`string \| null`	The bracket’s name, e.g. "CONMEBOL Libertadores 2026, Knockout stage", "NBA 25/26, Playoffs".
currentRound	`integer \| null`	The `order` of the round in play (or next to be played); null when the source gives none, or when the tree is over (the source then names a round past the last one).
rounds	`CupRound[]`	First round first.

CupRoundA round of a knockout bracket.3 fields

Field	Type	Meaning
order	`integer`	Round order in the bracket, first round 1.
name	`string \| null`	Round name as the source writes it ("1/8", "Quarterfinals", "Round of 32", "Conference finals").
blocks	`CupBlock[]`	The round’s ties, top to bottom.

CupBlockOne tie of a knockout round (a single match, two legs or a series).10 fields

Field	Type	Meaning
order	`integer`	The tie’s slot in its round, top to bottom, as the source draws the bracket: ascending, but not always 1..n — a round with byes or teams entering later leaves gaps (UCL qualifiers 15, 16, 19, …).
home	`CupParticipant \| null`	The first-listed participant (home in the first leg / higher seed); null when the slot is empty.
away	`CupParticipant \| null`	The second-listed participant; null when the slot is empty (a bye).
finished	`boolean`	Whether the tie is decided (a participant is marked winner, or the source says it is over).
inProgress	`boolean`	Whether one of its fixtures is being played now.
startTime	`string (ISO-8601 UTC) \| null`	Kick-off of the tie’s first fixture (UTC); null when not scheduled.
matchCount	`integer \| null`	How many fixtures the tie is played over (2 legs, best-of-7 → 7, 1); 0 for a bye.
fixtureIds	`integer[]`	Our ids of the tie’s fixtures (/v2/fixtures/{id}), as the source lists them.
automaticProgression	`boolean`	The source’s flag: the participant goes through without a fixture.
venue	`Venue \| null`	The tie’s venue when the source gives one (a single-match final, the first leg’s ground).

CupParticipantOne side of a knockout tie.6 fields

Field	Type	Meaning
team	`TeamRef \| null`	The team (or competitor). Null while the slot is a placeholder (“winner of quarter-final 1”) — see `fromBlock`.
seed	`string \| null`	Seed or entry label as the source writes it ("1", "Q" qualifier, "WC" wild card); null when none.
winner	`boolean`	Whether this participant won the tie / went through.
score	`integer \| null`	Its score in the tie, the source’s figure: aggregate goals over the legs (football), games won in a series (basketball, ice hockey), sets in a single match (tennis). Null before the tie is played.
penalties	`integer \| null`	Football: its penalty shoot-out goals when the tie went to one; null otherwise.
fromBlock	`integer \| null`	The `order` of the block in the PREVIOUS round this participant came from; null in the first round or when neither the source links it nor the team played in the previous round (a new entrant).

SearchResultOne search hit, in the source’s relevance order. Tennis and other individual-sport competitors are `team` results; managers, referees, racing series and races since 2026-10-24; fixtures and venues, and a player’s `team`, since 2026-11-04.9 fields

Field	Type	Meaning
type	`SearchType`	What a search hit is — and so which endpoint its id belongs to.
id	`integer`	Our id of the hit — use it with the endpoint its `type` names (/v2/teams, /v2/players, /v2/leagues, /v2/managers, /v2/referees, /v2/series, /v2/races, /v2/fixtures). A venue has no endpoint: its id is the one Fixture.venue and TeamDetail.venue carry.
name	`string`	Display name; a fixture’s is the source’s "Home - Away".
slug	`string \| null`
sport	`string \| null`	Sport slug; null for venues (a venue is not tied to one sport).
image	`string (URL) \| null`	Logo (team, league) or photo (player, manager, referee) on our CDN; null when the entity has no image (or it is not uploaded yet), and always for series, races, fixtures and venues.
team	`TeamRef \| null`	A player’s current team, as the source lists it (since 2026-11-04); null for every other type and for a player without one (free agent, retired).
fixture	`SearchFixture \| null`	The match facts of a `fixture` hit (since 2026-11-04); null for every other type.
venue	`Venue \| null`	The venue of a `venue` hit — city, country, capacity (since 2026-11-04); null for every other type.

SearchFixtureWhat a `fixture` search hit says about the match (since 2026-11-04). Status, score and the rest: /v2/fixtures/{id}.5 fields

Field	Type	Meaning
home	`TeamRef \| null`	Home team; null while the side is not decided yet.
away	`TeamRef \| null`	Away team; null while the side is not decided yet.
league	`LeagueRef \| null`	The competition; null when the source gives none.
startTime	`string (ISO-8601 UTC) \| null`	Scheduled start (UTC); null when the source gives none.
status	`StatusType \| null`	Coarse match state at the time of the search (the source gives no finer state here); null when the source gives none.

TopPlayersCategoryA season leaderboard.3 fields

Field	Type	Meaning
category	`string`	The leaderboard, e.g. averageRating, goals, expectedGoals (football), points, rebounds (basketball), points, savePercentage (ice hockey). The same as `statistic` except football `mostConceded` / `leastConceded` (goalkeepers by goals conceded, most / least first).
statistic	`string`	The key in each entry’s `statistics` the leaderboard ranks (its value is the entry’s `value`, a season total). The order is the source’s: a counting statistic is usually ranked PER APPEARANCE (value ÷ appearances — NBA points 104 in 3 games above 115 in 4), a rating or a share by its value; read the order, not `value`, as the rank.
players	`TopPlayerEntry[]`

TopPlayerEntryOne ranked player.6 fields

Field	Type	Meaning
player	`PlayerRef \| null`
team	`TeamRef \| null`
value	`number \| null`	The ranked statistic for the player: `statistics[statistic]`.
appearances	`integer \| null`	Appearances.
playedEnough	`boolean \| null`	Enough minutes / games to qualify for the ranking.
statistics	`Record<string, number>`	Every numeric statistic the entry was ranked with — v2 keys, the same as the per-match statistic for the same quantity (season rules: `…PerMatch` = total ÷ matches, `…Per90` per 90 minutes, `average…` a season mean, `…Percentage` 0–100, `<key>Against` the opponents’ value, units in the name — `…Seconds`, `…Kmh`).

TopTeamsCategoryA season team leaderboard.3 fields

Field	Type	Meaning
category	`string`	The leaderboard, e.g. averageRating, goalsScored, cleanSheets (football).
statistic	`string`	The key in each entry’s `statistics` the leaderboard ranks (its value is the entry’s `value`, a season total). The order is the source’s: a counting statistic is usually ranked PER APPEARANCE (value ÷ appearances — NBA points 104 in 3 games above 115 in 4), a rating or a share by its value; read the order, not `value`, as the rank.
teams	`TopTeamEntry[]`	The ranked teams, best first.

TopTeamEntryOne ranked team.4 fields

Field	Type	Meaning
team	`TeamRef \| null`
value	`number \| null`	The ranked statistic for the team: `statistics[statistic]`.
matches	`integer \| null`	Matches played.
statistics	`Record<string, number>`	Every numeric statistic the entry was ranked with — v2 keys, the same as the per-match statistic for the same quantity (season rules: `…PerMatch` = total ÷ matches, `…Per90` per 90 minutes, `average…` a season mean, `…Percentage` 0–100, `<key>Against` the opponents’ value, units in the name — `…Seconds`, `…Kmh`).

TeamSeasonStatisticsA team’s statistics for one league, season and type.1 field

Field	Type	Meaning
statistics	`Record<string, number>`	Season totals and averages — v2 keys, the same as the per-match statistic for the same quantity (season rules: `…PerMatch` = total ÷ matches, `…Per90` per 90 minutes, `average…` a season mean, `…Percentage` 0–100, `<key>Against` the opponents’ value, units in the name — `…Seconds`, `…Kmh`) (football: matches, goalsScored, goalsConceded, totalShots, averageBallPossession, averageRating, cleanSheets, …). Ratings rounded to 2 decimals.

SeasonInfoSeason facts: totals so far and the newcomers.5 fields

Field	Type	Meaning
statistics	`Record<string, number>`	Season totals as the source names them (football: goals, homeTeamWins, awayTeamWins, draws, yellowCards, redCards, numberOfCompetitors; other sports may only have numberOfCompetitors).
newcomersUpperDivision	`TeamRef[]`	Teams new this season, relegated from the division above.
newcomersLowerDivision	`TeamRef[]`	Teams new this season, promoted from the division below.
newcomersOther	`TeamRef[]`	Other new teams.
hostCountries	`Country[]`	The host countries of a tournament held in named countries (World Cup 2026: Canada, Mexico, USA; EURO 2020: eleven), in the source’s order. Usually empty for a league season, though the source names the country for some (Bundesliga: Germany; MLS, NFL: USA). `code` is null for a name the source’s country list does not carry.

PlayerLeagueSeasonsA league the player has statistics in, with the seasons.2 fields

Field	Type	Meaning
league	`LeagueRef`	A league / competition (also the shape of /v2/leagues/{id} and of every league list).
seasons	`({ id: integer; name: string \| null; year: string \| null; startYear: integer \| null; endYear: integer \| null; types: SeasonStatsType[] })[]`

PlayerStatisticsA player’s statistics for one league, season and type.2 fields

Field	Type	Meaning
team	`TeamRef \| null`
statistics	`Record<string, number>`	Season totals and averages — v2 keys, the same as the per-match statistic for the same quantity (season rules: `…PerMatch` = total ÷ matches, `…Per90` per 90 minutes, `average…` a season mean, `…Percentage` 0–100, `<key>Against` the opponents’ value, units in the name — `…Seconds`, `…Kmh`) (football: appearances, minutesPlayed, goals, averageRating, expectedGoals, …). Ratings rounded to 2 decimals.

PlayerFixtureA Fixture from a player’s fixture list, with the player’s own part in it (`playerMatch`).37 fields

Field	Type	Meaning
id	`integer`	Our fixture id.
sport	`string`	Sport slug (as in /v2/sports).
status	`Status`	Match status.
startTime	`string (ISO-8601 UTC) \| null`	Start time: the scheduled start, replaced by the recorded kick-off once the source records it (the live feed sends it a few minutes after the start). The same value on every endpoint and in WebSocket deltas.
league	`LeagueRef \| null`	The competition. null when the source files the fixture under a competition it has no league for — seen on minor regional football (South Africa’s National Second Division, 2026-10-23); season and round are then null too.
season	`Season \| null`	The season.
round	`Round \| null`	The round, when the competition has rounds.
home	`TeamRef \| null`	Home side; null while the side is not decided yet (the source’s placeholder such as "WQF1", winner of quarter-final 1).
away	`TeamRef \| null`	Away side; null while the side is not decided yet (the source’s placeholder such as "WQF1").
homeScore	`ScoreSide`	One side’s score.
awayScore	`ScoreSide`	One side’s score.
winner	`Winner \| null`	Null until status.type is finished, and for a fight ruled a no contest (`fightResult.method` noContest). A match finished on penalties: the shoot-out winner, whatever the source says (on a second leg the source names the side that won the 90 minutes). Named from the score when the source leaves it out, or calls a match draw in a sport that cannot draw (regular time or overtime finishes; not cricket).
venue	`Venue \| null`	Venue, when known (often null in lower tiers). Filled on /fixtures/{id} and, when the source lists it, in date lists; the source’s round, team, player and live lists carry no venue, so null there means "not included", not "unknown" — read /fixtures/{id} for it.
clock	`Clock \| null`	Match clock; null when the source has none for the fixture and once it is over.
firstToServe	`Side \| null`	Deprecated (2026-10-23): the same value as `serving`. The source updates this field every game / leg, so it is the side serving (throwing) NOW, not who served first — read `serving`.
serving	`Side \| null`	Tennis / darts / other serve sports: the side serving (throwing) now, as the source updates it every game / leg. Null when the source does not say.
homeSeed	`string \| null`	Seeded competitions — tennis draws, playoff seeding (basketball, …): the home side’s seed ("1", "12") or entry status ("WC" wild card, "Q" qualifier, "LL" lucky loser, "PR" protected ranking, …), as the draw prints it. Null when unseeded.
awaySeed	`string \| null`	The away side’s seed or entry status, like homeSeed.
note	`string \| null`	Cricket: the source’s match note — the result line once finished ("Pakistan beat Sri Lanka by 37 runs"). Display only.
battingSide	`Side \| null`	Cricket: the side batting now. Null when no innings is in progress and for other sports.
fightResult	`FightResult \| null`	MMA / boxing: method, round and time of the finish. Null until status.type is finished, and when the source has no method.
fightDiscipline	`FightDiscipline \| null`	Combat sports (sport `mma`, which also carries boxing, kickboxing and Muay Thai cards): the discipline of this fight, when the source tags it. The source tags only some cards (ONE, Queensbury, some OKTAGON fights; not UFC or PFL), so null does not mean MMA.
referee	`Referee \| null`	The referee, when the source names one (football and some other sports; cricket: the match referee). Filled on /fixtures/{id}; lists carry null (not included).
homeManager	`ManagerRef \| null`	The home side’s manager / head coach for this fixture, when the source names one. Filled on /fixtures/{id}; lists carry null.
awayManager	`ManagerRef \| null`	The away side’s manager / head coach, like homeManager.
surface	`Surface \| null`	Tennis: the court surface. Filled on /fixtures/{id} and live lists; null for other sports.
toss	`CricketToss \| null`	Cricket: the toss, once made. Filled on /fixtures/{id}; null for other sports.
umpires	`string[] \| null`	Cricket: the on-field umpires as the source names them (often with a country code: "Asif Yaqoob (PAK)"); null when not listed and for other sports.
tvUmpire	`string \| null`	Cricket: the TV (third) umpire, like umpires.
previousLegFixtureId	`integer \| null`	Two-legged ties and playoff series: our id of the previous leg / game of the tie, when the source links it. Read /fixtures/{id} of it for the first-leg score.
aggregateWinner	`Side \| null`	Second leg of a two-legged tie: the side that went through, once finished — the source’s verdict, else read from `aggregated` (higher wins) or, level on aggregate, the shoot-out. Null otherwise, and on a level aggregate the source does not settle (an away-goals rule). `winner` is this match’s winner: on a second leg decided on penalties both name the shoot-out winner; otherwise the two can differ (a side can win the second leg and go out). Filled on /fixtures/{id}; lists and live snapshots may carry null (not included).
fightCard	`FightCard \| null`	MMA / boxing: card section, order and weight class of the bout, when the source lists them.
attendance	`integer \| null`	Spectators, when the source reports it (seen on NBA and MLB games, often only once the game is under way). Filled on /fixtures/{id}; lists carry null (not included).
matchFormat	`MatchFormat \| null`	Darts and esports: the match format (best of N sets / legs / games), when the source gives it; null for other sports.
inningState	`InningState \| null`	Baseball: the game state in play (inning, half, balls, strikes, outs, runners on base). Null unless the game is in progress (or interrupted), and for other sports. Live: in WebSocket deltas.
timeouts	`Timeouts \| null`	Basketball: timeouts left per side. Null unless the game is in progress (or interrupted), and when the source does not track them. Live: in WebSocket deltas.
playerMatch	`PlayerMatch \| null`	The player’s part in this fixture; null when the source lists nothing for it.

PlayerMatchThe player’s own part in one fixture.5 fields

Field	Type	Meaning
side	`Side \| null`	The side the player played for.
onBench	`boolean`	Named on the bench and did not come on.
rating	`number \| null`	Match rating (e.g. 7.4), rounded to 2 decimals; null when the player has none (did not play, not rated, not played yet).
statistics	`Record<string, number>`	Per-match statistics listed with the player’s fixtures, with the lineup statistics’ keys — football minutesPlayed; basketball points, rebounds, assists, fieldGoalsMade, fieldGoalsAttempted, secondsPlayed, plusMinus …; ice hockey goals, assists, shotsOnGoal, secondsPlayed …. Every …Percentage is 0–100. Empty when there are none.
incidents	`Record<string, number>`	Counts from the match’s incidents: goals (penalties included), penaltyGoals (of those, from the spot), assists, yellowCards, redCards …. Empty when there are none.

RankingTypeInfoOne ranking table of GET /v2/rankings; pass `type` to GET /v2/rankings/{type}.5 fields

Field	Type	Meaning
type	`RankingTypeSlug`	A ranking table we serve — the list with names is GET /v2/rankings.
name	`string`	Display name, e.g. "ATP singles ranking".
sport	`string`	Sport slug (as in /v2/sports).
gender	`TeamGender \| null`	Men’s or women’s ranking; null when it ranks countries.
entry	`RankingEntry`	What one row of a ranking stands for.

RankingA ranking table (GET /v2/rankings/{type}).3 fields

Field	Type	Meaning
type	`RankingTypeSlug`	A ranking table we serve — the list with names is GET /v2/rankings.
updatedAt	`string (ISO-8601 UTC) \| null`	When the source last updated the table.
rows	`RankingRow[]`	Every row, best first.

RankingRowOne row of a ranking table.9 fields

Field	Type	Meaning
position	`integer`	Place in the ranking, 1 = first. MMA division rankings list the champion first with position 0.
previousPosition	`integer \| null`	Place in the previous edition of the ranking (0 = the champion, MMA); null when the source does not give one.
points	`number \| null`	Ranking points (coefficients for UEFA); null for rankings without points (MMA).
previousPoints	`number \| null`	Points in the previous edition; null when the source does not give them.
bestPosition	`integer \| null`	Career-best place (tennis); null otherwise.
tournamentsPlayed	`integer \| null`	Tournaments counted (ATP); null otherwise.
team	`TeamRef \| null`	The ranked team or competitor (tennis players and fighters are team objects); null in a ranking of countries.
league	`LeagueRef \| null`	A ranking of countries (UEFA): the country’s top league; null otherwise.
country	`Country \| null`	The country of the team, competitor or (UEFA countries) the ranked country; null when unknown.

CategoryA grouping of leagues within a sport — the top level of the league directory.5 fields

Field	Type	Meaning
id	`integer`	Our category id — pass it as `category` to GET /v2/leagues.
name	`string`	Category name: a country ("England"), a region ("International", "World"), a tour ("ATP") or a game (esports).
slug	`string \| null`	URL slug.
sport	`string \| null`	Sport slug (as in /v2/sports).
country	`Country \| null`	The category’s country, when it is one; null for regions, tours and games. Its `code` is what GET /v2/leagues takes as `country`.

PlayerStatisticsRowOne player in a league season’s player-statistics explorer.3 fields

Field	Type	Meaning
player	`PlayerRef`	A player as referenced from any other object.
team	`TeamRef \| null`	The team the player played for in this league season (the latest one after a mid-season move).
statistics	`Record<string, number>`	Season totals of the requested group — v2 season-statistic keys (the same as /v2/players/{id}/statistics: averageRating, goals, expectedGoals, shotsOnGoal, cleanSheets, …; `…Percentage` 0–100). A key the source leaves out for a player is absent; averageRating is absent for a player without a rating (the source sends 0).

SeriesRefA racing series — the race sports’ counterpart of a league (motorsport championships; in cycling the whole men’s or women’s road calendar). Its seasons hold the races; /v2/series/{id}/standings ranks the competitors over a season.4 fields

Field	Type	Meaning
id	`integer`	Our series id.
name	`string`	Series name ("Formula 1", "MotoGP", "NASCAR Cup Series"). Cycling: the source groups every road race of one gender under one series ("Cycling Men", "Cycling Women").
slug	`string \| null`	URL slug.
sport	`string \| null`	Sport slug (as in /v2/sports).

CircuitWhere a motorsport race is held.4 fields

Field	Type	Meaning
name	`string \| null`	Circuit name ("Circuit of the Americas").
city	`string \| null`	City.
country	`Country \| null`	Country.
lengthMeters	`integer \| null`	Lap length in metres.meters

RaceA race: a motorsport race weekend (practice, qualifying, sprint, race) or a cycling race (one-day race or stage race).17 fields

Field	Type	Meaning
id	`integer`	Our race id.
name	`string`	Race name ("USA GP", "Tour de France", "Gran Piemonte").
slug	`string \| null`	URL slug.
sport	`string \| null`	Sport slug (as in /v2/sports).
series	`SeriesRef \| null`	The series the race belongs to.
season	`Season \| null`	The series season ("Formula 1 2026"); pass its id to the /v2/series/{id}/… endpoints.
round	`integer \| null`	Round of the championship, as the source numbers it (canceled races can leave the numbering uneven).
status	`StatusType \| null`	Race state: notstarted until its first session, inprogress, finished once every session is over, canceled, postponed.
startDate	`string (YYYY-MM-DD) \| null`	First day of the race (UTC). Sessions carry exact times. On /v2/races and /v2/races/{id} it is never later than the first session’s day; a season’s race list (/v2/series/{id}/races) has the source’s own days.
endDate	`string (YYYY-MM-DD) \| null`	Last day of the race (UTC); on /v2/races and /v2/races/{id} never earlier than the last session’s day.
country	`Country \| null`	Host country.
circuit	`Circuit \| null`	The circuit (motorsport; null in cycling).
laps	`integer \| null`	Scheduled laps of the main race (motorsport).
distanceMeters	`integer \| null`	Distance of the main race in metres (motorsport).meters
category	`string \| null`	The source’s category label of the race (cycling, e.g. "World Tour 1 Grand Tour").
winner	`TeamRef \| null`	Winner of the race (motorsport: of the main race; a cycling stage race: of the general classification), only once finished. A driver / rider is a TeamRef (kind individual), like a tennis player.
sessions	`RaceSession[]`	The sessions in start order (oldest first).

RaceSnapshotrace:{id} snapshot: the race with its sessions and the current session’s results.3 fields

Field	Type	Meaning
race	`Race`	A race: a motorsport race weekend (practice, qualifying, sprint, race) or a cycling race (one-day race or stage race).
session	`integer \| null`	The session the results are of: the one in progress, else the last one that finished; null before any session ran.
results	`RaceResult[]`	That session’s classification (as /v2/races/{id}/results?session=); [] when there is none yet.

RaceSummaryA race as listed in a season (no sessions; /v2/races/{id} has them).16 fields

Field	Type	Meaning
id	`integer`	Our race id.
name	`string`	Race name ("USA GP", "Tour de France", "Gran Piemonte").
slug	`string \| null`	URL slug.
sport	`string \| null`	Sport slug (as in /v2/sports).
series	`SeriesRef \| null`	The series the race belongs to.
season	`Season \| null`	The series season ("Formula 1 2026"); pass its id to the /v2/series/{id}/… endpoints.
round	`integer \| null`	Round of the championship, as the source numbers it (canceled races can leave the numbering uneven).
status	`StatusType \| null`	Race state: notstarted until its first session, inprogress, finished once every session is over, canceled, postponed.
startDate	`string (YYYY-MM-DD) \| null`	First day of the race (UTC). Sessions carry exact times. On /v2/races and /v2/races/{id} it is never later than the first session’s day; a season’s race list (/v2/series/{id}/races) has the source’s own days.
endDate	`string (YYYY-MM-DD) \| null`	Last day of the race (UTC); on /v2/races and /v2/races/{id} never earlier than the last session’s day.
country	`Country \| null`	Host country.
circuit	`Circuit \| null`	The circuit (motorsport; null in cycling).
laps	`integer \| null`	Scheduled laps of the main race (motorsport).
distanceMeters	`integer \| null`	Distance of the main race in metres (motorsport).meters
category	`string \| null`	The source’s category label of the race (cycling, e.g. "World Tour 1 Grand Tour").
winner	`TeamRef \| null`	Winner of the race (motorsport: of the main race; a cycling stage race: of the general classification), only once finished. A driver / rider is a TeamRef (kind individual), like a tennis player.

RaceSessionOne timed part of a race: a practice, qualifying, sprint or the race in motorsport; a stage of a cycling stage race (a one-day race has one session, the race).19 fields

Field	Type	Meaning
id	`integer`	Our session id (pass it to /v2/races/{id}/results?session=).
name	`string`	Session name as the source gives it ("Practice 1", "Qualification", "Grand Prix", "Stage 5").
type	`RaceSessionType`	What the session is.
status	`StatusType \| null`	Session state (the fixture status types; null when the source gives none).
startTime	`string (ISO-8601 UTC) \| null`	Scheduled start (UTC).
laps	`integer \| null`	Scheduled laps (motorsport races).
lapsCompleted	`integer \| null`	Laps run (a shortened race has fewer than `laps`).
distanceMeters	`integer \| null`	Race distance in metres (a cycling stage’s length).meters
departureCity	`string \| null`	Start town (cycling).
arrivalCity	`string \| null`	Finish town (cycling).
profile	`StageProfile \| null`	Terrain (cycling).
weather	`RaceWeather \| null`	Weather (once the session has run).
trackCondition	`TrackCondition \| null`	Dry or wet.
airTemperatureC	`number \| null`	Air temperature in °C.celsius
trackTemperatureC	`number \| null`	Track temperature in °C (motorsport).celsius
humidityPercent	`number \| null`	Relative humidity, 0–100.percent
safetyCar	`boolean \| null`	True when a safety car came out (null: not reported).
winner	`TeamRef \| null`	The session’s winner (fastest in practice / qualifying), only once the session is finished.
parts	`RaceSessionPart[]`	The parts of a knock-out qualifying or sprint qualifying session (Q1, Q2…), in run order; empty for every other session and where the source lists none.

RaceSessionPartOne part of a knock-out qualifying session (MotoGP Q1 / Q2, Formula 1 Q1–Q3), in run order.4 fields

Field	Type	Meaning
id	`integer`	Our id of the part (pass it to /v2/races/{id}/results?session= for that part alone).
name	`string`	The part’s label in the series’ own terms: "Q1", "Q2", "Q3" (qualifying), "SQ1"… (sprint qualifying), numbered in run order.
status	`StatusType \| null`	Part state (null when the source gives none — Formula 1 parts).
startTime	`string (ISO-8601 UTC) \| null`	Scheduled start (UTC; null when the source gives none).

RaceResultOne competitor’s line in a session’s or a race’s classification.22 fields

Field	Type	Meaning
position	`integer \| null`	Place; null for a competitor out of the classification (see `state`).
competitor	`TeamRef \| null`	The driver / rider (a TeamRef, kind individual).
team	`TeamRef \| null`	The competitor’s team (constructor, cycling team).
state	`RaceResultState`	Classified, or why not.
outReason	`string \| null`	Why the competitor is out, as the source words it ("Retired"); null when classified.
carNumber	`integer \| null`	Car / bike number (motorsport).
gridPosition	`integer \| null`	Starting position (races; null from the pit lane or unknown).
startedFromPitLane	`boolean \| null`	True when the competitor started from the pit lane.
laps	`integer \| null`	Laps as the source counts them.
lapsBehind	`integer \| null`	Laps behind the winner (lapped cars); null when on the lead lap.
lapsLed	`integer \| null`	Laps led.
pitStops	`integer \| null`	Pit stops.
timeMs	`integer \| null`	Total time in ms (race / stage), or the best lap (practice, qualifying). Null for the lapped and the out, and when the source recorded no time for a classified rider.milliseconds
gapMs	`integer \| null`	Behind the winner in ms; null for the winner, the lapped and the out, and when the source recorded no time for a classified rider.milliseconds
intervalMs	`integer \| null`	Behind the competitor one place ahead in ms; null for the winner, the lapped and the out, and when the source recorded no time for a classified rider.milliseconds
bestLapMs	`integer \| null`	The competitor’s fastest lap in ms (races).milliseconds
bestLapNumber	`integer \| null`	Lap on which it was set.
fastestLap	`boolean \| null`	True for the fastest lap of the session.
points	`number \| null`	Championship points scored here.
tyreStints	`TyreStint[]`	Tyre stints in order (Formula 1 races; empty otherwise).
cycling	`CyclingStanding \| null`	Side classifications (a cycling stage race’s overall result; null otherwise).
part	`string \| null`	The qualifying part this line comes from ("Q2", "Q1") when the classification is assembled from the parts (MotoGP qualifying: the source has no table of its own) — timeMs / gapMs / intervalMs are then that part’s; null otherwise.

TyreStintOne stint on one set of tyres.2 fields

Field	Type	Meaning
compound	`TyreCompound`	The compound.
laps	`integer \| null`	Laps on this set.

CyclingStandingA rider’s side classifications in a stage race’s overall result.7 fields

Field	Type	Meaning
jersey	`CyclingJersey \| null`	The leader’s jersey this rider holds, if any.
pointsPosition	`integer \| null`	Place in the points classification.
points	`number \| null`	Points-classification points.
mountainsPosition	`integer \| null`	Place in the mountains classification.
mountainsPoints	`number \| null`	Mountains-classification points.
youngRiderPosition	`integer \| null`	Place in the young-rider classification.
youngRiderTimeMs	`integer \| null`	Total time counted for the young-rider classification, in ms.milliseconds

SeriesStandingsRowA row of a series’ championship table.10 fields

Field	Type	Meaning
position	`integer \| null`	Championship place.
competitor	`TeamRef \| null`	Who is ranked: the driver / rider (`type=competitors`) or the team (`type=teams`).
team	`TeamRef \| null`	The driver’s / rider’s team; null in the teams’ table.
points	`number \| null`	Championship points.
wins	`integer \| null`	Race wins.
podiums	`integer \| null`	Podium finishes.
polePositions	`integer \| null`	Pole positions.
fastestLaps	`integer \| null`	Fastest laps.
racesStarted	`integer \| null`	Races started.
racesWithPoints	`integer \| null`	Races that scored points.

WinProbabilityOur own in-play win-probability model for a football fixture (documented in the docs): pre-match expected goals (v2: from both teams’ recent matches in all competitions, their domestic tables and league-strength coefficients, blended with the competition’s table and form), then updated by time left, score, red cards and momentum. An analysis indicator — not betting advice; no bookmaker odds are used.7 fields

Field	Type	Meaning
fixtureId	`integer`	Our fixture id.
model	`WinProbabilityModel`	Model version (the docs describe each). A new version is announced in the changelog.
updatedAt	`string (ISO-8601 UTC)`	When this estimate was computed.
prematch	`WinProbabilityPrematch`	The pre-match estimate and the inputs it was built from. Fixed once computed (it does not move when the table is updated after the match).
current	`WinProbabilityState`	The latest estimate: the pre-match one before kick-off, certainty (1 / 0 / 0) once finished.
series	`WinProbabilityPoint[]`	The curve, oldest first (by `at`): a point at kick-off, one per match minute, and one right after every goal, red card, period start / end and big missed chance. Empty before kick-off. History: a point is stored once it is two minutes old (or the match is over) and is not changed after, so the curve shows what the model said at the time; kept for good. With `?since=` only the points after that instant.
inputs	`{ shotmap: boolean; momentum: boolean; events: boolean }`	Which live inputs the in-play estimate used.

WinProbabilityPrematchThe pre-match estimate and the inputs it was built from. Fixed once computed (it does not move when the table is updated after the match).9 fields

Field	Type	Meaning
home	`number`	Pre-match probability of a home win, 0–1.ratio
draw	`number`	Pre-match probability of a draw, 0–1.ratio
away	`number`	Pre-match probability of an away win, 0–1.ratio
homeExpectedGoals	`number`	The model’s expected goals for the home side over the whole match (λ home).
awayExpectedGoals	`number`	The model’s expected goals for the away side over the whole match (λ away).
standings	`boolean`	Whether the league table was available (attack / defence ratings); false = league or global averages were used.
form	`boolean`	Whether the pre-match form guide was available.
allCompetitions	`boolean \| null`	Model v2: whether the teams’ recent matches in all competitions were available (strength from up to their last 20 results, weighted by age and by the opponent’s strength). Null for model v1.
domesticTables	`boolean \| null`	Model v2: whether the teams’ domestic league tables were available (for a cup or European match: their own leagues’ tables, put on one scale by our league-strength coefficients). Null for model v1.

WinProbabilityStateOne estimate of the result: home / draw / away probabilities at a moment of the match.8 fields

Field	Type	Meaning
home	`number`	Probability that the home side ends the match ahead on the scoreboard, 0–1.ratio
draw	`number`	Probability that the match ends level on the scoreboard (a penalty shoot-out is not counted), 0–1. home + draw + away = 1.ratio
away	`number`	Probability that the away side ends the match ahead on the scoreboard, 0–1.ratio
minute	`integer \| null`	Match minute of the estimate, as incidents count it (a goal in the 23rd minute is minute 23; 45+2 is minute 45, addedMinute 2). Null before kick-off.minutes
addedMinute	`integer \| null`	Minutes into added time, else null.minutes
homeScore	`integer \| null`	Home goals at that moment. Null before kick-off.
awayScore	`integer \| null`	Away goals at that moment. Null before kick-off.
at	`string (ISO-8601 UTC) \| null`	UTC instant of the estimate. A curve point: the moment of the match it describes (the end of that minute, the goal, the whistle) — measured from the match clock while it runs, else estimated from kick-off (15 min half-time). `current`: when it was computed (in play / before kick-off) or the end of the match (finished). Non-decreasing along the series. Null only for points stored before 2026-10-22 whose kick-off time is unknown.

WinProbabilityPointA point of the win-probability curve: an estimate and why it was emitted.9 fields

Field	Type	Meaning
home	`number`	Probability that the home side ends the match ahead on the scoreboard, 0–1.ratio
draw	`number`	Probability that the match ends level on the scoreboard (a penalty shoot-out is not counted), 0–1. home + draw + away = 1.ratio
away	`number`	Probability that the away side ends the match ahead on the scoreboard, 0–1.ratio
minute	`integer \| null`	Match minute of the estimate, as incidents count it (a goal in the 23rd minute is minute 23; 45+2 is minute 45, addedMinute 2). Null before kick-off.minutes
addedMinute	`integer \| null`	Minutes into added time, else null.minutes
homeScore	`integer \| null`	Home goals at that moment. Null before kick-off.
awayScore	`integer \| null`	Away goals at that moment. Null before kick-off.
at	`string (ISO-8601 UTC) \| null`	UTC instant of the estimate. A curve point: the moment of the match it describes (the end of that minute, the goal, the whistle) — measured from the match clock while it runs, else estimated from kick-off (15 min half-time). `current`: when it was computed (in play / before kick-off) or the end of the match (finished). Non-decreasing along the series. Null only for points stored before 2026-10-22 whose kick-off time is unknown.
reason	`WinProbabilityReason`	Why a win-probability point was emitted.

CommentaryAI match commentary for a football fixture, written by SportsAPI AI from our own data only: one short entry per goal, red card, missed penalty, VAR decision, period start / end, big chance and sustained momentum swing, plus half-time and full-time summaries. Written once and shared by every client.2 fields

Field	Type	Meaning
fixtureId	`integer`	Our fixture id.
entries	`CommentaryEntry[]`	Oldest first (by `seq`), like every timeline list. Empty until something has been written — commentary is generated only while someone follows the match (this endpoint or the fixture:{id} channel; a featured match on sportsapi.app always has it), so a match nobody watched has none.

CommentaryEntryOne AI commentary entry.7 fields

Field	Type	Meaning
seq	`integer`	Position in the fixture’s commentary: 1, 2, 3, … in the order written. Never reused.
kind	`CommentaryKind`	What the entry is about — the most important event when it covers several.
minute	`integer \| null`	Match minute of the newest event it covers (as incidents count it: 45+2 is minute 45, addedMinute 2). Summaries: the whistle — halfTime 45, fullTime 90 (120 after extra time); null on a fullTime entry written before 2026-10-23.minutes
addedMinute	`integer \| null`	Minutes into added time, else null.minutes
text	`string`	One or two English sentences (summaries: up to three), written by SportsAPI AI from our own data of the match only — events, score, clock, statistics and our win-probability model. No betting language. Plain text.
model	`string`	The model that wrote it: "sportsapi-ai" (SportsAPI AI). Entries served before 2026-11-02 named the underlying provider model.
createdAt	`string (ISO-8601 UTC)`	When it was written.

PlayByPlayThe source’s text commentary, one entry per action (football, basketball, …): written by the source’s data provider, not by us — our own AI commentary is /commentary.1 field

Field	Type	Meaning
entries	`PlayByPlayEntry[]`	Oldest first, like every timeline list.

PlayByPlayEntryOne line of the source’s text commentary (play by play).21 fields

Field	Type	Meaning
type	`PlayByPlayType`	What a play-by-play entry records.
side	`Side \| null`	The side of `player` (or of the team the entry is about); null for match-level entries (kick-off, period ends, delays).
period	`PeriodKey \| null`	The period it happened in; null when the source gives none (football’s final whistle).
minute	`integer \| null`	Football: match minute (added time apart: 45+6 → minute 45, addedMinute 6). Null in clock sports (basketball: see `periodSecond`) and when the source gives no time.minutes
addedMinute	`integer \| null`	Football: minutes into added time (45+6 → 6); null otherwise.minutes
periodSecond	`integer \| null`	Clock sports (basketball): seconds played in the period; null in football.seconds
periodSecondsLeft	`integer \| null`	Clock sports (basketball): the game clock — seconds left in the period; null in football.seconds
at	`string (ISO-8601 UTC) \| null`	When the action was recorded (UTC), where the source stamps it (basketball); null otherwise.
text	`string`	The commentary line, in English, as the source writes it.
player	`PlayerRef \| null`	The player the entry is about: shooter, scorer, booked player, fouling player, rebounder, …
assist	`PlayerRef \| null`	The player who assisted it, when the source names one (basketball baskets).
playerIn	`PlayerRef \| null`	substitution: the player coming on.
playerOut	`PlayerRef \| null`	substitution: the player going off.
drawnBy	`PlayerRef \| null`	foul (basketball): the player who drew the foul.
stolenBy	`PlayerRef \| null`	possessionChange (basketball): the player who stole the ball.
goalkeeper	`PlayerRef \| null`	The goalkeeper the source attaches to a shot (football); the source also sets it on a few basketball shots, meaning not verified.
homeScore	`number \| null`	scoreChange / penaltyScored: the home score after it; null on other entries.
awayScore	`number \| null`	scoreChange / penaltyScored: the away score after it; null on other entries.
scoreType	`PlayByPlayScoreType \| null`	scoreChange (basketball): what the basket was worth; null in football and on other entries.
position	`CourtPosition \| null`	Basketball: where on the court; null when the source gives no location.
zone	`CourtZone \| null`	Basketball: the court zone; null when the source gives none.

CourtPositionWhere on the court an action happened (basketball), in the source’s court units.2 fields

Field	Type	Meaning
x	`number`	Horizontal court coordinate, in the source’s court units.
y	`number`	Vertical court coordinate, in the source’s court units.

LeagueDetailA league profile (/v2/leagues/{id}): the LeagueRef fields plus level, title holder, record holders and the divisions above and below. Host countries are per season (/v2/leagues/{id}/seasons/{seasonId}).17 fields

Field	Type	Meaning
id	`integer`	Our league id.
name	`string`	League / competition name.
slug	`string \| null`	URL slug.
sport	`string \| null`	Sport slug (as in /v2/sports).
category	`string \| null`	The source’s grouping of the league: a country ("England"), a region ("International", "North America", "World"), a tour ("ATP", "WTA") or a game (esports: "Counter Strike"). Not always a country — see `country`.
country	`Country \| null`	The league’s country, when its category is one; null for regions, tours and games.
image	`string (URL) \| null`	Logo on our CDN; null when the league has no image.
tier	`integer \| null`	Level in its country’s pyramid: 1 = top flight (Premier League), 2 = second tier (Championship); null for cups, international and non-pyramid competitions.
gender	`TeamGender \| null`	Men’s or women’s competition; null when the source does not say.
titleHolder	`TeamRef \| null`	The reigning champion (the last completed season’s winner), when the source names one.
titleHolderTitles	`integer \| null`	How many times the title holder has won the competition.
mostTitles	`integer \| null`	The record number of titles won by one team.
mostTitlesTeams	`TeamRef[]`	The team(s) holding that record (several on a tie); [] when the source names none.
upperDivisions	`LeagueRef[]`	The league(s) one level up (where promoted teams go); [] for a top flight or a cup.
lowerDivisions	`LeagueRef[]`	The league(s) one level down (where relegated teams go); [] when none is listed.
currentSeasonStart	`string (YYYY-MM-DD) \| null`	First day of the current (or upcoming) season, UTC.
currentSeasonEnd	`string (YYYY-MM-DD) \| null`	Last day of the current season, UTC (planned).

RefereeProfileA referee (/v2/referees/{id}): career totals over every competition the source covers (`games`, cards) and the figures per competition.11 fields

Field	Type	Meaning
id	`integer`	Our referee id.
name	`string`	Referee name.
slug	`string \| null`	URL slug.
country	`Country \| null`	The referee’s country, when the source gives it.
games	`integer \| null`	Matches the source has recorded the referee in charge of (career, all competitions).
yellowCards	`integer \| null`	Yellow cards shown over those matches; null in sports without cards (cricket).
redCards	`integer \| null`	Straight red cards shown over those matches; null in sports without cards.
yellowRedCards	`integer \| null`	Second-yellow sending-offs over those matches; null in sports without cards.
image	`string (URL) \| null`	Photo on our CDN; null when the referee has no image (or it is not uploaded yet). Since 2026-11-04.
sport	`string \| null`	Sport slug.
competitions	`RefereeCompetition[]`	Career figures per competition, in the source’s order; [] when the source has none.

RefereeCompetitionA referee’s career figures in one competition — divide by `appearances` for a per-match rate.6 fields

Field	Type	Meaning
league	`LeagueRef`	The competition.
appearances	`integer`	Matches refereed in it.
yellowCards	`integer \| null`	Yellow cards shown in those matches.
redCards	`integer \| null`	Straight red cards shown.
yellowRedCards	`integer \| null`	Second-yellow sending-offs.
penalties	`integer \| null`	Penalties awarded.

ManagerProfileA manager / head coach (/v2/managers/{id}): profile, career record and the jobs behind it.12 fields

Field	Type	Meaning
id	`integer`	Our manager id (the same id as ManagerRef on fixtures and teams).
name	`string`	Name.
slug	`string \| null`	URL slug.
shortName	`string \| null`	Short name, e.g. "J. Mourinho".
image	`string (URL) \| null`	Photo on our CDN; null when the manager has no image (or it is not uploaded yet). Since 2026-11-04.
sport	`string \| null`	Sport slug.
country	`Country \| null`	Nationality.
dateOfBirth	`string (YYYY-MM-DD) \| null`	Date of birth.
preferredFormation	`string \| null`	Football: his preferred formation as the source writes it ("4-2-3-1").
team	`TeamRef \| null`	The team he manages now; null when without a job.
career	`ManagerRecord \| null`	Career results over every job the source covers.
stints	`ManagerStint[]`	His jobs, newest first (like transfer lists); [] when the source has no history.

ManagerRecordA manager’s results over a period (a whole career or one job). Points per game = points / games.7 fields

Field	Type	Meaning
games	`integer`	Matches in charge.
wins	`integer`	Won.
draws	`integer \| null`	Drawn; null in sports without draws.
losses	`integer`	Lost.
scoresFor	`number \| null`	Goals (points, …) scored by his teams; null when the source does not give them.
scoresAgainst	`number \| null`	Conceded.
points	`number \| null`	Table points won (football: 3 a win, 1 a draw); null when the source does not give them.

ManagerStintOne job in a manager’s career.4 fields

Field	Type	Meaning
team	`TeamRef \| null`	The team he managed.
from	`string (YYYY-MM-DD) \| null`	First day in charge (UTC).
to	`string (YYYY-MM-DD) \| null`	Last day in charge (UTC). For the current job the source gives a FUTURE date (the end of his contract as it has it), not null.
record	`ManagerRecord \| null`	Results in that job; null when the source has none (youth teams, old spells).

TrophyOne competition in a team’s trophy cabinet.5 fields

Field	Type	Meaning
league	`LeagueRef`	The competition won.
competitionType	`CompetitionType \| null`	National league, national cup or international competition.
major	`boolean \| null`	Whether the source counts it as a major trophy (a league or cup, not a super cup).
count	`integer`	Times won.
seasons	`TrophySeason[]`	The seasons it was won in, newest first (like season lists). May be shorter than `count` for very old titles the source does not date.

TrophySeasonA season a trophy was won in (the source gives the label only — no season id).3 fields

Field	Type	Meaning
year	`string`	Season label as the source writes it ("23/24", "1932/1933", "2026").
startYear	`integer \| null`	The year that season started; null when the label cannot be read.
endYear	`integer \| null`	The year it ended.

PositionHistoryPointWhere a team stood in the table at the end of one week of the season.5 fields

Field	Type	Meaning
week	`integer`	Week of the season, 1-based (the source’s weekly buckets).
from	`string (YYYY-MM-DD)`	First day of that week (UTC).
to	`string (YYYY-MM-DD)`	Last day of that week (UTC, inclusive).
position	`integer \| null`	The team’s league position at the end of that week.
fixtureIds	`integer[]`	The team’s fixtures of the competition in that week (our ids; usually one, none in a blank week).

FighterCareerStatisticsAn MMA fighter’s career statistics as the source computes them over the fights it has detailed data for (not necessarily the whole career): per-round and per-15-minute rates, shares 0–100 and time in position. Keys follow the match-statistics vocabulary (`significantStrikesHeadLanded`, `takedownsSucceeded`, …) with the rate in the name. Null = the source has no figure.50 fields

Field	Type	Meaning
strikesLandedPerRound	`number \| null`	Strikes landed per round (all strikes).
strikesDistanceLandedPerRound	`number \| null`	Strikes landed at distance per round.
strikesDistancePercentage	`number \| null`	Share of his strikes landed at distance, 0–100.percent
strikesClinchLandedPerRound	`number \| null`	Strikes landed in the clinch per round.
strikesClinchPercentage	`number \| null`	Share landed in the clinch, 0–100.percent
strikesGroundLandedPerRound	`number \| null`	Strikes landed on the ground per round.
strikesGroundPercentage	`number \| null`	Share landed on the ground, 0–100.percent
strikesReceivedPerRound	`number \| null`	Strikes absorbed per round.
significantStrikesLandedPerRound	`number \| null`	Significant strikes landed per round.
significantStrikesPercentage	`number \| null`	Share of his landed strikes that were significant, 0–100.percent
significantStrikesHeadLandedPerRound	`number \| null`	Significant strikes to the head per round.
significantStrikesHeadPercentage	`number \| null`	Share of significant strikes to the head, 0–100.percent
significantStrikesBodyLandedPerRound	`number \| null`	Significant strikes to the body per round.
significantStrikesBodyPercentage	`number \| null`	Share to the body, 0–100.percent
significantStrikesLegsLandedPerRound	`number \| null`	Significant strikes to the legs per round.
significantStrikesLegsPercentage	`number \| null`	Share to the legs, 0–100.percent
significantStrikesDistanceLandedPerRound	`number \| null`	Significant strikes at distance per round.
significantStrikesDistancePercentage	`number \| null`	Share at distance, 0–100.percent
significantStrikesClinchLandedPerRound	`number \| null`	Significant strikes in the clinch per round.
significantStrikesClinchPercentage	`number \| null`	Share in the clinch, 0–100.percent
significantStrikesGroundLandedPerRound	`number \| null`	Significant strikes on the ground per round.
significantStrikesGroundPercentage	`number \| null`	Share on the ground, 0–100.percent
significantStrikesReceivedPerRound	`number \| null`	Significant strikes absorbed per round.
takedownsAttemptedPer15Min	`number \| null`	Takedowns attempted per 15 minutes of fighting.
takedownsSucceededPer15Min	`number \| null`	Takedowns landed per 15 minutes.
takedownsSucceededPercentage	`number \| null`	Takedown accuracy: landed / attempted, 0–100.percent
takedownsReceivedPer15Min	`number \| null`	Takedowns his opponents attempted per 15 minutes.
takedownsDefendedPer15Min	`number \| null`	Of those, defended per 15 minutes.
takedownsDefendedPercentage	`number \| null`	Takedown defence: defended / attempted against him, 0–100.percent
transitionsSucceededPer15Min	`number \| null`	Positional transitions (ground advances) made per 15 minutes.
transitionsReceivedPer15Min	`number \| null`	Transitions his opponents made per 15 minutes.
submissionsAttemptedPer15Min	`number \| null`	Submission attempts per 15 minutes.
submissionsSucceededPer15Min	`number \| null`	Submissions finished per 15 minutes.
submissionsSucceededPercentage	`number \| null`	Submissions finished / attempted, 0–100.percent
submissionsReceivedPer15Min	`number \| null`	Submission attempts against him per 15 minutes.
submissionsDefendedPer15Min	`number \| null`	Of those, defended per 15 minutes.
submissionsDefendedPercentage	`number \| null`	Submission defence, 0–100.percent
distanceSeconds	`number \| null`	Time fought at distance, career total.seconds
distanceSecondsPerRound	`number \| null`	Time at distance per round.seconds
distancePercentage	`number \| null`	Share of fight time at distance, averaged per round, 0–100 — the source’s figure: it can pass 100 by a fraction (100.2 seen), and the distance / clinch / ground shares need not add up to 100.percent
clinchSeconds	`number \| null`	Time in the clinch, career total.seconds
clinchSecondsPerRound	`number \| null`	Time in the clinch per round.seconds
clinchPercentage	`number \| null`	Share of fight time in the clinch, averaged per round, 0–100 (see `distancePercentage`).percent
clinchControlSeconds	`number \| null`	Time controlling the opponent in the clinch, career total.seconds
clinchControlPercentage	`number \| null`	Share of fight time in clinch control, 0–100.percent
groundSeconds	`number \| null`	Time on the ground, career total.seconds
groundSecondsPerRound	`number \| null`	Time on the ground per round.seconds
groundPercentage	`number \| null`	Share of fight time on the ground, averaged per round, 0–100 (see `distancePercentage`).percent
groundControlSeconds	`number \| null`	Time in control on the ground, career total.seconds
groundControlPercentage	`number \| null`	Share of fight time in ground control, 0–100.percent

FighterRecordAn MMA / boxing fighter’s CAREER record (e.g. 28-0-4). Not the same figure as /v2/fixtures/{id}/form, which is the source’s pre-fight form in that event’s competition (e.g. 8-0-3 for the same fighter).4 fields

Field	Type	Meaning
wins	`integer`	Career wins (professional, every promotion — the source’s career record).
draws	`integer`	Career draws.
losses	`integer`	Career losses.
recent	`RecentFight[]`	The last fights (up to five), oldest first, with the method. The source keeps no career breakdown by method (and lists only the recent fights it covers), so there is none here.

RecentFightOne of a fighter’s most recent fights, as the source’s record lists it.2 fields

Field	Type	Meaning
result	`FormResult`	Win, draw or loss for this fighter.
method	`FightMethod \| null`	How the fight was decided (KO, TKO, submission, decisions, …); null when the source gives no method.

Enums

Every closed value set, with what each value means. A value not listed here is never sent — when the source introduces one we do not classify yet, the field reads other (or null) until this list grows.

SideA side of the fixture.2 values

home	The fixture’s home side.
away	The fixture’s away side.

WinnerResult of a finished fixture.3 values

home	Home side won.
away	Away side won.
draw	Draw.

StatusTypeCoarse match state — what to filter on.7 values

notstarted	Not started yet (scheduled, or its start is delayed).
inprogress	Being played — including breaks such as half-time and a fight awaiting its decision.
interrupted	Stopped mid-match (weather, crowd, …) and expected to resume.
willcontinue	A multi-day match between days (cricket Tests: end of day N).
postponed	Moved to a later date; the fixture keeps its id.
canceled	Will not be played (canceled, abandoned, removed).
finished	Over, with a result.

StatusPhaseFiner match state — what a scoreboard shows.12 values

notstarted	Scheduled, not started.
delayed	Past its start time, start delayed.
inprogress	A period is being played (status.period says which).
break	A scheduled pause inside the match: half-time, pause between sets, awaiting extra time or penalties, cricket lunch / tea / drinks.
awaitingResult	Play is over, the result is not announced yet (combat sports judges’ decision).
interrupted	Stopped unexpectedly, expected to resume.
suspended	Suspended by the organiser; may resume another day.
willcontinue	A multi-day match between days.
postponed	Moved to a later date.
canceled	Canceled before it started, or removed.
abandoned	Started and called off without a result.
finished	Over — status.finish says how it was decided.

FinishTypeHow a finished match was decided.7 values

regular	Decided in regulation (also every set / frame / game sport’s normal finish).
overtime	Decided in overtime / extra time / extra innings (upstream “AET”).
penalties	Decided by a penalty shoot-out (upstream “AP”).
goldenSet	Decided by a golden set (volleyball).
walkover	Awarded without being played.
retired	One side retired during the match (tennis).
defaulted	One side was defaulted / disqualified.

FightMethodHow a fight was won.11 values

ko	Knockout.
tko	Technical knockout (referee or doctor stoppage).
submission	Submission.
unanimousDecision	Judges’ decision, all judges agreeing.
splitDecision	Judges’ decision, split.
majorityDecision	Judges’ decision by a majority: two judges for the winner and one scoring a draw — or, with `winner: "draw"`, a majority draw (two judges scoring a draw; real boxing capture 2026-10-19).
technicalDecision	Decision on the scorecards after a stoppage.
pointsDecision	Boxing: a points decision (the source’s PTS — scored by the referee alone, as in British small-hall bouts; a draw comes with `winner: "draw"`).
disqualification	Disqualification.
noContest	No contest.
other	A method not classified yet (the source’s code is logged).

FightDisciplineThe combat discipline of a fight.6 values

mma	Mixed martial arts.
boxing	Boxing.
kickboxing	Kickboxing.
muayThai	Muay Thai.
grappling	Submission grappling.
other	A discipline not classified yet (the source’s value is logged).

SurfaceTypeA tennis court surface.5 values

hard	Hard court.
clay	Clay (red or green).
grass	Grass.
carpet	Carpet (indoor synthetic).
other	A surface not classified yet (the source’s text is in `name`).

TossDecisionWhat a cricket toss winner chose.2 values

bat	The toss winner chose to bat first.
bowl	The toss winner chose to bowl (field) first.

FightCardSectionThe part of a fight card a bout is on.4 values

mainCard	The main card.
prelims	The preliminary card.
earlyPrelims	The early preliminary card.
other	A section not classified yet (the source’s value is logged).

PositionPlaying position, per sport (the source’s letter code is in `positionCode`).53 values

goalkeeper	Goalkeeper (football, futsal, handball).
defender	Defender (football, futsal).
midfielder	Midfielder (football, futsal).
forward	Forward (football, futsal, basketball, ice hockey, rugby).
guard	Guard (basketball).
center	Center (basketball, ice hockey, American football).
guardForward	Guard-forward (basketball).
forwardCenter	Forward-center (basketball).
goalie	Goalie (ice hockey).
defenseman	Defenseman (ice hockey).
leftWing	Left wing (ice hockey, handball).
rightWing	Right wing (ice hockey, handball).
leftBack	Left back (handball).
rightBack	Right back (handball).
centreBack	Centre back (handball).
pivot	Pivot / line player (handball).
quarterback	Quarterback (American football).
runningBack	Running back / fullback (American football).
wideReceiver	Wide receiver (American football).
tightEnd	Tight end (American football).
offensiveLineman	Offensive lineman (American football).
offensiveTackle	Offensive tackle (American football).
offensiveGuard	Offensive guard (American football).
defensiveTackle	Defensive tackle / nose tackle (American football).
defensiveEnd	Defensive end (American football).
defensiveLineman	Defensive lineman (American football).
linebacker	Linebacker (American football).
cornerback	Cornerback (American football).
safety	Safety (American football).
defensiveBack	Defensive back (American football).
kicker	Kicker (American football).
punter	Punter (American football).
longSnapper	Long snapper (American football).
pitcher	Pitcher (baseball).
startingPitcher	Starting pitcher (baseball).
reliefPitcher	Relief pitcher (baseball).
catcher	Catcher (baseball).
firstBase	First baseman (baseball).
secondBase	Second baseman (baseball).
thirdBase	Third baseman (baseball).
shortstop	Shortstop (baseball).
leftField	Left fielder (baseball).
centerField	Center fielder (baseball).
rightField	Right fielder (baseball).
infielder	Infielder (baseball).
outfielder	Outfielder (baseball).
designatedHitter	Designated hitter (baseball).
batter	Batter (cricket).
bowler	Bowler (cricket).
allRounder	All-rounder (cricket).
wicketKeeper	Wicket-keeper (cricket).
back	Back (rugby: any of the backs — the source does not say which).
other	A position code without a mapping for this sport (`positionCode` keeps it).

AvailabilityWhether a missing player is ruled out or doubtful.2 values

out	Ruled out of this fixture.
doubtful	May miss this fixture.

MissingReasonWhy a player is missing.9 values

injury	Injured (`description` names it when known, e.g. "Hamstring Injury").
illness	Ill.
suspension	Suspended (other than a card ban).
absent	Absent for another reason (personal, international duty, …).
yellowCardSuspension	Banned for accumulated yellow cards.
yellowRedCardSuspension	Banned after a second-yellow sending-off.
redCardSuspension	Banned after a straight red card.
onLoan	On loan and not eligible against the parent club.
other	A reason the source sent that this API does not classify yet.

StatKindHow to read a statistic’s value and total.3 values

value	`value` is the number shown (57 for "57%", 2.04 for "2.04"); `total` is null.
ratio	`value` successes out of `total` attempts ("33/53 (62%)" → 33 of 53; a percentage-only display such as "42%" is still value / total).
time	`value` is seconds; `total` is the seconds available (the period length), e.g. time spent in the lead.

HigherIsWhether more is better.2 values

better	A higher value is good for that side (shots, possession).
worse	A higher value is bad for that side (fouls, turnovers, errors).

IncidentTypeWhat happened.9 values

goal	A score: goal, basket, try, touchdown, … (`detail` says which kind). Set sports (volleyball, table tennis, badminton) do not list points — their set ends are `period` rows.
card	A card shown to a player (or a team official).
substitution	A player change: playerIn replaces playerOut.
period	A period ended — only that: a period still being played has no row (since 2026-10-23). `period` names the period that ended, `text` is the scoreboard label (HT, FT, Q2, 3rd period, 2. set, …). The scores are the running match score at that moment; in set sports (volleyball, table tennis, badminton) the sets won so far (the set’s own points are in the fixture’s `periods` and in /points).
injuryTime	Added time announced: `addedMinute` minutes after `minute`.
varDecision	A video-review decision (`detail`), `confirmed` = the original call stood.
inGamePenalty	A penalty kick during play that did not produce a goal (`detail` missed); a scored one is a `goal` with detail `penalty`.
shootoutPenalty	One kick of a penalty shoot-out: `shootoutSequence` = the overall kick order (1, 2, 3, … both sides counted), `shootoutRound` = the round (the taker’s side’s 1st, 2nd, … kick).
suspension	A timed exclusion (ice hockey penalty, handball two minutes): `durationSeconds`, `reason`.

IncidentDetailThe kind of incident within its type.31 values

regular	goal: an ordinary goal; substitution: a tactical change.
ownGoal	goal: scored by the conceding side (`side` = the team credited with the goal).
penalty	goal: a penalty kick / 7-metre throw converted.
powerPlay	goal (ice hockey): scored with a man advantage.
shortHanded	goal (ice hockey): scored a man down.
emptyNet	goal (ice hockey): scored into an empty net.
onePoint	goal (basketball): a free throw.
twoPoints	goal: basketball 2-point field goal; rugby conversion.
threePoints	goal: basketball 3-pointer; rugby penalty goal or drop goal.
try	goal (rugby): a try.
touchdown	goal (American football): a touchdown.
extraPoint	goal (American football): an extra point.
fieldGoal	goal (American football): a field goal.
twoPointConversion	goal (American football): a two-point conversion.
safety	goal (American football): a safety.
yellow	card: yellow card.
secondYellow	card: second yellow, i.e. a sending-off.
red	card: straight red card.
injury	substitution: forced by an injury.
goalAwarded	varDecision: goal given after review.
goalNotAwarded	varDecision: goal ruled out after review.
penaltyAwarded	varDecision: penalty given after review.
penaltyNotAwarded	varDecision: penalty cancelled after review.
cardUpgrade	varDecision: card upgraded (e.g. yellow → red).
cardDowngrade	varDecision: card downgraded.
scored	shootoutPenalty: kick scored.
missed	shootoutPenalty / inGamePenalty: kick missed or saved (`reason` says which).
twoMinutes	suspension: a two-minute (minor) penalty.
fiveMinutes	suspension: a five-minute (major) penalty.
tenMinutes	suspension: a ten-minute (misconduct) penalty.
other	A kind the source sent that this API does not classify yet.

BodyPartWhat the shot was struck with (football).4 values

rightFoot	Right foot.
leftFoot	Left foot.
head	Header.
other	Any other body part.

GoalMouthLocationWhere a shot ended relative to the goal (football).15 values

lowLeft	On target, low left (from the shooter’s view).
lowCentre	On target, low centre.
lowRight	On target, low right.
highLeft	On target, high left.
highCentre	On target, high centre.
highRight	On target, high right.
left	Wide left.
right	Wide right.
high	Over the bar.
closeLeft	Just wide left.
closeRight	Just wide right.
closeHigh	Just over.
closeHighLeft	Just over, left.
closeHighRight	Just over, right.
other	A location not classified yet.

BuildUpActionWhat one step of a goal’s build-up was.9 values

pass	A pass (`endPosition` = where it was received).
cross	A cross (`endPosition` = where it arrived).
throwIn	A throw-in (`endPosition` = where it landed). Since 2026-10-25.
carry	The player moved with the ball (the source’s ball-movement; no `endPosition`). Since 2026-10-25.
touch	A touch that kept the play going — a block, a deflection, a goalkeeper’s parry (the source’s ball-touch). Since 2026-10-25.
savedShot	A shot the goalkeeper saved; the play went on (a rebound).
missedShot	A shot that missed; the play went on. Since 2026-10-25.
goal	The shot that scored — the last step.
other	An action not classified yet (the source’s value is logged).

BestPlayerLabelWhat a best-player value measures.5 values

rating	Match rating (football, basketball, …).
points	Points (ice hockey: goals + assists).
goals	Goals (handball).
yards	Yards (American football).
other	A measure not classified yet.

ShotOutcomeWhat came of a shot.5 values

goal	Scored (basketball: a made field goal).
save	On target, stopped by the goalkeeper / goalie.
miss	Off target (basketball: a missed field goal).
block	Blocked by an outfield player / skater (basketball: a blocked field goal).
post	Hit the woodwork (football).

ShotTechniqueHow a shot was taken (ice hockey).10 values

wrist	Wrist shot.
snap	Snap shot.
slap	Slap shot.
backhand	Backhand.
tipIn	Tip-in.
deflected	Deflection.
wrapAround	Wrap-around.
poke	Poke.
bat	Batted puck.
other	A technique not classified yet.

ShotSituationThe play a shot came from (football).10 values

regular	Open play, unassisted.
assisted	Open play, from a team-mate’s pass.
corner	From a corner kick.
setPiece	From another set piece.
fastBreak	On a counter-attack.
freeKick	A direct free kick.
throwInSetPiece	From a throw-in routine.
penalty	A penalty kick in play.
shootout	A penalty shoot-out kick (`shootoutSequence` = overall kick order, `shootoutRound` = the taker’s side’s round).
other	A situation not classified yet.

ShotGoalTypeKind of goal.3 values

regular	An ordinary goal.
ownGoal	An own goal (the same name as the incident detail).
penalty	A converted penalty (in play or in the shoot-out).

ShotStrengthManpower situation (ice hockey).3 values

even	Ice hockey: even strength.
powerPlay	Ice hockey: the shooting side had a man advantage.
shortHanded	Ice hockey: the shooting side was a man down.

FormResultA result in a form guide.3 values

win	Won.
draw	Drew.
loss	Lost.

StreakSideWhose streak it is.3 values

home	The fixture’s home side has the streak.
away	The fixture’s away side has the streak.
both	Both sides (head-to-head streaks: their meetings).

StreakKindWhat a streak’s figure is: a run in a row, x of the last y, or an average.3 values

inARow	A run in a row: `count` matches ("5").
ofLast	`count` of the last `outOf` matches ("7/8").
average	An average over recent matches, in `average` ("83" points a game); `count` and `outOf` are null.

PointsFormatWhich point-by-point shape a fixture has.5 values

tennis	Tennis: sets → games → points (`sets[].games`).
rally	Volleyball, table tennis, badminton: sets → points (`sets[].points`).
cricket	Cricket: innings → overs → balls (`innings`).
baseball	Baseball: at-bat by at-bat (`atBats`) — pitcher, batter and win probability before / after each.
darts	Darts: sets → legs → visits (`darts`) — each visit’s score and both players’ remaining scores.

TennisPointDescriptionHow a tennis point was won, when the source says.3 values

ace	An ace: the server won the point on the serve.
doubleFault	A double fault: the receiver won the point.
other	A description not classified yet (the source’s code is logged).

TennisPointTypeWhat a tennis point meant for one side.6 values

won	Won the point, nothing more to mark.
none	Nothing to mark for this side — mostly: lost the point (the point that ends a tie-break can be `none` for both).
breakPoint	After this point the side, receiving, has a break point (one point from breaking serve).
setPoint	After this point the side has a set point — a match point too when the set decides the match (the source does not tell them apart). Beats breakPoint and miniBreak.
miniBreak	Tie-break: won this point on the opponent’s serve.
other	A type not classified yet (the source’s code is logged).

BallOutcomeWhat a cricket delivery produced.10 values

dot	No run.
runs	Runs off the bat other than a boundary (1, 2, 3, …).
four	A boundary four.
six	A six.
wicket	A wicket fell (see `dismissal`).
wide	A wide (an extra; the ball is bowled again).
noBall	A no-ball (an extra; the ball is bowled again).
legBye	Leg byes (extras off the body).
bye	Byes (extras past the keeper).
other	A delivery not classified yet (the source’s code is logged).

DismissalHow a batter was out.11 values

caught	Caught (by a fielder other than the bowler).
caughtAndBowled	Caught by the bowler.
bowled	Bowled.
lbw	Leg before wicket.
runOut	Run out.
stumped	Stumped.
hitWicket	Hit wicket.
retired	Retired (hurt or out).
obstructingTheField	Obstructing the field.
timedOut	Timed out.
other	A dismissal not classified yet (the source’s text is logged).

UmpirePositionA baseball umpire’s position on the field.7 values

homePlate	Home-plate umpire (calls balls and strikes).
firstBase	First-base umpire.
secondBase	Second-base umpire.
thirdBase	Third-base umpire.
leftField	Left-field umpire (six-man postseason crews).
rightField	Right-field umpire (six-man postseason crews).
other	An assignment not listed here.

WeatherConditionThe weather, in a few words.7 values

clear	Clear or sunny.
cloudy	Cloudy or overcast.
fog	Fog or mist.
rain	Rain or showers.
snow	Snow or sleet.
storm	Thunderstorm.
other	A condition not listed here (the source’s own words are in `description`).

EsportsRoleA player’s role in an esports game.10 values

top	Top lane (League of Legends).
jungle	Jungle (League of Legends).
mid	Mid lane (League of Legends; Dota 2 position 2).
bottom	Bottom-lane carry (AD carry, League of Legends).
support	Support (League of Legends).
carry	Carry, safe lane (Dota 2 position 1).
offlane	Offlane (Dota 2 position 3).
softSupport	Soft support (Dota 2 position 4).
hardSupport	Hard support (Dota 2 position 5).
other	A role not listed here, or a title without roles (Counter-Strike).

BatterStateWhere a batter’s innings stands.6 values

out	Dismissed (see `dismissal`).
notOut	Batted and was not out when the innings closed.
batting	At the crease now (innings in progress).
didNotBat	Did not bat (or not yet, while the innings is in progress).
retiredHurt	Retired hurt — left the crease injured, not dismissed.
other	A state not classified yet (the source’s code is logged).

TeamGenderWhether a team (or competitor) is a men’s, women’s or mixed one.3 values

male	A men’s team (or a male competitor).
female	A women’s team (or a female competitor).
mixed	A mixed team (mixed doubles).

TeamKindWhat a team object stands for: a team, one competitor of an individual sport, or a doubles pair.3 values

team	A team or club (also a national side).
individual	One competitor of an individual sport (a tennis player, a fighter, a darts player) — see `person`.
pair	A doubles pair (tennis, badminton, table tennis, beach volleyball).

HandednessThe hand a player plays with.3 values

right	Right-handed.
left	Left-handed.
ambidextrous	Plays with both hands.

DetailedPositionA detailed playing position (football), from the source’s position codes.13 values

goalkeeper	Goalkeeper (source code GK).
leftBack	Left back / left wing-back (DL).
centreBack	Centre back (DC).
rightBack	Right back / right wing-back (DR).
defensiveMidfielder	Defensive midfielder (DM).
leftMidfielder	Left midfielder (ML).
centralMidfielder	Central midfielder (MC).
rightMidfielder	Right midfielder (MR).
attackingMidfielder	Attacking midfielder (AM).
leftWinger	Left winger (LW).
rightWinger	Right winger (RW).
striker	Striker / centre forward (ST).
other	A code not classified yet (the source’s code is logged).

InjuryStatusHow a current injury affects selection.5 values

out	Ruled out until the expected return.
outForSeason	Out for the rest of the season (the source’s outForSeason, seen on NBA squads 2026-10-25).
dayToDay	Day to day: may play the next match.
doubtful	Doubtful for the next match.
other	A status not classified yet (the source’s value is logged).

TransferTypeWhat kind of move a transfer is.15 values

transfer	A permanent move from one team to another (paid, free or undisclosed — see `fee` and `freeTransfer`).
loan	A loan to another team.
loanEnd	The end of a loan: back to the parent team.
signed	Signed by the team, typically as a free agent (`from` is then null).
released	Released: the contract was terminated.
waived	Waived (US leagues): put on waivers / let go by the team (`to` is null).
claimed	Claimed off waivers by another team.
traded	Traded to another team (US leagues).
draft	Drafted (`draft` has the round and pick when listed).
contractExpired	The contract ran out.
tenDayContract	A 10-day contract (NBA).
secondTenDayContract	A second 10-day contract with the same team (NBA).
retired	End of career.
deceased	The player died.
other	A move the source sent that this API does not classify yet.

StandingsScoreUnitWhat a table’s scoresFor / scoresAgainst / scoreDifference count.7 values

goals	Goals (football, futsal, handball, ice hockey, water polo).
points	Points (basketball, rugby, American football).
runs	Runs (baseball).
sets	Sets won and lost (volleyball) — not rally points.
maps	Maps won and lost (esports).
frames	Frames (snooker).
legs	Legs (darts).

SearchTypeWhat a search hit is — and so which endpoint its id belongs to.9 values

team	A team — or an individual-sport competitor (tennis player, fighter, driver): /v2/teams/{id}.
player	A player of a team sport: /v2/players/{id}.
league	A league / competition: /v2/leagues/{id}.
manager	A manager / head coach: /v2/managers/{id}.
referee	A referee: /v2/referees/{id}.
series	A racing series (Formula 1, MotoGP, …): /v2/series/{id}.
race	One race of a racing series (a Grand Prix, a cycling race): /v2/races/{id}.
fixture	A match / fixture (since 2026-11-04): /v2/fixtures/{id}; its teams, league, start and status are in `fixture`.
venue	A stadium / arena (since 2026-11-04). No endpoint of its own: the id is the one Fixture.venue and TeamDetail.venue carry; city, country and capacity are in `venue`.

CompetitionTypeWhat kind of competition it is.4 values

domesticLeague	A national league (LaLiga).
domesticCup	A national cup or super cup (Copa del Rey, Supercopa).
internationalCup	An international club or national-team competition (Champions League, UEFA Super Cup).
other	A type not classified yet (the source’s value is logged).

SeasonStatsTypeWhich matches season statistics cover. Without `type` the endpoints use the season’s first listed type (`overall`, else `regularSeason`).5 values

overall	Every match of the season (football, handball, rugby, European basketball, …).
home	Home matches only.
away	Away matches only.
regularSeason	The regular season (North American leagues: NBA, NHL, … — they have no `overall`).
playoffs	The playoffs.

WinProbabilityModelModel version (the docs describe each). A new version is announced in the changelog.3 values

v1	The first model (2026-10-22): pre-match from the current competition’s table and form only. Still served for fixtures whose pre-match estimate was fixed before v2 (it is kept once a match starts).
v2	Since 2026-10-22: pre-match from both teams’ recent matches in all competitions, their domestic league tables and our league-strength coefficients (teams of different leagues on one scale), blended with the current competition’s table as it fills up. In play identical to v1. Still served for fixtures whose pre-match estimate was fixed before v3.
v3	Since 2026-10-25: v2’s pre-match estimate, except that a league match with a newcomer (one side promoted or relegated into the competition, early in a season) uses the current table and form only, plus the Turkish 1.Lig in the league-strength coefficients; in play, v2’s formula with a calibration step that makes the curve slightly less certain (it was a little over-confident), phased in over the first 15 minutes.

WinProbabilityReasonWhy a win-probability point was emitted.8 values

kickoff	The match started: the pre-match estimate at minute 0.
minute	A regular once-a-minute point (time running down moves the estimate even when nothing happens).
goal	Right after a goal (own goals count for the side credited).
redCard	Right after a red card (a second yellow included).
periodStart	A period started: the second half, or a half of extra time.
periodEnd	A period ended: half-time, the end of regulation, the end of extra time.
bigChance	Right after a big chance that was not scored (a shot of at least 0.3 expected goals) — marks the moment on the curve; the model (v1 and v2 alike) does not blend live expected goals into the estimate.
final	The match is over: the result, as certainty (1 / 0 / 0).

CommentaryKindWhat a commentary entry is about.13 values

kickoff	The match kicked off.
goal	A goal (own goals and penalties included).
redCard	A sending-off (a straight red or a second yellow).
missedPenalty	A penalty during play that was missed or saved (a scored one is a goal).
varDecision	A video-review decision: goal or penalty given / ruled out, card changed.
bigChance	A big chance that was not scored (a shot of at least 0.3 expected goals).
momentum	One side has had sustained pressure for several minutes (the attack-momentum graph).
periodStart	The second half or a half of extra time started.
periodEnd	Regulation time or the first half of extra time ended, and play goes on.
halfTime	Half-time summary.
fullTime	Full-time summary.
update	A summary of the match so far, written when commentary starts during a match.
correction	The source credited a goal already commented to another player: one line naming the scorer it now gives (earlier entries stay as written). Since 2026-10-27.

PlayByPlayTypeWhat a play-by-play entry records.36 values

matchStarted	Football: a half (or a half of extra time) kicked off.
matchEnded	Football: the match is over.
endFirstHalf	Football: the first half ended.
endSecondHalf	Football: the second half ended.
periodStart	Basketball and other clock sports: a period started (the opening tip is a periodStart too).
periodEnd	Basketball and other clock sports: a period ended.
addedTime	Football: the fourth official announced added time (the minutes are in `text`).
scoreChange	The score changed: a goal, or points in basketball (`scoreType` says which); `homeScore` / `awayScore` are the score after it.
shotSaved	Football: a shot on target that was saved.
shotOffTarget	A shot that missed: off target (football), a missed field goal (basketball).
shotBlocked	Football: a shot blocked by a defender.
cornerKick	Football: a corner kick (`player` = the defender who conceded it; `side` is his side, so the corner was won by the other one).
freeKickWon	Football: a free kick won (`player` = the player fouled).
freeKickLost	Football: a foul conceded (`player` = the player who fouled).
offside	Football: a player caught offside.
yellowCard	Football: a yellow card.
redCard	Football: a red card (a second yellow included).
substitution	A substitution (`playerIn` / `playerOut`).
startDelay	Football: play stopped (an injury, a delay).
endDelay	Football: play resumed after a delay.
foul	Basketball: a foul (`player` = who fouled, `drawnBy` = who drew it).
freeThrowMissed	Basketball: a missed free throw.
rebound	Basketball: a rebound (offensive or defensive, see `text`).
possessionChange	Basketball: a turnover (`stolenBy` = the player who stole the ball, when there was a steal).
jumpBall	Basketball: a jump ball.
lineupChange	Basketball: a side’s five on the floor changed (the names are in `text`).
timeout	A timeout.
stoppage	Basketball: the clock stopped (out of bounds, …).
review	An instant-replay review and its outcome (in `text`); in football a VAR decision.
penaltyAwarded	Football: a penalty kick awarded (`player` = the player fouled, `side` = his side).
penaltyConceded	Football: a penalty kick conceded (`player` = the player who gave it away, `side` = his side).
penaltyScored	Football: a goal from a penalty kick in play. `homeScore` / `awayScore` = the score after it, counted on from the previous goal of the list (the source gives none on this entry); null in a penalty shoot-out, which does not change the match score.
penaltyMissed	Football: a penalty kick missed (off target).
penaltySaved	Football: a penalty kick saved by the goalkeeper.
violation	Basketball: a violation (kicked ball, goaltending, …; the kind is in `text`).
other	Another kind of entry (a value the source added later — read `text`).

PlayByPlayScoreTypeWhat a basketball scoring play was worth.4 values

freeThrow	A made free throw (1 point).
twoPointer	A made two-point field goal.
threePointer	A made three-point field goal.
other	Another kind of score.

CourtZoneBasketball court zone of an action.14 values

underBasket	Right under the basket.
inThePaint	In the paint (the lane), away from the basket.
insideLeft	Inside the three-point line, left baseline side.
insideRight	Inside the three-point line, right baseline side.
insideCenter	Inside the three-point line, in front of the basket (mid-range, centre).
insideLeftWing	Inside the three-point line, left wing.
insideRightWing	Inside the three-point line, right wing.
outsideLeft	Beyond the three-point line, left corner.
outsideRight	Beyond the three-point line, right corner.
outsideCenter	Beyond the three-point line, top of the key.
outsideLeftWing	Beyond the three-point line, left wing.
outsideRightWing	Beyond the three-point line, right wing.
backcourt	The backcourt (the other half).
other	Another zone (a value the source added later).

RankingTypeSlugA ranking table we serve — the list with names is GET /v2/rankings.19 values

fifa-men	FIFA World Ranking (men) (football).
uefa-countries	UEFA country coefficients (football).
uefa-clubs	UEFA club coefficients (football).
world-rugby-men	World Rugby Rankings (men) (rugby).
atp	ATP singles ranking (tennis).
wta	WTA singles ranking (tennis).
atp-live	ATP live singles ranking (moves during tournaments) (tennis).
wta-live	WTA live singles ranking (moves during tournaments) (tennis).
ufc-flyweight	UFC flyweight rankings (mma).
ufc-bantamweight	UFC bantamweight rankings (mma).
ufc-featherweight	UFC featherweight rankings (mma).
ufc-lightweight	UFC lightweight rankings (mma).
ufc-welterweight	UFC welterweight rankings (mma).
ufc-middleweight	UFC middleweight rankings (mma).
ufc-light-heavyweight	UFC light heavyweight rankings (mma).
ufc-heavyweight	UFC heavyweight rankings (mma).
ufc-womens-strawweight	UFC women’s strawweight rankings (mma).
ufc-womens-flyweight	UFC women’s flyweight rankings (mma).
ufc-womens-bantamweight	UFC women’s bantamweight rankings (mma).

RankingEntryWhat one row of a ranking stands for.3 values

team	A team (a national side or a club): `team` is set.
competitor	One competitor of an individual sport (a tennis player, a fighter) — a team object of kind `individual`: `team` is set.
country	A country, ranked by its clubs’ results: `country` and `league` (the country’s top league) are set, `team` is null.

PlayerStatisticsGroupWhich statistics a player-statistics page carries (every group also has appearances and minutesPlayed, and the sort key).6 values

summary	Goals, expected goals, assists, dribbles, tackles, pass accuracy, rating.
attack	Shooting and scoring: shots, on / off target, blocked, goal conversion, penalties, set pieces, goals by body part and area, woodwork, offsides.
defense	Tackles, interceptions, clearances, blocks, errors, own goals, dribbled past, clean sheets, penalties conceded.
passing	Big chances created, assists, passes and their accuracy by area, key passes, crosses, long balls.
goalkeeping	Saves (inside / outside the box), clean sheets, penalties faced and saved, goals conceded by area, punches, runs out, high claims.
other	Cards, duels (ground, aerial, total), minutes, fouls, fouled, dispossessed, possession lost, appearances, starts.

SportKindWhich endpoint family a sport’s data lives in.2 values

fixtures	Matches between two sides: /v2/fixtures, /v2/livescores, /v2/leagues/… .
races	Races with a field of competitors (motorsport, cycling): /v2/races, /v2/series/… . The fixture endpoints have nothing for these sports.

RaceSessionTypeWhat a session of a race is.7 values

practice	A practice session (motorsport).
qualifying	Qualifying — sets the grid of the race (motorsport; also a qualifying part such as Q1 when the source lists it as a session).
sprintQualifying	Sprint qualifying — sets the grid of the sprint (Formula 1).
sprint	A sprint race: a short race of its own, with its own points (Formula 1, MotoGP).
race	The race (motorsport: the Grand Prix / main race; cycling: a one-day race).
stage	One stage of a cycling stage race (Tour de France stage 5).
other	A session of a kind not listed here.

RaceResultStateWhere a competitor stands in a classification.5 values

classified	In the classification, lapped or not (`position` is set unless the source left a gap).
didNotFinish	Started but did not finish (retired, crashed out); no position.
didNotStart	Entered but did not start; no position.
disqualified	Disqualified; no position.
notClassified	Out of the classification for another reason (the source marks the row out without saying why); no position.

TyreCompoundA tyre compound (Formula 1).6 values

soft	Soft slick (the source’s "S").
medium	Medium slick ("M").
hard	Hard slick ("H").
intermediate	Intermediate, for a damp track ("I").
wet	Full wet ("W").
other	A compound letter not listed here.

CyclingJerseyA leader’s jersey in a cycling stage race.5 values

general	Leader of the general classification (the Tour’s yellow jersey).
points	Leader of the points classification (green in the Tour).
mountains	Leader of the mountains classification (polka dot in the Tour).
young	Best young rider (white in the Tour).
other	A jersey not listed here.

StageProfileThe terrain of a cycling stage or one-day race.8 values

flat	Flat — a sprinters’ day.
hilly	Hilly.
intermediate	Medium mountains / rolling.
mountain	Mountains.
highMountain	High mountains, usually a summit finish.
timeTrial	Individual time trial.
teamTimeTrial	Team time trial.
other	A profile not listed here.

RaceWeatherWeather during a session, as the source words it.7 values

sunny	Sunny.
hot	Hot.
cloudy	Cloudy.
lightRain	Light rain.
rain	Rain.
night	A night session (the source gives no other weather word for it).
other	A weather word not listed here.

TrackConditionTrack / road surface during a session.3 values

dry	Dry track / road.
wet	Wet track / road.
other	A condition not listed here.

SeriesStandingsTypeWhich championship table.2 values

competitors	The drivers’ / riders’ championship.
teams	The teams’ (constructors’) championship.

StandingsSourceWhere a standings table comes from — `meta.source` of /standings.2 values

upstream	The table as the data source publishes it.
computed	Computed by us from the season’s finished fixtures, because the source publishes no such table (NBA and NHL home / away tables). Same columns as the source’s total table; ties ranked by our order, not head-to-head.

SeriesFiguresSourceWhere a series table’s wins / podiums / polePositions / racesStarted / racesWithPoints come from — `meta.figuresSource` of /series/{id}/standings.2 values

upstream

As the data source publishes them (null where it has none).

computed

Computed by us from the main race of every finished championship round, because the source publishes only positions and points (MotoGP): wins = 1st, podiums = top 3, polePositions = started from grid position 1, racesStarted = races started (a team: races with at least one entry started), racesWithPoints = races that scored points; a team counts every entry. Sprints are not counted. fastestLaps stays null when the races do not report them.

WsErrorCodeWebSocket error code.10 values

bad_frame	The frame was not valid JSON, not a known shape, or lacks a field it needs (`message` names the field, e.g. "channel: required").
unknown_channel	Not a channel name we serve (or an unknown sport slug).
channel_forbidden	The channel is not in your plan’s grade.
unknown_league	league:{id} names a league id we never issued (use the ids of /v2/leagues and of fixtures’ league) — REST answers the same id with 404 not_found.
unknown_fixture	fixture:{id} names a fixture id we never issued — REST answers the same id with 404 not_found. The channel is not counted.
unknown_race	race:{id} names no race (a season or session id, or one we never issued) — /v2/races/{id} answers the same id with 404. The channel is not counted.
not_subscribed	resync / unsubscribe of a channel this connection is not on.
too_many_channels	You hit maxChannels on this connection.
snapshot_failed	The snapshot could not be built — send resync to retry (for league:{id}, when the league id could not be checked right now: subscribe again).
rate_limited	More than 60 frames in 10 seconds on this connection; frames are dropped until the window resets.

Status codes

status.code is the source's numeric status. phase, type and finish already decode it — this table is how. An unknown code falls back to the source's type.

code	description	phase	type	finish
0	Not started	notstarted	notstarted	—
1	1st period	inprogress	inprogress	—
2	2nd period	inprogress	inprogress	—
3	3rd period	inprogress	inprogress	—
4	4th period	inprogress	inprogress	—
5	5th period	inprogress	inprogress	—
6	1st half	inprogress	inprogress	—
7	2nd half	inprogress	inprogress	—
8	1st set	inprogress	inprogress	—
9	2nd set	inprogress	inprogress	—
10	3rd set	inprogress	inprogress	—
11	4th set	inprogress	inprogress	—
12	5th set	inprogress	inprogress	—
13	1st quarter	inprogress	inprogress	—
14	2nd quarter	inprogress	inprogress	—
15	3rd quarter	inprogress	inprogress	—
16	4th quarter	inprogress	inprogress	—
20	Started	inprogress	inprogress	—
21	1st inning	inprogress	inprogress	—
22	2nd inning	inprogress	inprogress	—
23	3rd inning	inprogress	inprogress	—
24	4th inning	inprogress	inprogress	—
25	5th inning	inprogress	inprogress	—
26	6th inning	inprogress	inprogress	—
27	7th inning	inprogress	inprogress	—
28	8th inning	inprogress	inprogress	—
29	9th inning	inprogress	inprogress	—
30	Pause	break	inprogress	—
31	Halftime	break	inprogress	—
32	Awaiting extra time	break	inprogress	—
33	Extra time halftime	break	inprogress	—
34	Awaiting penalties	break	inprogress	—
40	Overtime	inprogress	inprogress	—
41	1st extra	inprogress	inprogress	—
42	2nd extra	inprogress	inprogress	—
43	Lunch	break	inprogress	—
44	Tea break	break	inprogress	—
45	Innings break	break	inprogress	—
46	Extra innings	inprogress	inprogress	—
47	Dinner	break	inprogress	—
48	Drinks	break	inprogress	—
50	Penalties	inprogress	inprogress	—
51	Penalties	inprogress	inprogress	—
52	Shootout	inprogress	inprogress	—
53	1st round	inprogress	inprogress	—
54	2nd round	inprogress	inprogress	—
55	3rd round	inprogress	inprogress	—
56	4th round	inprogress	inprogress	—
57	5th round	inprogress	inprogress	—
58	Awaiting announcement	awaitingResult	inprogress	—
60	Postponed	postponed	postponed	—
61	Start delayed	delayed	notstarted	—
70	Canceled	canceled	canceled	—
80	Interrupted	interrupted	interrupted	—
81	Suspended	suspended	interrupted	—
90	Abandoned	abandoned	canceled	—
91	Walkover	finished	finished	walkover
92	Retired	finished	finished	retired
93	Removed	canceled	canceled	—
97	Home defaulted	finished	finished	defaulted
98	Away defaulted	finished	finished	defaulted
100	Ended	finished	finished	regular
110	After overtime	finished	finished	overtime
120	After penalties	finished	finished	penalties
130	After golden set	finished	finished	goldenSet
140	Will continue	willcontinue	willcontinue	—
141	End of day 1	willcontinue	willcontinue	—
142	End of day 2	willcontinue	willcontinue	—
143	End of day 3	willcontinue	willcontinue	—
144	End of day 4	willcontinue	willcontinue	—
301	First break	break	inprogress	—
302	Second break	break	inprogress	—
303	Third break	break	inprogress	—
441	6th set	inprogress	inprogress	—
442	7th set	inprogress	inprogress	—
445	Break	break	inprogress	—
500	Not played	canceled	canceled	—
1001	Game 1	inprogress	inprogress	—
1002	Game 2	inprogress	inprogress	—
1003	Game 3	inprogress	inprogress	—
1004	Game 4	inprogress	inprogress	—
1005	Game 5	inprogress	inprogress	—
1006	Game 6	inprogress	inprogress	—
1007	Game 7	inprogress	inprogress	—

Periods

One period vocabulary (PeriodKey) for a ScoreSide's periods keys, status.period, statistics periods, incidents and shots.

periodN	The Nth regulation period: half (football, rugby, handball, futsal), quarter (basketball, American football, water polo), period (ice hockey), set (tennis, volleyball, table tennis, badminton), inning (baseball), round (combat sports), map / game (esports), leg / frame block (darts, snooker).
inningN	Cricket: the Nth innings.
extra1	Football / futsal: first half of extra time.
extra2	Football / futsal: second half of extra time.
overtime	Overtime as a whole (basketball, ice hockey, handball, American football, water polo, …; every overtime period together). Baseball: the extra-innings runs, only when the source gives no per-inning breakdown (period10, …).
penalties	Penalty shoot-out (a `status.period` value; the shoot-out score is ScoreSide.penalties, not a `periods` key).

Positions

The same letter means different things in different sports, so position is a word and positionCode keeps the source's letter. Per sport, code → position:

football4 codes

G	goalkeeper
D	defender
M	midfielder
F	forward

futsal4 codes

G	goalkeeper
D	defender
M	midfielder
F	forward

basketball7 codes

G	guard
F	forward
C	center
GF	guardForward
FG	guardForward
FC	forwardCenter
CF	forwardCenter

ice-hockey7 codes

G	goalie
D	defenseman
C	center
L	leftWing
R	rightWing
F	forward
W	leftWing

handball8 codes

G	goalkeeper
LW	leftWing
RW	rightWing
LB	leftBack
RB	rightBack
CB	centreBack
P	pivot
B	centreBack

american-football27 codes

QB	quarterback
RB	runningBack
FB	runningBack
WR	wideReceiver
TE	tightEnd
OL	offensiveLineman
T	offensiveTackle
OT	offensiveTackle
G	offensiveGuard
OG	offensiveGuard
C	center
DT	defensiveTackle
DE	defensiveEnd
DL	defensiveLineman
NT	defensiveTackle
LB	linebacker
ILB	linebacker
OLB	linebacker
CB	cornerback
SAF	safety
S	safety
FS	safety
SS	safety
DB	defensiveBack
K	kicker
P	punter
LS	longSnapper

baseball14 codes

P	pitcher
SP	startingPitcher
RP	reliefPitcher
C	catcher
1B	firstBase
2B	secondBase
3B	thirdBase
SS	shortstop
LF	leftField
CF	centerField
RF	rightField
IF	infielder
OF	outfielder
DH	designatedHitter

cricket4 codes

BM	batter
B	bowler
AR	allRounder
WK	wicketKeeper

rugby2 codes

F	forward
B	back

Statistic keys

Match statistic keys seen per sport (/fixtures/{id}/statistics), with how to read the value (kind) and whether more is better. A key always means the same quantity; coverage varies by competition, so a match may carry fewer — or, rarely, a key not listed yet.

american-football28 keys

key	name	group	kind	higherIs
touchdowns	Touchdowns	Offense	value	better
fieldGoalsMade	Field goals	Offense	ratio	better
totalYards	Total yards	Offense	value	better
turnovers	Turnovers	Offense	value	worse
redZoneConversion	Red zone efficiency	Offense	ratio	better
timeOfPossession	Time of Possession	Offense	time	better
firstDowns	First downs	Offense	value	better
penaltyFirstDowns	First downs by penalty	Offense	value	better
thirdDownConversion	Third down efficiency	Offense	ratio	better
punts	Punts	Offense	value	worse
puntingYardsPerPunt	Average yards per punt	Offense	value	better
yardsPerPlay	Average yards per play	Offense	value	better
passingFirstDowns	First downs by passing	Passing	value	better
passingNetYards	Net yards passing	Passing	value	better
passingYards	Gross yards passing	Passing	value	better
passingTouchdowns	Passing touchdowns	Passing	value	better
passingInterceptions	Interceptions thrown	Passing	value	worse
passingYardsPerAttempt	Average passing yards per attempt	Passing	value	better
passingRedZoneAttempts	Red zone passing attempts	Passing	value	better
rushingAttempts	Rushing attempts	Rushing	value	better
rushingYards	Rushing yards	Rushing	value	better
rushingYardsPerAttempt	Average rushing yards per attempt	Rushing	value	better
rushingFirstDowns	First downs by rushing	Rushing	value	better
rushingRedZoneAttempts	Red zone rushing attempts	Rushing	value	better
penalties	Penalties	Other	value	worse
penaltyYards	Yards penalized	Other	value	worse
fumbles	Fumbles	Other	value	worse
fumblesLost	Fumbles lost	Other	value	worse

badminton5 keys

key	name	group	kind	higherIs
pointsWon	Points won	Points	value	better
maxPointsInRow	Max points in a row	Points	value	better
matchPoints	Match points	Points	value	better
comebackToWin	Comeback to win	Points	value	better
biggestLead	Biggest lead	Points	value	better

baseball26 keys

key	name	group	kind	higherIs
battingRuns	Runs	Batting	value	better
battingDoubles	Doubles	Batting	value	better
battingTriples	Triples	Batting	value	better
battingHomeRuns	Home runs	Batting	value	better
battingStrikeOuts	Strike outs	Batting	value	worse
battingBaseOnBalls	Base on balls	Batting	value	better
battingHits	Hits	Batting	value	better
battingAvg	AVG	Batting	value	better
battingObp	OBP	Batting	value	better
battingSlg	SLG	Batting	value	better
battingOps	OPS	Batting	value	better
battingRbi	RBI	Batting	value	better
battingAtBats	At bats	Batting	value	better
battingLeftOnBase	Left on base	Batting	value	worse
pitchingRuns	Runs	Pitching	value	worse
pitchingHomeRuns	Home runs	Pitching	value	worse
pitchingStrikeOuts	Strike outs	Pitching	value	better
pitchingBaseOnBalls	Base on balls	Pitching	value	worse
pitchingHits	Hits	Pitching	value	worse
pitchingEra	ERA	Pitching	value	worse
pitchingInningsPitched	Innings pitched	Pitching	value	better
pitchingEarnedRuns	Earned runs	Pitching	value	worse
pitchingBattersFaced	Batters faced	Pitching	value	better
pitchingOuts	Outs	Pitching	value	better
fieldingAssists	Assists	Fielding	value	better
fieldingPutOuts	Put outs	Fielding	value	better

basketball17 keys

key	name	group	kind	higherIs
freeThrowsMade	Free throws	Scoring	ratio	better
twoPointersMade	2 pointers	Scoring	ratio	better
threePointersMade	3 pointers	Scoring	ratio	better
fieldGoalsMade	Field goals	Scoring	ratio	better
rebounds	Rebounds	Other	value	better
defensiveRebounds	Defensive rebounds	Other	value	better
offensiveRebounds	Offensive rebounds	Other	value	better
assists	Assists	Other	value	better
turnovers	Turnovers	Other	value	worse
steals	Steals	Other	value	better
blocks	Blocks	Other	value	better
fouls	Fouls	Other	value	worse
timeouts	Timeouts	Other	value	better
maxPointsInRow	Max points in a row	Lead	value	better
timeSpentInLead	Time spent in lead	Lead	time	better
leadChanges	Lead changes	Lead	value	better
biggestLead	Biggest lead	Lead	value	better

darts7 keys

key	name	group	kind	higherIs
threeDartAverage	Average 3 darts	Attacking	value	better
thrown180	Thrown 180	Attacking	value	better
thrownOver140	Thrown over 140	Attacking	value	better
thrownOver100	Thrown over 100	Attacking	value	better
highestCheckout	Highest checkout	Attacking	value	better
checkoutsOver100	Checkouts over 100	Attacking	value	better
checkouts	Checkouts accuracy	Attacking	ratio	better

football51 keys

key	name	group	kind	higherIs
ballPossession	Ball possession	Match overview	value	better
expectedGoals	Expected goals	Match overview	value	better
bigChances	Big chances	Match overview	value	better
totalShots	Total shots	Match overview	value	better
saves	Goalkeeper saves	Match overview	value	better
cornerKicks	Corner kicks	Match overview	value	better
fouls	Fouls	Match overview	value	worse
passes	Passes	Match overview	value	better
tackles	Tackles	Match overview	value	better
freeKicks	Free kicks	Match overview	value	better
yellowCards	Yellow cards	Match overview	value	worse
shotsOnGoal	Shots on target	Shots	value	better
hitWoodwork	Hit woodwork	Shots	value	worse
shotsOffGoal	Shots off target	Shots	value	worse
shotsBlocked	Blocked shots	Shots	value	worse
shotsInsideBox	Shots inside box	Shots	value	better
shotsOutsideBox	Shots outside box	Shots	value	better
bigChancesMissed	Big chances missed	Attack	value	worse
touchesInPenaltyArea	Touches in penalty area	Attack	value	better
fouledFinalThird	Fouled in final third	Attack	value	better
offsides	Offsides	Attack	value	worse
accuratePasses	Accurate passes	Passes	value	better
throwIns	Throw-ins	Passes	value	better
finalThirdEntries	Final third entries	Passes	value	better
finalThirdPhaseStatistic	Final third phase	Passes	ratio	better
accurateLongBalls	Long balls	Passes	ratio	better
accurateCrosses	Crosses	Passes	ratio	better
duelsWonPercentage	Duels	Duels	value	better
dispossessed	Dispossessed	Duels	value	worse
groundDuelsWon	Ground duels	Duels	ratio	better
aerialDuelsWon	Aerial duels	Duels	ratio	better
successfulDribbles	Dribbles	Duels	ratio	better
tacklesWon	Tackles won	Defending	ratio	better
interceptions	Interceptions	Defending	value	better
recoveries	Recoveries	Defending	value	better
clearances	Clearances	Defending	value	better
errorsLeadingToShot	Errors lead to a shot	Defending	value	worse
errorsLeadingToGoal	Errors lead to a goal	Defending	value	worse
diveSaves	Big saves	Goalkeeping	value	better
highClaims	High claims	Goalkeeping	value	better
punches	Punches	Goalkeeping	value	better
goalKicks	Goal kicks	Goalkeeping	value	better
kilometersCovered	Distance covered	Match overview	value	better
numberOfSprints	Number of sprints	Match overview	value	better
redCards	Red cards	Match overview	value	worse
averageRating	Average rating	Match overview	value	better
expectedGoalsOnTarget	Expected goals on target	Shots	value	better
bigChancesScored	Big chances scored	Attack	value	better
accurateThroughBalls	Through balls	Attack	value	better
goalsPrevented	Goals prevented	Goalkeeping	value	better
penaltySaves	Penalty saves	Goalkeeping	value	better

handball16 keys

key	name	group	kind	higherIs
shootingEfficiency	Shooting efficiency	Goals	ratio	better
wingGoals	Wing goals	Goals	value	better
fastBreakGoals	Fastbreak goals	Goals	ratio	better
goals7m	7 meters	Goals	ratio	better
goals9m	9m goals	Goals	value	better
goals6m	6m goals	Goals	value	better
saves	Saves	Saves	ratio	better
twoMinutePenalties	2 min penalty	Penalty	value	worse
yellowCards	Yellow cards	Penalty	value	worse
redCards	Red cards	Penalty	value	worse
maxGoalsInRow	Goal streak	Goals extra	value	better
powerPlayGoals	Goals in powerplay	Goals extra	value	better
shortHandedGoals	Shorthanded goals	Goals extra	value	better
steals	Steals	Other	value	better
technicalFaults	Technical faults	Other	value	worse
timeouts	Timeouts	Other	value	better

ice-hockey32 keys

key	name	group	kind	higherIs
shotsOnGoal	Shots on goal	Match overview	value	better
penalties	Penalties	Match overview	value	worse
penaltyMinutes	Penalty minutes	Match overview	value	worse
hits	Hits	Match overview	value	better
blocks	Blocked shots	Match overview	value	better
takeaways	Takeaways	Match overview	value	better
giveaways	Giveaways	Match overview	value	worse
powerPlayConversion	Power play %	Match overview	ratio	better
faceoffsWon	Faceoffs won %	Match overview	ratio	better
powerPlayShotConversion	Power play shot %	Special teams	ratio	better
shortHandedShotConversion	Shorthanded shot %	Special teams	ratio	better
evenStrengthShotConversion	Even strength shot %	Special teams	ratio	better
powerPlayFaceoffsWon	Power play faceoffs	Special teams	ratio	better
shortHandedFaceoffsWon	Shorthanded faceoffs	Special teams	ratio	better
evenStrengthFaceoffsWon	Even strength faceoffs	Special teams	ratio	better
fiveOnFourConversion	5v4 conversion	Special teams	ratio	better
corsiPercentage	Corsi %	Advanced	value	better
fenwickPercentage	Fenwick %	Advanced	value	better
averageShotDistance	Average shot distance	Advanced	value	better
wristGoals	Wrist	Shots	ratio	better
slapGoals	Slap	Shots	ratio	better
backhandGoals	Backhand	Shots	ratio	better
tipGoals	Tip	Shots	ratio	better
snapGoals	Snap	Shots	ratio	better
emptyNetGoals	Empty net goals	Match overview	value	better
saves	Saves	Match overview	value	better
puckPossession	Puck possession	Match overview	value	better
pokeGoals	Poke	Shots	ratio	better
fiveOnThreeConversion	5v3 conversion	Special teams	ratio	better
fourOnThreeConversion	4v3 conversion	Special teams	ratio	better
wrapAroundGoals	Wrap around	Shots	ratio	better
batGoals	Bat	Shots	value	better

mma46 keys

key	name	group	kind	higherIs
durationSeconds	Statistics time	General	value	—
distanceSeconds	Distance Seconds	Distance	value	—
distancePercentage	Distance Percent	Distance	value	—
groundSeconds	Ground Seconds	Ground	value	—
groundPercentage	Ground Percent	Ground	value	—
groundClinchSeconds	Ground Clinch Seconds	Ground	value	—
groundClinchPercentage	Ground Clinch Percent	Ground	value	—
groundClinchControlSeconds	Ground Clinch Control Seconds	Ground	value	better
groundClinchControlPercentage	Ground Clinch Control Percent	Ground	value	better
strikesGroundLanded	Strikes Ground	Ground	value	better
takedownsAttempted	Takedowns Attempted	Ground	value	better
takedownsSucceeded	Takedowns Succeeded	Ground	value	better
takedownsReceived	Takedowns Received	Ground	value	worse
takedownsDefended	Takedowns Defended	Ground	value	better
takedownsSucceededPercentage	Takedown Success Rate	Ground	value	better
takedownsDefendedPercentage	Takedown Defense Rate	Ground	value	better
transitionsSucceeded	Transitions Succeeded	Ground	value	better
transitionsReceived	Transitions Received	Ground	value	worse
submissionsAttempted	Submissions Attempted	Ground	value	better
submissionsSucceeded	Submissions Succeeded	Ground	value	better
submissionsReceived	Submissions Received	Ground	value	worse
submissionsDefended	Submissions Defended	Ground	value	better
submissionsSucceededPercentage	Submission Success Rate	Ground	value	better
submissionsDefendedPercentage	Submission Defense Rate	Ground	value	better
clinchSeconds	Clinch Seconds	Clinch	value	—
clinchPercentage	Clinch Percent	Clinch	value	—
clinchControlSeconds	Clinch Control Seconds	Clinch	value	better
clinchControlPercentage	Clinch Control Percent	Clinch	value	better
strikesLanded	Strikes	Strikes	value	better
strikesReceived	Strikes Received	Strikes	value	worse
strikesDistanceLanded	Strikes Distance	Strikes	value	better
strikesClinchLanded	Strikes Clinch	Strikes	value	better
significantStrikesLanded	Significant Strikes	Strikes	value	better
significantStrikesReceived	Significant Strikes Received	Strikes	value	worse
significantStrikesDistanceLanded	Significant Strikes Distance	Strikes	value	better
significantStrikesGroundLanded	Significant Strikes Ground	Strikes	value	better
significantStrikesClinchLanded	Significant Strikes Clinch	Strikes	value	better
significantStrikesDistancePercentage	Significant Strikes Distance Percentage	Strikes	value	better
significantStrikesGroundPercentage	Significant Strikes Ground Percentage	Strikes	value	better
significantStrikesHeadLanded	Significant Strikes Head	Strikes	value	better
significantStrikesBodyLanded	Significant Strikes Body	Strikes	value	better
significantStrikesLegsLanded	Significant Strikes Legs	Strikes	value	better
significantStrikesHeadPercentage	Significant Strikes Head Percentage	Strikes	value	better
significantStrikesBodyPercentage	Significant Strikes Body Percentage	Strikes	value	better
significantStrikesLegsPercentage	Significant Strikes Legs Percentage	Strikes	value	better
knockdowns	Knockdowns	Strikes	value	better

rugby21 keys

key	name	group	kind	higherIs
tries	Tries	Scoring	value	better
conversions	Conversions	Scoring	value	better
tryAssists	Try assists	Scoring	value	better
penaltyTries	Penalty tries	Scoring	value	better
penaltyGoals	Penalty goals	Scoring other	value	better
dropGoals	Drop goals	Scoring other	value	better
cleanBreaks	Clean breaks	Scoring other	value	better
carries	Carries	Scoring other	value	better
ballPossession	Ball possession	Possession	value	better
passes	Passes	Possession	value	better
yellowCards	Yellow cards	Penalty	value	worse
redCards	Red cards	Penalty	value	worse
penaltiesConceded	Penalties conceded	Penalty	value	worse
lineoutsWon	Lineouts	Other	ratio	better
scrumsWon	Scrums	Other	ratio	better
tackles	Tackles	Other	value	better
tacklesMissed	Tackles missed	Other	value	worse
turnovers	Turnovers	Other	value	worse
turnoversWon	Turnovers won	Other	value	better
metersRun	Meters run	Other	value	better
offloads	Offloads	Other	value	better

table-tennis9 keys

key	name	group	kind	higherIs
pointsWon	Points won	Points	value	better
maxPointsInRow	Max points in a row	Points	value	better
comebackToWin	Comeback to win	Points	value	better
biggestLead	Biggest lead	Points	value	better
servicePointsWon	Service points won	Points	ratio	better
returnPointsWon	Receiver points won	Points	ratio	better
serviceErrors	Service errors	Points	value	worse
timeouts	Timeouts	Other	value	better
lets	Number of lets	Other	value	worse

tennis42 keys

key	name	group	kind	higherIs
aces	Aces	Service	value	better
doubleFaults	Double faults	Service	value	worse
firstServesIn	First serve	Service	ratio	better
secondServesIn	Second serve	Service	ratio	better
firstServePointsWon	First serve points	Service	ratio	better
secondServePointsWon	Second serve points	Service	ratio	better
serviceGamesPlayed	Service games played	Service	value	better
breakPointsSaved	Break points saved	Service	ratio	better
pointsWon	Total	Points	value	better
servicePointsWon	Service points won	Points	value	better
returnPointsWon	Receiver points won	Points	value	better
maxPointsInRow	Max points in a row	Points	value	better
gamesWon	Total won	Games	value	better
serviceGamesWon	Service games won	Games	value	better
maxGamesInRow	Max games in a row	Games	value	better
winners	Total	Winners	value	better
forehandWinners	Forehand	Winners	value	better
backhandWinners	Backhand	Winners	value	better
volleyWinners	Volley	Winners	value	better
groundstrokeWinners	Groundstroke	Winners	value	better
lobWinners	Lob	Winners	value	better
overheadWinners	Overhead	Winners	value	better
dropShotWinners	Drop shot	Winners	value	better
returnWinners	Return	Winners	value	better
errors	Total	Errors	value	worse
forehandErrors	Forehand	Errors	value	worse
backhandErrors	Backhand	Errors	value	worse
groundstrokeErrors	Groundstroke	Errors	value	worse
overheadErrors	Overhead stroke	Errors	value	worse
returnErrors	Return	Errors	value	worse
unforcedErrors	Total	Unforced errors	value	worse
forehandUnforcedErrors	Forehand	Unforced errors	value	worse
backhandUnforcedErrors	Backhand	Unforced errors	value	worse
volleyUnforcedErrors	Volley	Unforced errors	value	worse
groundstrokeUnforcedErrors	Groundstroke	Unforced errors	value	worse
lobUnforcedErrors	Lob	Unforced errors	value	worse
dropShotUnforcedErrors	Drop shot	Unforced errors	value	worse
firstServeReturnPointsWon	First serve return points	Return	ratio	better
secondServeReturnPointsWon	Second serve return points	Return	ratio	better
returnGamesPlayed	Return games played	Return	value	better
breakPointsConverted	Break points converted	Return	value	better
tiebreaks	Tiebreaks	Miscellaneous	value	better

volleyball2 keys

key	name	group	kind	higherIs
serviceErrors	Errors	Service	value	worse
aces	Aces	Service	value	better