Every civil aircraft flying legally in the United States carries an N-number painted on its tail, and behind that tail number sits a row in a single federal database — the FAA Aircraft Registry, the public record of who owns what aircraft, where, and in what airworthiness condition. We hold a snapshot of the releasable registry as the table faa_aircraft, covering roughly 292,733 registered aircraft. It is the authoritative answer to a deceptively simple question — whose plane is that? — and, through one small hexadecimal field, it is also the bridge that turns an anonymous blip on a flight tracker into a named owner.
What it is and the N-number system
The FAA Aircraft Registry, operated by the FAA's Civil Aviation Registry in Oklahoma City, is the legal record of aircraft registration in the United States. Under the Chicago Convention every civil aircraft engaged in international navigation must carry a nationality and registration mark, and federal law — principally 49 U.S.C. § 44103 and the registration rules in 14 CFR Part 47 — requires that civil aircraft operated in the United States be registered with the FAA. Registration is what makes an aircraft legally eligible to fly; it is the aviation equivalent of a vehicle title and registration combined.
The United States was assigned the nationality prefix N by international agreement, which is why US-registered aircraft are universally called “N-numbers.” The mark consists of the letter N followed by an alphanumeric sequence, subject to strict formatting rules: a registration may be one to five characters after the N, ending in either no suffix, one letter, or two letters, and the digits cannot begin with zero. The letters I and O are excluded entirely because they are too easily confused with the digits 1 and 0. The result is a tightly bounded namespace — something on the order of 900,000 valid combinations — that the FAA allocates, reserves, and recycles. Owners may accept the next sequential number the FAA assigns, pay a fee to reserve a specific available number (a “vanity” N-number), or request to change an aircraft's number. The reserved-but-unassigned numbers live in their own file in the registry download.
Each registration record captures the aircraft along several axes. There is the N-number itself (stored without the leading N) and the airframe serial number assigned by the manufacturer, which together uniquely identify the physical machine. There is a manufacturer code — a seven-character key that encodes make, model, and series — which joins out to a separate reference file carrying the human-readable manufacturer name, model, aircraft type, engine type, engine count, and seat count. There is the year manufactured; the registrant name and mailing address; a registrant type code (individual, partnership, corporation, co-owned, LLC, government, non-citizen corporation, or trust); the airworthiness classification (standard, experimental, or special) and a more granular airworthiness category; the certificate issue and expiration dates; and — the field that quietly connects this database to the live sky — the aircraft's Mode S transponder hex code.
The registry files: MASTER, ACFTREF, ENGINE, DEALER
The FAA publishes the registry not as an API but as a single nightly ZIP archive — the Releasable Aircraft Database — that unpacks into a family of comma-delimited text files. Understanding the file structure is the prerequisite to using the data, because the information an analyst wants is deliberately split across files and must be reassembled by joining them.
MASTER is the heart of the registry: one row per registered aircraft. It carries the N-number, serial number, the seven-character manufacturer/model code, the year manufactured, the registrant name and address, the registrant type code, the airworthiness classification and category, the certificate issue date and expiration date, the registration status, and the Mode S hex code. MASTER answers “who is registered to this tail number, and in what condition?” but it stores the aircraft make and model only as that compact code — it does not spell out “Cessna 172.”
ACFTREF — the aircraft reference file — is the lookup table that decodes the manufacturer/model code. One row per code, it supplies the manufacturer name, the model designation, the aircraft type (a single-digit code distinguishing fixed-wing single-engine, fixed-wing multi-engine, rotorcraft, glider, balloon, and several smaller categories), the engine type, the number of engines, the number of seats, and a weight class. Joining MASTER to ACFTREF on that code is the single most important operation in working with the registry: it is what turns 292,733 cryptic registration rows into a fleet you can describe by make, model, and type.
ENGINE is a second reference file, keyed by an engine manufacturer/model code, that decodes the powerplant: engine manufacturer, model, horsepower or thrust, and engine type. It plays the same decoding role for engines that ACFTREF plays for airframes, and it matters for any analysis that turns on powerplant characteristics rather than just airframe identity.
DEALER holds aircraft dealer certificates rather than individual aircraft. A registered aircraft dealer may operate aircraft under a dealer certificate without registering each one individually — the mechanism that lets dealers demonstrate and reposition inventory — and those certificates live in their own file. The archive also includes RESERVED (N-numbers reserved but not yet assigned to an aircraft), DEREG (deregistered aircraft — sold abroad, destroyed, scrapped, or cancelled), and a document index pointing into the FAA's imaged registration paperwork. For most fleet and ownership analysis, MASTER joined to ACFTREF is the working core, with ENGINE pulled in when powerplant detail is needed.
Registrant types and the trust/LLC ownership-opacity problem
The single most consequential field for anyone using the registry to answer who really owns this aircraft is the registrant type, and it is also where the database's greatest limitation lives. The registrant-type code distinguishes an individual, a partnership, a corporation, a co-owned aircraft, an LLC, a government entity, a non-citizen corporation, and an aircraft held in trust. On its face, the registrant name and address tell you the owner. In practice, two of these categories — trusts and LLCs — have made the registry one of the more effective ownership-obscuring instruments in US recordkeeping.
The mechanism turns on a citizenship rule. US aircraft registration is generally restricted to US citizens, US permanent residents, and US-organized businesses; a foreign individual or a foreign-controlled company cannot directly register a US aircraft. But there is a long-standing, entirely legal workaround: a non-citizen may place an aircraft into a non-citizen trust, with a US-citizen trustee — typically a bank or a specialized trust company — holding legal title and registering the aircraft. The registry then shows the trustee as the registrant. The actual beneficial owner, the person who paid for the aircraft and directs its use, appears nowhere in the public record. A handful of professional trustee firms, many domiciled in states such as Delaware and Utah, hold legal title to thousands of aircraft on behalf of beneficiaries the registry does not name.
The LLC pathway produces a parallel, domestic-flavored opacity. Registering an aircraft to a single-purpose limited liability company — often a Delaware LLC formed solely to hold one airplane — is routine for liability and tax reasons, and entirely legitimate. But it means the registrant name in MASTER is frequently something like “N12345 LLC” or a generic holding-company name whose members are not disclosed in the aircraft registry and, in a state like Delaware, are not disclosed in the corporate record either. The aircraft is owned by an entity that is itself owned by people the public filing does not reveal.
This is not a hypothetical concern. The Federal Aviation Administration and the Department of Transportation Inspector General have both scrutinized the non-citizen trust structure, and the FAA has at various points tightened the information trustees must be able to furnish to the government on request — the trustee must, at minimum, be able to identify the beneficiary and the operator to the FAA and law enforcement, even though that information is not published. Journalists and researchers tracing the ownership of business jets routinely hit the trustee-and-LLC wall: the registry tells you a Delaware trust company holds title, and the trail goes cold there unless a corporate filing, a financing document, or a leak connects the entity to a beneficial owner. For aggregate analysis the registrant-type field is invaluable — you can count exactly how many aircraft are held in trust or by LLCs, and watch that share grow over time — but for resolving an individual aircraft to a named human being, trust and LLC registrations are precisely where the public record stops.
The Mode S hex code: linking the registry to ADS-B flight tracking
The registry would be a static ownership ledger were it not for one field that ties it to the live movement of aircraft: the Mode S transponder hex code, also called the ICAO 24-bit address. Every aircraft equipped with a Mode S transponder — which today means essentially every aircraft that flies in controlled airspace, because the FAA's ADS-B Out mandate requires it in most of US airspace — is assigned a unique 24-bit code that the transponder broadcasts continuously. The FAA derives each US aircraft's code from its registration and prints it in MASTER as a six-character hexadecimal string. US codes all fall within the block ICAO allocated to the United States, so a hex address can be recognized as American at a glance.
The significance is that ADS-B flight-tracking networks key on exactly this address. When an aircraft broadcasts its position via ADS-B Out, every ground receiver and satellite that hears it records the position report against the aircraft's 24-bit hex code, not against its tail number. Flight-tracking services and open feeds — the OpenSky Network, the community of dump1090 receivers behind FlightAware and ADSB Exchange, and the like — are therefore rivers of position reports indexed by hex code. On their own, those reports are anonymous: a hex address tracing an arc across a map. Joined to the FAA registry on the Mode S field, each hex address resolves to an N-number, a make and model, and a registrant. The registry is the Rosetta Stone that converts anonymous ADS-B traffic into named, owner-attributed flights.
That join is what powers an entire genre of public-interest aviation reporting and analysis: tracking corporate and celebrity jets, mapping government and law-enforcement surveillance aircraft, documenting deportation and rendition flights, and watching the movements of sanctioned oligarch aircraft. It is also why aircraft owners who want privacy lean on the opacity tools described above — a jet registered to a Delaware trust still broadcasts a hex code, so the flights are visible; the trust merely breaks the final link from hex-to-tail to a named human owner. The FAA has offered privacy programs (such as the Limiting Aircraft Data Displayed and Privacy ICAO Address initiatives) that let qualifying operators obscure or rotate the displayed identity, but the underlying registry-to-hex linkage remains the foundational mechanism, and the releasable database is the public key to it.
Triennial re-registration and the 2010–2013 purge
For decades, an aircraft registration in the United States effectively never expired. An owner registered an aircraft once and the certificate stood indefinitely, with no requirement to confirm that the aircraft still existed, was still owned by the registrant, or was still in the country. The predictable consequence accumulated over time: the registry filled with stale and erroneous records — aircraft that had been scrapped, destroyed, sold overseas, or whose owners had died or moved — that no one had any obligation to correct. By the late 2000s the FAA estimated that a large fraction of the registry, on the order of a third of records, contained inaccurate registration information.
This was not merely a data-hygiene embarrassment. A registry riddled with phantom and misattributed aircraft is a national-security and law-enforcement liability: it undermines the ability to identify the responsible party for an aircraft of interest, and it leaves valid N-numbers nominally tied to airframes that no longer exist. In response, the FAA issued a 2010 rule that re-engineered registration around expiration and renewal. Every aircraft registration would thereafter expire after three years — a triennial cycle — and owners would have to actively re-register to keep their aircraft legal.
To clear the accumulated backlog, the FAA ran a one-time re-registration program from 2010 through 2013, assigning existing aircraft staggered expiration dates and requiring each owner to re-register within a defined window. Aircraft whose owners did not respond had their registrations cancelled. The program functioned as a deliberate purge: tens of thousands of aircraft that no longer existed, or whose owners could no longer be reached, fell off the active registry, and the corresponding N-numbers returned to the pool. The effect on the data is important to understand for any longitudinal analysis — the active aircraft count drops sharply across that period not because aircraft were being scrapped at an elevated rate, but because the registry was being reconciled to reality. Since the program, an aircraft must be re-registered every three years, and the certificate expiration date in MASTER became a meaningful, enforced field rather than a formality. A registration that has lapsed renders the aircraft ineligible to fly until renewed.
What you can do with the registry
The releasable registry, especially once MASTER is joined to ACFTREF and ENGINE and cross-referenced against ADS-B feeds, supports a wide range of analysis.
Fleet composition by manufacturer and model. The most direct use is profiling the US civil fleet: counting registered aircraft by type (fixed-wing single, fixed-wing multi, rotorcraft, glider, balloon), by manufacturer, and by specific model. This is how you establish that the general-aviation fleet is dominated by a handful of single-engine piston designs, how many of a given model remain on the register, or how the rotorcraft and experimental populations compare to certificated fixed-wing aircraft.
Business-jet ownership mapping. Filtering to turbine and multi-engine business aircraft and grouping by registrant lets you map who owns corporate fleets — subject always to the trust and LLC opacity that makes the registrant name a starting point rather than a final answer. Combined with corporate filings, the registry is a primary input for tracing executive and corporate aviation assets.
Trust-registration analysis. Because the registrant type is a coded field, you can quantify the opacity directly: count aircraft held in trust, count single-purpose LLC registrations, identify the trustee firms that hold title to the most aircraft, and track how the trust and LLC share of the fleet has changed over successive registry snapshots. This turns an anecdotal concern about beneficial-ownership opacity into a measurable, longitudinal statistic.
Joining Mode S hex to ADS-B for tail-to-flight resolution. The highest-value analyses come from the hex-code join: resolving anonymous ADS-B traffic to named aircraft and owners, attributing specific flights to specific tail numbers, and building owner-level flight histories. This is the technical foundation of jet-tracking and surveillance-aircraft journalism.
Age of the general-aviation fleet. The year-manufactured field exposes one of the defining facts of US general aviation: the piston fleet is old. The median light aircraft on the US register was built decades ago, because new piston-aircraft production collapsed after the 1980s liability crisis and never fully recovered. Computing the distribution of manufacture years — overall and by type — quantifies the aging-fleet problem that drives debates over avionics modernization, airworthiness, and the cost of keeping legacy aircraft flying.
A worked example in Python
The workflow below downloads the FAA Releasable Aircraft Database ZIP from registry.faa.gov, unpacks the delimited text files, joins MASTER to ACFTREF on the manufacturer/model code to attach human-readable make, model, and aircraft type, and then computes fleet composition by aircraft type, the top manufacturers by registered airframe count, the median airframe age, and a count of aircraft registered to trusts. A second snippet shows the Mode S hex join that connects the registry to ADS-B flight data.
Step 1: Download and unpack the releasable ZIP
import requests, io, zipfile, pandas as pd
# ---------------------------------------------------------------------------
# FAA Releasable Aircraft Database (the public aircraft registry)
# Primary access: https://registry.faa.gov/database/
#
# The FAA publishes the entire releasable registry as a single ZIP archive,
# updated nightly. It is NOT an API -- it is a flat-file download. The ZIP
# unpacks into a set of comma-delimited text files, the two most important
# of which are:
#
# MASTER.txt -- one row per registered aircraft (the registration record)
# ACFTREF.txt -- the aircraft reference file: make/model/type by mfr code
#
# plus ENGINE.txt (engine reference), DEALER.txt (dealer certificates),
# RESERVED.txt (reserved N-numbers), DEREG.txt (deregistered aircraft), and
# a DOCINDEX of imaged registration documents.
# ---------------------------------------------------------------------------
ZIP_URL = "https://registry.faa.gov/database/ReleasableAircraft.zip"
print("Downloading FAA Releasable Aircraft Database ZIP...")
resp = requests.get(ZIP_URL, timeout=300)
resp.raise_for_status()
zf = zipfile.ZipFile(io.BytesIO(resp.content))
print("Files in archive:")
for name in zf.namelist():
info = zf.getinfo(name)
print(f" {name:<20} {info.file_size:>12,} bytes")
# The fixed/delimited text files carry trailing spaces in many fields and a
# stray trailing comma on each line; read as strings and strip afterward.
def read_faa(member):
with zf.open(member) as fh:
df = pd.read_csv(fh, dtype=str, low_memory=False)
df.columns = [c.strip() for c in df.columns]
# Strip whitespace from every string cell (FAA pads fixed-width exports)
for col in df.columns:
df[col] = df[col].str.strip()
return df
master = read_faa("MASTER.txt")
acftref = read_faa("ACFTREF.txt")
print(f"\nMASTER rows (registered aircraft): {len(master):,}")
print(f"ACFTREF rows (make/model reference): {len(acftref):,}")
print(f"\nMASTER columns: {list(master.columns)}")
Step 2: Join MASTER to ACFTREF and compute fleet composition
import pandas as pd
# Assumes master and acftref are loaded from the download step above.
#
# ---------------------------------------------------------------------------
# Join MASTER to ACFTREF on the manufacturer code.
#
# In MASTER the column is "MFR MDL CODE"; in ACFTREF it is "CODE". Both are a
# 7-character code that encodes manufacturer + model + series. Joining on it
# attaches the human-readable make, model, aircraft TYPE, engine TYPE, number
# of engines, and number of seats to every registration record.
# ---------------------------------------------------------------------------
master = master.rename(columns={"MFR MDL CODE": "CODE"})
ref = acftref.rename(columns={
"MFR": "MFR_NAME",
"MODEL": "MODEL_NAME",
"TYPE-ACFT": "ACFT_TYPE",
"TYPE-ENG": "ENG_TYPE",
"NO-ENG": "NO_ENG",
})[["CODE", "MFR_NAME", "MODEL_NAME", "ACFT_TYPE", "ENG_TYPE", "NO_ENG"]]
fleet = master.merge(ref, on="CODE", how="left")
print(f"Registered aircraft after join: {len(fleet):,}")
unmatched = fleet["MFR_NAME"].isna().sum()
print(f"Rows with no ACFTREF match: {unmatched:,}")
# ---------------------------------------------------------------------------
# 1. Fleet composition by aircraft TYPE.
# The ACFTREF TYPE-ACFT code is a single digit:
# 1 Glider 2 Balloon 3 Blimp/Dirigible
# 4 Fixed wing single-engine 5 Fixed wing multi-engine
# 6 Rotorcraft 7 Weight-shift 8 Powered parachute
# 9 Gyroplane H Hybrid Lift O Other
# ---------------------------------------------------------------------------
ACFT_TYPE_LABEL = {
"1": "Glider", "2": "Balloon", "3": "Blimp/Dirigible",
"4": "Fixed wing single-engine", "5": "Fixed wing multi-engine",
"6": "Rotorcraft", "7": "Weight-shift-control", "8": "Powered parachute",
"9": "Gyroplane", "H": "Hybrid Lift", "O": "Other",
}
by_type = fleet["ACFT_TYPE"].map(ACFT_TYPE_LABEL).fillna("Unknown").value_counts()
print("\nFleet composition by aircraft type:")
for label, cnt in by_type.items():
pct = cnt / len(fleet) * 100
print(f" {label:<28} {cnt:>8,} ({pct:4.1f}%)")
# ---------------------------------------------------------------------------
# 2. Top manufacturers by registered airframe count.
# ---------------------------------------------------------------------------
top_mfr = fleet["MFR_NAME"].fillna("(unmatched)").value_counts().head(15)
print("\nTop 15 manufacturers by registered aircraft:")
for mfr, cnt in top_mfr.items():
print(f" {mfr:<28} {cnt:>8,}")
# ---------------------------------------------------------------------------
# 3. Age of the fleet (year manufactured).
# ---------------------------------------------------------------------------
fleet["YEAR"] = pd.to_numeric(fleet["YEAR MFR"], errors="coerce")
valid_year = fleet.dropna(subset=["YEAR"])
median_year = int(valid_year["YEAR"].median())
print(f"\nMedian year manufactured (where known): {median_year}")
print(f"Median airframe age (assuming 2027): {2027 - median_year} years")
# ---------------------------------------------------------------------------
# 4. Trust-registration count.
# The MASTER "TYPE REGISTRANT" code identifies the registrant category:
# 1 Individual 2 Partnership 3 Corporation 4 Co-owned
# 5 Government 7 LLC 8 Non-citizen corporation
# 9 Non-citizen co-owned and trusts carry their own flag.
# Trust registrations are flagged where TYPE REGISTRANT is blank but the
# name/structure is a trust; the dedicated code in current files is "T".
# ---------------------------------------------------------------------------
REGISTRANT_LABEL = {
"1": "Individual", "2": "Partnership", "3": "Corporation",
"4": "Co-owned", "5": "Government", "7": "LLC",
"8": "Non-citizen corporation", "9": "Non-citizen co-owned",
"T": "Trust",
}
reg_type = fleet["TYPE REGISTRANT"].map(REGISTRANT_LABEL).fillna("Other/blank")
by_registrant = reg_type.value_counts()
print("\nRegistrations by registrant type:")
for label, cnt in by_registrant.items():
pct = cnt / len(fleet) * 100
print(f" {label:<28} {cnt:>8,} ({pct:4.1f}%)")
trust_count = (fleet["TYPE REGISTRANT"] == "T").sum()
print(f"\nAircraft registered to a trust: {trust_count:,}")
Step 3: Resolve Mode S hex codes against the registry
# ---------------------------------------------------------------------------
# Joining the registry to live flight data via the Mode S hex code.
#
# Every transponder-equipped aircraft broadcasts a 24-bit ICAO address. The
# FAA assigns each US registration a Mode S code and prints it in MASTER as
# "MODE S CODE HEX" (a 6-character hex string, e.g. "A12345"). ADS-B feeds
# (the OpenSky Network, the dump1090 receivers behind FlightAware/ADSB-
# Exchange, etc.) key every position report on exactly this hex address.
#
# So the hex code is the bridge: it turns an N-number in the registry into a
# join key against the live flight-tracking world. Given a hex code seen in
# an ADS-B feed, you can resolve the tail number and its registered owner;
# given a tail number, you can find every flight its transponder emitted.
# ---------------------------------------------------------------------------
import pandas as pd
# 'fleet' from the previous step has MASTER columns including the hex code.
hex_col = "MODE S CODE HEX"
fleet[hex_col] = fleet[hex_col].str.upper().str.strip()
# Build a lookup: hex -> (N-number, owner, make/model). N-NUMBER in MASTER is
# stored WITHOUT the leading "N", so prepend it for display.
lookup = (
fleet.dropna(subset=[hex_col])
.assign(TAIL="N" + fleet["N-NUMBER"].fillna(""))
.set_index(hex_col)[["TAIL", "NAME", "MFR_NAME", "MODEL_NAME"]]
)
# Example: an ADS-B receiver reports these ICAO hex addresses overhead.
seen_hex = ["A12345", "AB1234", "A9F0E1"]
print(f"{'Hex':<8} {'Tail':<8} {'Owner':<28} {'Type'}")
print("-" * 70)
for h in seen_hex:
if h in lookup.index:
row = lookup.loc[h]
# .loc can return a frame if the hex is duplicated; take the first.
if isinstance(row, pd.DataFrame):
row = row.iloc[0]
make_model = f"{row['MFR_NAME']} {row['MODEL_NAME']}".strip()
print(f"{h:<8} {row['TAIL']:<8} {str(row['NAME'])[:28]:<28} {make_model}")
else:
print(f"{h:<8} (not found in current registry)")
A few implementation notes. The FAA text files are exported from a fixed-width system and carry padding: column names and many cell values arrive with trailing spaces, and each data line ends with a stray comma, so reading every column as a string and stripping whitespace afterward (as the read_faa helper does) is the robust pattern. The join key is the seven-character manufacturer/model code, named “MFR MDL CODE” in MASTER and “CODE” in ACFTREF; a small fraction of MASTER rows will not match ACFTREF and should be carried through as an explicit unmatched bucket rather than silently dropped. The aircraft-type and registrant-type fields are single-character codes whose meanings come from the FAA registry layout documentation distributed with the download — the label dictionaries in the example reflect the published code lists, but you should verify them against the layout file shipped in the current ZIP, because the FAA has revised the code lists over time (the trust registrant code in particular has evolved). Finally, the N-number in MASTER is stored without the leading “N,” and the Mode S hex code should be upper-cased before any join against ADS-B feeds, which conventionally render the 24-bit address in lowercase or uppercase hex inconsistently.
Caveats and limitations
The registry is the authoritative ownership record, but several structural limitations shape what it can and cannot tell you.
Registration is not airworthiness, and not activity. A row in MASTER means an aircraft is registered — it says nothing about whether the aircraft is currently airworthy, currently flying, or even physically intact. An airframe can hold a valid registration while sitting disassembled in a hangar for years, mid-restoration, or grounded for want of an inspection. The airworthiness classification field records the category under which an airworthiness certificate was issued, not whether a current inspection makes the aircraft legal to fly today. Treat the registry as a count of registered aircraft, not as a count of active or flyable ones.
Address opt-outs and incomplete contact data. The FAA allows registrants to request that their address be withheld from the public releasable file, and registrant addresses can be post-office boxes, registered-agent addresses, or the address of a trust company rather than a residence or principal place of business. The address field is therefore an unreliable guide to where an aircraft or its true owner is actually located.
Trust and LLC opacity. As detailed above, the registrant name resolves to the legal title-holder, which for a large and growing share of higher-value aircraft is a trustee or a single-purpose LLC rather than the beneficial owner. The registry can tell you that an aircraft is held in trust or by an LLC, and which firm holds title, but it does not name the person behind the structure. Any analysis that treats the registrant name as the beneficial owner will systematically misattribute the most deliberately obscured aircraft in the fleet.
Re-registration lag and timing artifacts. Because registrations now expire on a three-year cycle, the active register at any moment includes a penumbra of aircraft whose registrations are technically lapsed but not yet cancelled, and excludes aircraft whose renewals are in process. Longitudinal counts are sensitive to the timing of the triennial cycle and, for any series that spans 2010–2013, to the one-time re-registration purge that mechanically removed tens of thousands of stale records. A drop in the active aircraft count across that window reflects registry reconciliation, not a real contraction of the fleet, and should be annotated as such in any trend analysis.
Snapshot, not history. The releasable database is a current-state file: MASTER reflects the registry as of the download, with deregistered aircraft shunted to a separate DEREG file. Reconstructing ownership history — who held an aircraft before its current registrant — requires either successive archived snapshots or the FAA's imaged document records, not the single current MASTER file. For any question about how ownership or fleet composition changed over time, you need a series of snapshots, not one.
Related writing
NTSB aviation accidents: the federal record behind every US aircraft accident investigation — the safety-outcome counterpart to the registry; NTSB accident records identify aircraft by the same N-number this database registers, so the two join directly to attach an accident's aircraft to its registered make, model, age, and owner.
FRA highway-rail grade crossing inventory: the federal database behind 250,000 railroad crossings — the rail analogue, another asset-identity registry keyed on a unique national code (the DOT/AAR crossing number) and paired with a companion incident file, illustrating the same inventory-plus-events pattern across a different mode.
FMCSA crash data: the federal database behind large truck and bus crashes — the highway-freight counterpart, where crashes join to a carrier registry on the USDOT number much as flights join to this aircraft registry on the Mode S hex code: an identity key turning anonymous events into owner-attributed records.