Skip to main content
After obtaining a Session object, you need to load the actual data using the load() method. This page explains the loading process and what data becomes available.

​
The load() Method

The Session.load() method is the primary way to fetch data from the F1 APIs: 
import fastf1

session = fastf1.get_session(2023, 'Monaco', 'Q')
session.load()  # Load all available data

​
Method Signature

session.load(
    *,
    laps: bool = True,
    telemetry: bool = True,
    weather: bool = True,
    messages: bool = True,
    livedata: LiveTimingData = None
)
​
laps
bool
default:"True"
Load lap timing data and session status. This includes:
  • Individual lap times for all drivers
  • Sector times
  • Pit stop information
  • Track status
  • Session status
​
telemetry
bool
default:"True"
Load telemetry data including:
  • Car data (speed, RPM, throttle, brake, gear, DRS)
  • Position data (X, Y, Z coordinates)
  • Timing information
​
weather
bool
default:"True"
Load weather data such as:
  • Air temperature
  • Track temperature
  • Wind speed and direction
  • Humidity
  • Rainfall
​
messages
bool
default:"True"
Load race control messages including:
  • Track status changes
  • Penalties
  • Deleted lap times
  • Other official race communications
​
livedata
LiveTimingData
default:"None"
Optional: Use locally saved live timing data instead of fetching from the API

​
Data Types Available

Depending on which parameters you enable, different data becomes available after loading.

​
Selective Loading

You can load only specific types of data to save time: 
# Fast loading - only timing data
session.load(laps=True, telemetry=False, weather=False, messages=False)
laps = session.laps
Loading all data is recommended for full functionality. FastF1 internally mixes data from multiple sources to correct errors and add additional information.

​
Available Data After Loading

Once loaded, various properties become accessible:

​
Lap Timing Data

Available when laps=True: 
session.load(laps=True)

# Access all laps
laps = session.laps  # Laps object (DataFrame-like)

# Driver list
drivers = session.drivers  # List of driver numbers as strings

# Session information
results = session.results  # SessionResults with driver info
total_laps = session.total_laps  # Total number of laps (race/sprint only)

# Session status and timing
session_status = session.session_status  # DataFrame
track_status = session.track_status  # DataFrame
session_start = session.session_start_time  # Timedelta

​
Telemetry Data

Available when telemetry=True: 
session.load(telemetry=True)

# Car data by driver number (as strings)
car_data = session.car_data  # Dict[str, Telemetry]
ver_car_data = session.car_data['1']  # Verstappen's car data

# Position data by driver number
pos_data = session.pos_data  # Dict[str, Telemetry]
ver_pos_data = session.pos_data['1']  # Verstappen's position data

# Reference timestamp
t0 = session.t0_date  # Timestamp marking start of data stream

​
Weather Data

Available when weather=True: 
session.load(weather=True)

weather = session.weather_data  # DataFrame with weather measurements

# Weather data columns:
# - Time: Session time
# - AirTemp: Air temperature (°C)
# - TrackTemp: Track temperature (°C) 
# - Humidity: Relative humidity (%)
# - Pressure: Air pressure (mbar)
# - WindSpeed: Wind speed (m/s)
# - WindDirection: Wind direction (degrees)
# - Rainfall: Whether it's raining (boolean)

​
Race Control Messages

Available when messages=True: 
session.load(messages=True)

messages = session.race_control_messages  # DataFrame

# Message data includes:
# - Time: When the message was sent
# - Category: Message category
# - Message: Full message text
# - Status: Track/session status
# - Flag: Any flag information

​
Data Sources and Backends

FastF1 supports multiple data sources (backends):

​
FastF1 Backend (Default)

The default backend provides the most complete data for 2018-present: 
session = fastf1.get_session(2023, 'Monza', 'R', backend='fastf1')
session.load()
  • Full telemetry support
  • Complete timing data
  • Weather information
  • Race control messages

​
F1 Timing Backend

Direct access to F1’s live timing API: 
session = fastf1.get_session(2023, 'Silverstone', 'Q', backend='f1timing')
session.load()
  • Same data as FastF1 backend
  • Only sessions with live timing available
  • 2018-present

​
Ergast Backend

Historical data from the Ergast database: 
session = fastf1.get_session(2005, 'Monaco', 'R', backend='ergast')
session.load()
  • Supports 1950-present
  • No telemetry data
  • No local timestamps
  • Limited to basic race results and lap times
For seasons before 2018, the Ergast backend is used automatically. Telemetry and detailed timing data are not available for these seasons.

​
Understanding Loaded Data

After loading, you can verify what data is available: 
import fastf1

session = fastf1.get_session(2023, 'Spa', 'R')
session.load()

# Check what's available
print(f"Number of drivers: {len(session.drivers)}")
print(f"Drivers: {session.drivers}")
print(f"Total laps in session: {len(session.laps)}")
print(f"F1 API support: {session.f1_api_support}")

# Session metadata
print(f"Session: {session.event.EventName} - {session.name}")
print(f"Date: {session.date}")

​
Live Timing Data

You can save live timing data during a session and replay it later: 
from fastf1.livetiming.data import LiveTimingData

# Save live timing data (during live session)
livedata = LiveTimingData('path/to/save')
# ... data is saved automatically ...

# Replay saved data later
session = fastf1.get_session(2023, 'Monaco', 'Q')
session.load(livedata=livedata)
This is useful for:
  • Replaying sessions without internet
  • Consistent data for testing
  • Archiving specific sessions

​
Performance Considerations

​
Loading Time

Loading data can take time, especially for races with full telemetry: 
import time

start = time.time()
session.load()
end = time.time()
print(f"Loading took {end - start:.2f} seconds")
Typical loading times:
  • Qualifying (with telemetry): 30-60 seconds
  • Race (with telemetry): 60-120 seconds
  • Practice (with telemetry): 40-90 seconds

​
Optimization Tips

Always enable caching to avoid re-downloading data:
import fastf1

fastf1.Cache.enable_cache('path/to/cache')
session = fastf1.get_session(2023, 'Monaco', 'Q')
session.load()  # First load: downloads data

# Later...
session = fastf1.get_session(2023, 'Monaco', 'Q')
session.load()  # Subsequent loads: uses cache, much faster!
See Caching for more details.
If you only need lap times, skip telemetry:
# Much faster - only loads timing data
session.load(laps=True, telemetry=False, weather=False, messages=False)
Load multiple sessions in parallel:
from concurrent.futures import ThreadPoolExecutor

def load_session(year, gp, identifier):
    session = fastf1.get_session(year, gp, identifier)
    session.load()
    return session

with ThreadPoolExecutor(max_workers=3) as executor:
    sessions = executor.map(
        lambda args: load_session(*args),
        [(2023, 1, 'FP1'), (2023, 1, 'FP2'), (2023, 1, 'FP3')]
    )

​
Error Handling

Some sessions may fail to load or have missing data: 
import fastf1
from fastf1.exceptions import DataNotLoadedError, NoLapDataError

try:
    session = fastf1.get_session(2023, 'Monaco', 'Q')
    session.load()
    laps = session.laps
except NoLapDataError:
    print("No lap data available for this session")
except Exception as e:
    print(f"Error loading session: {e}")
FastF1 uses “soft exceptions” for some errors, logging warnings instead of raising exceptions. Check logs for warnings about missing or incomplete data.

​
What’s Next?

Now that you know how to load data, explore what you can do with it:
  • Lap Timing - Analyze lap times and sector data
  • Telemetry - Work with car telemetry data
  • Caching - Speed up data loading with caching

Build docs developers (and LLMs) love

Get started for freeTalk to us