Skip to content

mclarenmp4-22/f1resultsdatabase

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

37 Commits
__pycache__
__pycache__
 
 
.gitignore
.gitignore
 
 
README.md
README.md
 
 
deleteseason.py
deleteseason.py
 
 
downloaddb.py
downloaddb.py
 
 
requirements.txt
requirements.txt
 
 
reset.py
reset.py
 
 
writedb.py
writedb.py
 
 

Repository files navigation

If you're an F1 nerd like me, sometimes questions arise in your mind:

  • When was the last time two people shared a car in a Grand Prix?

  • Both the Toyotas were on dry tyres at the end of the 2008 Brazilian Grand Prix, so how did Glock's lap times compare to Trulli's?

  • What were the fastest and slowest lap times ever?

  • How many laps have been raced in Formula One history?

  • How much distance has Formula One raced?

  • What was the race with the most shared cars ever?

  • How many laps in Formula One have been under the safety car/virtual safety car?

Some of this questions cannot be answered by search engines unfortunately.

So, if you're a programmer like me, your answer is just a few SELECTs away.

Or, you can do some cool data analysis with all this data.

Note:

This database has every single Grand Prix part of the World Championship. It does not contain non-Championship Grands Prix. When the word "Grand Prix" is used here, it refers to a World Championship Grand Prix. Similarly, when the word "Formula One", "F1", "Formula 1", or any of its variants have been used here, it refers to the World Championship, even though the 1952 and 1953 seasons were run to F2 regulations. The terms "Formula One", "Grand Prix", and "World Championship" are used synonymously.

Formula 1 and related trademarks are the property of their respective owners.

This is the most comprehensive F1 database with:

  • Every World Championship Grand Prix result since 1950.
  • Detailed lap-by-lap data positions from 1950 onwards, lap times from 1996 onwards, sector times, tyre compounds, and stints from 2018 onwards.
  • Full session coverage: Complete results for Practice, Qualifying, Sprints, and Races.
  • Accurate historical data: Includes shared car results, pre-qualifying, and vintage scoring systems.
  • Pit stop summary: Includes pit stop data from 1983 onwards, including pit stop times from 2018 onwards.
  • Technical Regulations: Season-by-season rules on engines, weight, fuel, and more.
  • Circuit Metadata: coordinates and SVG layout paths for every circuit configuration in history.
  • Comprehensive Penalties: A full database of penalties with official reasons and serving types.
  • In-Season Progress: Track the championship standings race-by-race.
  • Race Reports: Narrative reports for every Grand Prix, from Wikipedia.

Download the latest version:

To download the latest version of the database, please visit this link: https://drive.google.com/file/d/1M3ijJIWDEGqGOw4Prx2AXFhts2cv-J1d/view

OR

pip install gdown 
python download_db.py

Last updated: 2026 Japanese Grand Prix

Update the database:

If you want to update the database, all you need to do is run this command:

pip install beautifulsoup4
python writedb.py

Update race reports only:

If you only want to refresh race reports in the RaceReports table, you can use:

python writedb.py --updateracereport

It must be noted that the Wikipedia REST API only supports 500 requests per hour so you might hit rate limits.

To update race reports for a single season:

python writedb.py --updateracereport 2025

or:

python writedb.py --updateracereport season 2025

To update race reports from a season onward:

python writedb.py --updateracereport from 2025

or:

python writedb.py --updateracereport from season 2025

To update just one race report:

python writedb.py --updateracereport "2026 Japanese Grand Prix"

or:

python writedb.py --updateracereport race "2026 Japanese Grand Prix"

To update race reports from a specific race onward:

python writedb.py --updateracereport from "2026 Japanese Grand Prix"

or:

python writedb.py --updateracereport from race "2026 Japanese Grand Prix"

Race names are matched case-insensitively. This command updates only the RaceReports table and does not run the full database update flow.

Reset/initialise the database:

If, for whatever reason, you want to wipe out all the data in the database or you want to create the database with all the tables and columns, run this command:

python reset.py

Delete a specific season:

If you want to delete data for a single season (e.g. to re-scrape it), run:

python deleteseason.py <year>

This will remove all races, results, and standings for that year while keeping the rest of the database intact.

Tables

