Skip to main content

​
Get Started in Minutes

This guide will help you access and explore the TracingInsights 2026 F1 data repository. No API keys or authentication required — just clone and start analyzing!
1

Clone the Repository

Clone the repository to your local machine using Git:
git clone https://github.com/TracingInsights/2026.git
cd 2026
The repository size varies depending on how many sessions have been completed in the season. Expect 1-5 GB for a full season.
Alternatively, download specific files directly from GitHub without cloning:
  • Navigate to the repository
  • Browse to the file you need
  • Click “Raw” and save the JSON file
2

Explore the File Structure

The repository is organized by Grand Prix and session type:
ls -la
You’ll see:
  • Grand Prix folders — One folder per race (e.g., Australian Grand Prix/)
  • Pre-Season Testing folders — Separate folders for testing sessions
  • Python scripts — Data extraction scripts (FP1.py, Q.py, R.py, etc.)
  • DATA_REFERENCE.md — Comprehensive field documentation
Each Grand Prix contains session folders:
cd "Australian Grand Prix"
ls -la
You’ll find:
  • Practice 1/, Practice 2/, Practice 3/
  • Qualifying/
  • Sprint Shootout/, Sprint/ (if applicable)
  • Race/
3

Navigate a Session Folder

Each session folder contains:
cd "Practice 1"
ls -la
Session-level files:
  • drivers.json — All driver and team information
  • weather.json — Weather conditions throughout the session
  • rcm.json — Race control messages (flags, DRS, penalties)
  • corners.json — Circuit corner positions and layout data
Driver folders:
  • ALB/, VER/, LEC/, etc. — One folder per driver (3-letter code)
Each driver folder contains:
  • 1_tel.json, 2_tel.json, … — Telemetry data for each lap
  • laptimes.json — Lap timing data for all laps
4

Load and Explore Data

Let’s load and inspect a JSON file. Here’s an example using Python:
import json

# Load driver information
with open('Australian Grand Prix/Practice 1/drivers.json', 'r') as f:
    drivers_data = json.load(f)

# Display driver information
for driver in drivers_data['drivers']:
    print(f"{driver['fn']} {driver['ln']} ({driver['driver']}) - {driver['team']} - #{driver['dn']}")
Example output:
Lando Norris (NOR) - McLaren - #1
Max Verstappen (VER) - Red Bull Racing - #3
Gabriel Bortoleto (BOR) - Audi - #5
Isack Hadjar (HAD) - Red Bull Racing - #6
...
All JSON files follow a consistent structure. The top-level key matches the data type (e.g., {"drivers": [...]}, {"tel": {...}}).
5

Access Telemetry Data

Telemetry data is stored per lap. Each file contains arrays of synchronized data points:
import json

# Load telemetry for Verstappen's lap 1
with open('Australian Grand Prix/Practice 1/VER/1_tel.json', 'r') as f:
    telemetry = json.load(f)

tel_data = telemetry['tel']

# Print first few data points
print(f"Time points: {len(tel_data['time'])}")
print(f"First 5 speeds: {tel_data['speed'][:5]}")
print(f"First 5 throttle values: {tel_data['throttle'][:5]}")
print(f"First 5 RPM values: {tel_data['rpm'][:5]}")
Available telemetry fields:
  • time — Time from lap start (seconds)
  • speed — Speed in km/h
  • throttle — Throttle position (0-100%)
  • brake — Brake application (0 or 1)
  • rpm — Engine RPM
  • gear — Current gear (1-8)
  • drs — DRS status
  • x, y, z — 3D position coordinates
  • distance — Distance from lap start (meters)
  • acc_x, acc_y, acc_z — Acceleration in three axes
6

Load Weather Data

Weather conditions are sampled approximately once per minute:
import json

# Load weather data
with open('Australian Grand Prix/Practice 1/weather.json', 'r') as f:
    weather = json.load(f)

