Data reference

A single match. Every endpoint and every WebSocket snapshot returns it in this same shape.

idinteger

The fixture’s DataSportsAPI id.

sportstring

Slug of the sport, matching the values listed by /v2/sports.

statusStatus

Current state of the match.

startTimestring (ISO-8601 UTC) | null

Kick-off time. Holds the scheduled start until the source logs the actual kick-off, which then takes its place (the live feed delivers it a few minutes after play begins). Identical across all endpoints and WebSocket deltas.

leagueLeagueRef | null

Competition the fixture belongs to. It is null if the source places the fixture in a competition that has no matching league (observed in minor regional football, e.g. South Africa’s National Second Division on 2026-10-23); in that case season and round are null as well.

seasonSeason | null

Season the fixture is part of.

roundRound | null

Round of the fixture, for competitions organised in rounds.

homeTeamRef | null

The home team. Null until that slot is settled, e.g. while the source still shows a placeholder like "WQF1" (winner of quarter-final 1).

awayTeamRef | null

The away team. Null until that slot is settled (for instance a "WQF1" placeholder from the source).

homeScoreScoreSide

Score of the home team.

awayScoreScoreSide

Score of the away team.

winnerWinner | null

Stays null until status.type is finished, and also when a fight ends as a no contest (fightResult.method noContest). When penalties decide the match, this is always the shoot-out winner regardless of the source (which, on a second leg, reports the team that won the 90 minutes). If the source omits the winner, or declares a draw in a sport where draws are impossible (finishes in regular time or overtime; cricket excluded), we derive it from the score.

venueVenue | null

Where the match is played, if known (frequently null in lower divisions). Populated on /fixtures/{id}, and in date lists when the source provides it. Round, team, player and live lists never include a venue, so a null there means "omitted" rather than "unknown" — fetch /fixtures/{id} to get it.

clockClock | null

The match clock. Null if the source keeps no clock for this fixture, and after the match ends.

firstToServedeprecatedSide | null

Deprecated (2026-10-23); mirrors serving. Because the source refreshes it each game / leg, it reflects who is serving (throwing) at the moment, not who served first. Use serving instead.

servingSide | null

Tennis, darts and other sports with a serve: which side is currently serving (throwing), refreshed by the source every game / leg. Null if the source gives no indication.

homeSeedstring | null

For seeded events such as tennis draws or playoff brackets (basketball, …): the seed of the home side ("1", "12") or its entry status ("WC" wild card, "Q" qualifier, "LL" lucky loser, "PR" protected ranking, …), exactly as shown in the draw. Null for an unseeded side.

awaySeedstring | null

Seed or entry status of the away side; see homeSeed.

notestring | null

Cricket: the match note supplied by the source, which becomes the result line at the end ("Pakistan beat Sri Lanka by 37 runs"). Intended for display only.

battingSideSide | null

Cricket: which side is currently at the crease. Null outside a live innings and in every other sport.

fightResultFightResult | null

MMA / boxing: how, in which round and at what time the fight ended. Null before status.type reaches finished, and when the source supplies no method.

fightDisciplineFightDiscipline | null

Combat sports: the bout’s discipline, when the source labels it (the mma sport includes boxing, kickboxing and Muay Thai cards as well). Only some cards are labelled (ONE, Queensbury, certain OKTAGON fights; never UFC or PFL), so a null value does not imply MMA.

refereeReferee | null

Match official, if the source names one (football and a few other sports; in cricket, the match referee). Present on /fixtures/{id}; always null in lists, where it is omitted.

homeManagerManagerRef | null

Manager or head coach of the home side for this match, if the source names one. Present on /fixtures/{id}; null in lists.

awayManagerManagerRef | null

Manager or head coach of the away side; behaves like homeManager.

surfaceSurface | null

Tennis: the surface the match is played on. Present on /fixtures/{id} and in live lists; null in other sports.

tossCricketToss | null

Cricket: the toss result, after it has taken place. Present on /fixtures/{id}; null in other sports.

umpiresstring[] | null

Cricket: the on-field umpires, named as the source writes them (frequently with a country code, e.g. "Asif Yaqoob (PAK)"). Null when none are listed and in other sports.

tvUmpirestring | null

Cricket: the TV (third) umpire, formatted as for umpires.

previousLegFixtureIdinteger | null

Two-legged ties and playoff series: the DataSportsAPI id of the preceding leg / game, when the source links the two. Look that id up on /fixtures/{id} to get the first-leg score.

aggregateWinnerSide | null

Once the return leg of a two-legged tie is over: the side that went through. Taken from the source’s verdict when available; otherwise from aggregated (the higher total advances) or, if the aggregate is level, from the shoot-out. Null in every other case, including a level aggregate the source leaves unresolved (an away-goals rule). Compare winner, which refers to this match alone: when a second leg goes to penalties both fields name the shoot-out winner, but otherwise they can disagree (a side may win the second leg yet be eliminated). Filled on /fixtures/{id}; in lists and live snapshots it can be null.

fightCardFightCard | null

MMA / boxing: the bout’s section of the card, its running order and its weight class, if the source lists them.

attendanceinteger | null

Crowd figure, if the source reports one (observed for NBA and MLB games, frequently only after the game has started). Present on /fixtures/{id}; omitted (null) in lists.

matchFormatMatchFormat | null

Darts and esports: the format of the match (best of N sets / legs / games), if the source states it. Null in other sports.

inningStateInningState | null

Baseball: the live game situation — inning, half, balls, strikes, outs and runners on base. Null when the game is not in progress or interrupted, and in other sports. Delivered live via WebSocket deltas.

timeoutsTimeouts | null

Basketball: timeouts each side has left. Null outside an in-progress or interrupted game, and whenever the source does not track them. Delivered live via WebSocket deltas.

downAndDistancesince 2026-11-09DownAndDistance | null

American football: the current down, distance and field position. Null when the game is not in progress or interrupted, and in other sports. Delivered live via WebSocket deltas. Available since 2026-11-09.

varChecksince 2026-11-09VarCheck | null

Football: an ongoing VAR review. Null when no review is under way, outside play and in other sports. Delivered live via WebSocket deltas. Available since 2026-11-09.

bonussince 2026-11-09BasketballBonus | null

Basketball: whether each side is in the bonus. Null outside an in-progress or interrupted game, and whenever the source does not report it. The source’s live feed never carries it, so it appears in REST responses and lists only. Available since 2026-11-09.

finalResultOnlysince 2026-11-09boolean

True if the source provides only the final result for this fixture, with no live score, clock or events during play (available since 2026-11-09).

durationssince 2026-11-04Durations | null

Sports played in sets or rounds: the length of every finished period (available since 2026-11-04). Null for sports the source does not time by period (football, basketball, …) and until the first period is over. Delivered live via WebSocket deltas.

lineupsAvailablesince 2026-11-04boolean | null

Becomes true when the source publishes lineups for the fixture, whether predicted or official (check confirmed on /v2/fixtures/{id}/lineups to tell them apart), and false if they are withdrawn. We set it the moment the source’s live feed announces lineups, or when a lineup we fetch contains players. Null means we have no information yet (no announcement observed, nothing fetched). WebSocket deltas carry it live — on fixture:{id} from before kick-off, and on the list channels once play starts. Available since 2026-11-04.

lineupsConfirmedsince 2026-11-04boolean | null

Becomes true when the official lineups are released (matching confirmed on /v2/fixtures/{id}/lineups); otherwise behaves like lineupsAvailable, with null meaning we have no information. Delivered live via WebSocket deltas. Available since 2026-11-04.

Appears inTopPerformanceWsSnapshotWsFixture

The state of a match.

typeStatusType

High-level state, computed from phase (mapping in the StatusPhase table).

phaseStatusPhase

Detailed state, computed from code.

codeinteger | null

The source’s raw status code (the data dictionary lists every value); phase, period and finish give you its meaning ready-made.

descriptionstring | null

Human-readable English label taken from our status table (status codes in the data dictionary) and adapted to the sport, for example "Halftime", "2nd half", "After penalties", "After extra time" (football), "After extra innings" (baseball), "After overtime" (basketball, ice hockey, …), "1st innings" (cricket) or "Coverage canceled". For a code we do not recognise, the source’s own wording is passed through. Use it for display, never for branching logic.

periodPeriodKey | null

Period currently being played, or the one just completed during a break. Null before the start and after the end.

finishFinishType | null

The way the result was reached. Only set when type is finished; null otherwise.

Appears inFixturePlayerFixture

Score of one team.

currentnumber | null

The headline score you would see on a scoreboard: goals, points, sets won (tennis / volleyball) or runs (cricket, baseball), counting extra time / overtime. Shoot-out goals are excluded and reported in penalties instead — except in ice hockey, where the shoot-out winner is given one extra goal (3-3 after overtime becomes 3-4). Before the start, and for fixtures whose coverage was canceled, it is null.

periodsRecord<PeriodKey, number>

The score split by period and keyed by PeriodKey — goals per half, quarter or period; games per set in tennis; points per set in volleyball and table tennis; runs per inning in baseball. Extra periods are included too: football and futsal use extra1 / extra2; American football, basketball, handball, ice hockey, water polo and others use overtime; baseball extra innings run from period10 upwards (overtime only if the source reports extra-innings runs as one total). When the source’s breakdown is complete the values sum to current; it is occasionally incomplete (some baseball leagues omit innings, a few futsal matches lack a half), and ice hockey decided by a shoot-out is intentionally one goal short (see current). Esports uses one key per game (map), with a title-dependent meaning: Counter-Strike stores 1 for each map a side won and 0 for the rest (maps not played count as 0, through period5 in a best of 3); in League of Legends it is the side’s kill count in game N, so the values do not sum to current, which counts games won. Each game’s winner and score are on /fixtures/{id}/games. Empty when the source gives no breakdown.

tieBreaksRecord<PeriodKey, number>

Tennis: points won in each set’s tie-break, using the same keys as periods (e.g. { "period2": 7 }).

normalTimenumber | null

Score when regulation time ended, if the source provides it.

penaltiesnumber | null

Goals converted in a penalty shoot-out. In ice hockey the shoot-out winner gets 1 here and the loser 0, in line with the single goal added to current.

aggregatednumber | null

Combined score across both legs of a two-legged tie.

seriesnumber | null

Playoff series: number of games this side has won in the series to date (basketball, baseball, ice hockey, water polo).

pointstring | null

Tennis: score within the current game — "0" | "15" | "30" | "40" | "A", or a plain number ("0"–"N") during a tie-break. Null when play is neither in progress nor interrupted.

redCardsinteger | null

Football: number of red cards this side has received, counting second yellows.

inningsRecord<PeriodKey, CricketInnings>

Cricket: each innings of this side, keyed inning1…N. Empty in other sports.

hitsinteger | null

Baseball: hit total, i.e. the H in the R/H/E line.

errorsinteger | null

Baseball: error total, i.e. the E in the R/H/E line.

Appears inFixturePlayerFixture

A single cricket innings played by one side.

runsinteger | null

Total runs made.

wicketsinteger | null

Number of wickets that have fallen.

oversnumber | null

Overs delivered, in cricket notation (49.5 means 49 overs plus 5 balls).

runRatenumber | null

Average runs scored per over.

targetRunRatenumber | null

Run rate the chasing side needs to reach its target.

Appears inScoreSideScoreSidePatch

Timing data for a match. Running clocks (football, rugby, …): compute elapsed = periodOffsetSeconds + (now − periodStartedAt) and minute = floor(elapsed / 60) + 1; once periodEndSeconds is passed, display periodEndSeconds / 60 followed by "+" and the extra minutes. This applies only while status.phase is inprogress. Stop clocks (basketball, handball, ice hockey, …): playedSeconds is the value at playedAt and advances only while running is true. Tennis, table tennis, badminton and esports (set / map sports) carry only periodStartedAt (start of the current set or map), and only if the source sends it — the clock as a whole is frequently null. A field is null whenever the source does not provide it for that sport; the entire clock is null when no clock exists and after the match ends. Lists other than /fixtures/{id} may include fewer clock fields (static values such as periodLengthSeconds can be null there).

periodStartedAtstring (ISO-8601 UTC) | null

Moment the clock for the current period was started.

periodOffsetSecondsnumber | null

Running clock: seconds already on the clock at the start of the period (2700 for the second half in football). Unit: seconds.

periodEndSecondsnumber | null

Running clock: clock reading, in seconds, at which regulation time for the period runs out (2700 for the first half in football). Unit: seconds.

maxExtraSecondsnumber | null

Running clock: upper bound on the added time the source’s display permits after periodEndSeconds. Unit: seconds.

injuryTimeMinutesnumber | null

Stoppage time announced for the current period. Unit: minutes.

playedSecondsnumber | null

Stop clock: time played in seconds, valid at playedAt. Unit: seconds.

playedAtstring (ISO-8601 UTC) | null

Timestamp at which playedSeconds was captured.

runningboolean | null

Stop clock: true while the game clock is ticking.

runningUpdatedAtstring (ISO-8601 UTC) | null

Time of the most recent change to running.

periodLengthSecondsnumber | null

Stop clock: duration of a single regulation period. Unit: seconds.

overtimeLengthSecondsnumber | null

Duration of a single overtime period. Unit: seconds.

periodCountinteger | null

How many regulation periods the match has (in combat sports, the scheduled rounds).

