Data Sources

The TracingInsights F1 data platform aggregates data from multiple authoritative sources to provide comprehensive telemetry, timing, and session information. Understanding these sources helps you assess data quality and know what information is available.

Overview

Data is collected from three primary sources, each providing different types of information:

FastF1

Core telemetry, timing, and session data

MultiViewer

Real-time telemetry streams and position data

Ergast/Jolpica

Official race timing and historical data

Data Source Details

FastF1 - Primary Data Source

What FastF1 Provides

FastF1 is a Python library that serves as the primary data source for the majority of telemetry and timing information.Data types from FastF1:

Session information - Event names, session types, dates, and metadata
Lap timing data - Lap times, sector times, speed trap measurements
Tire information - Compound types, tire life, stint data
Weather data - Air temperature, track temperature, humidity, rainfall, wind
Driver information - Names, team assignments, car numbers
Position data - GPS coordinates (X, Y, Z) interpolated from timing data
Basic telemetry - Speed, throttle, brake, gear, RPM, DRS
Track layout - Corner positions and circuit rotation data

How It’s Used

The extraction scripts (FP1.py, FP2.py, FP3.py, Q.py, R.py, etc.) use FastF1 to:

import fastf1

# Load a session
session = fastf1.get_session(2026, 'Australian Grand Prix', 'Race')
session.load()

# Access driver laps
driver_laps = session.laps.pick_driver('VER')

# Get weather data
weather = session.weather_data

Data Processing

FastF1 data undergoes several processing steps:

Session Loading - Data is fetched from F1’s timing services
Interpolation - Position data is interpolated to match telemetry sampling rates
Validation - Accuracy flags indicate data quality
Gap Filling - Missing data may be interpolated (marked with ff1G flag)

Sampling Rate: Position data comes at ~220ms intervals, car telemetry at ~240ms intervals. FastF1 aligns these to ~270ms (3.7 Hz) for consistency.

Limitations

GPS position data is interpolated between actual measurements
Some laps may have gaps or inaccuracies (check iacc flag in laptimes.json)
Historical data quality varies by season

MultiViewer - Real-Time Telemetry

What MultiViewer Provides

The MultiViewer API provides real-time streaming data during live sessions.Data types from MultiViewer:

Live telemetry streams - Real-time car data during sessions
Position updates - Current car positions on track
Timing data - Live lap and sector times

How It’s Used

The extraction scripts fetch data from the MultiViewer API:

PROTO = "https"
HOST = "api.multiviewer.app"
HEADERS = {"User-Agent": "FastF1/"}

# API endpoint pattern
url = f"{PROTO}://{HOST}/endpoint"
response = requests.get(url, headers=HEADERS)

Integration with FastF1

MultiViewer data is primarily used to:

Supplement FastF1’s telemetry data
Provide additional real-time context
Fill gaps in position data

MultiViewer data is merged with FastF1 data during the extraction process. The final output files contain the best available data from both sources.

Ergast/Jolpica - Official Timing

What Ergast/Jolpica Provides

The Jolpica F1 API (successor to Ergast) provides official race timing data.Data types from Ergast/Jolpica:

Official lap times - FIA-certified race lap times
Race results - Final classifications and positions
Historical data - Complete historical F1 records
Championship standings - Driver and constructor points

How It’s Used

The LapTimes.py script specifically uses Ergast data for Race sessions only:

ERGAST_BASE_URL = "https://api.jolpi.ca/ergast/"

# For Race sessions: overwrite lap times with official Ergast data
ergast_times = fetch_ergast_laptimes(year, event_round)
laptimes.update(ergast_times)

When Ergast Data Is Used

Race Sessions
Practice & Qualifying

Official timing data replaces FastF1 lap times to ensure accuracy matches FIA records.The extraction process:

Fetches base lap data from FastF1
Retrieves official lap times from Ergast
Overwrites the time field with Ergast’s official values
Preserves all other telemetry and metadata from FastF1

Why Use Ergast for Races? Race lap times are official FIA records and must be exact. Ergast provides certified timing data that matches official results.

Data Extraction Process

Extraction Scripts

The repository includes Python extraction scripts that fetch and process data: Session Scripts:

FP1.py, FP2.py, FP3.py - Free Practice sessions
Q.py - Qualifying
SQ.py - Sprint Qualifying
SR.py - Sprint Race
R.py - Race
preseason.py - Pre-Season Testing

Data Scripts:

LapTimes.py - Generates laptimes.json files per driver
corner.py - Extracts circuit corner data

Extraction Workflow

Data Fetching - Scripts query FastF1, MultiViewer, and Ergast APIs
Data Merging - Information from multiple sources is combined
Processing - Calculations performed (e.g., acceleration from velocity)
Serialization - Data converted to optimized JSON format
File Writing - JSON files written to the repository structure