# Display first weather sample
idx = 0
print(f"Session Time: {weather['wT'][idx]}s")
print(f"Air Temperature: {weather['wAT'][idx]}°C")
print(f"Track Temperature: {weather['wTT'][idx]}°C")
print(f"Humidity: {weather['wH'][idx]}%")
print(f"Rainfall: {weather['wR'][idx]}")
print(f"Wind Speed: {weather['wWS'][idx]} m/s")
Weather data uses abbreviated field names (e.g., wT, wAT, wH). See the Weather Reference for complete field explanations.

​
Common Data Access Patterns

​
Finding the Fastest Lap

To find a driver’s fastest lap, load their lap times: 
import json

# Load lap times for a specific driver
with open('Australian Grand Prix/Practice 1/VER/laptimes.json', 'r') as f:
    lap_data = json.load(f)

laps = lap_data['laps']

# Find fastest valid lap
fastest_lap = None
fastest_time = float('inf')

for i, lap_time in enumerate(laps['time']):
    if lap_time is not None and lap_time < fastest_time:
        fastest_time = lap_time
        fastest_lap = laps['lap'][i]

print(f"Fastest lap: Lap {fastest_lap} - {fastest_time:.3f}s")

​
Comparing Two Drivers

Compare telemetry from two drivers on the same lap: 
import json
import matplotlib.pyplot as plt

# Load telemetry for two drivers
with open('Australian Grand Prix/Qualifying/VER/15_tel.json', 'r') as f:
    ver_tel = json.load(f)['tel']

with open('Australian Grand Prix/Qualifying/NOR/12_tel.json', 'r') as f:
    nor_tel = json.load(f)['tel']

# Plot speed comparison
plt.figure(figsize=(12, 6))
plt.plot(ver_tel['distance'], ver_tel['speed'], label='Verstappen', color='#4781D7')
plt.plot(nor_tel['distance'], nor_tel['speed'], label='Norris', color='#F47600')
plt.xlabel('Distance (m)')
plt.ylabel('Speed (km/h)')
plt.title('Speed Comparison - Qualifying')
plt.legend()
plt.grid(True)
plt.show()

​
Analyzing Weather Impact

Correlate weather conditions with lap times: 
import json

# Load weather and lap times
with open('Australian Grand Prix/Practice 1/weather.json', 'r') as f:
    weather = json.load(f)

with open('Australian Grand Prix/Practice 1/VER/laptimes.json', 'r') as f:
    laps = json.load(f)['laps']

# Find weather at each lap time
for i, (lap_num, lap_time, session_time) in enumerate(zip(laps['lap'], laps['time'], laps['sesT'])):
    if lap_time is None:
        continue
    
    # Find closest weather sample
    closest_idx = min(range(len(weather['wT'])), key=lambda i: abs(weather['wT'][i] - session_time))
    
    print(f"Lap {lap_num}: {lap_time:.3f}s | "
          f"Air: {weather['wAT'][closest_idx]}°C | "
          f"Track: {weather['wTT'][closest_idx]}°C")

​
Working with Race Control Messages

Race control messages provide context about track conditions: 
import json

# Load race control messages
with open('Australian Grand Prix/Race/rcm.json', 'r') as f:
    rcm_data = json.load(f)

# Display all safety car periods
for i, (time, category, message, flag) in enumerate(zip(
    rcm_data['time'], 
    rcm_data['cat'], 
    rcm_data['msg'],
    rcm_data['flag']
)):
    if 'SAFETY CAR' in message.upper() or category == 'Flag':
        print(f"{time} | {category} | {message} | Flag: {flag}")

​
Next Steps

Now that you can access the data, explore more advanced topics:

Data Reference

Complete documentation of all fields and data structures

Analysis Guides

Step-by-step tutorials for common analysis tasks

Field Specifications

Detailed field reference and specifications

Python Examples

Real-world examples and visualization projects
Large Files: Telemetry files can be large (1-5 MB per lap). When processing many laps, consider streaming or lazy loading approaches to manage memory usage.

​
Need Help?

If you encounter issues or have questions:

Build docs developers (and LLMs) love

Get started for freeTalk to us