lastPeriodEndedAtsince 2026-11-04string (ISO-8601 UTC) | null

End time of the latest completed period. During a break (half-time, between periods) this marks when the break started, so the break has lasted now − lastPeriodEndedAt. Used with football-style running clocks; null if the source sends nothing (before the first break, in other sports, or for data stored before 2026-11-04). Available since 2026-11-04.

Appears inFixturePlayerFixture

MMA / boxing: the way a completed fight was settled.

methodFightMethod

The winning method.

roundinteger | null

Round in which the fight finished.

roundTimeSecondsinteger | null

Elapsed time in that round when the fight was halted (KO, TKO, submission, disqualification, …), if the source records it. Null for every decision (unanimous, split, majority, technical, drawn ones too): nothing stopped the fight, and the source’s figure cannot be trusted there. Unit: seconds.

Appears inFixtureFixturePatchPlayerFixture

The match official (for cricket, the match referee) and the career totals the source records for them. For a per-match rate, divide a total by games.

idinteger

The referee’s DataSportsAPI id.

namestring

Name of the referee.

slugstring | null

Slug for use in URLs.

countryCountry | null

Country of the referee, if the source supplies it.

gamesinteger | null

Number of matches the source has logged with this referee in charge, across the whole career and all competitions.

yellowCardsinteger | null

Yellow cards issued across those matches. Null in sports that have no cards (cricket).

redCardsinteger | null

Direct red cards issued across those matches. Null in sports that have no cards.

yellowRedCardsinteger | null

Dismissals for a second yellow across those matches. Null in sports that have no cards.

imagesince 2026-11-04string (URL) | null

Referee photo hosted on our CDN. Null if no image exists or it has not been uploaded yet. Available since 2026-11-04.

Appears inFixturePlayerFixture

Tennis: the type of court used for the match.

typeSurfaceType

Surface category of the court.

indoorboolean | null

True for an indoor court and false for an outdoor one; null if the source does not specify.

namestring

Surface label as worded by the source, such as "Hardcourt outdoor". For display only.

Appears inFixturePlayerFixtureTennisYearStatistics

Cricket: outcome of the coin toss.

winnerSide | null

Toss winner; null if the team the source names matches neither participant.

decisionTossDecision | null

The choice the toss winner made.

Appears inFixturePlayerFixture

MMA / boxing: a bout’s placement on the event card.

sectionFightCardSection | null

The part of the card (main card, prelims, …), if the source specifies it.

orderinteger | null

Position of the bout in the source’s numbering of the card; larger numbers come later, and the main event carries the largest.

weightClassstring | null

Weight class of the bout, using the source’s naming ("light", "bantam", "feather", …).

Appears inFixturePlayerFixture

Contents of changes in a WebSocket delta: a partial Fixture that keeps the same field names and nesting. Deep-merge it into your local Fixture — nested objects merge key by key, while any other value (null included) overwrites. No fields beyond those listed here are ever sent.

`status` (optional){ type?: StatusType; phase?: StatusPhase; code?: integer | null; description?: string | null; period?: PeriodKey | null; finish?: FinishType | null }

Status fields that were modified. A status change always repeats type, phase and finish, plus period when it is known.

`startTime` (optional)string (ISO-8601 UTC) | null

Updated start time, either because the fixture was rescheduled or because the source has logged the actual kick-off (see Fixture.startTime).

`winner` (optional)Winner | null

Sent once the match is over.

`homeScore` (optional)ScoreSidePatch

Modified fields of the home ScoreSide.

`awayScore` (optional)ScoreSidePatch

Modified fields of the away ScoreSide.

`clock` (optional){ 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; lastPeriodEndedAt?: string (ISO-8601 UTC) | null } | null

A null value signals the match has ended; discard the clock.

`firstToServe` (optional)deprecatedSide | null

Deprecated; carries the same value as serving.

`serving` (optional)Side | null

Side currently serving (throwing).

`note` (optional)string | null

Cricket: updated match note.

`battingSide` (optional)Side | null

Cricket: side currently batting; null when nobody is.

`inningState` (optional)InningState | null

Baseball: updated game state, always delivered as a complete object; null once play has stopped.

`timeouts` (optional){ homeRemaining?: integer | null; awayRemaining?: integer | null; perTeam?: integer | null } | null

Basketball: timeout counts that were modified; null once play has stopped.

`downAndDistance` (optional)since 2026-11-09{ down?: integer | null; yardsToGo?: integer | null; possession?: Side | null; ballOn?: Side | null; yardLine?: integer | null; goalToGo?: boolean | null; playType?: DownPlayType | null } | null

American football: fields that were modified (the full object when tracking begins); null once play has stopped. Available since 2026-11-09.

`varCheck` (optional)since 2026-11-09VarCheck | null

Football: a full object when a VAR review begins, null when it finishes. Available since 2026-11-09.

`durations` (optional){ periods?: Record<PeriodKey, number | null>; totalSeconds?: integer | null }

A newly finished period with its length in seconds (keyed as in ScoreSide.periods; null means the source removed it, so delete it), together with the updated total. Merge it the same way as a score map.

`fightResult` (optional)FightResult | null

MMA / boxing: how, in which round and when the fight finished, sent as a whole object once the source has it. Expect it in a delta after the one that ends the fight, since the source releases it ~20–60 s after the winner is known.

`lineupsAvailable` (optional)since 2026-11-04boolean | null

True when lineups are published and false when they are pulled, sent as soon as the source announces it, including before kick-off (fixture:{id}). Available since 2026-11-04.

`lineupsConfirmed` (optional)since 2026-11-04boolean | null

Signals that the official lineups have been released. Available since 2026-11-04.

Appears inWsDelta

Only the ScoreSide fields that changed.

`current` (optional)number | null

The headline score you would see on a scoreboard: goals, points, sets won (tennis / volleyball) or runs (cricket, baseball), counting extra time / overtime. Shoot-out goals are excluded and reported in penalties instead — except in ice hockey, where the shoot-out winner is given one extra goal (3-3 after overtime becomes 3-4). Before the start, and for fixtures whose coverage was canceled, it is null.

`normalTime` (optional)number | null

Score when regulation time ended, if the source provides it.

`penalties` (optional)number | null

Goals converted in a penalty shoot-out. In ice hockey the shoot-out winner gets 1 here and the loser 0, in line with the single goal added to current.

`aggregated` (optional)number | null

Combined score across both legs of a two-legged tie.

`series` (optional)number | null

Playoff series: number of games this side has won in the series to date (basketball, baseball, ice hockey, water polo).

`point` (optional)string | null

Tennis: score within the current game — "0" | "15" | "30" | "40" | "A", or a plain number ("0"–"N") during a tie-break. Null when play is neither in progress nor interrupted.

`redCards` (optional)integer | null

Football: number of red cards this side has received, counting second yellows.

`hits` (optional)integer | null

Baseball: hit total, i.e. the H in the R/H/E line.

`errors` (optional)integer | null

Baseball: error total, i.e. the E in the R/H/E line.

`periods` (optional)Record<PeriodKey, number | null>

Just the periods whose value changed. A null value means the source removed that period, so delete it.

`tieBreaks` (optional)Record<PeriodKey, number | null>

Just the tie-breaks whose value changed; null means one was removed.

`innings` (optional)Record<PeriodKey, CricketInnings>

Just the innings that changed. Merge them key by key, as with periods; any innings left out keeps its previous value.

Appears inFixturePatch

Compact team reference embedded in other objects (fixtures, standings, players, leaders).

idinteger

The team’s DataSportsAPI id.

namestring

Name of the team. Individual sports (tennis, table tennis, darts, MMA, …) also model each competitor as a team — a single player, or a doubles pair.

slugstring | null

Slug for use in URLs.

shortNamestring | null

Abbreviated display name, if the source provides one.

codestring | null

Abbreviation of 1–4 characters as used on scoreboards (e.g. "ARS", "LA"); generated artificially for individual sports.

imagestring (URL) | null

Team logo hosted on our CDN; null if the team has no image.

Appears inFixturePlayerTransferFormFixturePlayerOfTheSeasonWinnerRaceCareerSeasonTeamRaceDriverScorecardInnings+31 more

Full profile of a team.

idinteger

The team’s DataSportsAPI id.

namestring

Name of the team. Individual sports (tennis, table tennis, darts, MMA, …) also model each competitor as a team — a single player, or a doubles pair.

slugstring | null

Slug for use in URLs.

shortNamestring | null

Abbreviated display name, if the source provides one.

codestring | null

Abbreviation of 1–4 characters as used on scoreboards (e.g. "ARS", "LA"); generated artificially for individual sports.

imagestring (URL) | null

Team logo hosted on our CDN; null if the team has no image.

sportstring | null

Slug of the sport.

countryCountry | null

Country the team is based in or represents.

venueVenue | null

The team’s home ground.

colors{ primary: string | null; secondary: string | null; text: string | null } | null

Kit colours in #rrggbb form. Null when the source has no real colours for the team (the source fills in a placeholder blue for every individual competitor and most minor teams).

genderTeamGender | null

Whether the team is men’s, women’s or mixed; null if the source does not specify.

nationalboolean | null

True for a national team, false for a club; null if the source does not specify.

kindTeamKind | null

Distinguishes a team, a single competitor in an individual sport and a doubles pair; null if the source does not specify.

managerManagerRef | null

Current manager or head coach, if the source names one.

personPerson | null

For individual competitors the source profiles (tennis, MMA): date of birth, height, weight and so on. Null for everyone else.

recordFighterRecord | null

MMA / boxing fighters: career win-draw-loss record together with how their most recent fights ended. Null for all other teams.

foundedOnsince 2026-11-09string (YYYY-MM-DD) | null

Founding date of the club, if the source has it (roughly half of the teams we have read); null otherwise. Available since 2026-11-09.

Personal details of an individual competitor (kind: individual) for whom the source keeps a profile (tennis players, MMA fighters). Field names and units match Player.

dateOfBirthstring (YYYY-MM-DD) | null

Birth date.

heightCminteger | null

Body height. Unit: cm.

weightKgnumber | null

Body weight in kilograms (for MMA, the weight the fighter is listed at).

reachCminteger | null

Arm reach, for MMA. Unit: cm.

nicknamestring | null

MMA ring name or nickname, such as "Storm".

weightClassstring | null

Weight class in the source’s wording (MMA: "feather", "light", "bantam", …).

birthplacestring | null

Place of birth in the source’s wording ("San Candido, Italy").

residencestring | null

Place of residence in the source’s wording ("Monte Carlo, Monaco").

handednessHandedness | null

Tennis: which hand the player plays with.

turnedProinteger | null

Tennis: year the player became a professional.

prizeMoneySeasonMoney | null

Tennis: prize money earned in the current season.

prizeMoneyCareerMoney | null

Tennis: total prize money earned over the career.

Appears inTeamDetail

A league or competition. /v2/leagues/{id} and every league list return this same shape.

idinteger

The league’s DataSportsAPI id.

namestring

Name of the league or competition.

slugstring | null

Slug for use in URLs.

sportstring | null

Slug of the sport, matching the values listed by /v2/sports.

categorystring | null

How the source groups the league: by country ("England"), region ("International", "North America", "World"), tour ("ATP", "WTA") or game (esports: "Counter Strike"). It is not necessarily a country; use country for that.

countryCountry | null

Country of the league when its category is a country; null for regions, tours and games.

imagestring (URL) | null

League logo hosted on our CDN; null if the league has no image.

prioritysince 2026-11-04integer | null

The source’s prominence ranking for the competition, handy for ordering leagues: a higher value means a bigger competition (for example 719 for the Champions League, 704 for the Premier League, 702 for LaLiga, 519 for Primeira Liga), and 0 means unranked. It is filled only where the source supplies it: on the league embedded in a fixture and in the /v2/fixtures?date&sport day lists. Everywhere else — league profiles, directories, search — it is null, as it is on rows saved before 2026-11-04. Available since 2026-11-04.

Appears inFixtureFormFixtureGrandSlamResultsSearchFixturePlayerLeagueSeasonsPlayerFixtureRankingRowLeagueDetail+3 more

A country record.

codestring | null

Two-letter code supplied by the source. ISO 3166-1 alpha-2, apart from XK for Kosovo and four codes for the UK home nations (England EN, Scotland SX, Wales WA, Northern Ireland NX). Null if unknown.

namestring

Country name in English.

flagsince 2026-11-04string (URL) | null

Flag image (PNG) hosted on our CDN. Null when there is no code or the image has not been uploaded yet. Available since 2026-11-04.

Appears inRefereeTeamDetailLeagueRefVenuePlayerSquadPlayerLineupPlayerSeasonInfo+9 more

One season of a league.

idinteger

The season’s DataSportsAPI id.

namestring | null

Full season name, such as "Premier League 26/27".

yearstring | null

Display label in the source’s format: "26/27" or "2026/2027" when the season spans two years, "2026" for a calendar-year season. Use startYear / endYear for sorting and filtering.

startYearinteger | null

Year in which the season begins (2026 for both "26/27" and "2026"); null if the label cannot be parsed.

endYearinteger | null

Year in which the season finishes (2027 for "26/27"; equal to startYear for a calendar-year season); null if the label cannot be parsed.

