# OpenF1

> Read Formula 1 timing and telemetry from OpenF1: the race calendar and session list, entry lists with team colours, classifications and starting grids, championship standings, and how a session actually unfolded - lap and sector times, pit stops, tyre stints, running order, gaps to the car ahead, overtakes, race control's flags and safety cars, trackside weather, and team radio with audio links. Down to the car itself: speed, throttle, brake, gear, RPM, DRS and track position, sampled about 3.7 times a second. Every session from 2023 onward is free and needs no API key. This is an independent integration. OpenF1 is an unofficial, open-source project and is not associated with the Formula 1 companies; F1, FORMULA 1, GRAND PRIX and related marks are trade marks of Formula One Licensing B.V.

App · Sports · 18 actions. Web page: https://docs.lodol.com/docs/integrations/openf1

## Actions

### Get car location

Get one car's position on track as 3D coordinates, sampled about 3.7 times a second - useful for following its progress around a lap. It does not say which side of the track the car is on, and the origin is arbitrary rather than a fixed point on the circuit. A session and a driver are both required, and a time window is the way to narrow it further.

**Inputs**

- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Session (`session_key`, text, required): Required. The session to read telemetry from. Pick a meeting first and this lists its sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Driver (`driver_number`, text, required): Required. The driver's car number. Telemetry is per-car, and one car's session is already tens of thousands of samples, so a driver must be chosen. Pick a session first and this lists that session's entries.
- From (`date_from`, date and time): Optional. Only include records at or after this UTC moment. Narrowing the window is the main way to keep a busy session's result readable.
- To (`date_to`, date and time): Optional. Only include records at or before this UTC moment.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 5000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 5000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "date": "2023-09-16T13:03:35.292000+00:00",
      "driver_number": 81,
      "meeting_key": 1219,
      "session_key": 9161,
      "x": 567,
      "y": 3195,
      "z": 187
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```

### Get car telemetry

Get one car's telemetry - speed, throttle, brake, gear, RPM and DRS - sampled about 3.7 times a second. The DRS code and the 0/100 brake reading are decoded into readable fields beside the raw values. A session and a driver are both required because a single car's session is already tens of thousands of samples; narrow it further with a time window or a speed floor.

**Inputs**

- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Session (`session_key`, text, required): Required. The session to read telemetry from. Pick a meeting first and this lists its sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Driver (`driver_number`, text, required): Required. The driver's car number. Telemetry is per-car, and one car's session is already tens of thousands of samples, so a driver must be chosen. Pick a session first and this lists that session's entries.
- Minimum speed (km/h) (`min_speed`, number): Optional. Only samples at or above this speed - 300 finds the fastest parts of a lap. At least 0.
- Maximum speed (km/h) (`max_speed`, number): Optional. Only samples at or below this speed. At least 0.
- Gear (`n_gear`, number): Optional. Only samples in this gear, 1 to 8. 0 is neutral or no gear engaged. From 0 to 8.
- From (`date_from`, date and time): Optional. Only include records at or after this UTC moment. Narrowing the window is the main way to keep a busy session's result readable.
- To (`date_to`, date and time): Optional. Only include records at or before this UTC moment.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 5000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 5000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "brake": 0,
      "brake_pressed": false,
      "date": "2023-09-15T13:08:19.923000+00:00",
      "driver_number": 55,
      "drs": 12,
      "drs_active": true,
      "drs_status": "DRS on",
      "meeting_key": 1219,
      "n_gear": 8,
      "rpm": 11141,
      "session_key": 9159,
      "speed": 315,
      "throttle": 99
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```

### Get constructors' championship

Get the constructors' championship standings around a race: points and position before and after it, and the points and places the race moved each team. Race sessions only, and in beta on OpenF1's side.

**Inputs**

