# US Aircraft Registration Records — FAA Technical (`nexgensignal/us-aircraft-registration-records`) Actor

Keyless pay-per-record FAA aircraft technical/status records — N-number, type/engine codes, specs, airworthiness, status, Mode S hex. Owner block and make/model text excluded. GOLD $0.05 ladder.

- **URL**: https://apify.com/nexgensignal/us-aircraft-registration-records.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 aircraft records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 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):

```json
{
  "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](https://apify.com/nexgensignal/airport-facility-records)
- [US Credit Union Financial Records — NCUA Call Report](https://apify.com/nexgensignal/us-credit-union-financial-records)
- [US Committee Finance Records — FEC Summaries](https://apify.com/nexgensignal/us-committee-finance-records)
- [US Hospital Ownership Records — CMS Owner Edges](https://apify.com/nexgensignal/us-hospital-ownership-records)
- [Mine Operator & Safety Records — US MSHA](https://apify.com/nexgensignal/mine-operator-safety-records)

*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.*

# Actor input Schema

## `statusCode` (type: `string`):

Optional FAA registration status code to filter (e.g. V = Valid).

## `aircraftType` (type: `string`):

Optional FAA TYPE AIRCRAFT code (e.g. 4 = fixed wing single engine, 5 = fixed wing multi engine, 6 = rotorcraft, 1 = glider, 2 = balloon).

## `engineType` (type: `string`):

Optional FAA TYPE ENGINE code (e.g. 1 = reciprocating, 5 = turbo-fan, 4 = turbo-prop).

## `maxRecords` (type: `integer`):

Maximum records delivered and billed.

## Actor input object example

```json
{
  "maxRecords": 500
}
```

# Actor output Schema

## `results` (type: `string`):

Delivered records.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxRecords": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/us-aircraft-registration-records").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "maxRecords": 500 }

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/us-aircraft-registration-records").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxRecords": 500
}' |
apify call nexgensignal/us-aircraft-registration-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/us-aircraft-registration-records"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/QBH8HbdM8EuEK7NPw/builds/SJbs1ybKIuLQNqCHy/openapi.json