Appears inFixturePlayerOfTheSeasonWinnerGrandSlamYearRaceCareerSeasonPlayerFixtureRaceRaceSummaryPlayerCareerSeason

One round within a league season.

numberinteger

Round number from the source. Treat it as an opaque key rather than a sequence: cups count rounds by how many entrants remain (32 for a tennis "Round of 64"), and playoff rounds get large values (636). Use it with /v2/leagues/{id}/fixtures. The source gives some competitions no round structure — NBA and NHL regular seasons, NCAA, one-off tennis or MMA events; their fixtures may still have a round, but /rounds comes back empty and filtering by round yields nothing, so query them by date.

namestring | null

Name of the round, if it has one ("Quarterfinals", "Playoff round").

slugstring | null

Tells apart rounds that share a number across different phases. When present, include it in /fixtures requests.

prefixstring | null

An additional qualifier (e.g. "Qualification"); send it to /fixtures along with slug.

Appears inFixtureRoundsPlayerFixture

All rounds of a season plus the one in progress. Returned empty (current: null, rounds: []) for competitions the source does not structure in rounds; see Round.number.

currentRound | null

—

roundsRound[]

—

A stadium or arena: where a fixture takes place, or a team’s home ground.

idinteger | null

The venue’s DataSportsAPI id; null if the source supplies the venue without an id.

namestring | null

Name of the stadium or arena.

citystring | null

City where the venue is located.

countryCountry | null

Country where the venue is located.

capacityinteger | null

Number of seats.

Appears inFixtureTeamDetailCupBlockSearchResultPlayerFixture

Compact player reference embedded in other objects.

idinteger

The player’s DataSportsAPI id.

namestring

Name of the player.

slugstring | null

Slug for use in URLs.

shortNamestring | null

Abbreviated display name such as "B. Saka", if the source provides one.

imagestring (URL) | null

Player photo hosted on our CDN; null if the player has no image.

Appears inTransferLineupPlayerMissingPlayerIncidentBuildUpStepBestPlayerShotAveragePosition+18 more

Compact reference to a team’s manager (head coach), embedded in other objects.

idinteger

The manager’s DataSportsAPI id.

namestring

Name of the manager or head coach.

slugstring | null

Slug for use in URLs.

shortNamestring | null

Abbreviated name such as "F. Hurzeler".

imagesince 2026-11-04string (URL) | null

Manager photo hosted on our CDN. Null if no image exists or it has not been uploaded yet. Available since 2026-11-04.

Appears inFixtureTeamDetailManagerDuelPlayerFixture

Full profile of a player.

idinteger

The player’s DataSportsAPI id.

namestring

The player’s full name.

slugstring | null

Slug for use in URLs.

shortNamestring | null

Abbreviated name such as "B. Saka".

positionPosition | null

Primary playing position.

positionCodestring | null

Position code as used by the source.

jerseyNumberstring | null

Shirt number as a string, since basketball and American football treat "0" and "00" as distinct numbers. Null if unknown; rugby squads’ "0" placeholder is dropped.

heightCminteger | null

Body height. Unit: cm.

preferredFoot"left" | "right" | "both" | null

Football: the player’s stronger foot — left, right or both.

dateOfBirthstring (YYYY-MM-DD) | null

Birth date.

countryCountry | null

The player’s nationality.

marketValueMoney | null

Estimated value on the transfer market; null if unknown.

contractUntilstring (YYYY-MM-DD) | null

Date the current contract expires; null if unknown.

imagestring (URL) | null

Player photo hosted on our CDN.

injuryInjury | null

Ongoing injury, if the source records one (football, mainly in covered leagues); null means no injury is listed.

detailedPositionsDetailedPosition[]

Football: fine-grained positions the player occupies, primary first (e.g. ["striker"], ["rightWinger", "attackingMidfielder"]). Empty if the source lists none, as in other sports and minor leagues; position keeps the broad line either way.

teamTeamRef | null

Team the player currently belongs to.

An injury a player is currently carrying.

descriptionstring | null

Name of the injury, such as "Hamstring Injury".

statusInjuryStatus | null

Availability status: out, day to day, …

sincestring (YYYY-MM-DD) | null

Date the injury began (UTC day).

expectedReturnstring (YYYY-MM-DD) | null

Projected return date (UTC day), if the source offers an estimate.

updatedAtstring (ISO-8601 UTC) | null

Time of the source’s latest update to this injury.

Appears inPlayerSquadPlayer

A member of a squad. Identical to Player minus team, which is implied by the squad.

idinteger

The player’s DataSportsAPI id.

namestring

The player’s full name.

slugstring | null

Slug for use in URLs.

shortNamestring | null

Abbreviated name such as "B. Saka".

positionPosition | null

Primary playing position.

positionCodestring | null

Position code as used by the source.

jerseyNumberstring | null

Shirt number as a string, since basketball and American football treat "0" and "00" as distinct numbers. Null if unknown; rugby squads’ "0" placeholder is dropped.

heightCminteger | null

Body height. Unit: cm.

preferredFoot"left" | "right" | "both" | null

Football: the player’s stronger foot — left, right or both.

dateOfBirthstring (YYYY-MM-DD) | null

Birth date.

countryCountry | null

The player’s nationality.

marketValueMoney | null

Estimated value on the transfer market; null if unknown.

contractUntilstring (YYYY-MM-DD) | null

Date the current contract expires; null if unknown.

imagestring (URL) | null

Player photo hosted on our CDN.

injuryInjury | null

Ongoing injury, if the source records one (football, mainly in covered leagues); null means no injury is listed.

detailedPositionsDetailedPosition[]

Football: fine-grained positions the player occupies, primary first (e.g. ["striker"], ["rightWinger", "attackingMidfielder"]). Empty if the source lists none, as in other sports and minor leagues; position keeps the broad line either way.

A single player movement between teams, such as a transfer, loan, signing, trade or release. It has no id; the combination of player, type and date identifies it.

playerPlayerRef

Player involved in the move.

typeTransferType

Category of the move.

datestring (YYYY-MM-DD) | null

Date the move became effective (UTC day); null if the source gives no date.

fromTeamRef | null

Club the player departed; null for a free agent or for a side the source has no team record for (see fromName).

fromNamestring | null

The club the player left, named as the source writes it (e.g. "Bryne FK Yth."); set even when from is null.

toTeamRef | null

Club the player moved to; null after a waiver, release or retirement, or for a side the source has no team record for (toName then reads "No team" for releases and free agents).

toNamestring | null

Name of the destination club as written by the source; works like fromName.

feeMoney | null

Transfer fee, if the source states it. Null for free, undisclosed or unknown fees and for any move that is not a transfer.

freeTransferboolean

True if the source marks the move as free, meaning no fee changed hands.

draft{ round: integer | null; pick: integer | null } | null

For type draft: the round and pick number, if listed. Null otherwise.

Appears inTeamTransfersTransferFeed

Recent incoming and outgoing moves for a team as listed by the source, covering roughly the past year.

arrivalsTransfer[]

Incoming moves, most recent first.

departuresTransfer[]

Outgoing moves, most recent first.

One page of the most recent football transfers (GET /v2/transfers). Available since 2026-11-09.

transfersTransfer[]

Moves on this page (no more than 50), sorted as requested.

hasNextPageboolean

True if another page might contain further moves.

A monetary value.

amountnumber

The value, expressed in units of currency.

currencystring

Currency as an ISO 4217 code, such as "EUR".

Appears inPersonPlayerSquadPlayerTransferLineupPlayer

Team sheets for both sides.

confirmedboolean

True when the official lineups have been released; false means they are predicted or not yet published.

homeTeamLineup

Lineup of the home side.

awayTeamLineup

Lineup of the away side.

Appears inWsLineups

The lineup of a single side.

formationstring | null

Tactical formation, such as "4-2-3-1" (football).

playersLineupPlayer[]

—

missingMissingPlayer[]

—

Appears inLineups

An individual entry in a lineup.

playerPlayerRef | null

Player reference.

positionPosition | null

Position the player fills in this lineup.

positionCodestring | null

Position code from the source, as shown on a team sheet ("G", "LW", "QB", "1B").

jerseyNumberstring | null

Shirt number as a string, since "00" is possible.

substituteboolean

True if the player started on the bench.

captainboolean

True for the team captain.

heightCmsince 2026-11-06integer | null

Height, copied over from the profile at GET /v2/players/{id}; null if the source has no value. Available since 2026-11-06. Unit: cm.

dateOfBirthsince 2026-11-06string (YYYY-MM-DD) | null

Birth date from the player’s profile; null if unknown. Available since 2026-11-06.

countrysince 2026-11-06Country | null

Nationality from the player’s profile, flag included; null if unknown. Available since 2026-11-06.

marketValuesince 2026-11-06Money | null

Estimated market value from the player’s profile; null if unknown (the source only provides it for some football players). Available since 2026-11-06.

ratingnumber | null

Match rating to 2 decimal places (e.g. 7.4); null for an unrated player.

avgRatingnumber | null

Football: the player’s average match rating over the season (2 decimals), included when the source sends it with the lineup — usually in the run-up to kick-off and around it.

ratingVersions{ original: number | null; alternative: number | null } | null

Football: the rating from the original model alongside the one from the source’s alternative model.

star1 | 2 | 3 | null

Ice hockey: whether the player was picked as first, second or third star of the game.

battingOrderinteger | null

Baseball: the player’s slot in the batting order.

statisticsRecord<string, number> | null

The player’s match statistics, using sport-specific camelCase keys from the same vocabulary as team statistics: whenever a key measures the same thing as a team StatItem, it shares that key (football minutesPlayed, passes, accuratePasses, shotsOnGoal, expectedGoals …; basketball points, fieldGoalsMade, fieldGoalsAttempted, secondsPlayed …; ice hockey goals, shotsOnGoal, penalties, plusMinus, savePercentage …). Every …Percentage key is a share from 0 to 100 — ice-hockey save percentages too (94.1 rather than 0.941). Values are in seconds where the key name says so. Null if the player has no statistics.

Appears inTeamLineup

A player who is unavailable for a fixture.

playerPlayerRef | null

Player reference.

availabilityAvailability | null

Whether the player is ruled out or only doubtful.

reasonMissingReason | null

Cause of the absence.

descriptionstring | null

Further detail in the source’s words, such as "Hamstring Injury" or "Red card suspension".

expectedReturnAtstring (ISO-8601 UTC) | null

Anticipated return time, if known.

Appears inTeamLineup

Match statistics broken down by period.

periods({ period: "all" | PeriodKey; groups: StatGroup[] })[]

An entry for each period the source provides statistics for, beginning with "all".

Appears inWsStatistics

A themed set of statistics.

keystring

Stable group identifier from a per-sport table, not derived from the display name — "matchOverview", "attack", "other" and so on.

namestring | null

Human-readable group title, such as "Match overview".

itemsStatItem[]

—

Appears inStatistics

A single match statistic with values for both teams.

keystring

Stable camelCase identifier. A given key always denotes the same quantity, across all sports and in lineup player statistics, though it may show up in two groups. Ratio keys are named after the successes their value counts (aerialDuelsWon, fieldGoalsMade, accurateCrosses, firstServesIn, powerPlayConversion) and never end in …Percentage; that suffix is reserved for keys whose value is already a 0–100 share (duelsWonPercentage, corsiPercentage). Note that blocks counts attempts this side blocked, while shotsBlocked counts this side’s own shots that got blocked. The data dictionary lists every key per sport.

namestring | null

English label as provided by the source.

kindStatKind

Tells you how to interpret the value and total of the statistic.

higherIsHigherIs | null

Indicates whether a larger number is better; use it to emphasise the side that leads.

homeStatSide

Home side’s figures.

awayStatSide

Away side’s figures.

Appears inStatGroup

A single team’s value for a statistic.

displaystring | null

Ready-to-display text, such as "57%", "33/53 (62%)" or "1:22".

valuenumber | null

Underlying numeric value; interpret it using the item’s kind.

totalnumber | null

For kind ratio, the number of attempts; for kind time, the seconds available. Null for other kinds.

Appears inStatItem

Something that happened during a match. As with all timeline lists, entries run oldest first (chronological order).

typeIncidentType

Category of the event.

detailIncidentDetail | null

Sub-category within the type; null on period and injuryTime rows.

sideSide | null

Side the event is credited to (an own goal belongs to the side that benefits from it); null on period / injuryTime rows.

minuteinteger | null

Match minute. Null whenever the clock is stopped — before kick-off, at half-time and after full time, for bench events, and during a shoot-out. Unit: minutes.

addedMinuteinteger | null

How far into stoppage time the event happened (90+3 gives minute 90, addedMinute 3). On injuryTime rows it holds the announced minutes. Unit: minutes.

secondinteger | null

Game clock in seconds, if the source supplies it — present on all rows in ice hockey, basketball, handball and rugby, but only on period rows in football. Unit: seconds.

periodPeriodKey | null

Period in which the event took place. On period rows it is the period that just ended (ET → extra2, PEN → penalties, FT → period2 in football and period4 in basketball). On other rows it is the period bounded by the surrounding period rows, or the source’s own value when supplied; shoot-out kicks use penalties. Null only if it cannot be determined (no period row yet and the period length for the sport is unknown).

playerPlayerRef | null

Main player involved: the scorer, the booked or penalised player, the subject of a VAR check, or the shoot-out taker.

