US Aircraft Registration Records — FAA Technical & Status

Keyless. Pay per record. Every US-registered aircraft's technical and registration-status profile — aircraft only, never owners or builder names.

This actor turns the US Federal Aviation Administration (FAA) Releasable Aircraft Database into clean, per-aircraft records — the technical and registration-status profile of every aircraft on the US civil register. Each run reads the FAA's keyless daily bulk file and delivers one row per aircraft: its N-number, airframe serial, aircraft and engine type codes, aircraft category, build-certification class, number of engines and seats, weight class, cruising speed, year manufactured, airworthiness and certification dates, registration status, expiration date, and Mode S transponder codes (octal and the ICAO 24-bit hex). Aircraft grain, structured for engineering use, in the public domain, with a two-layer person-gate: the registration owner block AND the make/model reference text — which the FAA populates with individual builders' names for amateur-built aircraft — are both structurally excluded and never read.

What this is, in one paragraph

The FAA publishes the US civil aircraft register as a daily "releasable" bulk download. That file pairs each aircraft's technical attributes with its owner's identity and mailing address, and its make/model reference table embeds the names of individual builders and sole proprietors for the tens of thousands of amateur-built and experimental aircraft on the register. This actor reads only the person-free technical and status attributes: it keys each aircraft on its N-number and carries the airframe serial, the aircraft and engine type codes, the aircraft category and build-certification code, the number of engines and seats, the weight class and cruising speed, the year manufactured, the certification and airworthiness dates, the registration status code, the expiration date, and the Mode S codes. The owner name, address, and every "other names" field are never indexed into a record, and the make/model text is never read — because for amateur-built aircraft it carries a natural person's name. Values are exactly as published for the current daily file. You are billed only for records actually delivered.

Who buys this and for what job

• Flight-tracking, ADS-B, and aviation-tech teams mapping the N-number ↔ Mode S / ICAO 24-bit hex correspondence across the whole US register.
• Fleet-analytics, MRO, and insurance-modelling teams profiling the US civil fleet by aircraft type, engine type, category, seats, weight, and age.
• Safety, research, and registration-status products studying airworthiness dates, expiration dates, and registration-status distributions.
• Data engineers who want the FAA registry's clean technical layer without unzipping a 190 MB file, joining the reference tables, and hand-dropping the owner and builder-name columns.

Public-domain data — free commercial reuse

One licence rider travels on every record. The FAA Releasable Aircraft Database is a work of the US federal government — no copyright, public domain under 17 U.S.C. §105 — free to reuse, including commercially, with attribution to the FAA. One honest caveat rides too: these are registration-and-technical facts as published for the current daily file, not an airworthiness determination or a certification of current flight status.

Aircraft grain — a two-layer person-gate

The unit of every record is an aircraft, keyed on its N-number — never a person. The FAA data carries person data in two places, and this actor excludes both structurally. First, the registration master interleaves each aircraft's technical fields with the registrant's identity and mailing address; the ingest reads only technical columns by fixed index, and the owner block — registrant type, name, street, street2, city, state, ZIP, region, county, country, fractional-owner flag, and OTHER NAMES(1) through (5) — is never indexed into a record. Second, and less obvious, the make/model reference table lists the manufacturer as an individual builder's or sole-proprietor (DBA) name for amateur-built and experimental aircraft (roughly 85,000 of them); to guarantee no person name ever surfaces, the make and model text is never read at all — only the numeric and coded specs from that table (category, build-certification code, engine count, seats, weight, speed) are carried. A person-key guard runs on every record as a backstop, and the acceptance suite feeds a master row whose owner name, address, and other-names are populated and an amateur-built reference whose "manufacturer" is a person name, and asserts that not one of those keys or values can ever appear in output. The N-number is the aircraft's public registration mark (like a vehicle plate), not a person.

Pricing

Event	Free plan	Bronze	Silver	Gold / Platinum / Diamond
aircraft_record	$0.05	$0.045	$0.04	$0.0335

Delivered before charged. Blocked runs and empty results cost nothing.

Input

Field	Type	Default	Description
statusCode	string	—	Optional FAA registration status code (e.g. V = Valid).
aircraftType	string	—	Optional FAA TYPE AIRCRAFT code (e.g. 4 = fixed wing single engine, 5 = fixed wing multi engine, 6 = rotorcraft).
engineType	string	—	Optional FAA TYPE ENGINE code (e.g. 1 = reciprocating, 4 = turbo-prop, 5 = turbo-fan).
maxRecords	integer	500	Ceiling on records delivered and billed.

Output

One JSON object per aircraft. Real example (values as published; owner block and make/model text excluded by construction):

{
  "record_id": "N100",
  "n_number": "N100",
  "serial_number": "5334",
  "mfr_model_code": "7100510",
  "aircraft_type_code": "4",
  "aircraft_category_code": "1",
  "build_cert_code": "0",
  "engine_type_code": "1",
  "num_engines": "01",
  "num_seats": "002",
  "aircraft_weight_class": "CLASS 1",
  "cruising_speed": "0067",
  "year_mfr": "1940",
  "certification": "1",
  "status_code": "V",
  "airworthiness_date": "19540430",
  "expiration_date": "20270430",
  "mode_s_code": "50002263",
  "mode_s_code_hex": "A004B3",
  "source": "US FAA Releasable Aircraft Database",
  "licence": "US FAA Releasable Aircraft Registration Database ... public domain (17 U.S.C. §105) ...",
  "disclaimer": "Aircraft technical and registration-status records ... make/model reference text ... never read ...",
  "observed_at": "2026-08-22T00:00:00Z"
}