Computed Values

Some values are computed during extraction rather than coming directly from F1 systems: Acceleration Vectors (acc_x, acc_y, acc_z):

Calculated using gradient analysis of position, speed, and distance
Include smoothing (3-point and 9-point moving averages)
Apply outlier filtering to remove unrealistic values
Not raw IMU sensor data - mathematically derived

From the extraction script comments:

# Longitudinal acceleration: gradient of velocity
ax = gradient(v_ms) / gradient(time)

# Lateral acceleration: v² × curvature
ay = v² × C  # where C = dθ / (ds + 0.0001)

# Apply smoothing and outlier removal
ax = moving_average(ax, kernel_3)  # 3-point smoothing
ay = moving_average(ay, kernel_9)  # 9-point smoothing

Acceleration data includes multi-stage outlier handling. Values exceeding realistic thresholds (~15G for lateral/vertical, 25 m/s² for longitudinal) are replaced or zeroed.

Data Update Frequency

Real-Time Updates

Data is typically updated 30 minutes after each session ends. Timeline:

Session ends (e.g., Race finishes)
30-minute wait - Allows F1’s systems to finalize timing data
Extraction runs - Scripts fetch data from all sources
Repository updated - New JSON files pushed to GitHub

The 30-minute delay ensures that official timing corrections and penalties are reflected in the data.

Historical Data

Historical seasons are complete and static. Updates only occur if:

Corrections are needed
Data quality improvements are made
New processing methods are applied

Data Quality Considerations

Accuracy Indicators

Each lap in laptimes.json includes quality flags:

iacc (Is Accurate) - Basic timing accuracy check passed
ff1G (FastF1 Generated) - Data was interpolated or filled by FastF1
del (Deleted) - Lap was deleted by stewards (e.g., track limits)
delR (Deleted Reason) - Reason for deletion

Known Limitations

Position Data: X, Y, Z coordinates are interpolated from GPS measurements, not continuous tracking. Precision is approximately ±2-3 meters.

Acceleration Data: Computed values, not direct sensor readings. Includes smoothing and filtering that may mask brief spikes.

Weather Sampling: Recorded approximately once per minute. Rapid weather changes may not be fully captured.

Best Practices

Check accuracy flags before analyzing lap times
Cross-reference sectors - If a lap time seems wrong, check individual sector times
Compare multiple laps - Single-lap anomalies can be identified by comparing to nearby laps
Consider track status - Yellow flags and safety cars affect lap validity

External Documentation

For detailed technical documentation about each data source:

FastF1 Docs

API reference, tutorials, and data accuracy information

MultiViewer

Real-time telemetry streaming documentation

Jolpica F1 API

Official timing data API reference

Dependencies

The extraction scripts require the following Python packages:

fastf1
numpy
pandas
requests
orjson
psutil

See /requirements.txt in the source repository for complete dependencies.

Introduction

Understanding the Data

Overview

FastF1

MultiViewer

Ergast/Jolpica

Data Source Details

What FastF1 Provides

How It’s Used

Data Processing

Limitations

What MultiViewer Provides

How It’s Used

Integration with FastF1

What Ergast/Jolpica Provides

How It’s Used

When Ergast Data Is Used

Data Extraction Process

Extraction Scripts

Extraction Workflow

Computed Values

Data Update Frequency

Real-Time Updates

Historical Data

Data Quality Considerations

Accuracy Indicators

Known Limitations

Best Practices

External Documentation

FastF1 Docs

MultiViewer

Jolpica F1 API

Dependencies

Build docs developers (and LLMs) love

Introduction

Understanding the Data

​Overview

FastF1

MultiViewer

Ergast/Jolpica

​Data Source Details

​What FastF1 Provides

​How It’s Used

​Data Processing

​Limitations

​What MultiViewer Provides

​How It’s Used

​Integration with FastF1

​What Ergast/Jolpica Provides

​How It’s Used

​When Ergast Data Is Used

​Data Extraction Process

​Extraction Scripts

​Extraction Workflow

​Computed Values

​Data Update Frequency

​Real-Time Updates

​Historical Data

​Data Quality Considerations

​Accuracy Indicators

​Known Limitations

​Best Practices

​External Documentation

FastF1 Docs

MultiViewer

Jolpica F1 API

​Dependencies

Build docs developers (and LLMs) love

Overview

Data Source Details

What FastF1 Provides

How It’s Used

Data Processing

Limitations

What MultiViewer Provides

How It’s Used

Integration with FastF1

What Ergast/Jolpica Provides

How It’s Used

When Ergast Data Is Used

Data Extraction Process

Extraction Scripts

Extraction Workflow

Computed Values

Data Update Frequency

Real-Time Updates

Historical Data

Data Quality Considerations

Accuracy Indicators

Known Limitations

Best Practices

External Documentation

Dependencies