How to find aircraft type by flight number with an API. Look up which airplane model operates a flight from its flight number and get the aircraft type, registration, model, manufacturer and age in a single call through the AirLabs flight data API.
It is one of the most common questions in aviation, asked by passengers, spotters and developers alike: given a flight number, what type of aircraft is actually flying it? You have a flight — say BA117 or AA100 — and you want to know whether it is a Boeing 787, an Airbus A350, or a narrowbody 737. Passengers ask because the aircraft type shapes their experience (seat width, cabin, range); spotters ask to log the specific airframe; and developers ask because they are building an app that needs to show aircraft type alongside a flight.
The reason this question comes up so often is that the flight number alone does not tell you the aircraft. A flight number like "BA117" identifies a scheduled service — a route an airline operates on a recurring basis — but the specific aircraft assigned to that service can change from day to day. An airline might fly BA117 with one aircraft today and a different one tomorrow, depending on demand, maintenance and fleet availability. So "what aircraft is BA117" is really "what aircraft is assigned to BA117 on this date."
The good news is that this is exactly the kind of lookup a flight data API is built for. With the AirLabs platform, a single call to the flight lookup takes a flight number and returns the operating aircraft's type, model, manufacturer, age and registration together. This guide explains how the lookup works, why it takes the shape it does, and how to build it reliably — using only documented AirLabs endpoints.
"A flight number is a schedule, not an airplane. The aircraft assigned to it is decided operationally and can change daily. To answer 'what aircraft is this flight,' you look up the live flight — and the type, model and age come back in that one response."
Understanding the relationship between a flight number and an aircraft is the key to doing this lookup correctly, and it explains why a single static database of "flight number → aircraft" would be wrong.
A flight number is a commercial designator: the airline's two-character code plus a number, like AA100 or LH401. It identifies a scheduled service between two airports, and it stays the same day after day even as the physical aircraft rotates. The aircraft, identified by its registration (tail number) and ICAO 24-bit hex address, is a specific airframe that gets assigned to flights operationally.
The link between them is made per flight, per day. When an airline builds its daily operations, it assigns a specific tail number to each scheduled flight — a process called fleet assignment or tail assignment. That assignment is what connects "BA117 on 29 June" to a particular Boeing 777. The next day, BA117 might be flown by a different 777, or occasionally a different type entirely if the airline swaps equipment.
This is why the correct approach is to look up the live or current instance of the flight number and read the aircraft assigned to it, rather than expecting a fixed mapping. AirLabs exposes exactly this: the flight lookup returns the aircraft operating that flight now, and from there you retrieve the full aircraft details.
The starting point — and for most needs, the only point — is the AirLabs Flight Information API. It takes a flight number and returns the current status of that flight, and importantly, it returns the aircraft type and details in the same response. Query by the flight's IATA code-number:
GET https://airlabs.co/api/v9/flight?flight_iata=BA117&api_key={KEY}
{
"response": {
"flight_iata": "BA117",
"flight_icao": "BAW117",
"airline_iata": "BA",
"dep_iata": "LHR",
"arr_iata": "JFK",
"status": "en-route",
"aircraft_icao": "B77W",
"reg_number": "G-STBH",
"hex": "400EA7",
"model": "Boeing 777-300ER pax",
"manufacturer": "BOEING",
"built": 2016,
"age": 10,
"engine": "jet",
"engine_count": "2"
}
}Everything needed to answer the question is in this single response. The aircraft_icao (B77W) is the ICAO aircraft type designator — a Boeing 777-300ER. Alongside it, the Flight Information API already includes the human-readable model ("Boeing 777-300ER pax"), the manufacturer ("BOEING"), the build year (built), the age, and the engine configuration. The reg_number (G-STBH) is the tail number of the specific airframe operating BA117 right now, and the hex is its permanent ICAO 24-bit address.
This is the key point for developers: you do not need a second call to get the model, manufacturer and age — the Flight Information API returns them inline. A single request to /flight with a flight number answers "what aircraft is flying this" completely. If you only need the type designator, read aircraft_icao; if you want the friendly model name and age, they are right there in the same object.
The single flight call covers the common case. If you need the complete airframe record — the manufacturer serial number (msn), line number, wake category, registration country and full type codes — the Fleets Database provides it, queried by the reg_number (or hex) you already have from the flight response:
GET https://airlabs.co/api/v9/fleets?reg_number=G-STBH&api_key={KEY}
[{
"hex": "400EA7",
"reg_number": "G-STBH",
"flag": "GB",
"airline_iata": "BA",
"icao": "B77W",
"iata": "77W",
"model": "Boeing 777-300ER pax",
"manufacturer": "BOEING",
"type": "landplane",
"category": "H",
"built": 2016,
"age": 10,
"msn": "43702",
"line": "1257"
}]Use this second call only when you need those extra fields — for a basic "what aircraft is this flight," the single Flight Information API call above is enough. Think of it as: the flight call answers the question; the Fleets call is there when you want the airframe's full dossier.
Here is the complete pattern in JavaScript — a single call that returns the aircraft type, model and age from a flight number:
async function aircraftForFlight(flightIata, apiKey) {
const res = await fetch(
`https://airlabs.co/api/v9/flight?flight_iata=${flightIata}` +
`&_fields=flight_iata,aircraft_icao,reg_number,model,manufacturer,age` +
`&api_key=${apiKey}`
);
const flight = (await res.json()).response;
if (!flight || !flight.aircraft_icao) return null; // no aircraft assigned yet
return {
flight: flight.flight_iata,
type_icao: flight.aircraft_icao,
registration: flight.reg_number,
model: flight.model,
manufacturer: flight.manufacturer,
age: flight.age,
};
}
// Usage
const info = await aircraftForFlight("BA117", KEY);
// { flight: "BA117", type_icao: "B77W", registration: "G-STBH",
// model: "Boeing 777-300ER pax", manufacturer: "BOEING", age: 10 }One request does the whole job, and _fields keeps the response to just the aircraft data you need. Only reach for a second call to the Fleets Database when you specifically need the extra airframe fields (msn, line, wake category) that the flight response does not include.
The aircraft_icao field returns an ICAO type designator, and the Fleets record includes both the ICAO (icao) and IATA (iata) type codes. Knowing how to read these helps you present the aircraft type clearly.
ICAO aircraft type designators are up to four characters and identify a specific model: B77W (Boeing 777-300ER), A359 (Airbus A350-900), B738 (Boeing 737-800), E190 (Embraer 190). They are precise and are what appears in the flight response.
IATA aircraft type codes are three characters and are the codes seen in booking and scheduling systems: 77W, 359, 738, 290.
The Fleets Database gives you both, plus the plain-language model name, so you can show whichever suits your audience — the ICAO code for aviation-savvy users, or the friendly "Boeing 777-300ER" for passengers.
| ICAO | IATA | Model |
| B77W | 77W | Boeing 777-300ER |
| B789 | 789 | Boeing 787-9 Dreamliner |
| A388 | 388 | Airbus A380-800 |
| B738 | 738 | Boeing 737-800 |
| A320 | 320 | Airbus A320-200 |
| E190 | 290 | Embraer 190 |
Being honest about how this data behaves is essential to building it correctly, so it is worth stating the key limitation plainly.
The aircraft assigned to a flight number is available when the flight is live or current — scheduled for today, active in the air, or recently operated. This is because the tail assignment is an operational fact that exists once the airline has assigned an aircraft to the flight. For a flight happening now or today, the Flight Information API returns the operating aircraft's aircraft_icao and reg_number as shown above.
What you should not expect is a reliable aircraft assignment for a flight far in the future. If you ask "what aircraft will fly BA117 three weeks from now," the specific tail may not be assigned yet — airlines finalize assignments closer to the day of operation, and equipment can change. The aircraft type is often planned in advance (the airline knows it intends to use a 777 on the route), but the specific airframe is a near-term operational decision.
The practical implication: this lookup is designed for "what aircraft is operating this flight now / today," which is exactly what passengers and tracking apps ask. For that question, the single flight lookup gives a precise, current answer. For long-range future planning, rely on the aircraft type planned for the route rather than a specific tail number.
A related detail from the documentation: the Flight Information API returns only the single closest instance of a flight number (live, scheduled or landed). For a number that operates several times a day, or to list every instance, use the Schedules API with a search by flight_iata; the aircraft type appears there too.
There is a second path to the same answer that suits map-based and tracking applications. Instead of starting from a flight number, you start from a live aircraft and read its flight and type together.
The Real-Time Flights API returns airborne aircraft with both their flight number and aircraft type in a single response. Filtering by a flight number returns the live aircraft operating it:
GET https://airlabs.co/api/v9/flights?flight_iata=BA117&api_key={KEY}
[{
"hex": "400EA7",
"reg_number": "G-STBH",
"flight_iata": "BA117",
"dep_iata": "LHR",
"arr_iata": "JFK",
"aircraft_icao": "B77W",
"lat": 51.9,
"lng": -10.3,
"alt": 11277,
"status": "en-route"
}]This is efficient for tracking interfaces because it returns the aircraft type (aircraft_icao) and registration (reg_number) together with the live position, so you can plot the aircraft on a map and label it with its type in one call. From the reg_number, you can still enrich to full model details via the Fleets Database when needed.
Identifying the aircraft type behind a flight number powers a range of features:
Travel and flight-status apps show passengers what aircraft they will fly — model, age and configuration context. Because the flight lookup returns aircraft_icao, model and age together, an app can display "You're flying a Boeing 777-300ER" alongside the flight status from a single call.
Spotters want the specific airframe, not just the type. The reg_number and hex from the flight lookup identify the exact aircraft, which enthusiasts log and cross-reference — turning "I saw BA117" into "I saw G-STBH, a 2016 Boeing 777-300ER."
Because cabin layout depends on aircraft type, apps that show seat maps or cabin information first need the aircraft type for the flight. The aircraft_icao from the flight lookup is the key that selects the right cabin configuration to display.
Analysts studying which aircraft types operate which routes use the flight-to-aircraft link at scale — sampling flights on a route and reading the aircraft_icao to understand equipment deployment. Combined with the Fleets Database, this supports fleet-utilization studies.
Any tracking interface benefits from labeling flights with aircraft type. Pulling aircraft_icao alongside live position from the Real-Time Flights API adds type context to every tracked aircraft without a separate lookup.
A few patterns make this lookup robust in production:
aircraft_icao, model, manufacturer and age inline, so a single /flight request answers the question; only call the Fleets Database when you need extra airframe fields like msn or line.aircraft_icao/reg_number yet; check for its presence and fall back to the planned type or a "not yet assigned" state.reg_number or hex aggressively and only refresh the flight lookup for live assignment._fields to stay lean — request only the fields you display (e.g. aircraft_icao,reg_number from the flight, model,manufacturer,age from the fleet) to keep responses compact.aircraft_icao from that same response rather than making an extra flight call.model to passengers and keep the aircraft_icao/iata codes available for aviation-savvy users.If you are building a flight-status app, an aircraft-spotting tool, a seat-map feature or any product that needs to identify the aircraft behind a flight number, the AirLabs API provides the full chain — flight lookup to aircraft type to complete airframe details — through documented REST endpoints.
Our Developer API allows you to create a custom experience for your users and increase the value of your product:
model, manufacturer, age, reg_number and aircraft_icao for a flight — in a single call by flight number.msn, line, wake category) when you need more than the flight call returns.aircraft_icao, icao) and IATA (iata) aircraft type codes, plus the plain-language model name.reg_number, hex (ICAO 24-bit) or msn in the Fleets Database._fields to return only what your application needs.You can try it right now without any obligation! Get a free flight API plan and see for yourself that we have exactly the data you need!
If you need more information, don't hesitate to contact us. We are always happy to chat with our customers and are sure to find a customized solution for each request.
Explore AirLabs, or create an account instantly and start using API.
Get FREE API Key