Championship standings

This guide covers how to retrieve driver and constructor championship standings, enrich them with participant and round context, and use them to build championship tables and season dashboards.

When to use this

Use the Standings endpoints when you want to:

Display the current drivers' championship table
Display the current constructors' championship table
Show which race weekend standings are current as of
Track points gaps between drivers or constructors
Build a season summary page with final championship positions

Driver standings vs constructor standings

The Motorsport API provides separate endpoints for the World Drivers' Championship and the World Constructors' Championship. They share the same response shape but resolve participant_id to different entity types.

Driver standings

Constructor standings

Endpoint

/standings/drivers/seasons/{id}

/standings/teams/seasons/{id}

participant_id resolves to

Driver profile

Team/constructor profile

Points source

Individual race finishes and sprint points

Combined points of both drivers

The Standing entity fields

Field

Description

Type

id

Unique ID of the standing entry

integer

participant_id

ID of the driver or team

integer

sport_id

Sport ID

integer

league_id

The championship this standing belongs to

integer

season_id

The season this standing belongs to

integer

stage_id

The most recently completed race weekend this standing reflects

integer

position

Championship position (1 = leader)

string

points

Total accumulated points

integer

result, group_id, round_id, and standing_rule_id are not used in the Motorsport API.

Available includes

sport participant season league stage

participant resolves to the full driver or team profile depending on which endpoint you call. stage resolves stage_id to the race weekend name and date, useful for displaying "Standings after Round X" context.

Maximum include depth: 2 nested includes.

Retrieving standings

Current drivers' championship:

GET https://api.sportmonks.com/v3/motorsport/standings/drivers/seasons/{season_id}
?api_token={your_token}&include=participant

Current constructors' championship:

GET https://api.sportmonks.com/v3/motorsport/standings/teams/seasons/{season_id}
?api_token={your_token}&include=participant

With round context (which race they reflect):

GET https://api.sportmonks.com/v3/motorsport/standings/drivers/seasons/{season_id}
?api_token={your_token}&include=participant;stage

Lightweight (position and points only):

GET https://api.sportmonks.com/v3/motorsport/standings/drivers/seasons/{season_id}
?api_token={your_token}&select=position,points,participant_id&include=participant

For all seasons rather than a specific one, use GET All Driver Standings or GET All Team Standings without the season path. The by-season endpoints are the right choice for most use cases to avoid fetching unnecessary historical data.

Working with the data

Build a drivers' championship table

const API_TOKEN = 'your_token';

async function getDriverStandings(seasonId) {
  const response = await fetch(
    `https://api.sportmonks.com/v3/motorsport/standings/drivers/seasons/${seasonId}?api_token=${API_TOKEN}&include=participant;stage`
  );
  const { data } = await response.json();
  return data.sort((a, b) => parseInt(a.position) - parseInt(b.position));
}

const standings = await getDriverStandings(25273);
standings.forEach(entry => {
  console.log(`P${entry.position} ${entry.participant.display_name} - ${entry.points} pts`);
});

import requests

API_TOKEN = "your_token"

def get_driver_standings(season_id):
    url = f"https://api.sportmonks.com/v3/motorsport/standings/drivers/seasons/{season_id}"
    params = {
        "api_token": API_TOKEN,
        "include": "participant;stage"
    }
    response = requests.get(url, params=params)
    standings = response.json()["data"]

    return sorted(standings, key=lambda s: int(s["position"]))

standings = get_driver_standings(25273)
for entry in standings:
    driver = entry["participant"]
    print(f"P{entry['position']} {driver['display_name']} - {entry['points']} pts")

<?php
function getDriverStandings(string $apiToken, int $seasonId): array {
    $url = "https://api.sportmonks.com/v3/motorsport/standings/drivers/seasons/
           {$seasonId}?api_token={$apiToken}&include=participant;stage";
    $standings = json_decode(file_get_contents($url), true)['data'];
    usort($standings, fn($a, $b) => (int)$a['position'] <=> (int)$b['position']);
    return $standings;
}

Build a constructors' championship table

async function getConstructorStandings(seasonId) {
  const response = await fetch(
    `https://api.sportmonks.com/v3/motorsport/standings/teams/seasons/${seasonId}
     ?api_token=${API_TOKEN}&include=participant`
  );
  const { data } = await response.json();
  return data.sort((a, b) => parseInt(a.position) - parseInt(b.position));
}