playerNamestring | null

Name of the player; filled even when the source provides a name without a player record (as with some own goals).

assistsPlayerRef[]

Players credited with assists on the goal, in order (up to two in ice hockey).

playerInPlayerRef | null

For a substitution: the player entering the field.

playerOutPlayerRef | null

For a substitution: the player leaving the field.

drawnByPlayerRef | null

For an ice hockey suspension: the player who drew the penalty.

homeScorenumber | null

Home score immediately after the event (on goals, period rows and shoot-out kicks). For period rows in set sports (volleyball, table tennis, badminton) it is the number of sets won so far; the points inside each set are given by /points and by the fixture’s periods.

awayScorenumber | null

Away score immediately after the event (sets won, on period rows in set sports).

textstring | null

On period rows: the label a scoreboard would show ("HT", "FT", "Q4", "3rd period", "Overtime", "PEN"). For display only.

reasonstring | null

For a card, why it was shown ("Foul", "Violent conduct"); for a suspension, the offence ("Holding"); for a missed penalty, how it was missed ("Goalkeeper save", "Off target").

rescindedboolean | null

For a card: true if it was later withdrawn.

confirmedboolean | null

For a varDecision: true when the original decision was upheld.

shootoutSequenceinteger | null

For a shootoutPenalty: position of the kick in the overall order across both teams (1 is the opening kick of the shoot-out).

shootoutRoundinteger | null

For a shootoutPenalty: the round, i.e. whether it was the taking side’s 1st, 2nd, … kick.

durationSecondsinteger | null

For a suspension: how long the player is excluded. Unit: seconds.

buildUpBuildUpStep[]

For a football goal: the sequence of passes and shots leading up to it, ending with the goal itself (covered leagues only; empty elsewhere and for all other incidents).

Appears inKeyedIncident

An incident paired with its stable key, as used in events frames.

keystring

Identifier of the incident that stays stable within the fixture, built as type:side:minute:addedMinute (e.g. "goal:home:34:0", with "-" standing in for a null side or minute). Additional incidents in the same slot get #2, #3, … in list order. The player is not part of the key, so correcting the scorer or goal type keeps the key and counts as an update; correcting the minute produces a new key and removes the old one.

incidentIncident

The match event itself. As with all timeline lists, entries run oldest first (chronological order).

Appears inIncidentChangesWsEvents

The difference between an events frame and the one before it.

addedstring[]

Keys of incidents that did not exist in the previous events frame (or in the server’s earlier copy).

updatedstring[]

Keys of incidents whose details were modified (scorer, assist, build-up, rescinded card, …).

removedKeyedIncident[]

Incidents that have disappeared from the source, each with its final content — for example a goal cancelled by VAR. The score reverts through a delta, and the goal shows up here once REST confirms its removal.

Appears inWsEvents

A single action in the move leading to a goal, as mapped by the source (football, covered leagues).

actionBuildUpAction

Type of action performed in this step.

sideSide | null

Team of the player performing the action (for an own goal, the final step belongs to the defending side).

playerPlayerRef | null

Player who performed the action.

minuteinteger | null

Minute of the match. Unit: minutes.

positionPitchSpot | null

Pitch location where the action began.

endPositionPitchSpot | null

For a pass / cross: where the ball ended up. Null for other actions.

assistboolean

True for the pass credited as the assist.

bodyPartBodyPart | null

For the goal: the body part used to strike it.

expectedGoalsnumber | null

For a goal / savedShot: xG value of the chance on a 0–1 scale, if the source provides it.

expectedGoalsOnTargetnumber | null

For a goal / savedShot: expected goals on target (xGOT), if available.

goalMouthLocationGoalMouthLocation | null

For the goal: the area of the goal mouth it went into.

Appears inIncident

A location on a football pitch.

xnumber

Lengthwise position from 0 to 100, oriented in the attacking direction of the SCORING side (100 is the goal the ball ended up in, own goals included). For away goals we rotate the source’s coordinates, in which the home side always attacks towards 100 (corrected 2026-10-23). Unit: percent.

ynumber

Widthwise position from 0 to 100, rotated together with x (seen from the scoring side). Unit: percent.

Appears inBuildUpStep

The record of the two teams against each other; the endpoint answers null when there is none.

homeWinsinteger

Meetings won by the home team of this fixture.

awayWinsinteger

Meetings won by the away team of this fixture.

drawsinteger

Number of drawn meetings.

managerDuelManagerDuel | null

How the two managers have fared head to head (football and other sports that have managers). Null if they have never met or the source has no data.

Head-to-head record between the two managers, counting every team either of them has managed.

homeManagerManagerRef | null

Manager of the home team in this fixture.

awayManagerManagerRef | null

Manager of the away team.

homeWinsinteger

Wins for teams led by the home manager over teams led by the away manager.

awayWinsinteger

Wins for the away manager’s teams.

drawsinteger

Number of drawn meetings.

Appears inH2H

Form of both sides heading into a fixture. A side is null if the source has no form for it. If only recent matches exist — tennis, for instance, has no competition form guide at the source — results is empty and the table figures are null, but lastFixtures is filled.

homeTeamForm | null

—

awayTeamForm | null

—

Pre-match form of a single side.

resultsFormResult[]

Up to five most recent results in this competition prior to the fixture, ordered from oldest to newest.

positioninteger | null

Table position before the fixture.

pointsinteger | null

Points in the table before the fixture, for competitions whose standings use points (football, ice hockey, handball, rugby, …); null otherwise.

winsinteger | null

Wins going into the fixture, for tables that count wins and losses instead of points (W-L in basketball and baseball, W-D-L in MMA); null otherwise. In MMA it is the source’s tally inside the event’s competition — e.g. Volkanovski at 8-0-3 ahead of UFC 333, with a 28-0-4 career record — not the career record — that lives in TeamDetail.record on /v2/teams/{id}.

drawsinteger | null

Draws, for records that include them (MMA W-D-L); null otherwise.

lossesinteger | null

Losses, set alongside wins; null otherwise.

avgRatingnumber | null

Average player rating of the side over its recent matches (2 decimals).

lastFixturessince 2026-11-04FormFixture[]

The source’s team form, which spans ALL competitions: up to five completed matches played before this fixture, oldest to newest, each carrying opponent, score and result. It differs from results, which only covers this competition, and it is filled for tennis too. Empty if the source has nothing, and on forms saved before 2026-11-04 until their next refresh. Available since 2026-11-04.

Appears inPregameForm

A recent match played by a side ahead of a fixture, including its score (used in TeamForm.lastFixtures).

fixtureIdinteger

DataSportsAPI id of that match (GET /v2/fixtures/{id}).

startTimestring (ISO-8601 UTC) | null

Start time of the match (UTC).

leagueLeagueRef | null

Competition the match belonged to, of any type (league, cup, European, friendly).

sideSide

Whether the team was home or away in that match.

opponentTeamRef | null

The opposing team.

scoreForinteger | null

Score the team achieved, equal to its side’s Fixture score current (goals, points; sets in tennis).

scoreAgainstinteger | null

Score of the opposing team.

resultFormResult | null

Outcome for the team as interpreted by the source; matches settled in overtime or on penalties count as a win for the side that prevailed.

Appears inTeamForm

Runs of form for both teams heading into a fixture.

generalStreak[]

For both sides, the streaks that run through their latest matches in every competition before this fixture. After the final whistle it keeps the streaks the match was played with.

headToHeadStreak[]

Streaks drawn from matches between the two sides.

A noteworthy team streak to highlight before a fixture.

namestring

English description of the streak, such as "Wins", "No losses" or "More than 2.5 goals". Display text only, since the source provides no stable key.

kindStreakKind

How to read the figure: an average, a consecutive run, or x out of the last y.

valuestring

The figure exactly as the source formats it: "5" for five in a row, "7/8" when seven of the last eight qualified, "83" for an average.

countinteger | null

Number of matches for which the streak holds (the 5 in "5", the 7 in "7/8"); null for an average.

outOfinteger | null

The y in an "x of the last y" streak; null for consecutive runs and averages.

averagenumber | null

For kind average, the value itself (83 points a game); null otherwise.

sideStreakSide

Which team the streak belongs to.

continuedboolean | null

True if the streak is still active.

Appears inStreaks

Top performers for each team.

playerOfTheMatchBestPlayer | null

The player of the match, in sports that award one.

homeBestPlayer[]

—

awayBestPlayer[]

—

One of the standout players in a match.

playerPlayerRef | null

Player reference.

valuenumber | null

Figure the ranking is based on (a rating, points, goals, yards). Null in baseball, where the list simply follows the source’s ordering (best first) without a figure we can account for.

labelBestPlayerLabel | null

Describes what value measures.

statisticssince 2026-11-04Record<string, number> | null

Basketball: the player’s stat line, using the same keys as lineup statistics (points, rebounds, assists, steals, blocks, rating). For baseball, available since 2026-11-04, the numbers — pitching or batting — that got the player picked (pitchingInningsPitched, pitchingStrikeOuts, battingHits, battingHomeRuns, battingRbi, …). Null in any sport where the source lists nothing.

rolesince 2026-11-04BestPlayerRole | null

Baseball (since 2026-11-04): pitcher or batter, i.e. the role the player was picked for; null for every other sport.

Appears inBestPlayers

Values for drawing a momentum chart: one per game in tennis, one per minute in football, basketball, handball, ice hockey and the like.

points({ minute: number; addedMinute: integer | null; value: number })[]

One value for every minute, in match order; points in added time come after the final minute of their period.

periodLengthMinutesnumber | null

How long one regulation period lasts — 45 minutes in football, 10 in basketball, 20 in ice hockey. Unit: minutes.

periodCountinteger | null

Number of regulation periods.

overtimeLengthMinutesnumber | null

Duration of a single overtime period. Unit: minutes.

overtimeCountinteger | null

How many overtime periods were played, if the source reports it.

games{ period: PeriodKey; game: integer; value: number; breakOfServe: boolean }[]

Tennis: a value for each game in sequence (minute points stay empty). Empty in other sports.

Appears inWsMomentum

A single shot attempt (football, ice hockey, basketball field goals). Lists run chronologically, oldest first, with shoot-out kicks at the end in kick order. Basketball is the exception: the source gives no timing, so home shots come before away shots in the source’s order, and only side, outcome and position are filled.

sideSide | null

Team that took the shot.

playerPlayerRef | null

Player who took the shot.

goalkeeperPlayerRef | null

Football: the opposing goalkeeper.

outcomeShotOutcome | null

Result of the shot.

techniqueShotTechnique | null

Ice hockey: type of shot.

goalTypeShotGoalType | null

Set on goals only: regular, ownGoal or penalty.

situationShotSituation | null

Football: the phase of play that produced the shot.

bodyPartBodyPart | null

Football: body part used to strike the ball.

strengthShotStrength | null

Ice hockey: the manpower situation at the time.

expectedGoalsnumber | null

xG value of the chance on a 0–1 scale.

expectedGoalsOnTargetnumber | null

Football: post-shot expected goals (xGOT), set for shots on target.

minuteinteger | null

Minute of the match. Unit: minutes.

addedMinuteinteger | null

How far into stoppage time the shot came. Unit: minutes.

secondinteger | null

Game clock reading in seconds. Unit: seconds.

periodPeriodKey | null

Period in which the shot came. In football the minute decides it (shoot-out kicks → penalties, 45+2 → period1, 92 → extra1); basketball has no timing, so it stays null.

positionPoint | null

Where the shot was taken from. Football: pitch percentages 0–100, with x measured from the goal line under attack and y across the pitch. Ice hockey: x roughly 0–240 along the ice (rink units from the source, each side attacking one end) and y covering 0–100 from side to side. Basketball: tenths of a foot measured from the basket being attacked; x runs across the court (−250…250 sideline to sideline), y away from the basket (0 is the rim, and the NBA three-point arc sits at 237.5).

goalMouthPoint | null

Football: point at which the ball crossed the goal line (y 0–100 across the goal mouth, z for height).

goalMouthLocationGoalMouthLocation | null

Football: zone of the goal mouth the shot reached, or of the near miss.

blockPositionPoint | null

Football: the point at which a blocked or saved shot was halted.

shootoutSequenceinteger | null

Football shoot-out kicks: where the kick falls in the combined order of both teams (the same numbering the shoot-out incidents use).

shootoutRoundinteger | null

Football shoot-out kicks: which of the shooting side’s kicks this was (1st, 2nd, …).

Appears inWsShotmap

A coordinate pair; see Shot for each sport’s coordinate system.

xnumber | null

—

ynumber | null

—

znumber | null

—

Appears inShotBallPenaltyKick

Activity map of one player across a fixture (football, covered leagues).

pointsHeatPoint[]

All recorded samples, meant to be drawn as a density map. If the source has no heatmap for this player and fixture — always so outside football — the list comes back empty with 200, not 404.

A single touch or position sample within a heatmap.

xnumber

Lengthwise position from 0 to 100, oriented in the player’s attacking direction (100 is the goal being attacked). Unit: percent.

ynumber

Widthwise position from 0 to 100. Unit: percent.

Appears inHeatmap

Mean on-pitch positions of every player on both sides (football, covered leagues).

homeAveragePosition[]

—

awayAveragePosition[]

—

Where a player was positioned on average during a fixture.

playerPlayerRef | null