- Session (`session_key`, text): Optional. The session to read - pick a meeting first and this lists its practice, qualifying, sprint and race sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Team name (`team_name`, text): Optional. The team's name, e.g. 'McLaren'. Matches the whole value.
- Top N in the championship (`max_position`, number): Optional. Only teams at or above this championship position after the race. At least 1.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 1000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 1000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "meeting_key": 1276,
      "points_current": 833,
      "points_gained": 33,
      "points_start": 800,
      "position_current": 1,
      "position_start": 1,
      "positions_gained": 0,
      "session_key": 9839,
      "team_name": "McLaren"
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```

### Get drivers' championship

Get the drivers' championship standings around a race: points and position before it, points and position after it, and the points and places the race moved each driver. Race sessions only, and in beta on OpenF1's side.

**Inputs**

- Session (`session_key`, text): Optional. The session to read - pick a meeting first and this lists its practice, qualifying, sprint and race sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Driver (`driver_number`, text): Optional. The driver's car number. Pick a session first and this lists that session's entries; a number from an earlier step also works.
- Top N in the championship (`max_position`, number): Optional. Only drivers at or above this championship position after the race. At least 1.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 1000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 1000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "driver_number": 4,
      "meeting_key": 1276,
      "points_current": 423,
      "points_gained": 15,
      "points_start": 408,
      "position_current": 1,
      "position_start": 1,
      "positions_gained": 0,
      "session_key": 9839
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```

### Get session result

Get the classification after a session: finishing position, laps completed, time or best lap, gap to the leader, and whether a driver was disqualified or failed to finish or start. Published a few minutes after the official F1 results. In qualifying the time and gap are three values (Q1, Q2, Q3), so a single best_duration is provided beside them.

**Inputs**

- Session (`session_key`, text): Optional. The session to read - pick a meeting first and this lists its practice, qualifying, sprint and race sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Driver (`driver_number`, text): Optional. The driver's car number. Pick a session first and this lists that session's entries; a number from an earlier step also works.
- Position (`position`, number): Optional. Only the driver in this exact position. At least 1.
- Top N positions (`max_position`, number): Optional. Only positions at or above this one - 3 for the podium, 10 for the points. At least 1.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 1000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 1000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "best_duration": 77.565,
      "classified": true,
      "dnf": false,
      "dns": false,
      "driver_number": 1,
      "dsq": false,
      "duration": 77.565,
      "gap_to_leader": 0,
      "gap_to_leader_seconds": 0,
      "is_lapped": false,
      "is_qualifying_format": false,
      "meeting_key": 1143,
      "number_of_laps": 24,
      "position": 1,
      "session_key": 7782
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```

### Get starting grid

Get the grid a race started from: each slot, the driver in it, and the qualifying lap that earned it. Published a few minutes after the official F1 results, so it reflects any penalties already applied.

**Inputs**

- Session (`session_key`, text): Optional. The session to read - pick a meeting first and this lists its practice, qualifying, sprint and race sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Driver (`driver_number`, text): Optional. The driver's car number. Pick a session first and this lists that session's entries; a number from an earlier step also works.
- Top N grid slots (`max_position`, number): Optional. Only grid slots at or above this one, e.g. 10 for the top ten starters. At least 1.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 1000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 1000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "driver_number": 1,
      "lap_duration": 76.732,
      "meeting_key": 1143,
      "position": 1,
      "session_key": 7783
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```

### List drivers

List the drivers entered for a session: car number, full and broadcast name, three-letter acronym, team, headshot and the team's livery colour (both as the API's bare RRGGBB and as a ready-to-use #RRGGBB). Car numbers are reassigned between seasons and substitutes come and go, so this is keyed on a session rather than being a standing list.

**Inputs**

- Session (`session_key`, text): Optional. The session to read - pick a meeting first and this lists its practice, qualifying, sprint and race sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Driver (`driver_number`, text): Optional. The driver's car number. Pick a session first and this lists that session's entries; a number from an earlier step also works.
- Team name (`team_name`, text): Optional. The team's name, e.g. 'Red Bull Racing' or 'McLaren'. Matches the whole value.
- Driver acronym (`name_acronym`, text): Optional. The driver's three-letter acronym, e.g. 'VER' or 'NOR'.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 1000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 1000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "broadcast_name": "M VERSTAPPEN",
      "driver_number": 1,
      "first_name": "Max",
      "full_name": "Max VERSTAPPEN",
      "headshot_url": "https://www.formula1.com/content/dam/fom-website/drivers/M/MAXVER01_Max_Verstappen/maxver01.png.transform/1col/image.png",
      "last_name": "Verstappen",
      "meeting_key": 1219,
      "name_acronym": "VER",
      "session_key": 9158,
      "team_colour": "3671C6",
      "team_colour_hex": "#3671C6",
      "team_name": "Red Bull Racing"
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```

### List intervals

List the gap to the car ahead and to the race leader, updated about every four seconds. Races only. Each gap is a number, '+1 LAP' for a lapped driver, or empty for the leader, so plain interval_seconds, gap_to_leader_seconds, is_lapped and is_leader fields are provided beside them to compare on.

**Inputs**

- Session (`session_key`, text): Optional. The session to read - pick a meeting first and this lists its practice, qualifying, sprint and race sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Driver (`driver_number`, text): Optional. The driver's car number. Pick a session first and this lists that session's entries; a number from an earlier step also works.
- Maximum interval (seconds) (`max_interval`, number): Optional. Only readings where the gap to the car ahead is at or under this many seconds - 1 finds the moments a driver was within a second and eligible for DRS. At least 0.
- From (`date_from`, date and time): Optional. Only include records at or after this UTC moment. Narrowing the window is the main way to keep a busy session's result readable.
- To (`date_to`, date and time): Optional. Only include records at or before this UTC moment.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 1000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 1000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "date": "2023-09-17T13:31:02.395000+00:00",
      "driver_number": 1,
      "gap_to_leader": 41.019,
      "gap_to_leader_seconds": 41.019,
      "interval": 0.003,
      "interval_seconds": 0.003,
      "is_lapped": false,
      "is_leader": false,
      "meeting_key": 1219,
      "session_key": 9165
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```

