Data

Every figure is cross-checked against independent sources, with every disagreement and every gap published in the data: a confidence tier on every row, both readings wherever two sources differ, and a register of what nobody has established.

The files

• f1.db.gz — the database, gzipped. One gunzip gives the SQLite file: gunzip f1.db.gz, then open it with any SQLite client; circuit_geometry in it is deliberately empty.
• f1.db — the same file uncompressed, too large for this host to serve: the repository’s current copy, which the next deploy is built from.
• f1-geometry.db — the circuit centrelines, © OpenStreetMap contributors under ODbL 1.0, in a file of their own.
• f1-parquet.zip — every table as Parquet, one file each; pandas, polars and DuckDB read it directly.

Two files rather than one because distributing them together keeps them a collective database: merging them would pull 117,000 unrelated rows under the centrelines’ share-alike licence. Take both, or you have no geometry and no way to get it. Everything you need to read it is inside it: SELECT sql FROM sqlite_master for the commented schema, SELECT * FROM meta for the version, the build date and what is held, and SELECT * FROM source_registry for the licence of every row.

Two JSON exports — f1_database.json.gz, every table, and f1_compat.json, the original v1 key layout — are written by the same build and travel with each release rather than being served from here.

f1.db digest

fee572593fca7f27

f1-geometry.db digest

b97e41de9348108e

The first sixteen hex digits of each file’s SHA-256, as db-manifest.json carries them. SHA256SUMS, beside the files themselves, gives the whole of each and names what it covers; it is rewritten on every deploy, and the copies attached to a release are digested by that release’s own list instead.

As JSON

The same data as static JSON, one file per driver, constructor, circuit, season and race weekend, open to any site’s scripts. It is rebuilt with every deploy and carries its licence and version in every file; the index lists the rest.

• /api/v1/index.json — the index: every endpoint, and what the files were written from
• /api/v1/drivers.json — the drivers, one row each; then api/v1/drivers/{id}.json
• /api/v1/constructors.json — the constructors; then api/v1/constructors/{id}.json
• /api/v1/circuits.json — the circuits; then api/v1/circuits/{id}.json
• /api/v1/seasons.json — every season; then api/v1/seasons/{year}.json
• /api/v1/races/2026/15.json — a race weekend, every session: api/v1/races/{year}/{round}.json

What explains it

• schema.sql — The schema, commented: every table, every column, and the reasoning behind the ones that need it.
• ATTRIBUTION.md — Where each part of the data came from, what its licence requires, and what that requirement cost or bought.
• LICENSE-DATA — The terms the data is offered under — CC BY-SA 4.0; CC BY 4.0 for the columns holding this project’s own writing: its reading of each disagreement, its account of each gap and the prose of ten of its twelve reference tables; and CC BY 4.0 for f1-facts.db, the facts alone — and why share-alike rather than something looser.

The database is served from here, so the documents that explain it are served from here too. The repository holds the build, the checks that gate it and the source data they read, so the cross-checking claimed above can be read rather than taken on trust.

Which ids you may keep

For anyone who keeps an id from one release to join on in the next. The file states its own policy in three rows of its meta table, and this is what they say.

Integer id columns are surrogates, handed out by the build in insert order, and are NOT stable between releases except in the tables named by meta.id_stability_stable. There the maintainers undertake not to renumber them; nothing in the build measures that, because no release is compared with the one before it. Join on the natural keys published in meta.id_stability_keys - a ? in one of those marks a column that holds NULL, so join it with IS rather than =. A text id is a natural key and does not move.

Stable ids

circuit_layouts, pit_stops, qualifying, race_entries, races, season_entrants, sprint_results

Natural keys

circuit_layouts(circuit_id, layout_key); discrepancies(key); known_gaps(key); pit_stops(race_id, source, driver_key, stop_number); practice(race_id, session, driver_id); qualifying(race_id, driver_id); race_entries(race_id, driver_id); races(year, round); records(key); season_entrants(year, entrant_id, f1db_constructor_id, engine_manufacturer_id); sprint_qualifying(race_id, driver_id); sprint_results(race_id, driver_id); standings(year, table_type, after_round, basis, driver_id, constructor_id, engine_id, source, position_text)

All three are rows of meta: SELECT key, value FROM meta WHERE key LIKE 'id_stability%' reads them. The README sets the policy out table by table, under Identifiers.

How far to trust it

The ladder, from the top: verified high reference medium unverified catalogued. Only an official source — the FIA or formula1.com — carries a row to the top. Where a career total derived from the race records differs from a published one, both are shown. The full account: the ladder defined, every gap, every disagreement, and the reconciliation that runs on each build.

Career totals are counted from the race records wherever the records can support it, and an em dash means nobody has established that figure — never zero.

What you may do with it

Redistributable

7 sources — their rows may be passed on under the licence shown beside them.

Facts only

7 sources — the facts are used; nothing is copied.

Not redistributable

4 sources — on the register so the position is on record; no row may cite one.

Nobody publishes Formula One race timing under a licence that permits passing it on, so this database holds none of it: lap times, stints, race timing and race control messages ship as four empty tables, on purpose. Everything that is here may be passed on under the licence shown beside it; the pit stops and the qualifying times come from F1DB, whose CC BY 4.0 allows exactly that.

Race data from F1DB is CC BY 4.0; prose and registers from Wikipedia are CC BY-SA 4.0 and carry share-alike; the centrelines are ODbL and the obligation follows f1-geometry.db alone. Most of what this project wrote itself — its reading of every disagreement, its account of every gap and the prose of ten of its twelve reference tables — is CC BY 4.0 and carries no share-alike; meta.project_prose_columns names those columns inside the database. Every source, what it is trusted for, and what each licence cost or bought.

f1.db as a whole is CC BY-SA 4.0. Its facts are also published alone, as f1-facts.db, under CC BY 4.0 with no share-alike: f1.db less everything that stays share-alike — chiefly the car specifications, circuit layouts and quotations taken from Wikipedia, the prose not granted CC BY 4.0, and the register of Commons photographs — with the race rows that cite a Wikipedia season article rebuilt from F1DB, so that nothing Wikipedia made is in it. It is a release asset published beside f1.db, from the first release after v2.25, rather than a file served from here, and LICENSE-DATA states its terms. tools/facts_artefact.py names every table and column it leaves out, and why.

The team livery palette this site draws from 2010 is CC BY-SA 4.0 as well, and carries share-alike: most of its entries adapt the colour tables of Wikipedia’s Formula One sponsorship liveries article. It is in the site’s code, web/src/lib/liveries.js, not in f1.db, and the code around it is MIT.

Ask it something

The SQL console runs any read against the whole database in your browser — and a query’s address is a link to it.

Where a view exists, start from it. standings keeps a row after every round and more than one source’s reading of each, so the obvious query over it answers with the season several times over. v_standings_final folds both away: each season’s table as it finished, or as it stands, one source’s reading of each entrant. What it does not fold is the constructors’ championship’s own grain — Cooper-Climax and Cooper-Maserati are two 1960 entries and not one — so count that side on constructor_id and engine_id together. The console’s schema panel prints the commented schema of every table and view, which is where each column says what it means.

What leaves this tab

Every page here is a query against one SQLite file, running in this tab: nothing you search for, sort or type is sent as you do it. Three things leave: the address you arrive on, counted once and without cookies by Cloudflare; the photographs, from Wikimedia Commons as you reach them; and the fonts, from Google. Moving between pages counts nothing further — but a search, a filter or a SQL statement is kept in the address, so arriving at one of those, by reload or by a link, hands it over with the page. Once it has loaded, this tab keeps working without a network.