Building Interactive F1 Racing Dashboards with Streamlit and Open F1 Race Data

What if you could transform the complex, granular world of F1 racing data into an intuitive, interactive dashboard, allowing for real-time exploration and analysis? I've often found myself drowning in static CSVs or endlessly tweaking Jupyter notebooks, wishing for a more dynamic way to explore and understand the data. After grappling with complex time series cross-validation strategies for F1 race data in a previous project, I realized that while advanced analytics are crucial, the initial exploration and ongoing monitoring often demand a more intuitive interface. This led me to a new challenge: building an interactive, real-time dashboard using Streamlit and the Open F1 Race Data API. In this post, I'll walk you through how I transformed raw event logs into a dynamic, explorable dashboard, demonstrating how to move beyond static reports to truly informed decision-making.

Key Takeaways

Streamlit provides a rapid development cycle for interactive web applications, making it ideal for data exploration dashboards.
Aggregating and preprocessing data from the Open F1 Race Data API is crucial for creating a meaningful and interactive dashboard.
Interactive dashboards can significantly enhance the exploratory data analysis process, allowing for more informed decision-making.
Streamlit's simplicity and flexibility make it an excellent choice for building custom, data-driven applications.
Combining Streamlit with real-time data sources like the Open F1 Race Data API enables the creation of dynamic, up-to-date dashboards.

Data and Sources

The Open F1 Race Data API (https://api.openf1.org/v1/meetings?year=2024) provides a comprehensive dataset of F1 racing meetings, including meeting names, locations, and country codes. Data accessed on 2026-08-07. For this project, we'll be using the `requests` library to fetch the data and Pandas for preprocessing.

Step 1 — Fetching and Preprocessing Open F1 Race Data

To begin, we need to fetch the data from the Open F1 Race Data API and preprocess it for our dashboard. This involves sending a GET request to the API endpoint and parsing the JSON response.

import requests
import pandas as pd

response = requests.get("https://api.openf1.org/v1/meetings?year=2024")
data = response.json()

# Convert the data to a Pandas DataFrame
df = pd.DataFrame(data)

Step 2 — Creating a Streamlit App

Next, we'll create a basic Streamlit app to serve as the foundation for our interactive dashboard. This involves importing Streamlit and using its functions to create a simple web application.

import streamlit as st

# Create a title for the app
st.title("F1 Racing Data Dashboard")

# Add a text input for the user to select a meeting
meeting_name = st.text_input("Select a meeting:")

Step 3 — Visualizing F1 Racing Data

With the data fetched and the app created, we can now focus on visualizing the F1 racing data. This involves using Streamlit's built-in functions to create interactive charts and tables.

import matplotlib.pyplot as plt

# Create a line chart to display the meeting names
fig, ax = plt.subplots()
ax.plot(df["meeting_name"])
st.pyplot(fig)

Putting It Together

Now that we have all the components, let's put them together to create a fully functional interactive dashboard. This involves combining the data fetching, preprocessing, and visualization steps into a single Streamlit app.

if __name__ == "__main__":
    response = requests.get("https://api.openf1.org/v1/meetings?year=2024")
    data = response.json()
    df = pd.DataFrame(data)

    st.title("F1 Racing Data Dashboard")
    meeting_name = st.text_input("Select a meeting:")

    fig, ax = plt.subplots()
    ax.plot(df["meeting_name"])
    st.pyplot(fig)

Complete Script

The full runnable script combining all steps:

#!/usr/bin/env python3
import requests
import pandas as pd
import streamlit as st
import matplotlib.pyplot as plt

def fetch_data():
    response = requests.get("https://api.openf1.org/v1/meetings?year=2024")
    data = response.json()
    return pd.DataFrame(data)

def create_app(df):
    st.title("F1 Racing Data Dashboard")
    meeting_name = st.text_input("Select a meeting:")

    fig, ax = plt.subplots()
    ax.plot(df["meeting_name"])
    st.pyplot(fig)

if __name__ == "__main__":
    df = fetch_data()
    create_app(df)

Expected Output

When you run the script, you should see an interactive dashboard with a line chart displaying the meeting names. You can select a meeting from the text input to filter the data.

Limitations and Tradeoffs

While this approach provides an interactive and dynamic way to explore F1 racing data, it has some limitations. The Open F1 Race Data API may have usage limits or require authentication for heavy usage. Additionally, the dashboard may become slow or unresponsive with large datasets. To address these limitations, you could consider using a more robust data storage solution or optimizing the dashboard for performance.

Frequently Asked Questions

How do I handle errors when fetching data from the API?

You can use try-except blocks to catch and handle exceptions when fetching data from the API. For example, you can catch the `requests.exceptions.RequestException` exception to handle network errors.

try:
    response = requests.get("https://api.openf1.org/v1/meetings?year=2024")
    response.raise_for_status()
except requests.exceptions.RequestException as e:
    print(f"Error fetching data: {e}")

How do I customize the appearance of the dashboard?

You can customize the appearance of the dashboard using Streamlit's built-in functions, such as `st.title()`, `st.header()`, and `st.write()`. You can also use CSS to customize the layout and styling of the dashboard.

Can I use this approach for other types of data?

Yes, you can use this approach for other types of data. Simply replace the Open F1 Race Data API with your own data source and modify the preprocessing and visualization steps to suit your data.

What I'd Change

In retrospect, I would focus on optimizing the dashboard for performance and scalability. This could involve using a more robust data storage solution, such as a database, and optimizing the visualization steps to handle large datasets. Additionally, I would consider adding more interactive features, such as filtering and sorting, to enhance the user experience.

Py Data