### List laps

List individual laps with sector times, the two intermediate speeds and the speed-trap speed, whether the lap was an out lap from the pits, and the mini-sector codes - decoded here into the yellow/green/purple/pitlane colours a timing screen shows. Filter to one driver, one lap, a range of laps, or laps under a given time. Mini-sectors are not published during races.

**Inputs**

- Session (`session_key`, text): Optional. The session to read - pick a meeting first and this lists its practice, qualifying, sprint and race sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Driver (`driver_number`, text): Optional. The driver's car number. Pick a session first and this lists that session's entries; a number from an earlier step also works.
- Lap number (`lap_number`, number): Optional. Only this exact lap of the session. At least 1.
- From lap (`min_lap_number`, number): Optional. Only laps at or after this lap number. At least 1.
- To lap (`max_lap_number`, number): Optional. Only laps at or before this lap number. At least 1.
- Pit out laps only (`is_pit_out_lap`, true/false): Optional. True for only out laps from the pits, false for only laps that are not. Leave blank for both - which is a different question from 'false'.
- Maximum lap time (seconds) (`max_lap_duration`, number): Optional. Only laps at or under this many seconds - a way to skip safety-car and in/out laps. At least 0.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 1000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 1000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "date_start": "2023-09-16T13:59:07.606000+00:00",
      "driver_number": 63,
      "duration_sector_1": 26.966,
      "duration_sector_2": 38.657,
      "duration_sector_3": 26.12,
      "i1_speed": 307,
      "i2_speed": 277,
      "is_pit_out_lap": false,
      "lap_duration": 91.743,
      "lap_number": 8,
      "meeting_key": 1219,
      "segments_sector_1": [
        2049,
        2049,
        2049,
        2051,
        2049,
        2051,
        2049,
        2049
      ],
      "segments_sector_1_colours": [
        "green",
        "green",
        "green",
        "purple",
        "green",
        "purple",
        "green",
        "green"
      ],
      "segments_sector_2": [
        2049,
        2049,
        2049,
        2049,
        2049,
        2049,
        2049,
        2049
      ],
      "segments_sector_2_colours": [
        "green",
        "green",
        "green",
        "green",
        "green",
        "green",
        "green",
        "green"
      ],
      "segments_sector_3": [
        2048,
        2048,
        2048,
        2048,
        2048,
        2064,
        2064,
        2064
      ],
      "segments_sector_3_colours": [
        "yellow",
        "yellow",
        "yellow",
        "yellow",
        "yellow",
        "pitlane",
        "pitlane",
        "pitlane"
      ],
      "session_key": 9161,
      "st_speed": 298
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```

### List meetings

List Formula 1 race weekends - each Grand Prix and testing weekend from 2023 onward - with the circuit, country, local GMT offset, start and end times, and the meeting key every other action is keyed on. Filter by season, country or circuit, or leave everything blank for the whole calendar. No API key required.

**Inputs**

- Season (`year`, number): Optional. The season, e.g. 2024. OpenF1's coverage starts at 2023, so an earlier year is refused rather than returning nothing. From 2023 to 2100.
- Country name (`country_name`, text): Optional. The country the weekend was held in, spelled in full, e.g. 'Singapore'. Matches the whole value.
- Country code (`country_code`, text): Optional. The three-letter country code, e.g. 'SGP'.
- Circuit (`circuit_short_name`, text): Optional. The circuit's short name, e.g. 'Spa-Francorchamps' or 'Singapore'.
- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- From (`date_from`, date and time): Optional. Only include records at or after this UTC moment. Narrowing the window is the main way to keep a busy session's result readable.
- To (`date_to`, date and time): Optional. Only include records at or before this UTC moment.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 1000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 1000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "circuit_image": "https://media.formula1.com/content/dam/fom-website/2018-redesign-assets/Track%20icons%204x3/Singapore%20carbon.png",
      "circuit_info_url": "https://api.multiviewer.app/api/v1/circuits/61/2026",
      "circuit_key": 61,
      "circuit_short_name": "Singapore",
      "circuit_type": "Temporary - Street",
      "country_code": "SGP",
      "country_flag": "https://media.formula1.com/content/dam/fom-website/2018-redesign-assets/Flags%2016x9/singapore-flag.png",
      "country_key": 157,
      "country_name": "Singapore",
      "date_end": "2026-10-11T14:00:00+00:00",
      "date_start": "2026-10-09T09:30:00+00:00",
      "gmt_offset": "08:00:00",
      "is_cancelled": false,
      "location": "Marina Bay",
      "meeting_key": 1296,
      "meeting_name": "Singapore Grand Prix",
      "meeting_official_name": "FORMULA 1 SINGAPORE AIRLINES SINGAPORE GRAND PRIX 2026",
      "year": 2026
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```