Note:

  • For boolean values, SQLite takes 1 to be true and 0 to be false. true and false used here refers to 1 and 0.
  • "Entries" used here refers to a driver being on the entry list for a Grand Prix, even if the driver did not take part in any of the sessions, it gets counted as an "entry" for the driver, the constructor, the team, the engine make, the engine model, the chassis, and the tyre supplier.

  1. Seasons

    This table contains a set of all seasons in F1, from 1950 to the present day.
    Columns:

    • Season: The year (e.g. 1982). INTEGER PRIMARY KEY
    • DriversRacesCounted: How many races counted for drivers. TEXT

    From 1950 till 1990, you could drop your worst results. In other words, say, for a season, only the points collected for a driver's best 11 races would count towards the championship. It could also be like the best 6 races from the first 7 races, and the best 7 results from the last eight races counted towards the championship.

    Values can range from "Best 11 scores." to

    "Best 5 scores from first 7 races.

    Best 5 scores from last 7 races."

    to "All scores and points are doubled for the last Grand Prix." for the 2014 season. If all races are counted, the value is "All scores."

    • PointsSharedForSharedCars: Whether points were shared for shared cars. BOOLEAN

    From 1950 till 1957, drivers who shared the same car would have their points shared proportionate to the laps they drove. In other words, Driver A could do 20 laps in a Grand Prix and Driver B would do the other 40 laps. Points would be shared accordingly to both drivers, although it would get a bit complicated. To see an example of this, you may see the results of the 1955 Argentine Grand Prix.

    The value is true if points were shared for shared cars and false if points were not shared for shared cars.

    • GrandPrixPointsSystemDrivers: Points system for drivers. (JSON) TEXT

    For any row, the data is stored in the following format:

    Keys: Position (as a string, e.g, "1")/ "Fastest Lap"/ "Fastest Lap (only for finishing in the top 10)" (2019-2024, where the fastest lap point was only awarded for finishing in the top ten)

    Values: the points alloted for that specific position or fastest lap.

    For the 1959 season, the value would be:

    {"1": 8, "2": 6, "3": 4, "4": 3, "5": 2, "Fastest Lap": 1}
    • SprintPointsSystemDrivers: Sprint points system for drivers. (JSON) TEXT

    For any row, the data is stored in the following format:

    Keys: Position (as a string, e.g, "1")

    Values: the points alloted for that specific position.

    For the 2025 season, the value would be:

    {"1": 8, "2": 7, "3": 6, "4": 5, "5": 4, "6": 3, "7": 2, "8": 1}
    • ConstructorsRacesCounted: How many races counted for constructors. TEXT

    From 1958 (the first year the Constructors' Championship was awarded) till 1978, you could drop your worst results. In other words, say, for a season, only the points collected for a constructor's best 11 races would count towards the championship. It could also be like the best 6 races from the first 7 races, and the best 7 results from the last eight races counted towards the championship.

    Values can range from "Best 11 scores." to

    "Best 5 scores from first 7 races.

    Best 5 scores from last 7 races." to "All scores and points are doubled for the last Grand Prix." for the 2014 season. If all races are counted, the value is "All scores."

    • PointsOnlyForTopScoringCar: Only top scoring car counted for constructors. BOOLEAN

    From 1958 till 1978 only the highest finishing car of a Constructor would be awarded points. For example, if the cars of a particular Constructor finished fourth and fifth, only the points scored for fourth place would count towards the Constructors' Championship.

    The value is true if points were only given towards the Constructors' Championship for the highest placed car and false if points were not given towards the Constructors' Championship for the highest placed car.

    • GrandPrixPointsSystemConstructors: Points system for constructors. (JSON) TEXT

    It is important to note that the same points system wasn't always used for the Drivers' and Constructors' Championship. In 1959 and 1960, the point for Fastest Lap didn't count towards the Constructors' Championship, hence the necessity for this column.

    For any row, the data is stored in the following format:

    Keys: Position (as a string, e.g, "1")/ "Fastest Lap (only for finishing in the top 10)" (2019-2024, where the fastest lap point was only awarded for finishing in the top ten)

    Values: the points alloted for that specific position or fastest lap.

    For the 2024 season, the value would be:

    {"1": 8, "2": 7, "3": 6, "4": 5, "5": 4, "6": 3, "7": 2, "8": 1}
    • SprintPointsSystemConstructors: Sprint points system for constructors. (JSON) TEXT

    For any row, the data is stored in the following format:

    Keys: Position (as a string, e.g, "1")

    Values: the points alloted for that specific position.

    For the 2021 season, the value would be:

    {"1": 3, "2": 2, "3": 1}
    • RegulationNotes: Notes about regulations for that season. (JSON) TEXT

    The notes are in the form of an array. For the 2020 season, the value would be:

    ["On 7 August 2020, following a protest by Renault at the Styria GP, the International Automobile Federation's stewards withdrew 15 points from Racing Point for copying the design of Mercedes' brake scoops.", "Qualifying is divided into 3 sessions.", "At the end of the first 18-minute session (Q1), the 5 slowest drivers are eliminated and placed on positions 16 to 20.", "At the end of the second 15-minute session (Q2), the 5 slowest drivers are eliminated and placed on positions 11 to 15.", "A final session (Q3) lasting 12 minutes determines positions 1 to 10 for the 10 remaining drivers.", "At the end of Q1, drivers whose time exceeds 107% of the best time do not qualify."]
    • MinimumWeightofCars: Minimum car weight. TEXT

    The values can vary from "500 kg" to "500 kg (naturally aspirated) or 540 kg (supercharged)" or even "595 kg with driver". It does not get into too much detail about how much weight must be shared by the front and rear tyres, how much the driver and the seat alone must weigh, and so on. For seasons with no weight limit, the value is "free".

    • EngineType: Engine type. TEXT

    For the turbo-hybrid era, the value is "hybrid, reciprocating 4-stroke with pistons and electric". For previous seasons, the value wold be "reciprocating 4-stroke with pistons". If there is no restriction to the type of engine, the value would be "free".

    • Supercharging: Whether forced induction (supercharging or turbocharging) is allowed for that season. TEXT

    For seasons where it is allowed, the value would be "authorized". For seasons where it is not allowed, the value would be "forbidden". For 1986, where every single team had turbos, even though there was no rule mandating turbos, the value is "imposed". From 2014 onwards, where turbos are mandatory, the value would be "madatatory".

    • MaxCylinderCapacity: Maximum engine displacement. Also can be the allowed engine displacement. TEXT

    Values can range from "1500 cc" to "3000 cc (naturally aspirated) or 1500 cc (supercharged)".

    • NumberOfCylinders: Number of cylinders, or engine configuration. TEXT

    For seasons with no restrictions, the value would be "free". For seasons with a cap on maximum number of cylinders, the value would be, for example, "maximum 12". For seasons where the configuration was mandated, the value could be "V10". For 2006, where every other team except Toro Rosso had V8s, because the FIA granted special permission for Toro Rosso to continue using V10s, the value would be "V8 or V10".

    • MaxRPM: Maximum RPM the engine can rev to. TEXT

    For seasons where there was no limit on the maximum RPM of the engine, the value would be "free". Otherwise, the value would be the maximum RPM, for example "19 000".

    • NumberOfEnginesAllowedPerSeason: Engine allocation per season. TEXT

    The values can range from "1 engine per Grand Prix" to "1 engine for 2 Grand Prix" to "3 per season". For seasons with no cap on the number of engines used, the value would be "free".

    • FuelType: Fuel type. TEXT

    For seasons where teams could use any type of fuel they wanted, the value would be "free". Otherwise it would tell the type of fuel that the teams could use.

    • RefuellingAllowed: Whether refuelling was allowed during a race. TEXT

    For seasons where refuelling was allowed, the value would be "authorized". For seasons where refuelling was not allowed, the value would be "forbidden".

    • MaxFuelConsumption: Maximum fuel consumption. TEXT

    For seasons where there was no limit, the value would be "free". The values can also range from "200 litres" to "free (naturally aspirated) or 195 litres (supercharged)" to "100 kg and 100 kg/hour". In the last example, the first part ("100 kg") shows the fuel tank capacity (the maximum amount of fuel consumed per race) annd the second part ("100 kg/hour") shows the fuel flow limit. For the 2026 season, it is "3000 MJ/hour".

    • TotalGrandPrix: Total number of World Championship Grands Prix held in that season. INTEGER DEFAULT 0
    • TotalDrivers: Total number of drivers to have entered a World Championship Grand Prix in that season. INTEGER DEFAULT 0
    • TotalConstructors: Total number of constructors to have entered a World Championship Grand Prix in that season. INTEGER DEFAULT 0
    • TotalEngines: Total number of engine manufacturers to have powered a World Championship Grand Prix entry in that season. INTEGER DEFAULT 0
    • TotalTeams: Total number of teams to have entered a World Championship Grand Prix in that season. INTEGER DEFAULT 0
    • TotalEngineModels: Total number of engine models used in World Championship Grands Prix in that season. INTEGER DEFAULT 0
    • TotalChassis: Total number of chassis to have entered a World Championship Grand Prix in that season. INTEGER DEFAULT 0
    • TotalNationalities: Total number of nationalities represented by drivers in that season. INTEGER DEFAULT 0
    • needstatsupdate: Internal flag for statistical calculations. BOOLEAN

  2. Circuits

    This table contains all circuits which have hosted a Grand Prix.

    Note: If a circuit changes its name, it is counted as a different circuit.

    Columns:

    • ID: Unique circuit ID. INTEGER PRIMARY KEY AUTOINCREMENT
    • CircuitName: Name of the circuit. TEXT
    • FirstGrandPrix: First Grand Prix held in that circuit. TEXT
    • LastGrandPrix: Last Grand Prix held in that circuit. TEXT
    • GrandPrixCount: Number of GPs held in that circuit. INTEGER DEFAULT 0
    • FirstGrandPrixID: Foreign key to GrandsPrix. INTEGER
    • LastGrandPrixID: Foreign key to GrandsPrix. INTEGER
    • Latitude: GPS Latitude of the circuit. REAL
    • Longitude: GPS Longitude of the circuit. REAL
    • needstatsupdate: Internal flag for statistical calculations. BOOLEAN

  3. CircuitLayouts

    This table contains the different track configurations for each circuit used in Grand Prix history. Columns:

    • ID: Unique layout ID. INTEGER PRIMARY KEY AUTOINCREMENT
    • Latitude: GPS Latitude. REAL
    • Longitude: GPS Longitude. REAL
    • CircuitVersion: Version number of the layout for the given location. TEXT
    • FirstGrandPrix: Name of the first GP held on this layout. TEXT
    • LastGrandPrix: Name of the last GP held on this layout. TEXT
    • GrandPrixCount: Number of GPs held on this specific layout. INTEGER DEFAULT 0
    • GrandPrixDates: JSON list of all race dates held on this layout, used for mapping a circuit layout to a Grand Prix. This is Adelaide, for example: ["19851103", "19861026", "19871115", "19881113", "19891105", "19901104", "19911103", "19921108", "19931107", "19941113", "19951112"] TEXT
    • SVG: SVG path data for the track layout. TEXT
    • CircuitChanges: Description of changes from the previous version of that circuit. TEXT
    • FirstGrandPrixID: Foreign key to GrandsPrix. INTEGER
    • LastGrandPrixID: Foreign key to GrandsPrix. INTEGER
    • needstatsupdate: Internal flag for statistical calculations. BOOLEAN

  4. GrandsPrix

    This table contains all Grands Prix.
    Columns:

    • ID: Unique Grand Prix ID. The ID corresponds to which Grand Prix it is from the start of the world championship; the Grand Prix with the ID 1000 will be the 1000th world championship Grand Prix (2019 Chinese Grand Prix). INTEGER PRIMARY KEY
    • Season: Year of the Grand Prix. INTEGER
    • GrandPrixName: Name of the Grand Prix. This does not refer to the Grand Prix's name alone, i.e. "Monaco Grand Prix". Instead, it refers to the full name of the Grand Prix, e.g. "2021 Monaco Grand Prix". This must be kept in mind for all tables that reference Grand Prix names. TEXT
    • RoundNumber: Round number in the season. For example, if a race was the seventeenth Grand Prix of the season, the value would be "17". INTEGER
    • CircuitName: Name of the circuit. TEXT
    • Date: Date of the Grand Prix. For example, "Sunday, 2 August 2020" TEXT
    • DateInDateTime: Date as datetime. TEXT
    • Laps: Number of laps the race was held. INTEGER
    • CircuitLength: The length of the circuit in which the race was held. TEXT
    • Weather: Weather conditions. For example "Sunny", "Overcast", "Cloudy", "Night", "Rain", etc. TEXT
    • Notes: Notes about the race. TEXT
    • SprintWeekend: Whether it was a sprint weekend. BOOLEAN
    • CircuitLayoutID: Foreign key to CircuitLayouts. INTEGER
    • PoleSide: Side of the track the pole position is on. TEXT
    • GridFormation: The formation of the starting grid (e.g. 2-2, 3-2-3). TEXT For example, here's the GridFormation for the 1950 Italian Grand Prix: 4-4-4-4-4-4-4-4-4-4-4-4-3-3
    • SprintWeekend Whether the weekend was a sprint weekend. BOOLEAN If it is a sprint weekend, the value is true, if it is not, the value is false.
    • CircuitID: Foreign key to Circuits. INTEGER
    • EntrantsNotes: Notes about the entrants to the race. TEXT
    • QualifyingNotes: Notes about qualifying. TEXT
    • StartingGridNotes: Notes about the starting grid. TEXT
    • RaceResultNotes: Notes about the race result. TEXT
    • SprintNotes: Notes about the sprint. TEXT
    • SprintGridNotes: Notes about the sprint grid. TEXT
    • needstatsupdate: Internal flag for statistical calculations. BOOLEAN

  5. Sessions

    This table contains the schedule for every session (Practice, Qualifying, Sprint, Race) of a Grand Prix. Columns:

    • ID: Unique session ID. INTEGER PRIMARY KEY AUTOINCREMENT
    • GrandPrix: Name of the Grand Prix. TEXT
    • SessionName: Name of the session (e.g. "Practice 1", "Qualifying", "Race"). TEXT
    • SessionNumber: Order of the session in the weekend. INTEGER
    • WasSessionCancelled: Whether the session was cancelled. BOOLEAN
    • StartTimeTimestampUTC: Start time UTC timestamp. INTEGER
    • EndTimeTimestampUTC: End time UTC timestamp. INTEGER
    • StartTimeTimestamp: Start time local timestamp. INTEGER
    • EndTimeTimestamp: End time local timestamp. INTEGER
    • IfPreciseStartTime: Whether the start time is precise. BOOLEAN
    • StartTimeinDatetimeUTC: Start time in UTC datetime string. TEXT
    • EndTimeinDatetimeUTC: End time in UTC datetime string. TEXT
    • StartTimeinDatetime: Start time in local datetime string. TEXT
    • EndTimeinDatetime: End time in local datetime string. TEXT
    • GrandPrixID: Foreign key to GrandsPrix. INTEGER

  6. Drivers

    This table contains all drivers who have entered a World Championship Grand Prix (this includes FP1 appearances and third/substitute drivers).
    Columns:

    • ID: Unique driver ID. INTEGER PRIMARY KEY AUTOINCREMENT
    • Name: Full name of that driver. TEXT UNIQUE
    • Nationality: Nationality of that driver. TEXT
    • Birthdate: Birth date of that driver. TEXT
    • Wins: Number of wins of that driver. INTEGER
    • Podiums: Number of podiums of that driver. INTEGER
    • Poles: Number of pole positions of that driver. INTEGER
    • FastestLaps: Number of fastest laps of that driver. INTEGER
    • SprintWins: Number of sprint wins of that driver. INTEGER
    • SprintPodiums: Number of sprint podiums of that driver. INTEGER
    • SprintPoles: Number of sprint pole positions of that driver. INTEGER
    • SprintFastestLaps: Number of sprint fastest laps of that driver. INTEGER
    • Championships: Number of championships of that driver. INTEGER
    • SeasonsRaced: Number of seasons in which that driver entered at least one World Championship Grand Prix weekend. This does not count FP1 appearances or drivers who were on the entry list but did not participate in the Grand Prix, but even drivers who did not pre-qualify are considered as having raced in that season. INTEGER
    • Points: Total points of that driver. REAL
    • Starts: Number of starts of that driver. INTEGER
    • Entries: Number of entries of that driver. INTEGER
    • SprintStarts: Number of sprint starts of that driver. INTEGER
    • SprintEntries: Number of sprint entries of that driver. INTEGER
    • DNFs: Number of DNFs of that driver. Only classified non-finishes are counted. For example, if a driver did not finish a race but has a classified finish in the race result, it is not counted here. INTEGER
    • GrandPrixLapsLed: Number of grand prix laps led of that driver. INTEGER
    • SprintLapsLed: Number of sprint laps led of that driver. INTEGER
    • HatTricks: Number of hat tricks (pole + win + fastest lap) of that driver. INTEGER
    • GrandSlams: Number of grand slams (pole + win + fastest lap + led every lap) of that driver. INTEGER
    • BestGridPosition: Best grid position of that driver. INTEGER
    • BestSprintGridPosition: Best sprint grid position of that driver. INTEGER
    • BestQualifyingPosition: Best qualifying position of that driver. INTEGER
    • BestRacePosition: Best race position of that driver. INTEGER
    • BestSprintPosition: Best sprint position of that driver. INTEGER
    • BestSprintQualifyingPosition: Best sprint qualifying position of that driver. INTEGER
    • BestChampionshipPosition: Best championship position of that driver. INTEGER
    • FirstGrandPrix: First Grand Prix of that driver. TEXT
    • LastGrandPrix: Last Grand Prix of that driver. TEXT

    FirstGrandPrix and LastGrandPrix does not count FP1 appearances or drivers on the entry list who did not participate in any session. Non-qualifications do count, though.

    • NationalityID: Foreign key to Nationalities. INTEGER
    • FirstGrandPrixID: Foreign key to GrandsPrix. INTEGER
    • LastGrandPrixID: Foreign key to GrandsPrix. INTEGER
    • needstatsupdate: Internal flag for statistical calculations. BOOLEAN
    • indy500only: Whether this driver only competed in Indianapolis 500 races. Set to 1 (true) if all races ended with "Indianapolis 500", otherwise 0 (false). BOOLEAN

  7. Teams

    This table contains all teams that have entered a Grand Prix. A constructor and a team are two very different things. A constructor is an entity that constructs a chassis for Formula One, while a team can also include private entries from people who don't construct a chassis. In a more modern sense, a constructor is just the chassis name (i.e, Mercedes), while a team also includes the sponsor names (i.e, Mercedes AMG Petronas Formula One Team). The team names are according to the entry list for that race.

    Columns:

    • ID: Unique team ID. INTEGER PRIMARY KEY AUTOINCREMENT
    • TeamName: Name of the team. TEXT UNIQUE
    • FirstGrandPrix: First Grand Prix of that team. TEXT
    • LastGrandPrix: Last Grand Prix of that team. TEXT
    • Wins: Number of wins of that team. INTEGER
    • Podiums: Number of podiums of that team. INTEGER
    • Poles: Number of pole positions of that team. INTEGER
    • FastestLaps: Number of fastest laps of that team. INTEGER
    • SprintWins: Number of sprint wins of that team. INTEGER
    • SprintPodiums: Number of sprint podiums of that team. INTEGER
    • SprintPoles: Number of sprint pole positions of that team. INTEGER
    • SprintFastestLaps: Number of sprint fastest laps of that team. INTEGER
    • SeasonsRaced: Number of seasons in which that team entered at least one World Championship Grand Prix weekend. INTEGER
    • Starts: Number of starts of that team. INTEGER
    • Entries: Number of entries of that team. INTEGER
    • SprintStarts: Number of sprint starts of that team. INTEGER
    • SprintEntries: Number of sprint entries of that team. INTEGER
    • DNFs: Number of DNFs of that team. INTEGER
    • GrandPrixLapsLed: Number of grand prix laps led. INTEGER
    • SprintLapsLed: Number of sprint laps led. INTEGER
    • Points: Total points. REAL
    • BestGridPosition: Best grid position. INTEGER
    • BestSprintGridPosition: Best sprint grid position. INTEGER
    • BestQualifyingPosition: Best qualifying position. INTEGER
    • BestRacePosition: Best race position. INTEGER
    • BestSprintPosition: Best sprint position. INTEGER
    • BestSprintQualifyingPosition: Best sprint qualifying position. INTEGER
    • FirstGrandPrixID: Foreign key to GrandsPrix. INTEGER
    • LastGrandPrixID: Foreign key to GrandsPrix. INTEGER
    • needstatsupdate: Internal flag for statistical calculations. BOOLEAN
    • indy500only: Whether this team only competed in Indianapolis 500 races. Set to 1 (true) if all races ended with "Indianapolis 500", otherwise 0 (false). BOOLEAN

  8. Constructors

    This table contains all constructors who have made a chassis that entered a Grand Prix.
    Columns:

    • ID: Unique constructor ID. INTEGER PRIMARY KEY AUTOINCREMENT
    • ConstructorName: Name of the constructor. TEXT UNIQUE
    • Wins: Number of wins of that constructor. INTEGER
    • Podiums: Number of podiums of that constructor. INTEGER
    • Poles: Number of pole positions of that constructor. INTEGER
    • FastestLaps: Number of fastest laps of that constructor. INTEGER
    • SprintWins: Number of sprint wins. INTEGER
    • SprintPodiums: Number of sprint podiums. INTEGER
    • SprintPoles: Number of sprint pole positions. INTEGER
    • SprintFastestLaps: Number of sprint fastest laps. INTEGER
    • Championships: Number of championships of that constructor. INTEGER
    • SeasonsRaced: Number of seasons in which that constructor entered at least one World Championship Grand Prix weekend. INTEGER
    • Points: Total points of that constructor. REAL
    • Starts: Number of starts of that constructor. INTEGER
    • Entries: Number of entries of that constructor. INTEGER
    • SprintStarts: Number of sprint starts. INTEGER
    • SprintEntries: Number of sprint entries. INTEGER
    • DNFs: Number of DNFs of that constructor. INTEGER
    • GrandPrixLapsLed: Number of grand prix laps led. INTEGER
    • SprintLapsLed: Number of sprint laps led. INTEGER
    • BestGridPosition: Best grid position of that constructor. INTEGER
    • BestSprintGridPosition: Best sprint grid position of that constructor. INTEGER
    • BestQualifyingPosition: Best qualifying position of that constructor. INTEGER
    • BestRacePosition: Best race position of that constructor. INTEGER
    • BestSprintPosition: Best sprint position of that constructor. INTEGER
    • BestSprintQualifyingPosition: Best sprint qualifying position. INTEGER
    • BestChampionshipPosition: Best championship position of that constructor. INTEGER
    • FirstGrandPrix: First Grand Prix of that constructor. TEXT
    • LastGrandPrix: Last Grand Prix of that constructor. TEXT
    • FirstGrandPrixID: Foreign key to GrandsPrix. INTEGER
    • LastGrandPrixID: Foreign key to GrandsPrix. INTEGER
    • needstatsupdate: Internal flag for statistical calculations. BOOLEAN
    • indy500only: Whether this constructor only competed in Indianapolis 500 races. Set to 1 (true) if all races ended with "Indianapolis 500", otherwise 0 (false). BOOLEAN

  9. Engines

    This table contains all engine manufacturers to power an entry in a Grand Prix. Rebadged engines like Acer, Mecachrome, etc. are also included.

    Columns:

    • ID: Unique engine manufacturer ID. INTEGER PRIMARY KEY AUTOINCREMENT
    • EngineName: Name of the engine manufacturer. TEXT UNIQUE
    • Wins: Number of wins of that engine manufacturer. INTEGER
    • Podiums: Number of podiums of that engine manufacturer. INTEGER
    • Poles: Number of pole positions of that engine manufacturer. INTEGER
    • FastestLaps: Number of fastest laps of that engine manufacturer. INTEGER
    • SprintWins: Number of sprint wins. INTEGER
    • SprintPodiums: Number of sprint podiums. INTEGER
    • SprintPoles: Number of sprint pole positions. INTEGER
    • SprintFastestLaps: Number of sprint fastest laps. INTEGER
    • Championships: Number of championships of that engine manufacturer. INTEGER
    • SeasonsRaced: Number of seasons in which that engine manufacturer entered at least one World Championship Grand Prix weekend. INTEGER
    • Points: Total points. REAL
    • Starts: Number of starts of that engine manufacturer. INTEGER
    • Entries: Number of entries of that engine manufacturer. INTEGER
    • SprintStarts: Number of sprint starts. INTEGER
    • SprintEntries: Number of sprint entries. INTEGER
    • DNFs: Number of DNFs of that engine manufacturer. INTEGER
    • GrandPrixLapsLed: Number of grand prix laps led. INTEGER
    • SprintLapsLed: Number of sprint laps led. INTEGER
    • BestGridPosition: Best grid position. INTEGER
    • BestSprintGridPosition: Best sprint grid position. INTEGER
    • BestQualifyingPosition: Best qualifying position. INTEGER
    • BestRacePosition: Best race position. INTEGER
    • BestSprintPosition: Best sprint position. INTEGER
    • BestSprintQualifyingPosition: Best sprint qualifying position. INTEGER
    • FirstGrandPrix: First Grand Prix of that engine manufacturer. TEXT
    • LastGrandPrix: Last Grand Prix of that engine manufacturer. TEXT
    • FirstGrandPrixID: Foreign key to GrandsPrix. INTEGER
    • LastGrandPrixID: Foreign key to GrandsPrix. INTEGER
    • needstatsupdate: Internal flag for statistical calculations. BOOLEAN
    • indy500only: Whether this engine manufacturer only competed in Indianapolis 500 races. Set to 1 (true) if all races ended with "Indianapolis 500", otherwise 0 (false). BOOLEAN

  10. Tyres

This table contains all tyre manufacturers that have provided tyres to an entry.
Columns:

  • ID: Unique tyre ID. INTEGER PRIMARY KEY AUTOINCREMENT
  • TyreName: Name of the tyre. TEXT UNIQUE
  • Wins: Number of wins of that tyre manufacturer. INTEGER
  • Podiums: Number of podiums of that tyre manufacturer. INTEGER
  • Poles: Number of pole positions of that tyre manufacturer. INTEGER
  • FastestLaps: Number of fastest laps of that tyre manufacturer. INTEGER
  • SprintWins: Number of sprint wins. INTEGER
  • SprintPodiums: Number of sprint podiums. INTEGER
  • SprintPoles: Number of sprint pole positions. INTEGER
  • SprintFastestLaps: Number of sprint fastest laps. INTEGER
  • SeasonsRaced: Number of seasons in which that tyre manufacturer entered at least one World Championship Grand Prix weekend. INTEGER
  • Points: Total points of that tyre manufacturer. REAL
  • Starts: Number of starts of that tyre manufacturer. INTEGER
  • Entries: Number of entries of that tyre manufacturer. INTEGER
  • SprintStarts: Number of sprint starts. INTEGER
  • SprintEntries: Number of sprint entries. INTEGER
  • DNFs: Number of DNFs of that tyre manufacturer. INTEGER
  • GrandPrixLapsLed: Number of grand prix laps led. INTEGER
  • SprintLapsLed: Number of sprint laps led. INTEGER
  • BestGridPosition: Best grid position. INTEGER
  • BestSprintGridPosition: Best sprint grid position. INTEGER
  • BestQualifyingPosition: Best qualifying position. INTEGER
  • BestRacePosition: Best race position. INTEGER
  • BestSprintPosition: Best sprint position. INTEGER
  • BestSprintQualifyingPosition: Best sprint qualifying position. INTEGER
  • FirstGrandPrix: First Grand Prix of that tyre manufacturer. TEXT
  • LastGrandPrix: Last Grand Prix of that tyre manufacturer. TEXT
  • FirstGrandPrixID: Foreign key to GrandsPrix. INTEGER
  • LastGrandPrixID: Foreign key to GrandsPrix. INTEGER
  • needstatsupdate: Internal flag for statistical calculations. BOOLEAN
  • indy500only: Whether this tyre manufacturer only competed in Indianapolis 500 races. Set to 1 (true) if all races ended with "Indianapolis 500", otherwise 0 (false). BOOLEAN

  1. Chassis

    This table contains all chassis to enter a race in Formula One (e.g, the Lotus 72).
    Columns:

    • ID: Unique chassis ID. INTEGER PRIMARY KEY AUTOINCREMENT
    • ConstructorName: Name of the constructor that made that chasis. TEXT
    • ChassisName: Name of the chassis. TEXT UNIQUE
    • ConstructorID: Foreign key to Constructors. INTEGER
    • Wins: Number of wins of that chassis. INTEGER
    • Podiums: Number of podiums of that chassis. INTEGER
    • Poles: Number of pole positions of that chassis. INTEGER
    • FastestLaps: Number of fastest laps of that chassis. INTEGER
    • SprintWins: Number of sprint wins. INTEGER
    • SprintPodiums: Number of sprint podiums. INTEGER
    • SprintPoles: Number of sprint pole positions. INTEGER
    • SprintFastestLaps: Number of sprint fastest laps. INTEGER
    • SeasonsRaced: Number of seasons in which that chassis entered at least one World Championship Grand Prix weekend. INTEGER
    • Points: Total points of that chassis. REAL
    • Starts: Number of starts of that chassis. INTEGER
    • Entries: Number of entries of that chassis. INTEGER
    • SprintStarts: Number of sprint starts. INTEGER
    • SprintEntries: Number of sprint entries. INTEGER
    • DNFs: Number of DNFs of that chassis. INTEGER
    • GrandPrixLapsLed: Number of grand prix laps led. INTEGER
    • SprintLapsLed: Number of sprint laps led. INTEGER
    • BestGridPosition: Best grid position. INTEGER
    • BestSprintGridPosition: Best sprint grid position. INTEGER
    • BestQualifyingPosition: Best qualifying position. INTEGER
    • BestRacePosition: Best race position. INTEGER
    • BestSprintPosition: Best sprint position. INTEGER
    • BestSprintQualifyingPosition: Best sprint qualifying position. INTEGER
    • FirstGrandPrix: First Grand Prix. TEXT
    • LastGrandPrix: Last Grand Prix. TEXT
    • ConstructorID: Foreign key to Constructors. INTEGER
    • FirstGrandPrixID: Foreign key to GrandsPrix. INTEGER
    • LastGrandPrixID: Foreign key to GrandsPrix. INTEGER
    • needstatsupdate: Internal flag for statistical calculations. BOOLEAN
    • indy500only: Whether this chassis only competed in Indianapolis 500 races. Set to 1 (true) if all races ended with "Indianapolis 500", otherwise 0 (false). BOOLEAN

  2. EngineModels

    This table contains all engine models used in F1 (e.g, the Cosworth DFV).
    Columns:

    • ID: Unique engine model ID. INTEGER PRIMARY KEY AUTOINCREMENT
    • EngineMake: Engine make (e.g "Mercedes" for "M11 EQ Performance V6 t h 1.6"). TEXT
    • EngineModel: Engine model. It also includes some specifications of the engine like displacement, configuration, turbocharged or not, hybrid or not. For example, the DFV is stored as "DFV V8 3.0". TEXT UNIQUE
    • EngineMakeID: Foreign key to Engines. INTEGER
    • Wins: Number of wins of that engine manufacturer. INTEGER
    • Podiums: Number of podiums of that engine manufacturer. INTEGER
    • Poles: Number of pole positions of that engine manufacturer. INTEGER
    • FastestLaps: Number of fastest laps of that engine manufacturer. INTEGER
    • SprintWins: Number of sprint wins. INTEGER
    • SprintPodiums: Number of sprint podiums. INTEGER
    • SprintPoles: Number of sprint pole positions. INTEGER
    • SprintFastestLaps: Number of sprint fastest laps. INTEGER
    • Championships: Number of championships of that engine manufacturer. INTEGER
    • SeasonsRaced: Number of seasons in which that engine model entered at least one World Championship Grand Prix weekend. INTEGER
    • Points: Total points. REAL
    • Starts: Number of starts of that engine manufacturer. INTEGER
    • Entries: Number of entries of that engine manufacturer. INTEGER
    • SprintStarts: Number of sprint starts. INTEGER
    • SprintEntries: Number of sprint entries. INTEGER
    • DNFs: Number of DNFs of that engine manufacturer. INTEGER
    • GrandPrixLapsLed: Number of grand prix laps led. INTEGER
    • SprintLapsLed: Number of sprint laps led. INTEGER
    • BestGridPosition: Best grid position. INTEGER
    • BestSprintGridPosition: Best sprint grid position. INTEGER
    • BestQualifyingPosition: Best qualifying position. INTEGER
    • BestRacePosition: Best race position. INTEGER
    • BestSprintPosition: Best sprint position. INTEGER
    • BestSprintQualifyingPosition: Best sprint qualifying position. INTEGER
    • FirstGrandPrix: First Grand Prix of that engine manufacturer. TEXT
    • LastGrandPrix: Last Grand Prix of that engine manufacturer. TEXT
    • EngineMakeID: Foreign key to Engines of that engine manufacturer. INTEGER
    • FirstGrandPrixID: Foreign key to GrandsPrix of that engine manufacturer. INTEGER
    • LastGrandPrixID: Foreign key to GrandsPrix of that engine manufacturer. INTEGER
    • needstatsupdate: Internal flag for statistical calculations. BOOLEAN
    • indy500only: Whether this engine model only competed in Indianapolis 500 races. Set to 1 (true) if all races ended with "Indianapolis 500", otherwise 0 (false). BOOLEAN

  3. GrandPrixResults

    This table contains all race entrants for each Grand Prix, with all session results and penalties. It then has all the results for each session that driver competed in. For shared cars, there are separate entries for each driver but it has the same car number.

    Q1 and Q2 can mean different things over different qualifying regulations. From 1950 till 1995, there were two different qualifying sessions, one on Friday (Q1), and one on Saturday (Q2). The best time from both sessions for each driver was counted towards the overall qualifying. In 2003 and 2004, during the first qualifying session (Q1), all the drivers set one lap in championship order, with the last going first and first going last. Then, on the second qualifying session (Q2), the drivers went on another lap, with the last on the first session going first, and the first going last. Then, for the first six races in 2005, there were two different sessions; one on low fuel (Q1), and one on race fuel (Q2). Then the two times would be aggregated to set the overall qualifying times. From 2006, the slowest drivers were eliminated in Q1 and Q2, now just part of qualifying, not two separate sessions.

    Pre-qualifying in Formula 1 was an additional elimination session used mainly between 1987 and 1992 to manage situations where more cars entered a race weekend than the maximum allowed grid of 26. During this period, many small and underfunded teams joined the sport, leading to entry lists of over 30 cars. To control this, the slowest teams—usually determined by their previous results—had to participate in a Friday morning pre-qualifying session, where only a few of the fastest drivers (typically four) would advance to the main qualifying rounds, while the rest were eliminated from the weekend entirely. This system was often harsh, as some teams traveled long distances only to complete a handful of laps before being sent home. A much earlier example of a similar issue can be seen at the 1965 South African Grand Prix held at Kyalami Circuit, where a large number of local and private entrants led to an overcrowded field. To pre-qualify, a driver had to set a lap time below 1:37.0, unlike later pre-qualifying sessions where only a few of the fastest drivers would pre-qualify. For this session, the prequalifyingtime is given as "+1:37.0" or "-1:37.0". Between the late-1970s and the mid-1980s, pre-qualifying occured in a few races where there were too many entrants.

    We also have data for practice sessions. This must not be confused with qualifying being called practice previously. There were up to four practice sessions in previous years, with the pre-race warm ups as well. There have been only two practice sessions in some years, and in Sprint weekends we only have one. We currently have three practice sessions in normal weekends.

    We have data for Q1 and Q2 only after 1983. To find drivers who did not pre-qualify or qualify, it is there in overall qualifying. We have data for the Sunday morning warm-up session from 1984 till 2003, when the session no longer happened.

    In 2021, the Qualifying session set the grid for the Sprint race, and the Sprint set the grid for the Grand Prix, with the top 3 finishers getting 3, 2, and 1 point respectively.

    In 2022, the Qualifying session set the grid for both the Sprint and the race.

    From 2023, there is one qualifying session for the race and one for the sprint.

    Columns:

    • grandprix: Grand Prix name. TEXT

    • number: Car number. INTEGER

    • driver: Driver name. TEXT

    • nationality: Nationality of the driver. TEXT

    • team: Team name. TEXT

    • constructor: Constructor name. TEXT

    • chassis: Chassis name. TEXT

    • engine: Engine name. TEXT

    • enginemodel: Engine model. TEXT

    • tyre: Tyre name. TEXT

    • substituteorthirddriver: Substitute or third driver. BOOLEAN

    • qualifyingposition: Qualifying position. INTEGER

    • qualifyingtime: Qualifying time. TEXT

    • qualifyinggap: Qualifying gap. TEXT

    • qualifyingtimeinseconds: Qualifying time in seconds. REAL

    • qualifyinggapseconds: Qualifying gap in seconds. REAL

    • qualifyinginterval: Gap to the car ahead in qualifying. REAL

    • prequalifyingposition: Pre-qualifying position. INTEGER

    • prequalifyingtime: Pre-qualifying time. TEXT

    • prequalifyinggap: Pre-qualifying gap. TEXT

    • prequalifyinginterval: Gap to the car ahead in pre-qualifying. REAL

    • prequalifyingtimeinseconds: Pre-qualifying time in seconds. REAL

    • starting_grid_position: Starting grid position. INTEGER

    • gridpenalty: Any grid penalty applied. It can be a pit lane start ("Start from pit lane"), start from the back of the grid ("Demoted to the back of the grid"), or a grid penalty by x number of postions (e.g, "Demoted by 7 places"). TEXT

    • gridpenalty_reason: Grid penalty reason (e.g "Modifying car under Parc Fermé conditions", "Exceeding quota of powertrain elements", and so on.). TEXT

    • sprintstarting_grid_position: Sprint starting grid position. INTEGER

    • sprintgridpenalty: Sprint grid penalty. Same format as gridpenalty TEXT

    • sprintgridpenalty_reason: Sprint grid penalty reason. Same format as gridpenalty_reason TEXT

    • fastestlap: Fastest lap position (e.g, out of each drivers' fastest laps, this driver set the sixth fastest lap). INTEGER

    • fastestlapinseconds: Fastest lap in seconds. REAL

    • fastestlapgapinseconds: Fastest lap gap in seconds. REAL

    • fastestlap_time: Fastest lap time. TEXT

    • fastestlap_gap: Fastest lap gap. TEXT

    • fastestlapinterval: Gap to the car with the next fastest lap. REAL

    • fastestlap_lap: Lap of fastest lap (e.g, driver set their fastest lap on the 17th lap). INTEGER

    • sprintfastestlap: Sprint fastest lap position. INTEGER

    • sprintfastestlapinseconds: Sprint fastest lap in seconds. REAL

    • sprintfastestlapgapinseconds: Sprint fastest lap gap in seconds. REAL

    • sprintfastestlap_time: Sprint fastest lap time. TEXT

    • sprintfastestlap_gap: Sprint fastest lap time gap. TEXT

    • sprintfastestlapinterval: Gap to the car with the next fastest sprint lap. REAL

    • sprintfastestlap_lap: Sprint fastest lap lap. INTEGER

    • qualifying2position: Q2 position. INTEGER

    • qualifying2time: Q2 time. TEXT

    • qualifying2gap: Q2 gap. REAL

    • qualifying2timeinseconds: Q2 time in seconds. REAL

    • qualifying2interval: Gap to the car ahead in Q2. REAL

    • qualifying2laps: Q2 laps. INTEGER

    • qualifying1position: Q1 position. INTEGER

    • qualifying1time: Q1 time. TEXT

    • qualifying1gap: Q1 gap. REAL

    • qualifying1timeinseconds: Q1 time in seconds. REAL

    • qualifying1interval: Gap to the car ahead in Q1. REAL

    • qualifying1laps: Q1 laps. INTEGER

    • qualifyinglaps: Qualifying laps. INTEGER

    • qualifying3time: Q3 time. TEXT

    • qualifying3gap: Q3 gap string. REAL

    • qualifying3interval: Gap to the car ahead in Q3. REAL

    • qualifying3timeinseconds: Q3 time in seconds. REAL

    • sprint_qualifyingposition: Sprint qualifying position. INTEGER

    • sprint_qualifying1time: Sprint Q1 time. TEXT

    • sprint_qualifying2time: Sprint Q2 time. TEXT

    • sprint_qualifying3time: Sprint Q3 time. TEXT

    • sprint_qualifying1gap: Sprint Q1 gap. REAL

    • sprint_qualifying1interval: Gap to the car ahead in sprint qualifying Q1. REAL

    • sprint_qualifying2gap: Sprint Q2 gap. REAL

    • sprint_qualifying2interval: Gap to the car ahead in sprint qualifying Q2. REAL

    • sprint_qualifying3gap: Sprint Q3 gap. REAL

    • sprint_qualifying3interval: Gap to the car ahead in sprint qualifying Q3. REAL

    • sprint_qualifyinggap: Sprint qualifying gap. REAL

    • sprint_qualifyinginterval: Gap to the car ahead in sprint qualifying. REAL

    • sprint_qualifying1timeinseconds: Sprint Q1 time in seconds. REAL

    • sprint_qualifying2timeinseconds: Sprint Q2 time in seconds. REAL

    • sprint_qualifying3timeinseconds: Sprint Q3 time in seconds. REAL

    • sprint_qualifyinglaps: Sprint qualifying laps. INTEGER

    • sprint_qualifyingtime: Sprint qualifying time. TEXT

    • sprint_qualifyingtimeinseconds: Sprint qualifying time in seconds. REAL

    • warmupposition: Warmup position. INTEGER

    • warmuptime: Warmup time. It only shows the gap for those who are not the leader. TEXT

    • warmupgap: Warmup gap. TEXT

    • warmuptimeinseconds: Warmup time in seconds. REAL

    • warmuplaps: Warmup laps. INTEGER

    • practice1position: Practice 1 position. INTEGER

    • practice1time: Practice 1 time. It only shows the gap for those who are not the leader. TEXT

    • practice1gap: Practice 1 gap. TEXT

    • practice1timeinseconds: Practice 1 time in seconds. REAL

    • practice1interval: Gap to the car ahead in Practice 1. REAL

    • practice1laps: Practice 1 laps. INTEGER

    • practice2position: Practice 2 position. INTEGER

    • practice2time: Practice 2 time. It only shows the gap for those who are not the leader. TEXT

    • practice2gap: Practice 2 gap. TEXT

    • practice2timeinseconds: Practice 2 time in seconds. REAL

    • practice2interval: Gap to the car ahead in Practice 2. REAL

    • practice2laps: Practice 2 laps. INTEGER

    • practice3position: Practice 3 position. INTEGER

    • practice3time: Practice 3 time. It only shows the gap for those who are not the leader. TEXT

    • practice3gap: Practice 3 gap. TEXT

    • practice3timeinseconds: Practice 3 time in seconds. REAL

    • practice3interval: Gap to the car ahead in Practice 3. REAL

    • practice3laps: Practice 3 laps. INTEGER

    • practice4position: Practice 4 position. INTEGER

    • practice4time: Practice 4 time. It only shows the gap for those who are not the leader. TEXT

    • practice4gap: Practice 4 gap. TEXT

    • practice4timeinseconds: Practice 4 time in seconds. REAL

    • practice4interval: Gap to the car ahead in Practice 4. REAL

    • practice4laps: Practice 4 laps. INTEGER

    • sprintposition: Sprint position. INTEGER

    • sprintlaps: Sprint laps. INTEGER

    • sprinttime: Sprint time. TEXT

    • sprintpoints: Sprint points. REAL

    • sprinttimeinseconds: Sprint time in seconds. REAL

    • sprintgap: Sprint gap. TEXT

    • sprintgapinseconds: Sprint gap in seconds. REAL

    • sprintinterval: Gap to the car ahead in the Sprint. REAL

    • sprintstatus: Status of the car in the sprint (e.g. Did not finish, Disqualified, Classified, etc.). TEXT

    • sprintstatusreason: Reason for the status in the sprint (e.g. "Engine failure"). TEXT

    • raceposition: Race position. INTEGER

    • racelaps: Race laps. INTEGER

    • racetime: Race time. TEXT

    • racepoints: Race points. REAL

    • racetimeinseconds: Race time in seconds. REAL

    • racegap: Race gap. TEXT

    • racegapinseconds: Race gap in seconds. REAL

    • raceinterval: Gap to the car ahead in the Race. REAL

    • racestatus: Status of the car in the race (Did not finish, Disqualified, Classified, etc.). TEXT

    • racestatusreason: Reason for the status in the race (e.g, "Collision with car ahead"). TEXT

    • penalties: Penalties (JSON). TEXT

      It has the following keys:

      • penalty: The nature and magnitude of the penalty. (e.g, "5 seconds", "10 seconds", "10 seconds Stop and Go", "Drive-through", etc.)

      • reason: The reason the penalty was given.

      • type: It has two types:

        • during_the_race: Served during the race (in a pit stop).
        • added_after_chequered_flag: Added to race time after the race.

      For example, here's Esteban Ocon's penalties at the 2023 Austrian Grand Prix:

      [{"penalty": "5 seconds", "reason": "Unsafe release from pit stop", "type": "during_the_race"}, {"penalty": "5 seconds", "reason": "Crossing track limits", "type": "added_after_chequered_flag", "lost_position": 0}, {"penalty": "5 seconds", "reason": "Crossing track limits", "type": "added_after_chequered_flag", "lost_position": 0}, {"penalty": "10 seconds", "reason": "Crossing track limits", "type": "added_after_chequered_flag", "lost_position": 0}, {"penalty": "10 seconds", "reason": "Crossing track limits", "type": "added_after_chequered_flag", "lost_position": 2}]

    • sprint_penalties: Sprint penalties (JSON). Same format as penalties. TEXT

    • driverid: Foreign key to Drivers. INTEGER

    • teamid: Foreign key to Teams. INTEGER

    • constructorid: Foreign key to Constructors. INTEGER

    • chassisid: Foreign key to Chassis. INTEGER

    • engineid: Foreign key to Engines. INTEGER

    • enginemodelid: Foreign key to EngineModels. INTEGER

    • tyreid: Foreign key to Tyres. INTEGER

    • grandprixid: Foreign key to GrandsPrix. INTEGER

    • nationalityid: Foreign key to Nationalities. INTEGER

  4. PitStopSummary

    This table shows the pit stops done during the race.
    Columns:

    • GrandPrix: Name of the Grand Prix. TEXT
    • Number: Car number. INTEGER
    • Driver: Driver name. TEXT
    • Constructor: Constructor name. TEXT
    • StopNumber: Stop number (e.g, it's the driver's second stop). INTEGER
    • Lap: Lap of the stop. INTEGER
    • DurationSpentInPitLane: Duration in pit lane. Not to be confused as the duration stationary in the pit stop TEXT
    • TimeInSeconds: Duration in seconds. REAL
    • TimeOfDayStopped: Time of day. TEXT
    • TotalTimeSpentInPitLane: Total pit lane time (all the stops combined till that point). TEXT
    • TotalTimeinSeconds: Total pit lane time in seconds. REAL
    • DurationStoppedInPitBox: Duration stationary in the pit box. REAL
    • type: Type of pit stop, such as a normal tyre stop or another kind of service stop. TEXT
    • GrandPrixID: Foreign key to GrandsPrix. INTEGER
    • DriverID: Foreign key to Drivers. INTEGER
    • ConstructorID: Foreign key to Constructors. INTEGER

  5. LapByLap

    This table has the lap-by-lap data for each race.
    Columns:

    • GrandPrix: Name of the Grand Prix. TEXT
    • Driver: Driver name. TEXT
    • Position: Position on that lap. INTEGER
    • Lap: Lap number. INTEGER
    • Type: Session type. For Grands Prix, the type is "grandprix", and for Sprints, the type is "sprint". We also have "practice1", "practice2", "practice3", and "qualifying" TEXT
    • SafetyCar: Safety car/ Virtual Safety car status. true for Safety Car/Virtual Safety Car in force that lap, false otherwise. BOOLEAN
    • Time: Lap time. Available from 1996. TEXT
    • TimeInSeconds: Lap time in seconds. REAL
    • TyreCompound: The tyre compound used on this lap (Soft, Medium, Hard, etc.). TEXT
    • StintNumber: The current stint number for the driver. A stint is a period of time during which the driver did not pass through the pit lane. A new stint starts the lap in which the driver exits the pit lane. So, even if the driver does not change tyres, a new stint is started. INTEGER
    • Sector1Time: Time spent in Sector 1. REAL
    • Sector2Time: Time spent in Sector 2. REAL
    • Sector3Time: Time spent in Sector 3. REAL
    • TyreAge: Number of laps the current set of tyres has done. INTEGER
    • TrackStatus: Condition of the track (Green, Yellow, SC, VSC, etc.). TEXT
    • QualifyingSegment: For qualifying laps, which segment (Q1, Q2, Q3, SQ1, SQ2, SQ3) it belongs to. TEXT
    • GrandPrixID: Foreign key to GrandsPrix. INTEGER
    • DriverID: Foreign key to Drivers. INTEGER

  6. DriversChampionship

    This table has the championship results for drivers for every year.
    Columns:

    • ID: Unique ID (year+driver). TEXT PRIMARY KEY

    • Season: Year. INTEGER

    • Position: Position in standings. The position is NULL until the position is mathematically locked, i.e., no driver can overtake them in the standings, and they can't overtake any driver in the standings. INTEGER

    • Driver: Driver name. TEXT

    • Points: Points scored. REAL

    • OutOf: Points out of. REAL

    • RaceByRace: JSON of race-by-race points. TEXT

      It has the following format:

      Key: It is the Grand Prix.

      Value: In the form of an array. The 0th element has the number of points scored. The 1st element has the info whether the score was dropped(whether it did not count towards the championship). true means the score was dropped. false means the score was not dropped. null means the driver scored 0 points in that race. If there is a [null, null], it indicates that the driver did not take part in that race in the season, or the event is upcoming. The third element in this list is "gp" or "sp". If it is "gp", it indicates it is a Grand Prix weekend, and if it is "sp", it indicates a sprint weekend. For example, here's Alain Prost's RaceByRace during the 1988 season:

      {"Brazil": [9.0, false, "gp"], "San Marino": [6.0, false, "gp"], "Monaco": [9.0, false, "gp"], "Mexico": [9.0, false, "gp"], "Canada": [6.0, false, "gp"], "Detroit": [6.0, false, "gp"], "France": [9.0, false, "gp"], "Britain": [0, null, "gp"], "Germany": [6.0, false, "gp"], "Hungary": [6.0, true, "gp"], "Belgium": [6.0, true, "gp"], "Italy": [0, null, "gp"], "Portugal": [9.0, false, "gp"], "gp", "Spain": [9.0, false, "gp"], "Japan": [6.0, true, "gp"], "Australia": [9.0, false, "gp"]}

      And here's Oscar Piastri's RaceByRace for the 2025 season:

      {"Australia": [2.0, false, "gp"], "China": [32.0, false, "sp"], "Japan": [15.0, false, "gp"], "Bahrain": [25.0, false, "gp"], "Saudi Arabia": [25.0, false, "gp"], "Miami": [32.0, false, "sp"], "Emilia-Romagna": [15.0, false, "gp"], "Monaco": [15.0, false, "gp"], "Spain": [25.0, false, "gp"], "Canada": [12.0, false, "gp"], "Austria": [18.0, false, "gp"], "Britain": [18.0, false, "gp"], "Belgium": [32.0, false, "sp"], "Hungary": [18.0, false, "gp"], "Netherlands": [25.0, false, "gp"], "Italy": [15.0, false, "gp"], "Azerbaijan": [0, null, "gp"], "Singapore": [12.0, false, "gp"], "USA": [10.0, false, "sp"], "Mexico City": [10.0, false, "gp"], "São Paulo": [10.0, false, "sp"], "Las Vegas": [0, null, "gp"], "Qatar": [26.0, false, "sp"], "Abu Dhabi": [18.0, false, "gp"]}

    • DriverID: Foreign key to Drivers. INTEGER

    • NationalityID: Foreign key to Nationalities. INTEGER

  7. ConstructorsChampionship

    This table has the championship results for constructors for every year.
    Columns:

    • ID: Unique ID (year+constructor+engine). TEXT PRIMARY KEY
    • Season: Year. INTEGER
    • Position: Position in standings. The position is NULL until the position is mathematically locked, i.e., no constructor can overtake them in the standings, and they can't overtake any constructor in the standings. INTEGER
    • Constructor: Constructor name. TEXT
    • Engine: Engine name. TEXT
    • Points: Points scored. REAL
    • OutOf: Points out of. REAL
    • RaceByRace: JSON of race-by-race points. Same format as RaceByRace in DriversChampionship. TEXT
    • ConstructorID: Foreign key to Constructors. INTEGER
    • EngineID: Foreign key to Engines. INTEGER
    • EngineModelID: Foreign key to EngineModels. INTEGER

  8. InSeasonProgressDrivers

    This table has the progress of each driver over the season. It is recorded after each race.
    Columns:

    • ID: Unique ID. INTEGER PRIMARY KEY AUTOINCREMENT
    • GrandPrix: Name of the Grand Prix. TEXT
    • PositionAtThisPoint: Position at this point, that is, after this race. INTEGER
    • Driver: Driver name. TEXT
    • PointsAtThisPoint: Points at this point, that is, after this race. REAL
    • GrandPrixID: Foreign key to GrandsPrix. INTEGER
    • DriverID: Foreign key to Drivers. INTEGER_

  9. InSeasonProgressConstructors

    This table has the progress of each constructor over the season. It is recorded after each race.
    Columns:

    • ID: Unique ID. INTEGER PRIMARY KEY AUTOINCREMENT
    • GrandPrix: Name of the Grand Prix. TEXT
    • PositionAtThisPoint: Position at this point, that is, after this race. INTEGER
    • Constructor: Constructor name. TEXT
    • Engine: Engine name. TEXT
    • PointsAtThisPoint: Points at this point, that is, after this race. REAL
    • GrandPrixID: Foreign key to GrandsPrix. INTEGER
    • ConstructorID: Foreign key to Constructors. INTEGER
    • EngineID: Foreign key to Engines. INTEGER

  10. Nationalities

    This table contains all nationalities that have participated in F1.
    Columns:

    • ID: Unique nationality ID. INTEGER PRIMARY KEY AUTOINCREMENT
    • Nationality: Nationality. TEXT UNIQUE FirstGrandPrix and LastGrandPrix does not count FP1 appearances or drivers on the entry list who did not participate in any session. Non-qualifications do count, though.
    • FirstGrandPrix: First Grand Prix of that nationality. TEXT
    • LastGrandPrix: Last Grand Prix of that nationality. TEXT
    • DriverCount: Number of drivers of that nationality. INTEGER DEFAULT 0
    • Wins: Number of wins of that nationality. INTEGER
    • Podiums: Number of podiums of that nationality. INTEGER
    • Poles: Number of pole positions of that nationality. INTEGER
    • FastestLaps: Number of fastest laps of that nationality. INTEGER
    • SprintWins: Number of sprint wins. INTEGER
    • SprintPodiums: Number of sprint podiums. INTEGER
    • SprintPoles: Number of sprint pole positions. INTEGER
    • SprintFastestLaps: Number of sprint fastest laps. INTEGER
    • Championships: Number of championships of that nationality. INTEGER
    • SeasonsRaced: Number of seasons in which a driver of that nationality entered at least one World Championship Grand Prix weekend. INTEGER
    • Points: Total points. REAL
    • Starts: Number of starts of that nationality. INTEGER
    • Entries: Number of entries of that nationality. INTEGER
    • SprintStarts: Number of sprint starts. INTEGER
    • SprintEntries: Number of sprint entries. INTEGER
    • DNFs: Number of DNFs of that nationality. INTEGER
    • GrandPrixLapsLed: Number of grand prix laps led. INTEGER
    • SprintLapsLed: Number of sprint laps led. INTEGER
    • BestGridPosition: Best grid position of that nationality. INTEGER
    • BestSprintGridPosition: Best sprint grid position of that nationality. INTEGER
    • BestQualifyingPosition: Best qualifying position of that nationality. INTEGER
    • BestRacePosition: Best race position of that nationality. INTEGER
    • BestSprintPosition: Best sprint position of that nationality. INTEGER
    • BestSprintQualifyingPosition: Best sprint qualifying position. INTEGER
    • FirstGrandPrixID: Foreign key to GrandsPrix. INTEGER
    • LastGrandPrixID: Foreign key to GrandsPrix. INTEGER
    • FirstDriver: First driver who represented this nationality. TEXT
    • LastDriver: Most recent driver who represented this nationality. TEXT
    • FirstDriverID: Foreign key to Drivers. INTEGER
    • LastDriverID: Foreign key to Drivers. INTEGER
    • needstatsupdate: Internal flag for statistical calculations. BOOLEAN

  11. RaceReports

    This table contains the full race reports for every Grand Prix. Reports are stored as markdown-style text and may include headings and bulleted lists. Columns:

    • ID: Primary key, matching the Grand Prix ID. INTEGER PRIMARY KEY
    • GrandPrixName: Name of the Grand Prix. TEXT UNIQUE
    • RaceReport: The full text of the race report. TEXT

Roadmap:

We are working on adding more features to the database to make it even more comprehensive. Some of the features and/or changes we want to add in the future include:

  • Add robust OCR detection for the circuit layouts. Currently, my attempt of the OCR detection is not very accurate as it includes false positives, false negatives, and incorrect detection. Once a robust OCR detection is added, we can add corner names and numbers to the circuit layout SVGs.
  • Check the viability of adding telemetry data and add if viable, including mini-sectors. Telemetry data can be added in a parquet file to reduce file size and bloating of the database.
  • In seasons where telemetry is not available, there is still data for speeds at the speed trap, Intermediate 1, Intermediate 2, and Intermediate 3. We can add that if possible.
  • Add race control messages for available races.
  • Add weather data, such as temperature, precipitation, wind speed, air pressure, and so on where available using data available from fastf1 or a historical weather API.
  • Migration for lap by lap and sector and tyre info from Pitwall and TracingInsights to Jolpica and FastF1.
  • Make writedb.py more efficient. Currently a lot of the code is O(n²) and can be optimised.
  • Once we optimise writedb.py, we would like to include asyncio or threading to make it even faster.

We would like to add more data for your database. If you have any suggestions, please open an issue, or submit a pull request.

Contributing

Contributions are welcome! If you find any data inaccuracies or want to suggest new features:

  1. Fork the repository.
  2. Create a new branch for your changes. Do not work on the main branch!
  3. Submit a Pull Request with a detailed description of your updates.
  4. Ensure any schema changes are also updated in reset.py and in the README.

Even if you don't have any code to contribute, you can still help by suggesting new features or contributing to the Wikipedia pages of race reports. Currently, a lot of pages of the race reports don't have enough data showing what happened. You can change that by editing and contributing to the Wikipedia pages of race reports. This helps both the F1 community as well as this database.

For major changes, please open an issue first to discuss what you would like to change.

About

A comprehensive F1 database designed for fastest query time with results from 1950 to the present day.

Topics

formula1 f1 formulaone formula1-data-analysis f1db formula1-database f1dataanalytics formula1-data

Resources

Readme
Activity

Stars

0 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages