# Jolpica-F1

> Look up any Formula 1 result since 1950. Read the race calendar with every session time, see what is on next and how long until lights out, pull race, qualifying and sprint classifications, follow a championship round by round, and go lap by lap or stop by stop through a single Grand Prix. Jolpica-F1 is the open successor to the Ergast API, and no account or API key is required.

App · Sports · 15 actions. Web page: https://docs.lodol.com/docs/integrations/jolpica-f1

## Actions

### Get constructor standings

Get the constructors' championship table for a season, leader first, with points and wins. Set a round to see the table as it stood after that race rather than as it stands now.

**Inputs**

- Season (`season`, text, required): Which championship season to look at. Pick 'Current season' and the step keeps working next year without being edited.
- Round (`round_number`, text): Which race of the season. Fill in the season first and this list loads with each round's Grand Prix and date. Leave it empty for the whole season.
- Constructor (`constructor_id`, text): Narrow to one team, chosen from every constructor that has entered a Formula 1 race. Leave it empty for all of them.
- Championship position (`position`, number): Narrow to whichever team holds this place in the championship, counting 1 as the leader. Leave it empty for the whole table. From 1 to 100.
- Limit (`limit`, number): How many rows to return, from 1 to 100, which is the most the API serves in one request. The answer always says how many rows there were in total, so a limited list never reads as a complete one. Defaults to 30. From 1 to 100. Default: `30`.
- Offset (`offset`, number): How many rows to skip before returning results, for reading a long list a page at a time. Defaults to 0. At least 0. Default: `0`.

**Outputs**

- `count` (number): Rows in this answer
- `filters` (object): The filters this query actually applied, repeated so an empty answer says what was asked for
- `leader_constructor_id` (text): Constructor id at the top of this page
- `leader_points` (number): That constructor's points
- `offset` (number): Rows skipped before this page
- `round` (number): Round these standings follow
- `season` (number): Season these standings are for
- `standings` (list): The championship table, leader first
- `total_count` (number): Rows the API holds for the query
- `truncated` (true/false): Whether more rows remain

**Example output**

```json
{
  "count": 1,
  "filters": {
    "season": "2024"
  },
  "leader_constructor_id": "mclaren",
  "leader_points": 666.0,
  "offset": 0,
  "round": 24,
  "season": 2024,
  "standings": [
    {
      "constructor_id": "mclaren",
      "constructor_name": "McLaren",
      "nationality": "British",
      "points": 666.0,
      "position": 1,
      "position_text": "1",
      "round": 24,
      "season": 2024,
      "wins": 6
    }
  ],
  "total_count": 10,
  "truncated": true
}
```

### Get driver standings

Get the drivers' championship table for a season, leader first, with points, wins and the teams each driver raced for. Leaving the round empty gives the table as it stands now; setting one gives it as it stood after that race, which is how to answer 'was the title already decided?'.

**Inputs**

- Season (`season`, text, required): Which championship season to look at. Pick 'Current season' and the step keeps working next year without being edited.
- Round (`round_number`, text): Which race of the season. Fill in the season first and this list loads with each round's Grand Prix and date. Leave it empty for the whole season.
- Driver (`driver_id`, text): Narrow to one driver, chosen from every driver who has started a Formula 1 race. Leave it empty for all of them.
- Championship position (`position`, number): Narrow to whoever holds this place in the championship, counting 1 as the leader. Leave it empty for the whole table. From 1 to 100.
- Limit (`limit`, number): How many rows to return, from 1 to 100, which is the most the API serves in one request. The answer always says how many rows there were in total, so a limited list never reads as a complete one. Defaults to 30. From 1 to 100. Default: `30`.
- Offset (`offset`, number): How many rows to skip before returning results, for reading a long list a page at a time. Defaults to 0. At least 0. Default: `0`.

**Outputs**

- `count` (number): Rows in this answer
- `filters` (object): The filters this query actually applied, repeated so an empty answer says what was asked for
- `leader_driver_id` (text): Driver id at the top of this page
- `leader_points` (number): That driver's points
- `offset` (number): Rows skipped before this page
- `round` (number): Round these standings follow
- `season` (number): Season these standings are for
- `standings` (list): The championship table, leader first
- `total_count` (number): Rows the API holds for the query
- `truncated` (true/false): Whether more rows remain

**Example output**

```json
{
  "count": 1,
  "filters": {
    "season": "2024"
  },
  "leader_driver_id": "max_verstappen",
  "leader_points": 437.0,
  "offset": 0,
  "round": 24,
  "season": 2024,
  "standings": [
    {
      "constructor_ids": [
        "red_bull"
      ],
      "constructor_names": [
        "Red Bull"
      ],
      "driver_code": "VER",
      "driver_id": "max_verstappen",
      "driver_name": "Max Verstappen",
      "nationality": "Dutch",
      "points": 437.0,
      "position": 1,
      "position_text": "1",
      "round": 24,
      "season": 2024,
      "wins": 9
    }
  ],
  "total_count": 24,
  "truncated": true
}
```

### Get lap times

Get a race's lap-by-lap timings as one flat list, a row per driver per lap, each with the position at the end of that lap and the time in seconds. Narrow to a single lap to see the whole field at one moment, or to a driver to follow their race. Lap data starts with the 1996 season.

**Inputs**

- Season (`season`, text, required): Which championship season to look at. Pick 'Current season' and the step keeps working next year without being edited.
- Round (`round_number`, text, required): Which race of the season. Fill in the season first and this list loads with each round's Grand Prix and date, plus the most recent race.
- Lap number (`lap`, number): Narrow to one lap of the race, which gives the whole field at that moment. Leave it empty for every lap. From 1 to 200.
- Driver (`driver_id`, text): Narrow to one driver, chosen from every driver who has started a Formula 1 race. Leave it empty for all of them.
- Constructor (`constructor_id`, text): Narrow to one team, chosen from every constructor that has entered a Formula 1 race. Leave it empty for all of them.
- Limit (`limit`, number): How many rows to return, from 1 to 100, which is the most the API serves in one request. The answer always says how many rows there were in total, so a limited list never reads as a complete one. Defaults to 30. From 1 to 100. Default: `30`.
- Offset (`offset`, number): How many rows to skip before returning results, for reading a long list a page at a time. Defaults to 0. At least 0. Default: `0`.

**Outputs**

- `count` (number): Rows in this answer
- `fastest_driver_id` (text): Whoever set the quickest lap on this page
- `fastest_seconds` (number): That lap time in seconds
- `filters` (object): The filters this query actually applied, repeated so an empty answer says what was asked for
- `offset` (number): Rows skipped before this page
- `race_name` (text): Grand Prix name
- `round` (number): Round of the race
- `season` (number): Season the race belongs to
- `timings` (list): One row per driver per lap, by lap then position
- `total_count` (number): Rows the API holds for the query
- `truncated` (true/false): Whether more rows remain

**Example output**

```json
{
  "count": 1,
  "fastest_driver_id": "max_verstappen",
  "fastest_seconds": 97.284,
  "filters": {
    "lap": 1,
    "round": "1",
    "season": "2024"
  },
  "offset": 0,
  "race_name": "Bahrain Grand Prix",
  "round": 1,
  "season": 2024,
  "timings": [
    {
      "driver_id": "max_verstappen",
      "lap": 1,
      "position": 1,
      "seconds": 97.284,
      "time": "1:37.284"
    }
  ],
  "total_count": 20,
  "truncated": true
}
```

### Get pit stops

Get a race's pit stops in the order they happened, each with the lap, the time of day and the duration in seconds. The answer also names the quickest stop of the page. Narrow to a driver, a lap or a stop number. Pit stop data starts with the 2011 season.

**Inputs**

- Season (`season`, text, required): Which championship season to look at. Pick 'Current season' and the step keeps working next year without being edited.
- Round (`round_number`, text, required): Which race of the season. Fill in the season first and this list loads with each round's Grand Prix and date, plus the most recent race.
- Stop number (`stop`, number): Narrow to each driver's first stop, second stop and so on. Leave it empty for every stop. From 1 to 60.
- Lap number (`lap`, number): Narrow to stops made on one lap of the race. Leave it empty for every lap. From 1 to 200.
- Driver (`driver_id`, text): Narrow to one driver, chosen from every driver who has started a Formula 1 race. Leave it empty for all of them.
- Limit (`limit`, number): How many rows to return, from 1 to 100, which is the most the API serves in one request. The answer always says how many rows there were in total, so a limited list never reads as a complete one. Defaults to 30. From 1 to 100. Default: `30`.
- Offset (`offset`, number): How many rows to skip before returning results, for reading a long list a page at a time. Defaults to 0. At least 0. Default: `0`.

**Outputs**

- `count` (number): Rows in this answer
- `filters` (object): The filters this query actually applied, repeated so an empty answer says what was asked for
- `offset` (number): Rows skipped before this page
- `pit_stops` (list): Pit stops in the order they happened
- `quickest_driver_id` (text): Whoever had the shortest stop on this page
- `quickest_seconds` (number): That stop in seconds
- `race_name` (text): Grand Prix name
- `round` (number): Round of the race
- `season` (number): Season the race belongs to
- `total_count` (number): Rows the API holds for the query
- `truncated` (true/false): Whether more rows remain

**Example output**

```json
{
  "count": 1,
  "filters": {
    "round": "1",
    "season": "2024"
  },
  "offset": 0,
  "pit_stops": [
    {
      "driver_id": "hulkenberg",
      "duration": "36.604",
      "duration_seconds": 36.604,
      "lap": 1,
      "stop": 1,
      "time_of_day": "18:05:33"
    }
  ],
  "quickest_driver_id": "stroll",
  "quickest_seconds": 24.418,
  "race_name": "Bahrain Grand Prix",
  "round": 1,
  "season": 2024,
  "total_count": 43,
  "truncated": true
}
```

### Get qualifying results