### List overtakes

List position swaps between two drivers, with who passed whom and the position gained. Races only. This counts changes from pit stops and post-race penalties as well as on-track passes, and OpenF1 notes the data may be incomplete.

**Inputs**

- Session (`session_key`, text): Optional. The session to read - pick a meeting first and this lists its practice, qualifying, sprint and race sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Overtaking driver (`overtaking_driver_number`, text): Optional. The car number of the driver doing the passing.
- Overtaken driver (`overtaken_driver_number`, text): Optional. The car number of the driver being passed.
- Position gained (`position`, number): Optional. Only passes that put the overtaking driver into this position - 1 finds passes for the lead. At least 1.
- From (`date_from`, date and time): Optional. Only include records at or after this UTC moment. Narrowing the window is the main way to keep a busy session's result readable.
- To (`date_to`, date and time): Optional. Only include records at or before this UTC moment.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 1000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 1000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "date": "2024-11-03T15:50:07.565000+00:00",
      "meeting_key": 1249,
      "overtaken_driver_number": 4,
      "overtaking_driver_number": 63,
      "position": 1,
      "session_key": 9636
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```

### List pit stops

List trips through the pit lane, with the lap they happened on, the time spent stationary and the time spent in the lane overall. The stationary time is only recorded from the 2024 US Grand Prix onward; the lane time is available throughout.

**Inputs**

- Session (`session_key`, text): Optional. The session to read - pick a meeting first and this lists its practice, qualifying, sprint and race sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Driver (`driver_number`, text): Optional. The driver's car number. Pick a session first and this lists that session's entries; a number from an earlier step also works.
- Lap number (`lap_number`, number): Optional. Only stops made on this lap. At least 1.
- Maximum stationary time (seconds) (`max_stop_duration`, number): Optional. Only stops at or under this many seconds stationary - 2.5 finds the quick ones. Note this excludes stops before the 2024 US Grand Prix, which have no stationary time recorded. At least 0.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 1000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 1000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "date": "2025-10-26T20:46:37.358000+00:00",
      "driver_number": 16,
      "lane_duration": 22.215,
      "lap_number": 31,
      "meeting_key": 1272,
      "pit_duration": 22.215,
      "session_key": 9877,
      "stop_duration": 2.2
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```

### List positions

List the running order through a session - where each driver started and every change afterwards, each stamped with the moment it happened. A row is written when a position changes rather than at a fixed rate, so a quiet race produces few rows and a chaotic one many.

**Inputs**