An unbilled RUN_RECEIPT records the robots check, the filters, aircraft matched and delivered, and whether charged equals delivered — plus a notice that the owner block and make/model text are structurally excluded.

Field reference

Each record is one aircraft. Identity: record_id / n_number (the registration mark), serial_number, mfr_model_code (the FAA reference code — a number, not a name), and unique_id. Type and class: aircraft_type_code, aircraft_category_code, build_cert_code, and engine_type_code (the FAA's own codes, carried verbatim). Specs: num_engines, num_seats, aircraft_weight_class, and cruising_speed. Age and certification: year_mfr and certification. Registration status and dates: status_code, airworthiness_date, cert_issue_date, last_action_date, and expiration_date. Equipment identifiers: mode_s_code (octal) and mode_s_code_hex (the ICAO 24-bit address, the key for ADS-B / flight-tracking correlation). Provenance: source, source_url, licence, attribution, disclaimer, and observed_at.

How a run works

A run first re-reads the source host's robots posture from your runtime — the FAA registry host, whose only Disallow scopes the /aircraftinquiry/*.asp interactive pages, leaving the /database/ bulk file clear — and stops at the door if that ever changes. It downloads the releasable-aircraft ZIP once, builds a numeric/coded aircraft-spec lookup (never reading the make/model text), and streams the registration master — reading only the technical and status columns by fixed index, never the owner block — applies your optional status, type, and engine filters, and flattens each aircraft to one record, delivered before it is charged, so a blocked or empty run costs you nothing. The actor stops at your maxRecords ceiling and records charge_equals_delivered in the receipt.

Coverage and scope

The register holds on the order of 300,000+ aircraft on the current daily file. Because each record carries the aircraft_type_code, engine_type_code, status_code, and year_mfr, segmenting the fleet by type, engine, status, or age is straightforward, and the mode_s_code_hex gives a direct join key to ADS-B and flight-tracking feeds. Pull one aircraft type, one engine type, or the whole register to seed a fleet table, then take fresh daily pulls as the file refreshes.

Working with the register

The register is built to be joined and segmented, and the codes make that mechanical. The mode_s_code_hex is the ICAO 24-bit address broadcast by an aircraft's transponder, so a single pull gives the N-number ↔ ICAO-hex map that ADS-B and flight-tracking systems need to turn a raw broadcast into a registered airframe. The aircraft_type_code and engine_type_code split the fleet by airframe and powerplant class, while num_engines, num_seats, aircraft_weight_class, and cruising_speed add a performance profile, and year_mfr supports an age analysis across the whole register. The status_code, airworthiness_date, and expiration_date support a registration-lifecycle view — which aircraft are current, which are lapsing — and two daily pulls can be diffed on status_code and last_action_date to see what changed. Every one of these is a code, a number, a date, or an identifier — never a name.

Cost guidance

One aircraft_record per delivered aircraft: cost = aircraft delivered × your plan's per-record price. Scope with statusCode, aircraftType, or engineType to keep runs bounded. The whole register is ~316,000 aircraft; 1,000 aircraft is $50 (Free) / $33.50 (Gold).

Honest limitations

• No make/model text. By design, the make/model reference text is never read, because the FAA populates it with individual builders' names for amateur-built aircraft; this actor carries the person-free mfr_model_code, type/category codes, and numeric specs instead. If you need the make/model name, join the code to the FAA reference table yourself under your own person-data controls.
• Technical and status only. No owner, registrant, or address field is ever emitted.
• Codes as published. Status, type, category, and certification codes are the FAA's own codes, carried verbatim.
• No person data of any kind.

Differentiation

This is a net-new category for the NexGenData fleet — no existing fleet actor covers the FAA aircraft register. It is distinct from the fleet's airport-facility-records (airports and facilities, not aircraft) and from any airworthiness-directive or aviation-safety feed (those cover safety directives and incident reports, not the registration master). Its specific job is the FAA aircraft register's person-free technical and status layer — type, engine, specs, airworthiness, registration status, and the Mode S / ICAO hex identifier, aircraft by aircraft.

The NexGen Signal family

Part of the NexGen Signal family of pay-per-record data products:

• Airport Facility Records — US Airports
• US Credit Union Financial Records — NCUA Call Report
• US Committee Finance Records — FEC Summaries
• US Hospital Ownership Records — CMS Owner Edges
• Mine Operator & Safety Records — US MSHA

Source: US Federal Aviation Administration (FAA) Releasable Aircraft Database (registry.faa.gov). A work of the US federal government, no copyright, public domain (17 U.S.C. §105); free to reuse, including commercially, with attribution to the FAA. Aircraft grain, person-free technical and registration-status attributes only; the owner block and the make/model reference text (which carries individual builders' names for amateur-built aircraft) are structurally excluded at ingest and never read into a record. Registration-and-technical facts as published, not an airworthiness determination.