Player reference.

jerseyNumberstring | null

The player’s shirt number.

positionPosition | null

Position as used in lineups, derived from positionCode.

positionCodestring | null

Single-letter position code from the source ("G", "D", "M", "F").

xnumber | null

Mean lengthwise position from 0 to 100, oriented in the team’s attacking direction. Unit: percent.

ynumber | null

Mean widthwise position from 0 to 100. Unit: percent.

pointsCountinteger | null

Number of position samples the average is computed from.

Appears inAveragePositions

A fixture’s point-by-point record, shaped by sport: sets → games → points in tennis, sets → rallies in rally sports, innings → overs → balls in cricket, at-bats in baseball, and sets → legs → visits in darts.

formatPointsFormat | null

Names the list among sets / innings / atBats / darts that has data. Null until something arrives, and in sports without any point-by-point data — those get 200 with empty lists rather than 404.

setsPointSet[]

Tennis and rally sports: an entry for each set, in sequence.

inningsInningsBalls[]

Cricket: an entry for each innings, in sequence.

atBatsAtBat[]

Baseball: all plate appearances in chronological order, oldest first.

dartsDartsSet[]

Darts: nested sets → legs → visits, in sequence.

Point-by-point detail of a single set.

periodPeriodKey

Which set this is: period1, period2, …

homeScoreinteger | null

Games (tennis) or points (rally sports) the home side won in the set, taken from the final listed score. For a tennis match tie-break the points are counted (10-8), consistent with the fixture’s period score.

awayScoreinteger | null

Games / points the away side won in the set.

gamesTennisGame[]

Tennis: each game in sequence. Empty for rally sports.

pointsRallyPoint[]

Rally sports: each rally in sequence as recorded by the source. Lower-tier coverage may skip a rally, which shows up as a jump in the running score. Empty for tennis.

Appears inPoints

A single game within a tennis set.

numberinteger

Position of the game in the set (13 is the tie-break). When a match tie-break stands in for the deciding set, it is that set’s game 1, played to 10 points.

serverSide | null

The serving side. For a tie-break the source reports whoever served its LAST point rather than its first (verified against real tie-breaks on 2026-10-19).

winnerSide | null

Side that took the game; if it differs from the server, serve was broken. For a completed tie-break we take the winner from its final point, because in a check on 2026-10-19 the source had the wrong game winner on 3 of 8 match tie-breaks.

homeGamesinteger | null

Games won by the home side in the set once this game is over.

awayGamesinteger | null

Games won by the away side in the set once this game is over.

pointsTennisPoint[]

Each point in sequence. For a completed game the final point is the one that decided it (its winner matches the game’s winner); for a game still under way, the points played so far.

Appears inPointSet

A single point within a tennis game.

homeScorestring | null

Home side’s game score following the point: "0", "15", "30", "40", "A" (plain numbers in a tie-break). It is a string to accommodate "A". Null on the point that closes a regular game, since no score exists once the game is over.

awayScorestring | null

Away side’s game score following the point; null in the same case as homeScore.

winnerSide | null

Side that won the point, inferred from how the score changed; null if that cannot be inferred.

descriptionTennisPointDescription | null

Marks an ace or a double fault; null for all other points and for the game-winning point we append. The source does not list that final point, so an ace that closes a game goes unmarked.

homeTypeTennisPointType | null

What the point means for the home side (point won, now holding break or set point, mini-break in a tie-break). Null on the game-winning point added at the end.

awayTypeTennisPointType | null

Significance of the point for the away side, as for homeType.

Appears inTennisGame

A single rally within a set (volleyball, table tennis, badminton).

winnerSide | null

Side that won the rally.

homeScoreinteger | null

Home side’s points in the set following the rally.

awayScoreinteger | null

Away side’s points in the set following the rally.

Appears inPointSet

Ball-by-ball record of a single cricket innings.

inningPeriodKey

Innings key (inning1, inning2, …), matching ScoreSide.innings.

battingSideSide | null

Side at bat during this innings.

oversOver[]

Each over in sequence.

Appears inPoints

A single over within an innings.

numberinteger

Over number, starting at 1 for the opening over. Cricket notation counts completed overs instead, so the 3rd ball of over 46 reads "45.3".

ballsBall[]

Each delivery in sequence.

Appears inInningsBalls

A single cricket delivery.

sequenceinteger | null

Running delivery counter from the source across the whole match, useful for ordering deliveries between overs.

ballinteger | null

Delivery number inside the over; extras can take it above 6.

outcomeBallOutcome

Result of the delivery.

runsinteger | null

Runs scored off the bat.

totalRunsinteger | null

All runs the delivery contributed, extras included.

wicketboolean

True if a wicket fell on this ball.

dismissalDismissal | null

Manner of dismissal, when a wicket fell.

batterPlayerRef | null

Batter facing the delivery.

bowlerPlayerRef | null

Bowler who delivered the ball.

fielderPlayerRef | null

Fielder who took part in a dismissal (catch, run-out, stumping).

dismissedBatterPlayerRef | null

Batter who was dismissed, which is not always the striker (run-outs).

scoreRunsinteger | null

Batting side’s total runs once the delivery is complete.

scoreWicketsinteger | null

Wickets fallen once the delivery is complete.

commentarysince 2026-11-04string | null

English ball-by-ball commentary for the delivery, verbatim from the source — e.g. "FOUR! … driven firmly through the covers". Null if the source has none (lower-tier matches, or deliveries stored before 2026-11-04). Available since 2026-11-04.

shotsince 2026-11-04CricketShot | null

Direction the ball travelled off the bat, as plotted on a wagon wheel. Null if the source records no direction (an unhit dot ball, a leave, a bye; lower-tier matches). Available since 2026-11-04.

pitchedAtsince 2026-11-04Point | null

Landing spot of the ball for a pitch map, in the source’s units: y increases with distance from the batter’s stumps (yorker ≈ 25, good length ≈ 41, short ball ≈ 54) and x spans the width of the pitch (values of ≈ 6–26 observed); z is always null. Null if the source has no data. Available since 2026-11-04.

Appears inOver

Direction and distance of a cricket shot, forming one line on the wagon wheel.

zoneCricketShotZone | null

Field sector of the shot; null if the source provides only an angle.

angleinteger | null

Shot direction in degrees in the source’s reference frame, seen from a right-handed batter: 0 ≈ square leg, 90 ≈ right behind the keeper, 180 ≈ point, 270 ≈ straight back down the pitch. Unit: degrees.

distanceinteger | null

How far the ball went, on a 1–5 scale set by the source: 1–2 near the bat (say, back to the bowler or edged to the keeper), 3 the ring, 4 the deep, 5 the boundary — every four and six. We inferred these bands from the data on 2026-11-04; the source does not document them.

Appears inBall

A single baseball plate appearance. The at-bat list has no outcome field; the result is that of the final pitch (/at-bats/{atBatId}/pitches).

idsince 2026-11-04integer | null

DataSportsAPI id of the at-bat, for use with /v2/fixtures/{id}/at-bats/{atBatId}/pitches. Present since 2026-11-04; lists saved before then show null.

inninginteger

Inning number (10, 11, … indicate extra innings).

half"top" | "bottom"

top: the away team is batting; bottom: the home team is batting.

battingSideSide

Side at bat, derived from the half.

batterPlayerRef | null

Batter reference.

pitcherPlayerRef | null

Pitcher reference.

homeWinProbabilityBeforenumber | null

Home win probability before the at-bat on a 0–100 scale, as calculated by the SOURCE (not a DataSportsAPI model, and not bookmaker odds). Unit: percent.

homeWinProbabilityAfternumber | null

Home win probability after the at-bat according to the source, 0–100; the away probability is 100 − home. Unit: percent.

atstring (ISO-8601 UTC) | null

Time the at-bat was recorded.

Appears inPoints

A single set in darts; a match played in legs consists of one set.

numberinteger

Set number, always 1 in a legs match.

winnerSide | null

Winner of the set; null in a match played in legs and while the set is still going.

homeSetsinteger | null

Sets won by the home side once this set is over; null in a legs match.

awaySetsinteger | null

Sets won by the away side once this set is over; null in a legs match.

legsDartsLeg[]

Each leg in sequence.

Appears inPoints

A single darts leg broken down visit by visit.

numberinteger

Leg number inside the set (in a legs match, the whole match is one set).

startScoreinteger | null

Starting score for each player in the leg (501), as listed by the source.

throwingFirstSide | null

Side that threw first in the leg according to the source (the throw alternates between legs). The visit list may still open with the other player; this has been seen once on a first leg.

winnerSide | null

Side that won the leg; null while it is still being played.

homeLegsinteger | null

Legs won by the home side in the set once this leg is over.

awayLegsinteger | null

Legs won by the away side in the set once this leg is over.

checkoutinteger | null

Score of the visit that won the leg (the checkout); null while the leg is in progress or if the final visit is missing.

visitsDartsVisit[]

Each visit in sequence.

Appears inDartsSet

One player’s turn at the board: a visit of up to three darts. The source does not report how many darts were thrown.

sideSide

Side that threw.

scoredinteger | null

Points scored in the visit, computed as the thrower’s remaining score before minus after. 0 covers both a scoreless visit and a bust, which the source does not distinguish. Null if the drop is impossible for one visit (over 180, meaning the source skipped a visit).

homeRemaininginteger

Home side’s remaining score once the visit is done.

awayRemaininginteger

Away side’s remaining score once the visit is done.

checkoutboolean

True if this visit won the leg by bringing the thrower to 0; scored then holds the checkout.

Appears inDartsLeg

Baseball: occupancy of each base.

firstboolean

True when first base is occupied.

secondboolean

True when second base is occupied.

thirdboolean

True when third base is occupied.

Appears inInningState

Baseball: the current game situation — inning, half, count, outs and runners. It contains no batter or pitcher because the source does not provide them here; find the current at-bat’s in /points atBats. The source’s live feed refreshes this state roughly once a minute rather than after each pitch, so the count may trail the game by up to a minute.

inninginteger

Current inning (10, 11, … indicate extra innings).

half"top" | "bottom"

top: the away team is batting; bottom: the home team is batting.

battingSideSide

Side at bat, derived from the half.

ballsinteger | null

Number of balls in the current count.

strikesinteger | null

Number of strikes in the current count.

outsinteger | null

Outs recorded in the half-inning; 3 means the half has just finished.

basesBases

Occupancy of each base.

Appears inFixtureFixturePatchPlayerFixture

Basketball: remaining timeouts for each side, as tracked by the source.

homeRemaininginteger | null

Timeouts still available to the home side.

awayRemaininginteger | null

Timeouts still available to the away side.

perTeaminteger | null

Timeouts each side is allotted for the game (7 in the NBA).

Appears inFixturePlayerFixture

Tyres currently fitted to a car (available since 2026-11-09).

compoundTyreCompound

Tyre compound.

isNewboolean | null

True for a fresh set, false for a used one; null if the source does not specify.

Appears inRaceResult

League of Legends: count of elemental dragons killed, split by element (available since 2026-11-09).

chemtechinteger

Number of Chemtech dragons killed.

cloudinteger

Number of Cloud dragons killed.

hextechinteger

Number of Hextech dragons killed.

infernalinteger

Number of Infernal dragons killed.

mountaininteger

Number of Mountain dragons killed.

oceaninteger

Number of Ocean dragons killed.

Appears inEsportsTeamStats

American football: current down, distance and field position as tracked by the source (available since 2026-11-09). The live feed pushes an update after every play; fields not included in an update keep their previous value.

downinteger | null

The down in play (1–4); null on a kickoff and on the try that follows a touchdown.

yardsToGointeger | null

Yards needed for a first down (or to the goal line when goalToGo); null when there is no down.

possessionSide | null

Side in possession of the ball.

ballOnSide | null

Half of the field the ball is in; combined with yardLine, "home 35" means the home side’s 35-yard line.

yardLineinteger | null

Yard line within that half (50 is midfield).

goalToGoboolean | null

True if the goal line is the line to gain (the source calls it isGoalPossession).

playTypeDownPlayType | null

Kind of play the ball is set up for: scrimmage play, kickoff or try.

Appears inFixturePlayerFixture

Football: an ongoing video (VAR) review (available since 2026-11-09).

sideSide | null

Side whose incident (a goal, a penalty, a card) is being reviewed, if the source specifies it; null when it does not name one.

Appears inFixtureFixturePatchPlayerFixture

Basketball: bonus (penalty situation) status for each side, as reported by the source (available since 2026-11-09).

homeboolean

True when the home side is in the bonus, so the away side’s next team foul awards it free throws.

awayboolean

True when the away side is in the bonus.

Appears inFixturePlayerFixture

Length of the match in sets / legs / games, if the source states it.

bestOfSetsinteger | null

Darts: number of sets in the format ("best of 5 sets"); 1 indicates a legs match without sets.

bestOfLegsinteger | null

Darts: legs per set if bestOfSets > 1, otherwise legs in the whole match ("best of 7 legs").

bestOfGamesinteger | null

Esports: how many games (maps) the series is played over ("best of 3").

Appears inFixturePlayerFixture

Baseball only: the umpires working a game.

umpiresUmpire[]

Crew members in the source’s order, starting with home plate; empty if the source lists none and in other sports.

A single umpire working a baseball game.

namestring

Umpire’s full name in the source’s spelling.