- Session (`session_key`, text): Optional. The session to read - pick a meeting first and this lists its practice, qualifying, sprint and race sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Driver (`driver_number`, text): Optional. The driver's car number. Pick a session first and this lists that session's entries; a number from an earlier step also works.
- Position (`position`, number): Optional. Only changes into this exact position. At least 1.
- Top N positions (`max_position`, number): Optional. Only positions at or above this one, e.g. 3 to follow the podium places. At least 1.
- From (`date_from`, date and time): Optional. Only include records at or after this UTC moment. Narrowing the window is the main way to keep a busy session's result readable.
- To (`date_to`, date and time): Optional. Only include records at or before this UTC moment.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 1000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 1000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "date": "2023-08-26T09:30:47.199000+00:00",
      "driver_number": 40,
      "meeting_key": 1217,
      "position": 2,
      "session_key": 9144
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```

### List race control messages

List race control's own narration of a session: flags, safety cars, DRS enabled and disabled, incidents noted, investigated and penalised, and the session being stopped and restarted. Filter by category, flag colour, scope, lap or driver.

**Inputs**

- Session (`session_key`, text): Optional. The session to read - pick a meeting first and this lists its practice, qualifying, sprint and race sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Driver (`driver_number`, text): Optional. The driver's car number. Pick a session first and this lists that session's entries; a number from an earlier step also works.
- Category (`category`, text): Optional. The event category, e.g. 'Flag', 'SafetyCar', 'Drs', 'CarEvent' or 'SessionStatus'.
- Flag (`flag`, text): Optional. The flag shown, e.g. 'GREEN', 'YELLOW', 'DOUBLE YELLOW', 'RED', 'BLACK AND WHITE' or 'CHEQUERED'.
- Scope (`scope`, text): Optional. What the message applied to: 'Track', 'Driver' or 'Sector'.
- Lap number (`lap_number`, number): Optional. Only messages from this lap of a race. At least 1.
- From (`date_from`, date and time): Optional. Only include records at or after this UTC moment. Narrowing the window is the main way to keep a busy session's result readable.
- To (`date_to`, date and time): Optional. Only include records at or before this UTC moment.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 1000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 1000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "category": "Flag",
      "date": "2023-06-04T14:21:01+00:00",
      "driver_number": 1,
      "flag": "BLACK AND WHITE",
      "lap_number": 59,
      "meeting_key": 1211,
      "message": "BLACK AND WHITE FLAG FOR CAR 1 (VER) - TRACK LIMITS",
      "qualifying_phase": null,
      "scope": "Driver",
      "sector": null,
      "session_key": 9102
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```

### List sessions

List sessions - practice, qualifying, sprint and race - with their start and end times, circuit and session key. A session key is what nearly every other OpenF1 action is keyed on, so this is usually the first step of a workflow. Filter by season, country, circuit, session name or race weekend.

**Inputs**

- Season (`year`, number): Optional. The season, e.g. 2024. OpenF1 covers 2023 onward. From 2023 to 2100.
- Country name (`country_name`, text): Optional. The country, spelled in full.
- Circuit (`circuit_short_name`, text): Optional. The circuit's short name.
- Session name (`session_name`, text): Optional. The session's name, e.g. 'Practice 1', 'Qualifying', 'Sprint Qualifying' or 'Race'.
- Session type (`session_type`, text): Optional. The broader type, e.g. 'Practice', 'Qualifying' or 'Race'.
- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Session (`session_key`, text): Optional. The session to read - pick a meeting first and this lists its practice, qualifying, sprint and race sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- From (`date_from`, date and time): Optional. Only include records at or after this UTC moment. Narrowing the window is the main way to keep a busy session's result readable.
- To (`date_to`, date and time): Optional. Only include records at or before this UTC moment.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 1000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 1000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "circuit_key": 7,
      "circuit_short_name": "Spa-Francorchamps",
      "country_code": "BEL",
      "country_key": 16,
      "country_name": "Belgium",
      "date_end": "2023-07-29T15:35:00+00:00",
      "date_start": "2023-07-29T15:05:00+00:00",
      "gmt_offset": "02:00:00",
      "is_cancelled": false,
      "location": "Spa-Francorchamps",
      "meeting_key": 1216,
      "session_key": 9140,
      "session_name": "Sprint Qualifying",
      "session_type": "Sprint Qualifying",
      "year": 2023
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```

### List stints

List stints - each unbroken run on one set of tyres - with the compound, the laps it spanned, how many laps that was, and how old the tyres already were when it began. Filtering on tyre age is how a workflow finds runs started on a scrubbed set.

**Inputs**

- Session (`session_key`, text): Optional. The session to read - pick a meeting first and this lists its practice, qualifying, sprint and race sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Driver (`driver_number`, text): Optional. The driver's car number. Pick a session first and this lists that session's entries; a number from an earlier step also works.
- Tyre compound (`compound`, text): Optional. The compound, e.g. SOFT, MEDIUM, HARD, INTERMEDIATE or WET.
- Stint number (`stint_number`, number): Optional. Only this stint of the session, counting from 1. At least 1.
- Minimum tyre age (laps) (`min_tyre_age_at_start`, number): Optional. Only stints begun on tyres at least this many laps old. 1 or more finds every run on a used set. At least 0.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 1000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 1000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "compound": "SOFT",
      "driver_number": 16,
      "lap_count": 20,
      "lap_end": 20,
      "lap_start": 1,
      "meeting_key": 1219,
      "session_key": 9165,
      "stint_number": 1,
      "tyre_age_at_start": 3
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```