Get qualifying classifications with each of Q1, Q2 and Q3, both as the time was printed and converted to seconds, plus each driver's best of the three. The seconds are what make a gap workable: comparing '1:29.179' with '1:29.374' as text answers nothing.

**Inputs**

- Season (`season`, text): Which championship season to look at. Pick 'Current season' and the step keeps working next year without being edited. Leave it empty to search every season since 1950.
- Round (`round_number`, text): Which race of the season. Fill in the season first and this list loads with each round's Grand Prix and date. Leave it empty for the whole season.
- Circuit (`circuit_id`, text): Narrow to one circuit, chosen from every track Formula 1 has raced at. Leave it empty for all of them.
- Constructor (`constructor_id`, text): Narrow to one team, chosen from every constructor that has entered a Formula 1 race. Leave it empty for all of them.
- Driver (`driver_id`, text): Narrow to one driver, chosen from every driver who has started a Formula 1 race. Leave it empty for all of them.
- Fastest lap rank (`fastest_lap_rank`, number): Narrow to entries whose best lap ranked this fast in the race, counting 1 as the fastest lap of all. Leave it empty for every rank. From 1 to 100.
- Grid position (`grid_position`, number): Narrow to entries that started the race from this slot on the grid, counting 1 as pole. Leave it empty for every grid slot. From 1 to 100.
- Finishing status (`status_id`, text): Narrow to entries that ended a given way, such as Finished or Retired. The statuses marked stable are the five the API guarantees will keep their id. Leave it empty for every status.
- Limit (`limit`, number): How many rows to return, from 1 to 100, which is the most the API serves in one request. The answer always says how many rows there were in total, so a limited list never reads as a complete one. Defaults to 30. From 1 to 100. Default: `30`.
- Offset (`offset`, number): How many rows to skip before returning results, for reading a long list a page at a time. Defaults to 0. At least 0. Default: `0`.

**Outputs**

- `count` (number): Rows in this answer
- `filters` (object): The filters this query actually applied, repeated so an empty answer says what was asked for
- `offset` (number): Rows skipped before this page
- `results` (list): Matching qualifying results, by race then position
- `total_count` (number): Rows the API holds for the query
- `truncated` (true/false): Whether more rows remain

**Example output**

```json
{
  "count": 1,
  "filters": {
    "round": "1",
    "season": "2024"
  },
  "offset": 0,
  "results": [
    {
      "best_seconds": 89.179,
      "car_number": 1,
      "circuit_id": "bahrain",
      "constructor_id": "red_bull",
      "constructor_name": "Red Bull",
      "date": "2024-03-02",
      "driver_code": "VER",
      "driver_id": "max_verstappen",
      "driver_name": "Max Verstappen",
      "position": 1,
      "q1": "1:30.031",
      "q1_seconds": 90.031,
      "q2": "1:29.374",
      "q2_seconds": 89.374,
      "q3": "1:29.179",
      "q3_seconds": 89.179,
      "race_name": "Bahrain Grand Prix",
      "round": 1,
      "season": 2024
    }
  ],
  "total_count": 20,
  "truncated": true
}
```

### Get race results

Get race classifications, one row per driver per race, with the points, grid slot, status and fastest lap of each. Points and positions come back as numbers rather than text, so a step can compare and total them directly. Every filter narrows the same list, so 'how did Ferrari finish at Monza?' and 'who has won from tenth on the grid?' are this action with different fields filled in.

**Inputs**

- Season (`season`, text): Which championship season to look at. Pick 'Current season' and the step keeps working next year without being edited. Leave it empty to search every season since 1950.
- Round (`round_number`, text): Which race of the season. Fill in the season first and this list loads with each round's Grand Prix and date. Leave it empty for the whole season.
- Circuit (`circuit_id`, text): Narrow to one circuit, chosen from every track Formula 1 has raced at. Leave it empty for all of them.
- Constructor (`constructor_id`, text): Narrow to one team, chosen from every constructor that has entered a Formula 1 race. Leave it empty for all of them.
- Driver (`driver_id`, text): Narrow to one driver, chosen from every driver who has started a Formula 1 race. Leave it empty for all of them.
- Fastest lap rank (`fastest_lap_rank`, number): Narrow to entries whose best lap ranked this fast in the race, counting 1 as the fastest lap of all. Leave it empty for every rank. From 1 to 100.
- Grid position (`grid_position`, number): Narrow to entries that started the race from this slot on the grid, counting 1 as pole. Leave it empty for every grid slot. From 1 to 100.
- Finishing status (`status_id`, text): Narrow to entries that ended a given way, such as Finished or Retired. The statuses marked stable are the five the API guarantees will keep their id. Leave it empty for every status.
- Finishing position (`finish_position`, number): Narrow to entries that finished in this position, counting 1 as the win. Leave it empty for every position. From 1 to 100.
- Limit (`limit`, number): How many rows to return, from 1 to 100, which is the most the API serves in one request. The answer always says how many rows there were in total, so a limited list never reads as a complete one. Defaults to 30. From 1 to 100. Default: `30`.
- Offset (`offset`, number): How many rows to skip before returning results, for reading a long list a page at a time. Defaults to 0. At least 0. Default: `0`.

