How to Track an Aircraft by Tail Number (Registration) via API

Resolve the tail number operating any flight with FlightNerve's regNumber field, then follow that exact airframe live while it is airborne.

July 24, 2026 · · 10 min read

A flight number is a promise on a timetable; a tail number is the physical aircraft that keeps it. When you want to track aircraft by tail number — the actual registration painted near the rear of the fuselage — you are no longer asking "when does EK72 leave Dubai?" You are asking "which airframe is flying EK72 today, and where is it right now?" That is a fundamentally different question, and it is the one that matters to maintenance planners, lessors, dispatchers, and anyone building a serious flight-tracking app. This guide shows how to resolve the registration operating any flight through the FlightNerve API using the regNumber field, why the same flight number rides a different tail on different days, and how to follow that tail live while it is airborne.

Tail number vs. flight number vs. callsign vs. type code

These four identifiers are constantly confused, and mixing them up is the root cause of most "wrong aircraft" bugs. Here is how they differ:

• Flight number (e.g. EK72): a commercial schedule slot. It is reused every day and can be operated by any suitable aircraft in the fleet. It identifies a service, not a machine.
• Tail number / registration (e.g. A6-EOA): the legal, unique identity of one physical aircraft, assigned by its country of registry. It stays with the airframe for years. This is the value FlightNerve returns as regNumber.
• Callsign (e.g. UAE72): what the crew says to air traffic control. Often derived from the flight number but not identical, and not a stable asset identifier.
• Aircraft type code (e.g. 388 for an Airbus A380-800): the model, shared by hundreds of airframes. It tells you what kind of aircraft, never which one.

Only the tail number answers "which specific aircraft." An aircraft registration API that ties a live flight to its regNumber is therefore the bridge between a schedule and a real-world asset. That is exactly the gap FlightNerve fills.

How to get the registration operating a flight

You do not look up a tail number in the abstract — you query by flight, and FlightNerve tells you which tail is operating it. There are two endpoints that carry regNumber for this.

The /airline endpoint — full status plus the aircraft object

The /airline endpoint returns a flight's complete status. Inside the response is an aircraft object that describes the machine actually flying the service:

{
  "aircraft": {
    "code": "388",
    "name": "Airbus A380-800",
    "regNumber": "A6-EOA"
  }
}

The code is the type, the name is the human-readable model, and regNumber is the tail number — the registration of the aircraft FlightNerve identifies live while it is airborne. Query it with the flight number split into its airline (name) and numeric (num) parts, plus a date:

# cURL — which tail is flying EK72 today?
curl "https://api.flightnerve.com/YOUR_KEY/airline/YOUR_KEY?num=72&name=EK&date=20260726"

# Node.js
const key = "YOUR_KEY";
const res = await fetch(
  `https://api.flightnerve.com/${key}/airline/${key}?num=72&name=EK&date=20260726`
);
const flight = await res.json();
console.log(flight.aircraft.regNumber); // "A6-EOA"
console.log(flight.aircraft.name);      // "Airbus A380-800"

The /track endpoint — the live position, also carrying regNumber

Once you know a flight is in the air, /track gives you its live position — and it carries regNumber too, so you can confirm the tail and follow it in one call:

# Python
import requests

key = "YOUR_KEY"
r = requests.get(
    f"https://api.flightnerve.com/{key}/track/{key}",
    params={"num": "72", "name": "EK"},
)
pos = r.json()
if pos:  # [] when the flight is not airborne
    p = pos[0]
    print(p["regNumber"], p["latitude"], p["longitude"], p["altitude"], p["phase"])

Alongside regNumber, /track returns latitude, longitude, altitude, groundSpeed, heading, phase, progress, source, and onGround. That is enough to place a specific airframe on a map, labelled with its tail.

The honest part: regNumber is live-while-airborne

FlightNerve identifies the tail live while the aircraft is airborne. This is a strength — you are seeing the airframe that is actually operating the flight right now, not a stale schedule guess — but it comes with an expectation you must design around: regNumber is null when the flight is not currently in the air, and /track returns an empty array [] for a flight that is on the ground or pre-departure.

Practically, that means:

• If you query a flight hours before pushback, aircraft.regNumber will be null. The tail is confirmed once the aircraft is up.
• Poll around and after departure to capture the registration as the flight becomes airborne.
• Treat null / [] as "not airborne yet," not as an error. Build your UI to show "tail confirmed on departure" rather than a blank or a crash.

Setting this expectation honestly up front saves you from writing retry logic that fights the data model instead of working with it.

Worked example: EK72, from schedule to live tail

Here is the full flow for an aircraft tail number lookup on a real service — Emirates flight 72.

Step 1 — ask which aircraft is operating the flight. Call /airline with name=EK, num=72. Once the flight is airborne, the aircraft object resolves to:

{ "code": "388", "name": "Airbus A380-800", "regNumber": "A6-EOA" }

You now know EK72 is being flown by A6-EOA, a specific Airbus A380-800 — not just "an A380," but that exact superjumbo.