positionUmpirePosition

Umpire’s station for this game.

experienceYearsinteger | null

Experience in years, according to the source.

Appears inUmpires

Baseball: conditions at the ballpark. The source reports weather for baseball alone, so other sports return an empty list. The source reports in °F and mph; we convert to metric (58 °F → 14.44 °C, 5 mph → 8.05 km/h). For a stadium with a roof, the reported weather is still the outdoor one.

observationsWeatherObservation[]

Measured and forecast conditions in the source’s order, with the observation first; empty if the source has none and in other sports.

Weather conditions at a venue at a given moment.

atstring (ISO-8601 UTC) | null

When the observation was made — or, for a forecast, when it was issued.

forecastboolean

True if this is a forecast, false if it is a measured observation.

conditionWeatherCondition

Broad weather category.

descriptionstring | null

Conditions as worded by the source ("Overcast"). For display only.

temperatureCnumber | null

Temperature of the air in °C. Unit: celsius.

dewPointCnumber | null

Dew-point temperature in °C. Unit: celsius.

humidityPercentnumber | null

Relative humidity on a 0–100 scale. Unit: percent.

cloudCoverPercentnumber | null

Share of the sky covered by cloud, 0–100. Unit: percent.

windSpeedKmhnumber | null

Speed of the wind in km/h. Unit: kilometersPerHour.

windDirectionstring | null

Compass point the wind blows from ("SE", "SSE").

Appears inWeather

Esports: a game-by-game breakdown of a fixture, with map, winner and score, lineups including K/D/A, bans and objectives.

gamesEsportsGame[]

Each game in sequence; empty before the first game starts and in other sports.

A single game (map) within an esports series.

numberinteger

Position of the game in the series (1, 2, …).

status"notstarted" | "inprogress" | "interrupted" | "willcontinue" | "postponed" | "canceled" | "finished"

Status type of this game (finished, inprogress, notstarted, …).

mapstring | null

Map played ("Dust2"); null for single-map titles (League of Legends).

startedAtstring (ISO-8601 UTC) | null

Start time of the game.

durationSecondsinteger | null

How long the game lasted. Unit: seconds.

winnerSide | null

Side that won the game; null until it ends.

homeEsportsGameSide

Home side’s data for this game.

awayEsportsGameSide

Away side’s data for this game.

homeStartingSidesince 2026-11-04CsSide | null

Counter-Strike: which side the home team opened the map on; null for other titles. Available since 2026-11-04.

roundssince 2026-11-04EsportsRound[]

Counter-Strike: the rounds so far, in order, with winner, how it ended and which side the home team was on. Empty for other titles, and until the source lists them (it adds a map’s rounds while they are played). Available since 2026-11-04.

roundsPerHalfinteger | null

Counter-Strike: rounds per regulation half (12 under MR12); null if unspecified.

overtimeRoundsPerHalfinteger | null

Counter-Strike: how many rounds an overtime half has (3 under MR3); null without overtime.

Appears inEsportsGames

Counter-Strike: a single round on a map.

numberinteger

Round number within the game, starting at 1; overtime rounds carry on the same count.

overtimeboolean

True for an overtime round.

winnerSide | null

Side that won the round.

outcomeCsRoundOutcome

The way the round was decided.

homeSideCsSide | null

Side the home team played on in this round (the away team had the opposite one); null if the source does not specify.

Appears inEsportsGame

Racing: the career history of a driver or constructor (GET /v2/teams/{id}/race-career).

totalsRaceCareerTotals | null

Aggregated career figures; null if the source has none.

seasonsRaceCareerSeason[]

One entry per season, most recent first.

Penalty record of a player for a single league season (GET /v2/players/{id}/penalties).

scoredinteger | null

Penalties converted during the league season.

attemptsinteger | null

Total penalties attempted.

penaltiesPenaltyKick[]

Every penalty taken, in chronological order (oldest first).

A single penalty taken by a player (football).

fixtureIdinteger | null

Fixture in which the penalty was taken.

startTimestring (ISO-8601 UTC) | null

Start time of that fixture.

outcomeShotOutcome

Result of the kick: goal, save, miss or post.

goalMouthLocationGoalMouthLocation | null

Where the ball finished relative to the goal, from the taker’s perspective.

goalMouthPoint | null

Point at which the ball crossed the goal line, on 0–100 axes following the source’s drawing of the goal; null if not provided.

expectedGoalsnumber | null

Expected-goals value of the penalty (roughly 0.79).

Appears inPenaltyHistory

A date in a league season that has fixtures (GET /v2/leagues/{id}/calendar).

datestring (YYYY-MM-DD)

Calendar day of the season, in UTC.

fixtureCountinteger

Number of the league season’s fixtures on that day.

The player of the season named for a league in a past season.

playerPlayerRef

Player reference.

teamTeamRef | null

Team the player represented that season.

ratingnumber | null

The player’s mean match rating for the season according to the source, rounded to 2 decimals.

appearancesinteger | null

Number of matches in which the player received a rating.

seasonSeason | null

Season in which the award was won.

Results of a tennis player at a single Grand Slam, as returned by GET /v2/teams/{id}/grand-slams.

leagueLeagueRef | null

The Grand Slam tournament, represented as a league.

yearsGrandSlamYear[]

One entry per year, oldest first, going back as far as the source’s records.

A tennis player’s furthest progress at a given Grand Slam in a particular year.

yearinteger

The calendar year.

seasonSeason | null

The league season for that year’s edition, if we have its id.

roundstring | null

Deepest round reached, in the source’s wording ("Final", "Semifinals", "Round of 16").

wonboolean

True if the player took the title.

inProgressboolean

True while the edition is still running, meaning the round may still change.

Appears inGrandSlamResults

Career totals for a driver or constructor as counted by the source, combining all its series.

racesStartedinteger | null

Number of race starts across the career.

winsinteger | null

Number of races won.

podiumsinteger | null

Number of top-three finishes.

polePositionsinteger | null

Number of times starting from pole.

championshipsinteger | null

Number of world championships won.

Appears inRaceCareer

A single season in a driver’s or constructor’s career within one series.

seriesSeriesRef | null

Racing series the season belongs to.

seasonSeason

The series season; its id is what the season parameter expects on the /v2/series/{id}/… endpoints and on /v2/teams/{id}/races.

teamTeamRef | null

For a driver, the team (constructor) driven for that season; null on a constructor’s own row.

positioninteger | null

Position in the championship standings; null if unranked (or not yet ranked).

pointsnumber | null

Points earned in the championship.

racesStartedinteger | null

Number of race starts.

winsinteger | null

Number of races won.

podiumsinteger | null

Number of top-three finishes.

polePositionsinteger | null

Number of times starting from pole.

Appears inRaceCareer

One race result in a season for a driver or constructor (from GET /v2/teams/{id}/races).

raceRaceSummary

The race weekend in question; the result refers to its main race.

positioninteger | null

Finishing position of a driver, or a constructor’s ranking among constructors; null if unclassified (see state).

pointsnumber | null

Championship points earned in this race.

stateRaceResultState

Whether a driver was classified and, if not, why; constructors are always classified.

outReasonstring | null

Reason a driver did not finish, in the source’s words ("Retired"); null when classified.

gridPositioninteger | null

Grid slot the driver started from.

timeMsinteger | null

Driver’s total race time in ms; null if the driver is out, and for constructors. Unit: milliseconds.

gapMsinteger | null

Driver’s gap to the winner; for the winner, and for drivers who are out or lapped, it is null. Unit: milliseconds.

driversTeamRaceDriver[]

Drivers who raced for the constructor in that event; empty on a driver’s row.

A constructor’s driver in a particular race.

driverTeamRef | null

Driver reference.

positioninteger | null

Finishing position; null if not classified.

gapMsinteger | null

Gap to the winner; for the winner, and for drivers who are out or lapped, it is null. Unit: milliseconds.

Appears inTeamRaceResult

A single team’s data for one esports game.

scorenumber | null

Score of the side in this game — rounds won in Counter-Strike, kills in League of Legends and Dota 2.

periodsRecord<PeriodKey, number>

Counter-Strike: rounds won in each half (period1, period2), with all overtime rounds combined under overtime, so the values sum to the game score. Empty if the source has no breakdown.

playersEsportsGamePlayer[]

Players fielded by the side; empty if the source provides no lineup.

bansEsportsCharacter[]

Characters banned by the side, in ban order; empty if none are listed.

statisticsEsportsTeamStats | null

Objective statistics; null if the source has none.

Appears inEsportsGame

Stat line for one player in one esports game. Only the fields relevant to the title are filled and the rest stay null: League of Legends uses gold / creepScore / level; Dota 2 uses creepScore (last hits) / level / denies / netWorth / goldPerMinute / experiencePerMinute; Counter-Strike uses averageDamagePerRound / headshotKills / kastPercentage / killDeathDifference / firstKillDifference / flashAssists.

playerPlayerRef | null

Player reference.

roleEsportsRole

Role the player filled in this game.

characterEsportsCharacter | null

Champion / hero the player used.

killsinteger | null

Kill count.

deathsinteger | null

Death count.

assistsinteger | null

Assist count.

goldinteger | null

League of Legends: total gold earned.

creepScoreinteger | null

Creeps killed — minions and monsters in League of Legends, last hits in Dota 2.

levelinteger | null

Champion / hero level when the game ended (League of Legends, Dota 2).

deniesinteger | null

Dota 2: friendly creeps the player last-hit to deny the opponent their gold.

netWorthinteger | null

Dota 2: final net worth in gold (gold held plus items).

goldPerMinutenumber | null

Dota 2: average gold earned per minute of play.

experiencePerMinutenumber | null

Dota 2: average experience earned per minute of play.

averageDamagePerRoundnumber | null

Counter-Strike: ADR — hit points of damage dealt per round, on average.

headshotKillsinteger | null

Counter-Strike: number of kills scored with a headshot. This is a count capped by kills, not a percentage.

kastPercentagenumber | null

Counter-Strike: KAST, the 0–100 share of rounds in which the player recorded a kill or assist, survived, or was traded. Unit: percent.

killDeathDifferenceinteger | null

Counter-Strike: kills minus deaths; negative if the player died more often than they killed.

firstKillDifferenceinteger | null

Counter-Strike: opening kills minus opening deaths — an opening duel being the round’s first kill, whether by or on the player. Summed over every player on a map, the values come to 0.

flashAssistsinteger | null

Counter-Strike: kills made by teammates on opponents this player had blinded with a flash.

Appears inEsportsGameSide

A champion / hero / agent that was picked or banned.

namestring

Character name ("Viktor").

slugstring | null

Slug for use in URLs.

Appears inEsportsGameSideEsportsGamePlayer

One side’s objectives in one game of League of Legends or Dota 2: kills and towers, plus barracks and first blood in Dota 2. Fields that do not exist in the title are null. Counter-Strike has no objectives, so the whole object is null.

killsinteger | null

Kill count.

goldinteger | null

Total gold earned by the side.

towersinteger | null

Opposing towers taken down (in Dota 2, the towers the opponent lost).

inhibitorsinteger | null

Number of inhibitors taken down.

dragonsinteger | null

Dragons (drakes) killed according to the source’s count, excluding elderDragons.

elderDragonsinteger | null

Number of Elder dragons killed.

baronsinteger | null

Number of Barons (Nashor) killed.

heraldTakenboolean | null

True if the side secured the Rift Herald.

barracksinteger | null

Dota 2: opposing barracks taken down (those the opponent lost).

dragonsByTypesince 2026-11-09DragonsByType | null

League of Legends: elemental dragon kills by element (they add up to dragons). Null in other titles, or if the source does not split them. Available since 2026-11-09.

firstBloodboolean | null

Dota 2: true if the side scored first blood, i.e. the opening kill of the game.

Appears inEsportsGameSide

Complete scorecard of a cricket fixture. For other sports the response is 200 with { innings: [], current: null } rather than 404.

inningsScorecardInnings[]

All innings, in the order played; empty until the first ball is bowled, and in other sports.

currentCricketState | null

The innings under way right now: striker, non-striker, bowler, plus the current over and ball. Null whenever no innings is under way (not started, between innings, finished) and in other sports.

The batters at the crease during a live innings. We DERIVE this from the ball-by-ball data instead of using the source’s current-batsman field: we start from the batter on the last ball, switch ends whenever an odd number of runs is run and when an over ends, and bring in the new batter after a wicket. Validated against the following ball on more than 3,000 deliveries.

inningPeriodKey

Key of the innings under way (inning1, inning2, …).

battingSideSide | null

Side currently at bat.

strikerPlayerRef | null

Batter due to face the next delivery. Null when this cannot be determined at the moment (no ball bowled yet in the innings, or a brief mismatch between the ball-by-ball and the scorecard just after a delivery).

nonStrikerPlayerRef | null

The second batter at the crease; null when unknown, under the same conditions as striker.

bowlerPlayerRef | null

Bowler of the current over. Null between overs, because the next bowler is only known once they deliver a ball.

overinteger

Current over, numbered from 1 as in Points; once an over is completed it moves on to the next one.

ballinteger

Legal balls bowled in the current over so far (0–5), not counting wides and no-balls.

Appears inScorecard

One cricket innings: totals, the batting card and the bowling card, falls of wicket and partnerships.

inningPeriodKey