**Outputs**

- `count` (number): Rows in this answer
- `filters` (object): The filters this query actually applied, repeated so an empty answer says what was asked for
- `offset` (number): Rows skipped before this page
- `results` (list): Matching classifications, by race then finishing position
- `total_count` (number): Rows the API holds for the query
- `truncated` (true/false): Whether more rows remain

**Example output**

```json
{
  "count": 1,
  "filters": {
    "round": "1",
    "season": "2024"
  },
  "offset": 0,
  "results": [
    {
      "car_number": 1,
      "circuit_id": "bahrain",
      "constructor_id": "red_bull",
      "constructor_name": "Red Bull",
      "date": "2024-03-02",
      "driver_code": "VER",
      "driver_id": "max_verstappen",
      "driver_name": "Max Verstappen",
      "fastest_lap": 39,
      "fastest_lap_rank": 1,
      "fastest_lap_seconds": 92.608,
      "fastest_lap_speed_kph": 210.383,
      "fastest_lap_time": "1:32.608",
      "finished": true,
      "grid": 1,
      "laps_completed": 57,
      "points": 26.0,
      "position": 1,
      "position_text": "1",
      "race_name": "Bahrain Grand Prix",
      "round": 1,
      "season": 2024,
      "status": "Finished",
      "total_time": "1:31:44.742",
      "total_time_millis": 5504742
    }
  ],
  "total_count": 20,
  "truncated": true
}
```

### Get sprint results

Get sprint race classifications, in the same shape as a race result so the two can be added together. Sprints started in 2021, so an earlier season comes back empty rather than as an error.

**Inputs**

- Season (`season`, text): Which championship season to look at. Pick 'Current season' and the step keeps working next year without being edited. Leave it empty to search every season since 1950.
- Round (`round_number`, text): Which race of the season. Fill in the season first and this list loads with each round's Grand Prix and date. Leave it empty for the whole season.
- Circuit (`circuit_id`, text): Narrow to one circuit, chosen from every track Formula 1 has raced at. Leave it empty for all of them.
- Constructor (`constructor_id`, text): Narrow to one team, chosen from every constructor that has entered a Formula 1 race. Leave it empty for all of them.
- Driver (`driver_id`, text): Narrow to one driver, chosen from every driver who has started a Formula 1 race. Leave it empty for all of them.
- Grid position (`grid_position`, number): Narrow to entries that started the race from this slot on the grid, counting 1 as pole. Leave it empty for every grid slot. From 1 to 100.
- Finishing status (`status_id`, text): Narrow to entries that ended a given way, such as Finished or Retired. The statuses marked stable are the five the API guarantees will keep their id. Leave it empty for every status.
- Limit (`limit`, number): How many rows to return, from 1 to 100, which is the most the API serves in one request. The answer always says how many rows there were in total, so a limited list never reads as a complete one. Defaults to 30. From 1 to 100. Default: `30`.
- Offset (`offset`, number): How many rows to skip before returning results, for reading a long list a page at a time. Defaults to 0. At least 0. Default: `0`.

**Outputs**

- `count` (number): Rows in this answer
- `filters` (object): The filters this query actually applied, repeated so an empty answer says what was asked for
- `offset` (number): Rows skipped before this page
- `results` (list): Matching classifications, by race then finishing position
- `total_count` (number): Rows the API holds for the query
- `truncated` (true/false): Whether more rows remain

**Example output**

```json
{
  "count": 1,
  "filters": {
    "round": "5",
    "season": "2024"
  },
  "offset": 0,
  "results": [
    {
      "car_number": 1,
      "circuit_id": "shanghai",
      "constructor_id": "red_bull",
      "constructor_name": "Red Bull",
      "date": "2024-04-21",
      "driver_code": "VER",
      "driver_id": "max_verstappen",
      "driver_name": "Max Verstappen",
      "fastest_lap": 3,
      "fastest_lap_rank": 1,
      "fastest_lap_seconds": 100.331,
      "fastest_lap_speed_kph": null,
      "fastest_lap_time": "1:40.331",
      "finished": true,
      "grid": 4,
      "laps_completed": 19,
      "points": 8.0,
      "position": 1,
      "position_text": "1",
      "race_name": "Chinese Grand Prix",
      "round": 5,
      "season": 2024,
      "status": "Finished",
      "total_time": "32:04.660",
      "total_time_millis": 1924660
    }
  ],
  "total_count": 20,
  "truncated": true
}
```

### Get the next race

Get the next Grand Prix that has not been run, with the hours and days left until lights out and until every other session of the weekend. This is the action a race-day reminder is built on: it needs nothing filled in, and it stays correct as the season moves on.

**Inputs**

- Season (`season`, text): Which season's next race to look for. Leave it empty for the season running now, which is what a reminder wants.

**Outputs**