def get_constructor_standings(season_id):
    url = f"https://api.sportmonks.com/v3/motorsport/standings/teams/seasons/
          {season_id}"
    params = {
        "api_token": API_TOKEN,
        "include": "participant"
    }
    response = requests.get(url, params=params)
    standings = response.json()["data"]
    return sorted(standings, key=lambda s: int(s["position"]))

<?php
function getConstructorStandings(string $apiToken, int $seasonId): array {
    $url = "https://api.sportmonks.com/v3/motorsport/standings/teams/seasons/
            {$seasonId}?api_token={$apiToken}&include=participant";
    $standings = json_decode(file_get_contents($url), true)['data'];
    usort($standings, fn($a, $b) => (int)$a['position'] <=> (int)$b['position']);
    return $standings;
}

Show points gap to championship leader

function getPointsGap(standings) {
  const leaderPoints = standings[0]?.points ?? 0;
  return standings.map(s => ({
    position: s.position,
    name: s.participant.display_name,
    points: s.points,
    gap: leaderPoints - s.points
  }));
}

def get_points_gap(standings):
    leader_points = standings[0]["points"] if standings else 0
    return [
        {
            "position": s["position"],
            "name": s["participant"]["display_name"],
            "points": s["points"],
            "gap": leader_points - s["points"]
        }
        for s in standings
    ]

<?php
function get_points_gap($standings) {
    $leaderPoints = $standings[0]["points"] ?? 0;
    return array_map(function ($standing) use ($leaderPoints) {
        $points = $standing["points"] ?? 0;
        return [
            "position" => $standing["position"] ?? null,
            "name" => $standing["participant"]["display_name"] ?? null,
            "points" => $points,
            "gap" => $leaderPoints - $points
        ];
    }, $standings);
}

Display which round standings are current as of

function getStandingsContext(standings) {
  const stage = standings[0]?.stage;
  return stage ? `Standings after Round ${stage.sort_order}: ${stage.name}` : null;
}

def get_standings_context(standings):
    if not standings:
        return None
    stage = standings[0].get("stage")
    if stage:
        return f"Standings after Round {stage['sort_order']}: {stage['name']}"
    return None

<?php
function get_standings_context($standings) {
    $stage = $standings[0]["stage"] ?? null;
    if (!$stage) {
        return null;
    }
    $sortOrder = $stage["sort_order"] ?? null;
    $stageName = $stage["name"] ?? "";
    return "Standings after Round " . $sortOrder . ": " . $stageName;
}

Common pitfalls

Using a single /standings endpoint to get both driver and constructor standings. These are separate endpoints: /standings/drivers/seasons/{id} for drivers and /standings/teams/seasons/{id} for constructors. You cannot get both from one call.

Using the "all standings" endpoints for current standings. GET All Driver Standings and GET All Team Standings return standings across every season. Always use the by-season-ID endpoints for a specific season's current standings.

position is a string, not an integer. Convert to integer before sorting: int(s["position"]) in Python, parseInt(s.position) in JavaScript.

Expecting result to show position movement. The result field is not used in the Motorsport API and is always null. Do not build UI logic around it.

Polling standings during a live race. Standings update after a session is marked as finished, not during. Fetch standings once after you detect the session state has changed to finished. See Session states.

Common errors

Status

Likely cause

401

Missing or invalid api_token

404

The season ID does not exist or is not in your subscription

FAQ

How do I get the season ID to pass to the standings endpoint? See Leagues and seasons. The 2025 F1 season ID is 25273.

What is stage_id on a standing entry? It is the ID of the most recently completed race weekend that this standing reflects. Include stage to resolve it to the weekend name and round number, useful for displaying "Standings after Round X" in your UI.

Can I get standings after a specific race round? Use standingStages filter with the stage ID of the race weekend to get standings as they stood after that round.

How do I link a standing entry back to lap or result data? The participant_id on a standing entry is the same value as participant_id across laps, pitstops, stints, and race results endpoints. Use it directly to join standings data with session-level performance data.

Are sprint race points included in standings? Yes. Points from sprint races (where SPRINT_RACE metadata is true) are included in the season standings totals.

Last updated 11 days ago

Was this helpful?

When to use this

Driver standings vs constructor standings

The Standing entity fields

Available includes

Retrieving standings

Working with the data

Common pitfalls

Common errors

See also

FAQ