Step 2 — follow that same tail live. Call /track for the same flight and read the live block, which also reports regNumber: "A6-EOA" so you can be certain the position you are drawing belongs to the airframe you just identified. You get its latitude, longitude, altitude, ground speed, heading, and flight phase — the raw material for a moving map dot labelled "A6-EOA · A380."

Step 3 — tomorrow, expect a different tail. Run the same EK72 query on another date and regNumber may well come back as a different A380 registration. The flight number is a schedule; the tail is the asset. This is precisely why you resolve the registration per operation rather than caching a fixed mapping.

Reading registration prefixes by country

Every tail number begins with a country prefix assigned under international convention, so regNumber also tells you where an aircraft is registered — useful for asset tracking and for labelling in a UI. A few common prefixes:

• A6- — United Arab Emirates (e.g. A6-EOA)
• N — United States (N-numbers, e.g. N12345)
• G- — United Kingdom (e.g. G-XWBA)
• D- — Germany (e.g. D-AIMA)
• F- — France
• VH- — Australia
• B- — China (and separately Taiwan/Hong Kong ranges)

Because the prefix is part of the registration string, you can group airframes by country of registry directly from regNumber without any extra lookup — handy when the flag of registration, not the operator, is what your dashboard cares about.

Real-world use cases for tracking by tail number

MRO and utilization

Maintenance planning is airframe-specific. Cycles, flight hours, and check intervals accrue against a tail, not a flight number. By resolving regNumber for the flights an airframe operates, an MRO team can confirm which aircraft actually flew a rotation and feed accurate utilization into planning — answering "which airframe flew this leg, and is it airborne right now?" from a single API.

Leasing and asset tracking

For lessors and finance/asset managers, the aircraft is the collateral. "Where is my aircraft and is it flying?" is a daily question. Query the flights an operator assigns to your tail, read regNumber to confirm identity, and follow the live position through /track to verify the asset is in service and on an expected route.

Airline ops and dispatch

Ops and dispatch teams need to confirm the assigned airframe is the one actually operating — tail swaps happen. Because FlightNerve identifies the tail live, regNumber is a check against reality rather than against the plan, catching substitutions as they happen in the air.

Spotter and tracker apps

Enthusiast apps live or die on showing the specific aircraft. Surfacing regNumber alongside the type name — "A6-EOA · Airbus A380-800" — turns a generic dot into a known airframe with a history. Pair it with the position fields from /track for a labelled live map, and use /monitored to keep a watchlist of tails your users follow.

Surfacing regNumber and type in your UI

A clean way to present this is a two-line label: the tail on top, the type beneath. Because /monitored returns regNumber on every airborne flight in your watchlist alongside status, route, times, and position, you can render a whole board of tails from one call:

# cURL — watchlist board, every airborne flight carries regNumber
curl "https://api.flightnerve.com/YOUR_KEY/monitored/YOUR_KEY"

Map each entry to a card showing regNumber as the headline, aircraft.name as the subtitle, and the live route and progress underneath. When regNumber is null, show "tail confirms on departure" so the ground state reads intentionally rather than looking broken.

Getting started

Each call costs one credit, and the free tier includes 1,000 credits with no card required, so you can build and test a full flight by tail number feature before committing. Get a free API key, point it at /airline and /track, and read the regNumber field — that single value is the difference between tracking a schedule and tracking a real aircraft. See pricing for higher volumes.

FAQ

How do I track an aircraft by tail number with FlightNerve?

You do not query the tail directly — you query by flight (airline + number, e.g. EK72) and FlightNerve returns the regNumber of the aircraft operating that flight. Use /airline for the full status including the aircraft object, or /track for the live position, both of which carry regNumber.

Why is regNumber null?

FlightNerve identifies the tail live while the aircraft is airborne. When a flight is on the ground or before departure, regNumber is null and /track returns an empty array. Poll around departure to capture the registration once the aircraft is up.

Which aircraft is operating a given flight today?

Query the flight with /airline and read aircraft.regNumber. The same flight number is flown by different airframes on different days, so resolve the tail per operation rather than caching a fixed mapping.

What is the difference between a tail number and a flight number?

A flight number (EK72) is a reusable schedule slot; a tail number (A6-EOA) is the unique, lasting identity of one physical aircraft. FlightNerve's aircraft registration API links the two by telling you which tail is flying a given flight right now.

Can I tell where an aircraft is registered from its tail number?

Yes. The prefix of regNumber encodes the country of registry — A6- UAE, N US, G- UK, D- Germany, F- France, VH- Australia, B- China — so you can group airframes by flag directly from the field.

Does regNumber work for private and non-airline aircraft?

The registration is returned for the aircraft operating whichever flight you query, identified live while airborne, and the same country-prefix rules apply (for example US N-numbers). You query by the operating flight's airline and number, and read the tail from the response.

How much does it cost to look up a tail number?

Each API call is one credit, and the free tier gives you 1,000 credits with no card. Get a free API key to start, and check pricing for higher volumes.