- `days_until_race` (number): The same wait expressed in days
- `found` (true/false): False when the season is over and no calendar is published yet
- `hours_until_race` (number): Hours from now until lights out
- `next_session` (text): The next session still to run, e.g. 'Practice 1'
- `race` (object)
- `season` (number): Season the race belongs to

**Example output**

```json
{
  "days_until_race": 13.64,
  "found": true,
  "hours_until_race": 327.45,
  "next_session": "Practice 1",
  "race": {
    "circuit_id": "monza",
    "circuit_name": "Autodromo Nazionale di Monza",
    "country": "Italy",
    "date": "2026-09-06",
    "is_sprint_weekend": false,
    "locality": "Monza",
    "race_name": "Italian Grand Prix",
    "round": 13,
    "season": 2026,
    "sessions": [
      {
        "date": "2026-09-04",
        "hours_until": 276.95,
        "session": "Practice 1",
        "starts_at": "2026-09-04T10:30:00Z"
      },
      {
        "date": "2026-09-05",
        "hours_until": 304.45,
        "session": "Qualifying",
        "starts_at": "2026-09-05T14:00:00Z"
      },
      {
        "date": "2026-09-06",
        "hours_until": 327.45,
        "session": "Race",
        "starts_at": "2026-09-06T13:00:00Z"
      }
    ],
    "starts_at": "2026-09-06T13:00:00Z",
    "url": "https://en.wikipedia.org/wiki/2026_Italian_Grand_Prix"
  },
  "season": 2026
}
```

### List circuits

List the circuits Formula 1 has raced at, with the town, country and coordinates of each. Narrow to one season for that year's calendar of tracks, or to a driver or team for the circuits they have raced at.

**Inputs**

- Season (`season`, text): Which championship season to look at. Pick 'Current season' and the step keeps working next year without being edited. Leave it empty to search every season since 1950.
- Round (`round_number`, text): Which race of the season. Fill in the season first and this list loads with each round's Grand Prix and date, plus the most recent and the next race. Leave it empty for the whole season.
- Circuit (`circuit_id`, text): Narrow to one circuit, chosen from every track Formula 1 has raced at. Leave it empty for all of them.
- Constructor (`constructor_id`, text): Narrow to one team, chosen from every constructor that has entered a Formula 1 race. Leave it empty for all of them.
- Driver (`driver_id`, text): Narrow to one driver, chosen from every driver who has started a Formula 1 race. Leave it empty for all of them.
- Fastest lap rank (`fastest_lap_rank`, number): Narrow to entries whose best lap ranked this fast in the race, counting 1 as the fastest lap of all. Leave it empty for every rank. From 1 to 100.
- Grid position (`grid_position`, number): Narrow to entries that started the race from this slot on the grid, counting 1 as pole. Leave it empty for every grid slot. From 1 to 100.
- Finishing position (`finish_position`, number): Narrow to entries that finished in this position, counting 1 as the win. Leave it empty for every position. From 1 to 100.
- Finishing status (`status_id`, text): Narrow to entries that ended a given way, such as Finished or Retired. The statuses marked stable are the five the API guarantees will keep their id. Leave it empty for every status.
- Limit (`limit`, number): How many rows to return, from 1 to 100, which is the most the API serves in one request. The answer always says how many rows there were in total, so a limited list never reads as a complete one. Defaults to 30. From 1 to 100. Default: `30`.
- Offset (`offset`, number): How many rows to skip before returning results, for reading a long list a page at a time. Defaults to 0. At least 0. Default: `0`.

**Outputs**

- `circuits` (list): Matching circuits, in id order
- `count` (number): Rows in this answer
- `filters` (object): The filters this query actually applied, repeated so an empty answer says what was asked for
- `offset` (number): Rows skipped before this page
- `total_count` (number): Rows the API holds for the query
- `truncated` (true/false): Whether more rows remain

**Example output**

```json
{
  "circuits": [
    {
      "circuit_id": "albert_park",
      "country": "Australia",
      "latitude": -37.8497,
      "locality": "Melbourne",
      "longitude": 144.968,
      "name": "Albert Park Grand Prix Circuit",
      "url": "https://en.wikipedia.org/wiki/Albert_Park_Circuit"
    }
  ],
  "count": 1,
  "filters": {
    "season": "2024"
  },
  "offset": 0,
  "total_count": 24,
  "truncated": true
}
```

### List constructors

List the teams that have entered a Formula 1 race, with each one's nationality. Narrow to a season for that year's grid, or to a driver for the teams they have driven for.

**Inputs**

