OpenF1 API

Free Formula 1 API with no key: live and historical timing, car telemetry, radio messages, pit stops and driver positions at sub-second resolution. Tested example included.

No API key requiredCORS enabledHTTPSFree tier

Endpoint tested and returned HTTP 200 on 2026-08-21

What is the OpenF1 API?

OpenF1 is a free, key-free Formula 1 API providing both live and historical race data. It exposes session and meeting metadata, lap times, pit stops, driver positions, team radio and car telemetry — speed, throttle, brake, gear and DRS — at sub-second resolution.

Formula 1 data has traditionally meant either scraping the official timing feed or paying for a commercial licence. OpenF1 changed that by publishing the same underlying telemetry stream as an open REST and streaming API, at a granularity that genuinely supports analysis: car data arrives at roughly 3.7 Hz, so you can reconstruct a lap's throttle and brake trace rather than just its time.

The structure to learn first is the key hierarchy. A `meeting_key` identifies a grand prix weekend, and a `session_key` identifies one session within it — practice, qualifying, sprint or race. Almost every other endpoint is filtered by `session_key`, so the normal workflow is to query `/sessions` to find the session you want and then use its key everywhere else. Filters also support comparison operators appended to the parameter name, such as `date>` and `speed>=`, which is unusual and very useful for slicing telemetry without pulling the whole session.

Quick facts

Base URL: https://api.openf1.org/v1
Authentication: No API key or account for historical data — but only between sessions. While a Formula 1 session is live, OpenF1 blocks all unauthenticated requests, including for past seasons, until it ends. Real-time access during sessions is a paid tier.
Rate limit: No hard published limit on historical queries. Telemetry responses are very large, so filter rather than paginating blindly.
Pricing: Free for historical data; a paid tier covers real-time delivery during live sessions.
CORS: Enabled — callable directly from browser JavaScript
Official docs: Read the docs

How to use the OpenF1 API

Every request below was executed against the live API on 2026-08-21, and the response shown is the real body it returned — not an illustration.

1. Find every Sprint session in the 2024 season

GET https://api.openf1.org/v1/sessions?year=2024&session_name=Sprint

curl

curl 'https://api.openf1.org/v1/sessions?year=2024&session_name=Sprint'

JavaScript (fetch)

const res = await fetch("https://api.openf1.org/v1/sessions?year=2024&session_name=Sprint");
if (!res.ok) throw new Error(`Request failed: ${res.status}`);
const data = await res.json();
console.log(data);

Python (requests)

import requests

res = requests.get("https://api.openf1.org/v1/sessions?year=2024&session_name=Sprint", timeout=20)
res.raise_for_status()
print(res.json())

Response — HTTP 200 (truncated)