### List team radio

List radio exchanges between drivers and their teams, each with a link to the audio recording. Only a selection of a session's radio is ever released, and OpenF1 notes that far less has been published from 2026 onward - many sessions carry none at all, so an empty result is normal rather than a fault.

**Inputs**

- Session (`session_key`, text): Optional. The session to read - pick a meeting first and this lists its practice, qualifying, sprint and race sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Driver (`driver_number`, text): Optional. The driver's car number. Pick a session first and this lists that session's entries; a number from an earlier step also works.
- From (`date_from`, date and time): Optional. Only include records at or after this UTC moment. Narrowing the window is the main way to keep a busy session's result readable.
- To (`date_to`, date and time): Optional. Only include records at or before this UTC moment.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 1000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 1000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "date": "2023-09-15T09:40:43.005000+00:00",
      "driver_number": 11,
      "meeting_key": 1219,
      "recording_url": "https://livetiming.formula1.com/static/2023/2023-09-17_Singapore_Grand_Prix/2023-09-15_Practice_1/TeamRadio/SERPER01_11_20230915_104008.mp3",
      "session_key": 9158
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```

### List weather readings

List trackside weather taken once a minute: air and track temperature, humidity, air pressure, wind speed and direction, and whether it was raining. Filter to the readings above a temperature or wind speed to find when conditions turned.

**Inputs**

- Session (`session_key`, text): Optional. The session to read - pick a meeting first and this lists its practice, qualifying, sprint and race sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Meeting (Grand Prix) (`meeting_key`, text): Optional. The race weekend to read. Setting this also fills the Session dropdown with that weekend's sessions. Accepts a key from an earlier step, or 'latest' for the session or meeting happening now.
- Minimum air temperature (°C) (`min_air_temperature`, number): Optional. Only readings at or above this air temperature.
- Minimum track temperature (°C) (`min_track_temperature`, number): Optional. Only readings at or above this track temperature - the number that decides tyre behaviour.
- Minimum wind speed (m/s) (`min_wind_speed`, number): Optional. Only readings at or above this wind speed. At least 0.
- From (`date_from`, date and time): Optional. Only include records at or after this UTC moment. Narrowing the window is the main way to keep a busy session's result readable.
- To (`date_to`, date and time): Optional. Only include records at or before this UTC moment.
- Maximum rows (`limit`, number): Optional. How many rows to return, 1 to 1000 (default 100). OpenF1 has no paging, so the whole matching set is fetched and cut to this; the result says how many matched in total and whether it was cut. From 1 to 1000. Default: `100`.
- Show in the run (`output_detail`, text): How much of each row to print into the run output for a person to read. Every row that was returned is listed either way, however many that is: the Maximum rows field above decides that, not this one. 'One line each' gives the fields that matter for this collection; 'Every field' adds everything else the API sent. This only changes what is displayed, never what is saved - a later step sees the same data whichever is chosen. Defaults to one line each. One of: `summary` (One line each), `full` (Every field). Default: `summary`.

**Outputs**

- `output_detail` (text)
- `result_count` (number)
- `results` (list)
- `total_matched` (number)
- `truncated` (true/false)

**Example output**

```json
{
  "output_detail": "summary",
  "result_count": 1,
  "results": [
    {
      "air_temperature": 27.8,
      "date": "2023-05-07T18:42:25.233000+00:00",
      "humidity": 58,
      "meeting_key": 1208,
      "pressure": 1018.7,
      "rainfall": 0,
      "rainfall_detected": false,
      "session_key": 9078,
      "track_temperature": 52.5,
      "wind_direction": 136,
      "wind_speed": 2.4
    }
  ],
  "total_matched": 1,
  "truncated": false
}
```