- Season (`season`, text): Which championship season to look at. Pick 'Current season' and the step keeps working next year without being edited. Leave it empty to search every season since 1950.
- Round (`round_number`, text): Which race of the season. Fill in the season first and this list loads with each round's Grand Prix and date. Leave it empty for the whole season.
- Circuit (`circuit_id`, text): Narrow to one circuit, chosen from every track Formula 1 has raced at. Leave it empty for all of them.
- Constructor (`constructor_id`, text): Narrow to one team, chosen from every constructor that has entered a Formula 1 race. Leave it empty for all of them.
- Driver (`driver_id`, text): Narrow to one driver, chosen from every driver who has started a Formula 1 race. Leave it empty for all of them.
- Fastest lap rank (`fastest_lap_rank`, number): Narrow to entries whose best lap ranked this fast in the race, counting 1 as the fastest lap of all. Leave it empty for every rank. From 1 to 100.
- Grid position (`grid_position`, number): Narrow to entries that started the race from this slot on the grid, counting 1 as pole. Leave it empty for every grid slot. From 1 to 100.
- Finishing position (`finish_position`, number): Narrow to entries that finished in this position, counting 1 as the win. Leave it empty for every position. From 1 to 100.
- Finishing status (`status_id`, text): Narrow to entries that ended a given way, such as Finished or Retired. The statuses marked stable are the five the API guarantees will keep their id. Leave it empty for every status.
- Limit (`limit`, number): How many rows to return, from 1 to 100, which is the most the API serves in one request. The answer always says how many rows there were in total, so a limited list never reads as a complete one. Defaults to 30. From 1 to 100. Default: `30`.
- Offset (`offset`, number): How many rows to skip before returning results, for reading a long list a page at a time. Defaults to 0. At least 0. Default: `0`.

**Outputs**

- `constructors` (list): Matching constructors, in id order
- `count` (number): Rows in this answer
- `filters` (object): The filters this query actually applied, repeated so an empty answer says what was asked for
- `offset` (number): Rows skipped before this page
- `total_count` (number): Rows the API holds for the query
- `truncated` (true/false): Whether more rows remain

**Example output**

```json
{
  "constructors": [
    {
      "constructor_id": "alpine",
      "name": "Alpine F1 Team",
      "nationality": "French",
      "url": "https://en.wikipedia.org/wiki/Alpine_F1_Team"
    }
  ],
  "count": 1,
  "filters": {
    "season": "2024"
  },
  "offset": 0,
  "total_count": 10,
  "truncated": true
}
```

### List database dumps

See what database dumps are available to download and how fresh each one is. Jolpica-F1 publishes its whole database periodically for anyone who needs more than the API's page limits. The open tier runs a couple of weeks behind the latest, and this reports both with the delay between them.

**Inputs**: None.

**Outputs**

- `available_types` (list): The dump formats on offer, e.g. ['csv']
- `count` (number): How many dumps were listed
- `delay_days` (number): How far behind the latest dump the open one runs
- `dumps` (list): Every published dump, latest tier first
- `newest_uploaded_at` (text): When the freshest dump was made

**Example output**

```json
{
  "available_types": [
    "csv"
  ],
  "count": 1,
  "delay_days": 14,
  "dumps": [
    {
      "download_url": "https://api.jolpi.ca/data/dumps/download/delayed/?dump_type=csv",
      "dump_type": "csv",
      "file_hash": "a6e8104572cdb291116325d804e999221277a15cff03f7f80edbf0c6e888b55c",
      "file_size_bytes": 14289820,
      "file_size_mb": 14.29,
      "tier": "delayed",
      "uploaded_at": "2026-08-01T09:02:06.922560Z"
    }
  ],
  "newest_uploaded_at": "2026-08-23T16:58:55.431783Z"
}
```

### List drivers

List Formula 1 drivers with their car number, three-letter code, nationality and date of birth. Narrow to a season for that year's field, or to a team for its line-up. This is also how to find the exact driver id every other action filters by.

**Inputs**

- Season (`season`, text): Which championship season to look at. Pick 'Current season' and the step keeps working next year without being edited. Leave it empty to search every season since 1950.
- Round (`round_number`, text): Which race of the season. Fill in the season first and this list loads with each round's Grand Prix and date. Leave it empty for the whole season.
- Circuit (`circuit_id`, text): Narrow to one circuit, chosen from every track Formula 1 has raced at. Leave it empty for all of them.
- Constructor (`constructor_id`, text): Narrow to one team, chosen from every constructor that has entered a Formula 1 race. Leave it empty for all of them.
- Driver (`driver_id`, text): Narrow to one driver, chosen from every driver who has started a Formula 1 race. Leave it empty for all of them.
- Fastest lap rank (`fastest_lap_rank`, number): Narrow to entries whose best lap ranked this fast in the race, counting 1 as the fastest lap of all. Leave it empty for every rank. From 1 to 100.
- Grid position (`grid_position`, number): Narrow to entries that started the race from this slot on the grid, counting 1 as pole. Leave it empty for every grid slot. From 1 to 100.
- Finishing position (`finish_position`, number): Narrow to entries that finished in this position, counting 1 as the win. Leave it empty for every position. From 1 to 100.
- Finishing status (`status_id`, text): Narrow to entries that ended a given way, such as Finished or Retired. The statuses marked stable are the five the API guarantees will keep their id. Leave it empty for every status.
- Limit (`limit`, number): How many rows to return, from 1 to 100, which is the most the API serves in one request. The answer always says how many rows there were in total, so a limited list never reads as a complete one. Defaults to 30. From 1 to 100. Default: `30`.
- Offset (`offset`, number): How many rows to skip before returning results, for reading a long list a page at a time. Defaults to 0. At least 0. Default: `0`.