[
  {
    "session_key": 9672,
    "session_type": "Race",
    "session_name": "Sprint",
    "date_start": "2024-04-20T03:00:00+00:00",
    "date_end": "2024-04-20T04:00:00+00:00",
    "meeting_key": 1233,
    "circuit_key": 49,
    "circuit_short_name": "Shanghai",
    "country_key": 53,
    "country_code": "CHN",
    "country_name": "China",
    "location": "Shanghai",
    "gmt_offset": "08:00:00",
    "year": 2024,
    "is_cancelled": false
  },
  {
    "session_key": 9506,
    "session_type": "Race",
    "session_name": "Sprint",
    "date_start": "2024-05-04T16:00:00+00:00",
    "date_end": "2024-05-04T17:00:00+00:00",
    "meeting_key": 1234,
    "circuit_key": 151,
    "circuit_short_name": "Miami",
    "country_key": 19,
    "country_code": "USA",
    "country_name": "United States",
    "location": "Miami",
    "gmt_offset": "-04:00:00",
    "year": 2024,
    "is_cancelled": false
  },
  {
    "session_key": 9549,
    "session_type": "Race",
    "session_name": "Sprint",
    "date_start": "2024-06-29T10:00:00+00:00",
    "date_end": "2024-06-29T11:00:00+00:00",
    "meeting_key": 1239,
    "circuit_key": 19,
    "circuit_short_name": "Spielberg",
    "country_key": 17,
    "country_code": "AUT",
    "country_name": "Austria",
    "location": "Spielberg",
    "gmt_offset": "02:00:00",
    "year": 2024,
    "is_cancelled": false
  },
  {
    "session_key": 9616,
    "session_type": "Race",
    "session_name": "Sprint",
    "date_start": "2024-10-19T18:00:00+00:00",
    "date_end": "2024-10-19T19:00:00+00:00",
    "meeting_key": 1247,
    "circuit_key": 9,
    "circui

Parameters

Parameter	Type	Required	Description
`session_key`	query	Optional	Identifies one session. The primary filter for nearly every other endpoint. `latest` resolves to the most recent session. `9672`
`meeting_key`	query	Optional	Identifies a race weekend, which groups several sessions. `1233`
`year`	query	Optional	Filter sessions by season. `2024`
`session_name`	query	Optional	`Practice 1`, `Qualifying`, `Sprint`, `Race` and so on. `Sprint`
`driver_number`	query	Optional	Filter to one car by its race number. `44`
`date>`	query	Optional	Comparison operators are appended to the parameter name — `date>`, `date<`, `speed>=`. This is the key to slicing telemetry. `2024-04-20T03:00:00`

Response fields

session_keyinteger: Unique id for the session. Carry this into `/laps`, `/car_data`, `/position` and the rest.
meeting_keyinteger: Id for the race weekend the session belongs to.
session_type / session_namestring: `Race` versus `Sprint` — note that a Sprint has `session_type: "Race"`, so filter on `session_name` when you mean the sprint specifically.
date_start / date_endstring: ISO 8601 with a UTC offset. Telemetry timestamps line up with these.
circuit_key / circuit_short_namestring: Circuit identifier and short label, for joining across seasons.
country_code / country_name / locationstring: Where the session was held.
gmt_offsetstring: Local timezone offset for the circuit, which matters when presenting session times to fans.

What you can build with the OpenF1 API

Build a lap-time comparison or race-pace analysis tool
Reconstruct throttle and brake traces for a single qualifying lap
Create a live-ish timing board from historical session replay
Analyse pit strategy and undercut effectiveness across a season

Common errors and how to fix them

401 during a live session

While a Formula 1 session is running, OpenF1 restricts ALL unauthenticated access — including historical data for past seasons — and returns 401 with a message pointing at a paid key.

Fix: Nothing is wrong with your request. Cache the historical data you need rather than fetching it live, and expect a free integration to go dark for the duration of every practice, qualifying, sprint and race session.

Empty array

The filters matched no records.

Fix: Check `session_key` first — a valid key for the wrong season returns nothing. Query `/sessions` and copy the key from there rather than guessing.

Enormous response

Telemetry endpoints return every sample for the whole session.

Fix: Always narrow by `driver_number` and a `date>` / `date<` window. A full session of car data for twenty cars is very large.

Sprint sessions look like races

`session_type` is `Race` for both.

Fix: Filter on `session_name` when you specifically want sprints — this is exactly what the documented example does.

OpenF1 API — frequently asked questions

Is the OpenF1 API free?

Historical data is free with no API key or account. Real-time delivery during a live session is a paid tier, but everything becomes freely available once the session has finished.

What telemetry does OpenF1 provide?

Speed, throttle, brake, gear, RPM and DRS state per car at roughly 3.7 Hz, alongside lap times, sector times, pit stops, positions, intervals and team radio. That resolution is high enough to reconstruct a lap's driving trace rather than just its result.

How do I find a session_key?

Query the `/sessions` endpoint filtered by year and session name, then read `session_key` from the result. Nearly every other endpoint is filtered by it, so this is the standard first call. Passing `latest` resolves to the most recent session.

Can I filter by a range rather than an exact value?

Yes, and it is one of the API's better features. Append a comparison operator to the parameter name — `date>`, `date<`, `speed>=` — which lets you slice a telemetry window without downloading the whole session.

Tools that pair with this API

JSON to CSV Converter

Convert a JSON array of objects to CSV online. Automatic column headers from the union of all keys, delimiter choice and proper quoting — all in-browser.

Timestamp Converter

Convert timestamps to human-readable dates and dates back to timestamps. Auto-detects seconds vs milliseconds, shows local, UTC and ISO 8601 formats.

Time Duration Calculator

Add or subtract hours, minutes and seconds, or sum a list of durations into a total shown in h:m:s and in total seconds. Free and 100% in-browser.

OpenF1 is an independent third-party service and is not affiliated with ByteTools or ByteVancer. Details on this page were verified on 2026-08-21; always check the official documentation before relying on this API in production, as terms and limits can change.