Innings key in match order (inning1, inning2, …): the second innings of the match is always inning2, regardless of who bats. Uses the same keys as Points.innings.

battingSideSide | null

Side currently at bat.

battingTeamTeamRef | null

Team at bat in this innings.

bowlingTeamTeamRef | null

Team in the field in this innings.

runsinteger | null

Innings total, combining runs off the bat and extras.

wicketsinteger | null

Wickets fallen, including a batter retired hurt who is unable to return.

oversnumber | null

Overs received, in cricket notation (19.3 means 19 overs plus 3 balls).

extrasExtras

Runs conceded other than off the bat.

battingScorecardBatter[]

Batting card in order of appearance, including did-not-bat entries.

bowlingScorecardBowler[]

Bowling card in the order the bowlers were used.

fallOfWicketsFallOfWicket[]

Each fall of wicket in sequence; retirements are not counted as falls.

partnershipsPartnership[]

Each batting partnership in sequence.

Appears inScorecard

A single entry on a batting card, listed in batting order.

batterPlayerRef | null

Batter reference.

stateBatterState

Current status of the batter’s innings.

dismissalDismissal | null

Manner of dismissal; only set when state is out.

descriptionstring | null

State as phrased by the source ("Not out", "LBW", "Did not bat", "Caught & Bowled"). For display only.

bowlerPlayerRef | null

Bowler involved in the dismissal, who is credited with the wicket unless it was a run out. The source also names a bowler on a retired-hurt line.

fielderPlayerRef | null

Fielder involved in the dismissal: whoever took the catch (the bowler for caught & bowled), the wicket-keeper for a stumping, or the fielder who effected a run out.

runsinteger | null

Runs the batter made.

ballsinteger | null

Number of deliveries faced.

foursinteger | null

Number of boundaries for four.

sixesinteger | null

Number of sixes struck.

strikeRatenumber | null

Runs scored per 100 balls, to 2 decimals; null until the batter has faced a ball.

Appears inScorecardInnings

A single bowler’s figures from the bowling card; entries follow the order in which they bowled.

bowlerPlayerRef | null

The player who bowled these figures.

oversnumber | null

Overs delivered, written the cricket way: 3.4 means three complete overs plus four balls.

maidensinteger | null

Count of maiden overs.

runsinteger | null

Runs charged to the bowler: wides and no-balls count towards it, byes and leg byes do not.

wicketsinteger | null

Dismissals credited to the bowler; run outs and retirements are excluded.

widesinteger | null

Number of wides delivered.

noBallsinteger | null

Number of no-balls delivered.

economynumber | null

Runs conceded per six-ball over, to two decimal places; null until the first delivery.

Appears inScorecardInnings

A single entry in the fall-of-wickets list.

wicketinteger

Wicket number, counting from 1 for the first dismissal.

runsinteger | null

Team score at the moment the wicket went down.

oversnumber | null

Point in the innings at which it went down, in cricket notation: 4.2 is the second ball of the fifth over, while the sixth ball of that over is written 5 (never 4.6).

batterPlayerRef | null

The dismissed batter.

Appears inScorecardInnings

A stand between two batters. Our data source provides these for limited-overs games; multi-day matches frequently come without any.

batter1PlayerRef | null

The first batter in the stand.

batter2PlayerRef | null

The second batter in the stand.

runsinteger | null

Runs the pair put on together.

ballsinteger | null

Number of balls the stand lasted.

Appears inScorecardInnings

Runs credited to the batting side that did not come off the bat.

totalinteger | null

Combined extras, computed as wides + noBalls + byes + legByes + penalties.

widesinteger | null

Extras from wides.

noBallsinteger | null

Extras from no-balls.

byesinteger | null

Extras from byes.

legByesinteger | null

Extras from leg byes.

penaltiesinteger | null

Runs awarded as penalties.

Appears inScorecardInnings

A single standings table within a season — the overall table, or a conference, division or group.

namestring | null

The table’s label, such as "Eastern Conference", "Group A" or "NHL".

primaryboolean

Marks the table that /standings returns when none is requested. Each season has exactly one: the overall table if it exists, otherwise the largest one (for a group stage, the first group).

overallboolean

true when the table includes all of the season’s teams (a league table); false for conference and division tables and for the individual groups of a group stage.

tieBreakRulestring | null

How ties are broken, as described by our data source.

scoreUnitStandingsScoreUnit | null

Unit behind this table’s scoresFor / scoresAgainst columns. Tables without score columns (cricket) return null.

rowsStandingsRow[]

—

A team’s line in a standings table. Any column that is irrelevant to the sport is null.

positioninteger | null

Position in this table, from 1 to n. When our data source’s positions do not run 1..n (as in its NBA tables early in a season), we rank the rows ourselves by win share, then wins, then fewer losses — or by points, then score difference, then scores for.

teamTeamRef | null

The team this row describes.

playedinteger | null

Number of games played.

winsinteger | null

Total wins, including those in overtime.

drawsinteger | null

Drawn games — filled in American football, cricket, football, futsal, handball and rugby. Where a table has no draw column (baseball, basketball, esports, ice hockey, volleyball, water polo, …) the value is null, meaning the column does not exist — not that no draws have happened yet.

lossesinteger | null

Total losses, including those in overtime.

overtimeWinsinteger | null

Ice hockey only: overtime wins as tallied by our data source. Where shoot-outs are counted separately (the KHL, the NHL’s league table) this covers overtime alone; elsewhere it combines overtime and shoot-out wins. Null where no figure is listed.

overtimeLossesinteger | null

Ice hockey only. Across all NHL tables — league, conference, division, and the home / away tables we compute — it counts losses in overtime and in shoot-outs together, i.e. the NHL’s OTL column, each worth a point. Elsewhere it is the overtime-loss figure our data source reports (for the KHL, overtime losses only).

scoresFornumber | null

How much the team has scored — goals, points, runs, sets, … depending on the table’s scoreUnit.

scoresAgainstnumber | null

How much the team has conceded, expressed in the table’s scoreUnit.

scoreDifferencenumber | null

Difference between the two: scoresFor − scoresAgainst.

pointsnumber | null

Points in the table; null for tables ordered by win percentage (NBA).

winPercentagenumber | null

Basketball, baseball and American football: proportion of games won, from 0 to 1, calculated the league’s way (in the NFL a tie is worth half a win). Unit: ratio.

gamesBehindnumber | null

Basketball and baseball: how many games the team trails the leader (the side with the best wins − losses), calculated as ((leader wins − wins) + (losses − leader losses)) / 2. Our data source shows 0 for every row of its EuroLeague tables; the computed NBA home / away tables work it out separately for each table.

streakinteger | null

The team’s ongoing streak in this competition: +3 means three wins in a row, −2 two defeats in a row. Present when our data source’s table includes it (NBA, EuroLeague, Liga ACB, …); null for other tables and for home / away tables.

zonestring | null

Name of the zone (qualification or relegation) this row sits in — for example "Champions League", "Playoffs" or "Relegation".

formFormResult[] | null

Up to five of the team’s latest results in this competition season, ordered oldest first so the newest comes last; a home / away table shows only home / away results. Null when our data source gives no form for this table — computed tables, rows stored earlier, or a read that failed.

Appears inStandingsGroup

Bracket view of a league season’s knockout phase: cup rounds, playoffs or a tennis draw.

namestring | null

What the bracket is called — "CONMEBOL Libertadores 2026, Knockout stage" or "NBA 25/26, Playoffs", for instance.

currentRoundinteger | null

order of the round currently being played, or the next one due. Null if our data source does not supply it, or once the bracket is complete (at that point the source points to a round beyond the final one).

roundsCupRound[]

The bracket’s rounds, beginning with the first.

A single round within a knockout bracket.

orderinteger

Position of the round in the bracket, starting at 1 for the opening round.

namestring | null

Label our data source gives the round, such as "1/8", "Quarterfinals", "Round of 32" or "Conference finals".

blocksCupBlock[]

Ties in this round, listed from the top of the bracket down.

Appears inCupTree

A single tie in a knockout round — one match, a two-legged tie or a series.

orderinteger

Where the tie sits in its round, counting from the top as our data source lays out the bracket. Values rise but are not guaranteed to run 1..n: byes or late-entering teams leave gaps (UCL qualifiers 15, 16, 19, …).

homeCupParticipant | null

The participant listed first (first-leg home side or higher seed); null if the slot is unfilled.

awayCupParticipant | null

The participant listed second; null if the slot is unfilled (a bye).

finishedboolean

true once the tie is settled — a participant has been marked as winner, or our data source reports it finished.

inProgressboolean

true while any of the tie’s fixtures is live.

startTimestring (ISO-8601 UTC) | null

Start time of the tie’s opening fixture, in UTC; null if it has not been scheduled.

matchCountinteger | null

Number of fixtures that make up the tie (2 for two legs, 7 for a best-of-7, or 1); 0 for a bye.

fixtureIdsinteger[]

Fixture ids for the tie (usable with /v2/fixtures/{id}), in the order our data source gives them.

automaticProgressionboolean

Flag from our data source indicating the participant advances without playing a fixture.

venueVenue | null

Venue of the tie when our data source provides one (for a one-off final, or the ground of the first leg).

Appears inCupRound

One of the two sides in a knockout tie.

teamTeamRef | null

The team or individual competitor. Null as long as the slot is only a placeholder (“winner of quarter-final 1”); check fromBlock in that case.

seedstring | null

Seeding or entry label in our data source’s own spelling ("1", "Q" for qualifier, "WC" for wild card); null if there is none.

winnerboolean

true if this side won the tie and advanced.

scoreinteger | null

This side’s score in the tie as reported by our data source: aggregate goals across the legs in football, series games won in basketball and ice hockey, sets in a single tennis match. Null until the tie has been played.

penaltiesinteger | null

Football only: goals this side scored in a penalty shoot-out, if the tie needed one; otherwise null.

fromBlockinteger | null

The order value of the block, one round back (PREVIOUS round), that this participant advanced from. Null in the opening round, or when our data source provides no link and the team did not appear in the previous round (a new entrant).

Appears inCupBlock

A single search match, ordered by our data source’s relevance ranking. Competitors in tennis and other individual sports come back as team results. Since 2026-10-24 managers, referees, racing series and races can match too; since 2026-11-04, fixtures and venues as well, plus a player’s team.

typeSearchType

The kind of entity matched, which tells you which endpoint its id is for.

idinteger

Identifier of the matched entity. Which endpoint it works with depends on type: /v2/teams, /v2/players, /v2/leagues, /v2/managers, /v2/referees, /v2/series, /v2/races, /v2/fixtures or /v2/venues.

namestring

Name to show; for a fixture it is our data source’s "Home - Away" string.

slugstring | null

—

sportstring | null

Slug of the sport; null for venues, as a venue does not belong to a single sport.

gendersince 2026-11-04TeamGender | null

Only set on team results (since 2026-11-04): whether the team is men’s, women’s or mixed, as shown on TeamDetail. All other result types return null, as does an individual competitor flagged mixed by our data source.

imagestring (URL) | null

Image on our CDN — a logo for teams and leagues, a photo for players, managers and referees. Series, races, fixtures and venues never have one; for other entities it is null when no image exists or it is still to be uploaded.

teamsince 2026-11-04TeamRef | null

For player results, the club our data source currently lists them at (since 2026-11-04). Null for other types and for players with no team (free agents, retired).

fixturesince 2026-11-04SearchFixture | null

Populated only for fixture results (since 2026-11-04) with the key facts of the match; null otherwise.

venuesince 2026-11-04Venue | null

Populated only for venue results (since 2026-11-04) with the venue’s city, country and capacity; null otherwise.

The match summary carried by a fixture search result (since 2026-11-04). For status, score and everything else, call /v2/fixtures/{id}.

homeTeamRef | null

The home side; null until it has been determined.

awayTeamRef | null

The away side; null until it has been determined.

leagueLeagueRef | null

Competition the match belongs to; null if our data source does not name one.

startTimestring (ISO-8601 UTC) | null

Planned start time in UTC; null if our data source does not provide one.

statusStatusType | null

Broad match state when the search ran (no more detailed state is available here); null if our data source gives none.

Appears inSearchResult

One leaderboard for a season.

categorystring

Which leaderboard this is — for example football: goals, averageRating, expectedGoals; basketball: rebounds, points; ice hockey: savePercentage, points. It equals statistic, except for football’s mostConceded / leastConceded, which rank goalkeepers by goals conceded with the most / fewest first.

statisticstring

The statistics key this leaderboard is built on; each entry’s value holds it as a season total. The ordering is our data source’s: counting statistics are generally ranked PER APPEARANCE (value ÷ appearances, so 104 NBA points in 3 games sits above 115 in 4), while ratings and shares rank by the value itself. Treat list position, not value, as the rank.

playersTopPlayerEntry[]

—

A single player on a leaderboard.

playerPlayerRef | null

—

teamTeamRef | null

—

valuenumber | null

This player’s figure for the ranked statistic, i.e. statistics[statistic].

appearancesinteger | null

Number of appearances.

playedEnoughboolean | null

true if the player has played enough minutes or games to qualify for the ranking.

statisticsRecord<string, number>