**Outputs**

- `count` (number): Rows in this answer
- `drivers` (list): Matching drivers, in id order
- `filters` (object): The filters this query actually applied, repeated so an empty answer says what was asked for
- `offset` (number): Rows skipped before this page
- `total_count` (number): Rows the API holds for the query
- `truncated` (true/false): Whether more rows remain

**Example output**

```json
{
  "count": 1,
  "drivers": [
    {
      "code": "BEA",
      "date_of_birth": "2005-05-08",
      "driver_id": "bearman",
      "family_name": "Bearman",
      "full_name": "Oliver Bearman",
      "given_name": "Oliver",
      "nationality": "British",
      "permanent_number": 87,
      "url": "http://en.wikipedia.org/wiki/Oliver_Bearman"
    }
  ],
  "filters": {
    "constructor_id": "ferrari",
    "season": "2024"
  },
  "offset": 0,
  "total_count": 3,
  "truncated": true
}
```

### List finishing statuses

See how races ended, with a count for each status and the share that finished. Narrowed to a driver or a team it becomes a reliability record: how often the car got to the flag, and what stopped it when it did not.

**Inputs**

- Season (`season`, text): Which championship season to look at. Pick 'Current season' and the step keeps working next year without being edited. Leave it empty to search every season since 1950.
- Round (`round_number`, text): Which race of the season. Fill in the season first and this list loads with each round's Grand Prix and date. Leave it empty for the whole season.
- Circuit (`circuit_id`, text): Narrow to one circuit, chosen from every track Formula 1 has raced at. Leave it empty for all of them.
- Constructor (`constructor_id`, text): Narrow to one team, chosen from every constructor that has entered a Formula 1 race. Leave it empty for all of them.
- Driver (`driver_id`, text): Narrow to one driver, chosen from every driver who has started a Formula 1 race. Leave it empty for all of them.
- Fastest lap rank (`fastest_lap_rank`, number): Narrow to entries whose best lap ranked this fast in the race, counting 1 as the fastest lap of all. Leave it empty for every rank. From 1 to 100.
- Grid position (`grid_position`, number): Narrow to entries that started the race from this slot on the grid, counting 1 as pole. Leave it empty for every grid slot. From 1 to 100.
- Finishing position (`finish_position`, number): Narrow to entries that finished in this position, counting 1 as the win. Leave it empty for every position. From 1 to 100.
- Finishing status (`status_id`, text): Narrow to entries that ended a given way, such as Finished or Retired. The statuses marked stable are the five the API guarantees will keep their id. Leave it empty for every status.
- Limit (`limit`, number): How many rows to return, from 1 to 100, which is the most the API serves in one request. The answer always says how many rows there were in total, so a limited list never reads as a complete one. Defaults to 30. From 1 to 100. Default: `30`.
- Offset (`offset`, number): How many rows to skip before returning results, for reading a long list a page at a time. Defaults to 0. At least 0. Default: `0`.

**Outputs**

- `count` (number): Rows in this answer
- `entries_counted` (number): Total entries behind the statuses on this page
- `filters` (object): The filters this query actually applied, repeated so an empty answer says what was asked for
- `finished_count` (number): How many of those entries were classified as Finished
- `finished_percent` (number): Finished entries as a percentage of the entries counted
- `offset` (number): Rows skipped before this page
- `statuses` (list): Finishing statuses, most common first
- `total_count` (number): Rows the API holds for the query
- `truncated` (true/false): Whether more rows remain

**Example output**

```json
{
  "count": 1,
  "entries_counted": 474,
  "filters": {
    "season": "2024"
  },
  "finished_count": 287,
  "finished_percent": 60.55,
  "offset": 0,
  "statuses": [
    {
      "count": 287,
      "is_stable_id": true,
      "status": "Finished",
      "status_id": "1"
    }
  ],
  "total_count": 5,
  "truncated": true
}
```

### List races

Get the race calendar, with every session of each weekend given as a single timestamp rather than a separate date and time. Practice, qualifying, the sprint and the race come back as one ordered list, so a step can put the whole weekend in a calendar without knowing which sessions this season runs.

**Inputs**

