# OpenF1 Live Data MCP > OpenF1 Live Data & Telemetry gives your AI client access to granular, real-time Formula 1 data. You can read car telemetry (RPM, DRS usage), audit lap times and sector performance, track team radio comms, and map out tire strategies across the entire field. It's a full analyst toolkit for race data. ## Overview - **Category:** data-analytics - **Price:** Free - **Tags:** formula-1, telemetry, race-data, real-time-monitoring, lap-times, car-performance ## Description This server hands your AI client the keys to every piece of live Formula 1 data out there. You'll get granular access to real-time telemetry and historic race metrics without having to write complicated API calls. It’s a full analyst kit for tracking everything that goes down on track. **Live Car Performance Metrics** You can grab the raw technical readouts using `get_car_telemetry`, which pulls speed, engine RPM, and DRS usage for any car in a session. If you're checking out race strategy, `list_pit_stops` gives you specific data on how long every car spent in the pits. You can map out tire strategies by listing full history of tire compounds used and stint lengths across multiple drivers using `list_tyre_stints`. To really compare performance, use `get_lap_times` to get detailed lap and sector times for any session you specify. **Analyze Sector and Lap Consistency** Comparing how fast a driver runs through certain parts of the track is easy. You'll check out precise performance gaps between drivers by using `get_driver_intervals`, which calculates time gaps between cars on the circuit. For comprehensive comparison, `get_lap_times` lets you get detailed sector times for specified laps or sessions. To see how the whole field stacks up, run `list_drivers` to list all active F1 drivers participating in a given session. **Build Pre-Race Context** before the lights go out, you can check the starting order with `get_starting_grid`. You'll pull the current championship status for both individuals and teams using `get_driver_standings` and `get_team_standings`, respectively. For context on what to expect, use `get_weather_data` to get specific track and surrounding air weather conditions for race days. **Audit Race Incidents & Communication** You can follow the narrative of the race using `get_team_radio`, which retrieves links to recorded team radio communications between drivers and pit crews. For official warnings or penalties, you'll pull data from `get_race_control_messages`, which fetches official FIA messages regarding track limits or warnings. You don't wanna miss a major move; use `list_overtakes` to compile every recorded overtake incident that happened during the race. If you need final results for a completed run, `get_session_results` provides the classification and results immediately. **Mapping Out Sessions** You can see what data is available by running `list_sessions`, which gives you a list of all recorded F1 sessions within a specific year. To understand who was involved in any given event, run `list_drivers`. If you're investigating the whole race day, `get_session_results` provides final classification and results for that entire session. **The Full Scope** This server also lets you check out initial championship data by running `get_driver_standings` or `get_team_standings`. You've got the means to track every detail, from getting historical records using `list_sessions`, to viewing all recorded team radio comms via `get_team_radio`. It’s a complete set of tools for any kind of F1 analysis you wanna run. ## Tools ### get_car_telemetry Retrieves technical telemetry data, including speed, RPM, and DRS usage for a specific car. ### get_driver_intervals Calculates the time gaps and intervals between different drivers on track. ### get_driver_standings Fetches the current championship standings for all F1 drivers. ### get_lap_times Gets detailed lap and sector times for specified laps or sessions. ### get_race_control_messages Retrieves official FIA race control messages regarding track limits, penalties, or warnings. ### get_session_results Provides the final classification and results for a completed racing session. ### get_starting_grid Gets the initial grid position list and starting order for an upcoming race. ### get_team_radio Retrieves links to recorded team radio communications between drivers and pit crews. ### get_team_standings Gets the current championship standing for all F1 teams. ### get_weather_data Provides specific track and surrounding air weather conditions for race days. ### list_drivers Lists all active F1 drivers participating in a given session. ### list_overtakes Compiles and lists every recorded overtake incident that occurred during the race. ### list_pit_stops Lists specific data points regarding pit stop durations for various cars. ### list_sessions Provides a list of all recorded F1 sessions available within a given year. ### list_tyre_stints Lists the full history of tire compounds used and stint lengths for multiple drivers. ## Prompt Examples **Prompt:** ``` Get the technical telemetry for Max Verstappen in the latest session. ``` **Response:** ``` I've retrieved Verstappen's high-frequency telemetry. At the last sample, he was at 312 km/h in 7th gear at 11,200 RPM with DRS active. I also have his throttle and brake traces. Would you like to compare this to his previous lap? ``` **Prompt:** ``` Analyze the tire strategy for the top 5 drivers in the current session. ``` **Response:** ``` Running the stint query... I found that Verstappen and Norris are currently on Mediums (8 laps old), while Hamilton has just pitted for new Hards. I have the full stint history for the top 5. Would you like to see the projected life of their current sets? ``` **Prompt:** ``` Provide all race control messages involving 'Track Limits' from lap 10 onwards. ``` **Response:** ``` Inspecting FIA updates... I found 3 messages regarding Track Limits since lap 10. Drivers warned include Perez at Turn 4 and Leclerc at Turn 12. No penalties have been issued yet. Shall I continue monitoring for specific driver numbers? ``` ## Capabilities ### Retrieve Live Car Performance Metrics Get real-time telemetry, including speed, engine RPM, and DRS usage, for any car during a session. ### Map Race Strategy and Pit Stops Track tire compounds, stint lengths, and detailed pit stop durations across all cars to map out race strategy. ### Analyze Sector and Lap Consistency Compare sector times (S1, S2, S3) and lap-by-lap data instantly to pinpoint precise performance gaps between drivers. ### Audit Race Incidents & Communication Follow team radio communications or official race control updates in real time to understand the flow of incidents and warnings. ### Build Pre-Race Context Pull initial data points like the starting grid, current standings, and predicted weather conditions before the race starts. ## Use Cases ### Investigating a suspicious pit stop A fan noticed Max seemed slow on lap 40. Instead of just reading the race summary, your agent runs `list_pit_stops` and combines it with `get_car_telemetry`. You instantly see that his average speed dropped significantly *after* he left the pit box, suggesting a mechanical issue or tire setup problem. ### Analyzing track limits violations You're writing a piece on race control discipline. Instead of combing through old FIA reports, your agent runs `get_race_control_messages` for 'Track Limits' since lap 10. You get an instant list of drivers and the specific turn number cited, making reporting precise. ### Modeling tire degradation over a wet race The rain started late in the session. Your agent uses `list_tyre_stints` to see which cars were on older compounds and combines this with `get_weather_data`. You can predict which car will struggle most when the dry track returns. ### Comparing team performance across eras You want to compare Red Bull's 2019 season versus their current run. Your agent runs `get_team_standings` for both years and uses `list_sessions` to pull historical data, allowing you to benchmark consistency over time. ## Benefits - Track performance gaps by running `get_lap_times` and comparing sector times (S1, S2, S3). This pinpoints exactly where a driver loses time—whether it’s braking or corner exit speed. It's better than just looking at the final lap differential. - Build complex race narratives using `list_tyre_stints`. You can model how tire wear interacts with track conditions and pit stop timing, moving beyond simple 'Medium vs Hard' observations to genuine strategy auditing. - Understand *why* a race happened by checking official comms. Use `get_race_control_messages` and `get_team_radio` to see the immediate context of incidents or penalties that might not show up in the final classification. - Get full pre-race clarity using `get_starting_grid` alongside `get_weather_data`. You'll know if the predicted wet conditions will affect pole position, giving you a complete picture before the race even starts. - Track every move on track. Beyond just who finished where (`get_session_results`), use `list_overtakes` and `get_driver_intervals` to quantify the drama—knowing exactly how many times one car passed another and by how much margin. ## How It Works The bottom line is you get deep technical intelligence on F1 racing without writing a single query. 1. Connect your AI client to the OpenF1 MCP Server. No API key is required for public access. 2. Ask your agent a specific question (e.g., 'What was Hamilton's best lap time at Silverstone?'). 3. The agent runs the necessary tool (`get_lap_times` or `list_pit_stops`) and presents the structured data and analysis directly in conversation. ## Frequently Asked Questions **How do I check performance gaps between drivers using get_driver_intervals?** Run `get_driver_intervals` and specify the session. It immediately shows you the time difference (the gap) between cars at any point on the track, allowing direct comparison. **What is the best way to audit tire wear using list_tyre_stints?** Use `list_tyre_stints` to get the full stint history. You can then combine this data with `get_lap_times` to see if the lap time degradation matches the expected wear pattern. **Can I find out what happened when a car was penalized? (get_race_control_messages)** Yes. Run `get_race_control_messages`, filtering by 'Penalty' or specific driver numbers, to retrieve the exact message and timing of the infraction from official FIA records. **Does get_car_telemetry include throttle data?** Yes. It provides high-frequency metrics including throttle application percentage (throttle traces), which is key for understanding driver input during corner exit and braking zones. **How do I use get_driver_standings to check a driver's current championship placement?** It returns the latest points and overall rankings for all drivers. You get their total accumulated season points, score from the most recent race, and their standing relative to the top competitors. **How do I find out which F1 sessions are available using list_sessions?** It provides a comprehensive list of past and upcoming race weekends. You get the specific dates, track locations, and session types (Practice, Qualifying, Race). This is how you target your data requests. **What kind of context does get_weather_data provide for an analysis?** It pulls both track and ambient air weather metrics. You retrieve temperature readings, wind speed, and general conditions for the race day. This helps you contextualize performance gaps in your reporting. **What does list_overtakes track during a race?** It logs every recorded pass between two cars. You get the specific lap number, both vehicles involved, and the calculated gap size at the time the overtake occurred. This is useful for analyzing corner exit speed. **Can my AI automatically analyze technical performance gaps between two specific drivers in a session?** Yes! By using tools like `get_lap_times` and `get_car_telemetry`, your agent can compare sector-by-sector data, top speeds, and braking points to identify exactly where one driver is gaining or losing time compared to another. **How do I easily listen to or read the team radio communications during a race weekend?** Simply ask the agent to run the `get_team_radio` tool for a specific session and driver. It will retrieve direct URLs to the official audio recordings, allowing you to hear the narrative between drivers and engineers. **Does the integration permit tracking official FIA race control decisions in real-time?** Yes. The `get_race_control_messages` action allows your agent to fetch all official updates, including yellow flags, steward investigations, and track limit warnings, mapped to specific lap numbers.