All numeric statistics supplied with the ranked entry, under v2 keys that match the per-match key for the same measure (naming conventions for season figures: …PerMatch is the total divided by matches, …Per90 is per 90 minutes, average… is a season mean, …Percentage runs 0–100, <key>Against holds the opponents’ figure, and units are spelled out in the key (…Seconds, …Kmh)).

Appears inTopPlayersCategory

For one statistic, the highest individual match figures recorded in a league season (since 2026-11-09).

categorystring

Which per-match player statistic the list ranks. Keys match those in a lineup player’s statistics — for football rating, goals, assists, kilometersCovered, topSpeed, keyPass, …; for basketball points, rebounds, …; for ice hockey points, hits, ….

performancesTopPerformance[]

At most 10 entries, top performance first in our data source’s ranking — for turnovers, errors and misses that means the highest count, not the lowest.

A single player’s figure from a single match.

playerPlayerRef | null

—

fixtureFixture

The fixture in which the figure was recorded.

valuenumber

The figure itself, in whatever unit the category’s per-match statistic uses — e.g. rating 0–10, topSpeed in km/h, kilometersCovered in km.

Appears inTopPerformancesCategory

A single round of a league draft, as returned by GET /v2/leagues/{id}/draft. Available since 2026-11-09.

picksDraftPick[]

Picks in this round, sorted by overall pick number.

teamsWithoutPickTeamRef[]

Clubs that hold no pick in this round because they traded or forfeited it.

A single selection in a draft (since 2026-11-09).

overallPickinteger

Pick number counted across the entire draft.

roundinteger

Round in which the pick falls.

pickInRoundinteger | null

Pick number counted within its round.

teamTeamRef | null

Club that makes the selection.

tradedFromTeamRef | null

For a traded pick, the club that originally owned it; null if it was not traded.

playerPlayerRef | null

The drafted player as a record available from /v2/players/{id}; null if our data source has no player entry for him.

prospectDraftProspect | null

The drafted player as described in the draft listing; null while the pick is still to be made.

Appears inDraftRound

How the draft itself describes the selected player.

namestring

Name of the prospect as printed in the draft.

positionstring | null

Listed position, using our data source’s abbreviations: G, F, C, FC, … in basketball; QB, WR, OT, … in American football.

topProspectboolean

true if he was flagged as a top prospect ahead of the draft.

fromTeamTeamRef | null

The college or former club he comes from, when our data source holds it as a team.

fromTeamNamestring | null

Name of that college or club as given in the draft — filled even when fromTeam is null.

Appears inDraftPick

One team leaderboard for a season.

categorystring

Leaderboard identifier — in football, for example, averageRating, goalsScored or cleanSheets.

statisticstring

The statistics key this leaderboard is built on; each entry’s value holds it as a season total. The ordering is our data source’s: counting statistics are generally ranked PER APPEARANCE (value ÷ appearances, so 104 NBA points in 3 games sits above 115 in 4), while ratings and shares rank by the value itself. Treat list position, not value, as the rank.

teamsTopTeamEntry[]

Teams on the leaderboard, top-ranked first.

A single team on a leaderboard.

teamTeamRef | null

—

valuenumber | null

This team’s figure for the ranked statistic, i.e. statistics[statistic].

matchesinteger | null

Number of matches played.

statisticsRecord<string, number>

All numeric statistics supplied with the ranked entry, under v2 keys that match the per-match key for the same measure (naming conventions for season figures: …PerMatch is the total divided by matches, …Per90 is per 90 minutes, average… is a season mean, …Percentage runs 0–100, <key>Against holds the opponents’ figure, and units are spelled out in the key (…Seconds, …Kmh)).

Appears inTopTeamsCategory

Statistics for one team in a given league, season and type.

statisticsRecord<string, number>

Totals and averages for the season under v2 keys, which match the per-match key for the same measure (naming conventions for season figures: …PerMatch is the total divided by matches, …Per90 is per 90 minutes, average… is a season mean, …Percentage runs 0–100, <key>Against holds the opponents’ figure, and units are spelled out in the key (…Seconds, …Kmh)). Football examples: goalsScored, goalsConceded, matches, averageRating, totalShots, averageBallPossession, cleanSheets, …. Ratings are rounded to two decimal places.

Key facts about a season: running totals and the teams new to it.

statisticsRecord<string, number>

Totals for the season under our data source’s own names (football: goals, yellowCards, redCards, homeTeamWins, awayTeamWins, draws, numberOfCompetitors; in other sports numberOfCompetitors may be the only one).

newcomersUpperDivisionTeamRef[]

Newcomers this season that came down from the division above.

newcomersLowerDivisionTeamRef[]

Newcomers this season that came up from the division below.

newcomersOtherTeamRef[]

Newcomers that arrived by any other route.

hostCountriesCountry[]

Host nations of a tournament held in particular countries, listed in our data source’s order — Canada, Mexico and USA for the 2026 World Cup, eleven of them for EURO 2020. League seasons usually leave it empty, though a few name their country (Germany for the Bundesliga; USA for MLS and the NFL). code is null when the name is missing from our data source’s country list.

A league in which the player has recorded statistics, together with the relevant seasons.

leagueLeagueRef

League or competition reference — the same structure /v2/leagues/{id} and all league lists return.

seasons({ id: integer; name: string | null; year: string | null; startYear: integer | null; endYear: integer | null; types: SeasonStatsType[] })[]

—

Statistics for one player in a given league, season and type.

teamTeamRef | null

—

statisticsRecord<string, number>

Totals and averages for the season under v2 keys, which match the per-match key for the same measure (naming conventions for season figures: …PerMatch is the total divided by matches, …Per90 is per 90 minutes, average… is a season mean, …Percentage runs 0–100, <key>Against holds the opponents’ figure, and units are spelled out in the key (…Seconds, …Kmh)). Football examples: appearances, minutesPlayed, goals, averageRating, expectedGoals, …. Ratings are rounded to two decimal places.

An entry in a player’s fixture list: a Fixture plus the player’s personal involvement (playerMatch).

idinteger

The fixture’s id.

sportstring

Slug of the sport, matching /v2/sports.

statusStatus

Current state of the match.

startTimestring (ISO-8601 UTC) | null

When the match starts: initially the planned time, swapped for the actual kick-off once our data source logs it (its live feed delivers this a few minutes after the start). Every endpoint and every WebSocket delta carries the same value.

leagueLeagueRef | null

Competition the fixture belongs to. Null if our data source places the fixture in a competition without a matching league — seen on 2026-10-23 in minor regional football, e.g. South Africa’s National Second Division; in that case season and round are null as well.

seasonSeason | null

Season the fixture is part of.

roundRound | null

Round of the fixture, for competitions organised in rounds.

homeTeamRef | null

The home side; null until it is known (our data source shows a placeholder such as "WQF1", the winner of quarter-final 1).

awayTeamRef | null

The away side; null until it is known (our data source shows a placeholder such as "WQF1").

homeScoreScoreSide

The home side’s score.

awayScoreScoreSide

The away side’s score.

winnerWinner | null

Remains null until status.type is finished, and stays null for a fight declared a no contest (fightResult.method noContest). If a match was settled on penalties, this is always the shoot-out winner, regardless of our data source (which, on a second leg, names whoever won the 90 minutes). When the source omits a winner, or reports a draw in a sport where draws are impossible, we derive it from the score (matches ending in regular time or overtime; cricket excluded).

venueVenue | null

Where the match is played, if known (lower tiers often have none). Populated on /fixtures/{id} and, when our data source provides it, in date lists. Round, team, player and live lists never include a venue, so null there means "not included" rather than "unknown"; fetch /fixtures/{id} to get it.

clockClock | null

Running match clock; null if our data source has no clock for the fixture, and after the match ends.

firstToServedeprecatedsince 2026-10-23Side | null

Deprecated since 2026-10-23 — mirrors serving. Because our data source refreshes it every game / leg, it reflects the side serving (throwing) at present, not the one that served first; use serving instead.

servingSide | null

Tennis, darts and other sports with a serve: which side is serving (throwing) at the moment, refreshed by our data source each game / leg. Null if the source does not report it.

homeSeedstring | null

In seeded events — tennis draws, or playoff seeding in basketball and other sports — the seed of the home side ("1", "12") or its entry status ("WC" wild card, "Q" qualifier, "LL" lucky loser, "PR" protected ranking, …) as printed on the draw. Unseeded sides get null.

awaySeedstring | null

Seed or entry status of the away side, following the same rules as homeSeed.

notestring | null

Cricket only: our data source’s match note, which becomes the result line after the finish ("Pakistan beat Sri Lanka by 37 runs"). Intended for display only.

battingSideSide | null

Cricket only: the side currently batting. Null when no innings is under way, and for all other sports.

fightResultFightResult | null

MMA and boxing: how, in which round and at what time the fight ended. Null until status.type is finished, or when our data source gives no method.

fightDisciplineFightDiscipline | null

Combat sports: the discipline of this bout when our data source tags one (the mma sport includes boxing, kickboxing and Muay Thai cards too). Only some cards get a tag — ONE, Queensbury and some OKTAGON fights, but never UFC or PFL — so null tells you nothing about whether the bout is MMA.

refereeReferee | null

Named only if our data source has one (football and some other sports; in cricket, the match referee). You get it on /fixtures/{id}; list endpoints return null since it is not included there.

homeManagerManagerRef | null

Manager or head coach of the home side for this fixture, if our data source names one. Populated on /fixtures/{id}; null in lists.

awayManagerManagerRef | null

Manager or head coach of the away side; same behaviour as homeManager.

surfaceSurface | null

Court surface for tennis matches, returned on /fixtures/{id} and in live lists; other sports get null.

tossCricketToss | null

Cricket only: the toss result, once it has taken place. Populated on /fixtures/{id}; null for every other sport.

umpiresstring[] | null

Cricket only: the on-field umpires in our data source’s wording (frequently with a country code, e.g. "Asif Yaqoob (PAK)"); null if none are listed, and for every other sport.

tvUmpirestring | null

Cricket only: the TV (third) umpire, handled the same way as umpires.

previousLegFixtureIdinteger | null

For two-legged ties and playoff series: the fixture id of the tie’s preceding leg / game, if our data source links it. Look it up via /fixtures/{id} to get the first-leg score.

aggregateWinnerSide | null

Set only once a two-legged tie’s return leg has finished: the team that progressed. We take our data source’s verdict; failing that, we use aggregated (the higher total goes through) or, when the aggregate is level, the shoot-out. Null in all other cases, including a level aggregate the source leaves unresolved (an away-goals rule). Compare winner, which is this match’s winner: after a second leg settled on penalties both point to the shoot-out winner, but otherwise they can disagree (a team can win the second leg yet be eliminated). Only /fixtures/{id} fills it; lists and live snapshots leave it out and may show null.

fightCardFightCard | null

MMA and boxing: the bout’s card section, position on the card and weight class, if our data source lists them.

attendanceinteger | null

Crowd size, if our data source reports one (observed for NBA and MLB games, often appearing only after the game has started). Populated on /fixtures/{id}; lists return null because it is not included.

matchFormatMatchFormat | null

Match format for darts and esports — best of N sets / legs / games — when our data source provides it. Other sports get null.

inningStateInningState | null

Baseball only: the game situation right now — inning, half, balls, strikes, outs and runners on base. It is null while the game is not in progress or interrupted, and in every other sport. WebSocket deltas carry it live.

timeoutsTimeouts | null

Basketball: timeouts left for each side, filled only during an in-progress or interrupted game and only if our data source tracks them; null otherwise. WebSocket deltas carry live updates.

downAndDistancesince 2026-11-09DownAndDistance | null

American football only: down, distance and field position at this moment. It is null while the game is not in progress or interrupted, and in every other sport. Delivered live through WebSocket deltas. Available since 2026-11-09.

varChecksince 2026-11-09VarCheck | null

Football only: an ongoing VAR review; null when there is none, outside play, and for every other sport. Delivered live through WebSocket deltas. Available since 2026-11-09.

bonussince 2026-11-09BasketballBonus | null

Basketball only: the side or sides in the bonus. It is null while the game is not in progress or interrupted, and when our data source gives no value; the source’s live feed lacks it, so you only get it over REST and in lists. Available since 2026-11-09.

finalResultOnlysince 2026-11-09boolean

true if our data source covers only the final result of this fixture, with no live score, clock or events during play (since 2026-11-09).

durationssince 2026-11-04Durations | null

Sports played in sets or rounds: the length of every finished period (since 2026-11-04). Null for sports our data source does not time by period (football, basketball, …) and until the first period is over. Delivered live through WebSocket deltas.

lineupsAvailablesince 2026-11-04boolean | null

true once our data source has published lineups for the fixture, whether predicted or official (confirmed on /v2/fixtures/{id}/lineups tells you which); false if they were withdrawn. We set it the moment the source’s live feed announces lineups, or when a lineup we fetch contains players. Null means we have no information (no announcement observed, nothing fetched). WebSocket deltas carry it live — on fixture:{id} from before kick-off, and on the list channels once play starts. Available since 2026-11-04.

lineupsConfirmedsince 2026-11-04boolean | null

true once official lineups have been released (confirmed on /v2/fixtures/{id}/lineups), set in the same way as lineupsAvailable; null means we have no information. Delivered live through WebSocket deltas. Available since 2026-11-04.

playerMatchPlayerMatch | null

The player’s own involvement in this fixture, or null when our data source has nothing listed.