IATA vs ICAO codes explained. The difference between IATA and ICAO airport and airline codes, why aircraft have two codes, when each is used, and how both appear together in aviation data through the AirLabs API.
Anyone who works with aviation data quickly notices something puzzling: the same airport has two different codes. Paris Charles de Gaulle is both CDG and LFPG. Los Angeles is both LAX and KLAX. American Airlines is both AA and AAL. These are not typos or regional variants — they are two parallel coding systems, maintained by two different organizations, for two different purposes.
The two systems are IATA codes and ICAO codes. Both identify the same airports and airlines, but they were created by different bodies to solve different problems, and they are used in different parts of the aviation world. Understanding which is which — and when each is used — is one of the first things anyone building an aviation application needs to get straight, because using the wrong code in the wrong context is a common and confusing source of bugs.
This guide is a focused comparison of the two systems: what each is, how they differ in format, when each is used, and why both appear side by side in flight data. If you are looking instead for how to access the codes themselves — the databases and lookup endpoints — see our dedicated pages on the IATA Codes Database API and the ICAO API Data Service. This article is about understanding the difference; those pages are about getting the data.
"IATA codes are the ones passengers see; ICAO codes are the ones pilots and controllers use. Same airport, same airline — two audiences, two systems. Once you know which world a code belongs to, the two-code puzzle stops being confusing."
IATA codes are assigned by the International Air Transport Association, the trade association of the world's airlines. IATA's focus is the commercial side of aviation — ticketing, reservations, baggage handling, scheduling — so its codes are built for the passenger-facing world.
IATA airport codes are three letters. CDG, LAX, JFK, LHR. These are the codes you see on your boarding pass, your baggage tag, the departure board and the booking confirmation. They are short and, where possible, mnemonic, which is why they are the codes the traveling public recognizes.
IATA airline codes are two characters. AA (American Airlines), BA (British Airways), LH (Lufthansa). These are the codes that begin a flight number — "AA100," "BA249" — on tickets and schedules.
Because IATA codes serve commercial aviation, they are optimized for human readability and brevity. Three letters give 26³ = 17,576 possible airport codes, which is enough for the world's commercial airports but does mean the codes are a globally shared, finite pool managed by IATA. IATA codes are also assigned to some non-airport locations relevant to travel, such as rail and bus stations used in intermodal ticketing.
ICAO codes are assigned by the International Civil Aviation Organization, a specialized agency of the United Nations. ICAO's focus is the operational and regulatory side of aviation — air traffic control, flight planning, navigation, safety — so its codes are built for the cockpit and the control tower.
ICAO airport codes are four letters. LFPG (Paris CDG), KLAX (Los Angeles), EGLL (London Heathrow). Unlike IATA codes, ICAO airport codes are structured geographically: the first letter (or two) indicates a region and country. Everything in the contiguous United States starts with K; the United Kingdom uses EG; France uses LF; Germany uses ED. This regional structure means an ICAO code tells you roughly where in the world an airport is, which is valuable for flight planning and air traffic management.
ICAO airline codes are three letters. AAL (American Airlines), BAW (British Airways), DLH (Lufthansa). These are paired with a telephony callsign — "AAL" is spoken as "American," "BAW" as "Speedbird," "DLH" as "Lufthansa" — used in radio communication between pilots and controllers.
Because ICAO codes serve operational aviation, they are designed for global uniqueness and systematic structure rather than brevity. Four letters give a much larger, regionally organized space, which is why ICAO codes cover not just commercial airports but also small airfields, military bases and heliports that may have no IATA code at all.
The clearest way to see the difference is to line the two systems up directly.
| Aspect | IATA | ICAO |
| Assigned by | International Air Transport Association (airline trade body) | International Civil Aviation Organization (UN agency) |
| Focus | Commercial: ticketing, baggage, schedules | Operational: ATC, flight planning, safety |
| Airport code | 3 letters (CDG, LAX) | 4 letters (LFPG, KLAX) |
| Airline code | 2 characters (AA, BA) | 3 letters (AAL, BAW) |
| Structure | Mnemonic, no geographic logic | Geographically structured by region/country |
| Coverage | Commercial airports and travel points | All airfields, including military & heliports |
| Who sees it | Passengers, travel agents | Pilots, air traffic controllers |
| Where you see it | Boarding passes, bookings, baggage tags | Flight plans, ATC, cockpit systems |
The pattern behind the table is simple: IATA is the commercial, passenger-facing system; ICAO is the operational, aviation-facing system. Almost every difference — the code length, the geographic structure, the coverage — follows from that split in purpose.
For a developer, the practical question is not "which system is better" but "which code does this context expect." Using an IATA code where an ICAO code belongs, or vice versa, produces lookups that fail or match the wrong entity.
Use IATA codes when you are working with the commercial, passenger-facing layer. Displaying a flight to a traveler, matching a booking, showing a departure board, building a fare or schedule search — these expect IATA codes, because that is what passengers and commercial systems use. When a user types "flights from JFK to LHR," they are speaking IATA.
Use ICAO codes when you are working with the operational layer. Flight planning tools, ADS-B and radar correlation, air traffic data, and anything touching the cockpit or control tower expect ICAO codes. Live aircraft tracking data, for instance, often carries ICAO airline codes and callsigns because that is the operational identity.
A subtlety worth knowing: not every airport has both codes. Every commercial airport has an IATA code and an ICAO code, but small airfields, military bases and heliports frequently have an ICAO code and no IATA code — because they matter operationally but not commercially. This is why operational datasets are keyed on ICAO codes: they cover airports that the commercial IATA system simply does not list. Conversely, a handful of purely commercial points (like some rail stations in intermodal ticketing) have IATA codes but no ICAO code.
In practice, aviation data does not make you choose between the two systems — it carries both, because a single flight lives in both worlds at once. A flight is sold commercially under its IATA identity and operated under its ICAO identity simultaneously.
Consider a single flight. To the passenger it is "AA100" (IATA airline code AA), departing "JFK" and arriving "LHR" (IATA airport codes). To air traffic control the same flight is "AAL100" (ICAO airline code AAL), flying from "KJFK" to "EGLL" (ICAO airport codes), with the pilot checking in on the radio as "American 100" (the AAL callsign). It is one flight, wearing its commercial identity for passengers and its operational identity for controllers.
This is exactly why well-designed flight data exposes both codes for the same entity, rather than forcing you to convert between them. Whether your application lives in the commercial world (showing flights to travelers) or the operational world (tracking aircraft, planning routes), the code you need is present, and you can cross-reference between the two whenever you need to bridge the passenger view and the operational view.
The AirLabs API reflects this dual system directly: every airport and airline record carries both its IATA and ICAO codes, so you never have to maintain your own conversion table between the two. This is the practical payoff of understanding the difference — the data already speaks both languages.
In the Airports Database, each airport record includes both iata_code and icao_code:
GET https://airlabs.co/api/v9/airports?iata_code=CDG&_fields=name,iata_code,icao_code&api_key={KEY}
[{
"name": "Paris Charles de Gaulle Airport",
"iata_code": "CDG",
"icao_code": "LFPG"
}]Here the same airport carries its commercial identity (CDG) and its operational identity (LFPG) in one object. Because you can query the Airports Database by either iata_code or icao_code, you can look an airport up by whichever code you have and read off the other — which is exactly how you convert between the two systems when you need to.
The same holds for airlines. In the Airlines Database, each carrier record carries both codes plus the operational callsign:
GET https://airlabs.co/api/v9/airlines?iata_code=AA&_fields=name,iata_code,icao_code,callsign&api_key={KEY}
[{
"name": "American Airlines",
"iata_code": "AA",
"icao_code": "AAL",
"callsign": "AMERICAN"
}]This single record captures both worlds: the commercial code AA that begins a passenger-facing flight number, the operational code AAL used in air traffic data, and the callsign "AMERICAN" spoken over the radio. An application can display the IATA code to travelers and use the ICAO code and callsign when working with operational data — all from one lookup.
A frequent developer need is converting a code from one system to the other — you have an IATA code and need the ICAO equivalent, or vice versa. Because AirLabs stores both codes on the same record, conversion is simply a lookup: query by the code you have, read the code you need.
To convert an IATA airport code to ICAO, query the Airports Database by iata_code and read the icao_code from the response (CDG → LFPG). To go the other way, query by icao_code and read the iata_code. The same pattern works for airlines via the Airlines Database: query by iata_code or icao_code and read the other, with the callsign available alongside.
This is more reliable than maintaining a static conversion table of your own, which would need constant updating as airports and airlines are added, renamed or recoded. Letting the database be the source of truth for the mapping keeps your conversions current.
There is a third identifier that is sometimes confused with the codes discussed here, and it is worth distinguishing clearly. ICAO also administers the 24-bit address (the "hex" code) — a unique identifier assigned to each aircraft for its transponder, not to airports or airlines.
This is a different kind of code entirely: the IATA and ICAO codes in this article identify airports and airlines, while the 24-bit address identifies an individual airframe. They serve different roles and appear in different fields. For a full explanation of the hex address and how it works in aircraft tracking, see our dedicated ICAO 24-bit Address guide.
The takeaway is that "ICAO code" can refer to two unrelated things depending on context — the four-letter airport / three-letter airline codes covered here, or the aircraft hex address covered separately — so it helps to be specific about which you mean.
Handling both IATA and ICAO codes correctly matters across many kinds of applications:
Booking engines, flight search and travel apps work in IATA codes because that is what travelers recognize, but may need ICAO codes when integrating with operational data sources. Storing both from the Airports Database lets a product display IATA to users while speaking ICAO to operational systems.
Tracking tools consume operational data keyed on ICAO codes and callsigns, then often need to present flights to users in familiar IATA terms. Carrying both codes bridges the operational feed and the passenger-friendly display.
Flight planning, dispatch and ATC-adjacent tools work natively in ICAO codes, taking advantage of their geographic structure and full airfield coverage — including airports that have no IATA code at all.
Any system that ingests aviation data from multiple sources must reconcile IATA-keyed and ICAO-keyed datasets. Having both codes on every record makes this normalization a lookup rather than a maintenance burden.
A few patterns help when working with both systems:
iata_code and icao_code together from the Airports and Airlines databases so you can present or match by either without a second lookup.If you are building any aviation application, you will work with both IATA and ICAO codes — and the AirLabs API gives you both on every airport and airline record, so you can display the right code to the right audience and convert between the two with a simple lookup.
For accessing the code databases directly, see the IATA Codes Database API and the ICAO API Data Service. This page has covered the difference between the two systems; those cover getting the data.
Our Developer API allows you to create a custom experience for your users and increase the value of your product:
iata_code (3-letter) and icao_code (4-letter) on every airport record.iata_code (2-char) and icao_code (3-letter) plus the operational callsign._fields to return just the codes you need.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