- Season (`season`, text): Which championship season to look at. Pick 'Current season' and the step keeps working next year without being edited. Leave it empty to search every season since 1950.
- Round (`round_number`, text): Which race of the season. Fill in the season first and this list loads with each round's Grand Prix and date, plus the most recent and the next race. Leave it empty for the whole season.
- Circuit (`circuit_id`, text): Narrow to one circuit, chosen from every track Formula 1 has raced at. Leave it empty for all of them.
- Constructor (`constructor_id`, text): Narrow to one team, chosen from every constructor that has entered a Formula 1 race. Leave it empty for all of them.
- Driver (`driver_id`, text): Narrow to one driver, chosen from every driver who has started a Formula 1 race. Leave it empty for all of them.
- Grid position (`grid_position`, number): Narrow to entries that started the race from this slot on the grid, counting 1 as pole. Leave it empty for every grid slot. From 1 to 100.
- Finishing status (`status_id`, text): Narrow to entries that ended a given way, such as Finished or Retired. The statuses marked stable are the five the API guarantees will keep their id. Leave it empty for every status.
- From date (`from_date`, date): Leave out races before this day. The API has no date filter of its own, so this is applied to the races the query returned: set a season and the whole calendar fits in one page.
- To date (`to_date`, date): Leave out races after this day.
- Include session times (`include_sessions`, true/false): Turn off to return just the race itself, without the practice, qualifying and sprint times. On by default. Default: `true`.
- Limit (`limit`, number): How many rows to return, from 1 to 100, which is the most the API serves in one request. The answer always says how many rows there were in total, so a limited list never reads as a complete one. Defaults to 30. From 1 to 100. Default: `30`.
- Offset (`offset`, number): How many rows to skip before returning results, for reading a long list a page at a time. Defaults to 0. At least 0. Default: `0`.

**Outputs**

- `count` (number): Rows in this answer
- `fetched_count` (number): Rows the API returned before the date window was applied
- `filters` (object): The filters this query actually applied, repeated so an empty answer says what was asked for
- `offset` (number): Rows skipped before this page
- `races` (list): Matching races, oldest first
- `total_count` (number): Rows the API holds for the query
- `truncated` (true/false): Whether more rows remain

**Example output**

```json
{
  "count": 1,
  "fetched_count": 1,
  "filters": {
    "season": "2024"
  },
  "offset": 0,
  "races": [
    {
      "circuit_id": "bahrain",
      "circuit_name": "Bahrain International Circuit",
      "country": "Bahrain",
      "date": "2024-03-02",
      "is_sprint_weekend": false,
      "locality": "Sakhir",
      "race_name": "Bahrain Grand Prix",
      "round": 1,
      "season": 2024,
      "sessions": [
        {
          "date": "2024-02-29",
          "session": "Practice 1",
          "starts_at": "2024-02-29T11:30:00Z"
        },
        {
          "date": "2024-03-01",
          "session": "Qualifying",
          "starts_at": "2024-03-01T16:00:00Z"
        },
        {
          "date": "2024-03-02",
          "session": "Race",
          "starts_at": "2024-03-02T15:00:00Z"
        }
      ],
      "starts_at": "2024-03-02T15:00:00Z",
      "url": "https://en.wikipedia.org/wiki/2024_Bahrain_Grand_Prix"
    }
  ],
  "total_count": 24,
  "truncated": true
}
```

### List seasons

List Formula 1 championship seasons, oldest first. Narrowing by driver or constructor turns this into a career span: the seasons Hamilton raced in, or the ones Ferrari entered. Narrowing by circuit gives the seasons a track was on the calendar.

**Inputs**

- Season (`season`, text): Which championship season to look at. Pick 'Current season' and the step keeps working next year without being edited. Leave it empty to search every season since 1950.
- Circuit (`circuit_id`, text): Narrow to one circuit, chosen from every track Formula 1 has raced at. Leave it empty for all of them.
- Constructor (`constructor_id`, text): Narrow to one team, chosen from every constructor that has entered a Formula 1 race. Leave it empty for all of them.
- Driver (`driver_id`, text): Narrow to one driver, chosen from every driver who has started a Formula 1 race. Leave it empty for all of them.
- Grid position (`grid_position`, number): Narrow to entries that started the race from this slot on the grid, counting 1 as pole. Leave it empty for every grid slot. From 1 to 100.
- Finishing status (`status_id`, text): Narrow to entries that ended a given way, such as Finished or Retired. The statuses marked stable are the five the API guarantees will keep their id. Leave it empty for every status.
- Limit (`limit`, number): How many rows to return, from 1 to 100, which is the most the API serves in one request. The answer always says how many rows there were in total, so a limited list never reads as a complete one. Defaults to 30. From 1 to 100. Default: `30`.
- Offset (`offset`, number): How many rows to skip before returning results, for reading a long list a page at a time. Defaults to 0. At least 0. Default: `0`.

**Outputs**

- `count` (number): Rows in this answer
- `filters` (object): The filters this query actually applied, repeated so an empty answer says what was asked for
- `offset` (number): Rows skipped before this page
- `seasons` (list): Matching seasons, oldest first
- `total_count` (number): Rows the API holds for the query
- `truncated` (true/false): Whether more rows remain

**Example output**

```json
{
  "count": 1,
  "filters": {
    "driver_id": "hamilton"
  },
  "offset": 0,
  "seasons": [
    {
      "season": 2007,
      "url": "https://en.wikipedia.org/wiki/2007_Formula_One_World_Championship"
    }
  ],
  "total_count": 20,
  "truncated": true
}
```