canonical: https://jentic.com/apis/openf1.org/openf1

# OpenF1 API

OpenF1 is a free REST API that exposes real-time and historical Formula 1 data including car telemetry, driver and team metadata, lap times, intervals, pit stops, race-control messages, sessions, stints, team radio, and weather. It is widely used by Formula 1 fan apps, second-screen experiences, race-strategy simulators, and analytics dashboards that need timing and telemetry without the cost of a commercial provider. All thirteen endpoints accept rich query filtering and return JSON.

## For AI agents

Pull live and historical Formula 1 telemetry, lap times, pit stops, race-control messages, and weather across 13 endpoints from a free public REST API.

## Scope

Does not handle live video, official results certification, or fantasy-league management - use for read-only Formula 1 telemetry, timing, and contextual race data only.

## Capabilities

- Stream car telemetry samples (speed, RPM, gear, throttle, brake) via /car_data with session and driver filters
- Retrieve lap times and lap-by-lap data through /laps for any session and driver
- Track gaps between cars during a session via /intervals at high refresh
- Pull pit-stop events from /pit and stint information from /stints to reconstruct race strategy
- Read race-control messages and team-radio transcripts via /race_control and /team_radio
- Look up sessions, meetings, drivers, and weather context for a Grand Prix weekend

## Use cases

### Race-Day Companion App

Build a second-screen race companion app that shows live laps, intervals, pit stops, and race-control messages while a Formula 1 session is underway. OpenF1 streams the data through query-filtered REST endpoints; the app polls /laps and /intervals every few seconds and renders a live timing tower without negotiating a commercial timing-data licence.

Example prompt: Call /laps?session_key=9999&driver_number=44 and return the most recent lap time and sector breakdown for the driver.

### Strategy Reconstruction

Reconstruct a team's race strategy from /pit, /stints, /laps, and /race_control. Useful for analyst content ("what if Mercedes had pitted on lap 18?") and for engineering students learning tyre and stint modelling. Historical sessions are indexed with stable session_key and meeting_key values so notebooks can be re-run reliably.

Example prompt: For session_key 9472, fetch /stints and group by driver_number to list compound and lap span for each stint.

### Telemetry Visualisation

Visualise raw telemetry - throttle, brake, RPM, speed, gear - via /car_data filtered by session and driver. Used by content creators and engineering tutorials to overlay driver inputs through a single corner. Sample rates are high enough for frame-by-frame charts without ingesting full broadcast feeds.

Example prompt: Call /car_data?session_key=9472&driver_number=1 with a date filter for one minute around lap 12 and chart speed over time.

### Agent-Driven F1 Q&A

An AI agent answering Formula 1 questions can use Jentic to discover the right OpenF1 endpoint for a query like "what was Verstappen's fastest lap in Bahrain 2024?". Jentic returns /laps with the input schema; the agent chooses the session_key and driver_number, sorts the response by lap_duration, and returns the answer grounded in the API.

Example prompt: Through Jentic, find the operation for "laps in a session" and call it with the resolved session_key and driver_number, returning the minimum lap_duration.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/sessions` | List F1 sessions filtered by meeting, year, or type |
| GET | `/meetings` | List Grand Prix weekends |
| GET | `/drivers` | List drivers participating in a session |
| GET | `/laps` | Get lap times and sector data |
| GET | `/intervals` | Gaps between cars during a session |
| GET | `/pit` | Pit-stop events |
| GET | `/car_data` | Per-car telemetry samples |
| GET | `/race_control` | Race-control messages |

## Key resources

- **Sessions and Meetings** — Identify Grand Prix weekends and individual practice, qualifying, and race sessions
- **Drivers** — Driver and team metadata for each session
- **Timing** — Lap times, intervals, and positions for every driver in a session
- **Telemetry** — Per-car telemetry samples - speed, throttle, brake, RPM, gear
- **Race Context** — Pit stops, stints, race-control messages, team radio, and weather

## Why Jentic

- **Setup:** Wiring the OpenF1 API by hand means shaping the session, timing, and telemetry queries with their session_key and driver_number filters and parsing the responses yourself, even though no credentials are involved. Through Jentic you install once, import the OpenF1 API from the API Directory, and your agent calls it directly.
- **Permission scoping:** OpenF1 is a read-only telemetry API with no credentials whose filters travel in the request parameters, so scope it by limiting the agent to the operations it needs, such as lap times, pit stops, or car data. You choose the operations it may call, and nothing beyond that set runs.
- **Credential handling:** OpenF1 is unauthenticated, so there is nothing to store; your Jentic One instance still routes the call through its execution layer. No secret ever enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'lap times in an F1 session' or 'pit stops in a Grand Prix', and Jentic returns the matching OpenF1 operation with its session_key and driver_number schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **SportsData.io** — Commercial multi-sport data provider including motor racing, with paid licensing
- **API-Sports** — Multi-sport data aggregator with a Formula 1 product alongside football and others
- **TheSportsDB** — Crowd-curated sports metadata including F1 teams, drivers, and event imagery

## FAQ

### What authentication does the OpenF1 API use?

OpenF1 is fully unauthenticated - no API key, OAuth token, or signed request is required. Jentic still routes the request through your Jentic One instance so observability and retry behaviour match authenticated APIs and the integration is forward-compatible if OpenF1 adds keys later.

### Can I get live timing data with the OpenF1 API?

Yes. /intervals and /laps return data within a few seconds of the live broadcast feed during sessions, and /position tracks running order in real time. Poll with the session_key for the active session and a date filter for the most recent samples.

### What are the rate limits for the OpenF1 API?

OpenF1 publishes guidance to be reasonable with polling - there is no hard documented limit but heavy real-time consumers should aggregate filters (session_key plus a tight date range) rather than scanning the dataset, and back off on HTTP 429 if returned.

### How do I find the session_key for a specific Grand Prix through Jentic?

Use the Jentic search query "list F1 sessions for a Grand Prix". Jentic returns /sessions with its query schema; the agent supplies meeting_key (resolved from /meetings by year and country) and reads the resulting session_key values. Run it through Jentic One, the self-hosted execution layer.

### Is the OpenF1 API free to use?

Yes. OpenF1 is a free public service. The project accepts donations but does not charge for API access at any tier.

### Can the OpenF1 API stream telemetry as WebSocket?

No. OpenF1 is REST-only - clients poll the relevant endpoint with a date filter to get recent samples. For low-latency consumers, narrow the time window and increase polling frequency rather than expecting a push channel.

### Can I limit what my agent is allowed to do with the OpenF1 API?

Yes. Because you run Jentic One yourself, your own rules decide which OpenF1 operations the agent may call, so you can allow only the reads it needs, such as /laps for lap times, /pit for pit stops, or /car_data for telemetry, and nothing beyond that set runs. OpenF1 is read-only with no credentials and its filters travel in the request parameters, so scoping is a matter of picking the exact operations you grant. If a task only needs timing data, the agent never gets the ability to pull car telemetry or race-control messages.