Where the aircraft is now, and how late it actually is
The FlightAware API returns live flight-tracking data as clean JSON.
3 active endpoints. Every call is 1 credit.
- POST/flightaware/v1/flight_status
- POST/flightaware/v1/live_position
- POST/flightaware/v1/airport_board
What FlightAware endpoints does ReefAPI ship?
3 live read endpoints. Read-only data API: no writes, no account actions, no dashboard access on the target site.
FlightAware API
3 of 3 endpoints, ready to run
The live activity board for an airport — arrivals, departures, en-route or scheduled. Every row gives the flight identifier in the form the other two actions want, the aircraft type and the other end of the trip.
{ "ok": true, "meta": { "api": "flightaware", "endpoint": "airport_board", "mode": "live", "latency_ms": 1083.4, "record_count": 20, "cache_hit": false }, "data": { "airport": { "name": "John F Kennedy Intl Airport", "iata": "JFK", "icao": "KJFK" }, "flights": [ { "ident": "DAL2475", "aircraft_type": "B738", "origin_airport": "TPA", "origin_airport_name": "Tampa Intl", "url": "https://www.flightaware.com/live/flight/DAL2475", "departure_time": "07:56a EDT", "arrival_time": "10:06a EDT" }, { "ident": "EDV5284", "aircraft_type": "CRJ9", "origin_airport": "BUF", "origin_airport_name": "Buffalo Niagara Intl", "url": "https://www.flightaware.com/live/flight/EDV5284", "departure_time": "09:01a EDT", "arrival_time": "10:04a EDT" }, { "ident": "DAL9960", "aircraft_type": "B764", "origin_airport": "ATL", "origin_airport_name": "Hartsfield-Jackson Intl", "url": "https://www.flightaware.com/live/flight/DAL9960", "departure_time": "08:20a EDT", "arrival_time": "10:02a EDT" } ] } }
How the FlightAware API works
FlightAware is a normal ReefAPI surface — the same four rules that hold for every other engine on the key.
No OAuth app, no request signing, no per-site account. One key covers all 185 engines.
Every route is a POST with a JSON body. Parameters are validated against the published schema before anything is charged.
Credits, not seats. Failed and blocked calls are never charged, and cache hits cost nothing.
One envelope everywhere. meta carries latency_ms, record_count and the endpoint that answered.
Read the board, take the identifier off it, then open the flight
The board is the discovery surface and it hands you identifiers in exactly the form the other two actions accept. Three calls, measured against JFK while writing this.
{"airport": "KJFK", "board": "enroute", "limit": 20}Twenty inbound flights in 1.3 seconds, each with an ICAO identifier, the aircraft type and the airport it left. Take the ident from here rather than composing one yourself.
{"ident": "DAL915"}Los Angeles to JFK: gate 34A at terminal 3 out, gate B24 at terminal 4 in, and the honest arithmetic — push-back 5,820 seconds after schedule, wheels up 6,300 seconds after schedule, and a landing estimate running 11,520 seconds past the timetable.
{"ident": "ANA110"}Tokyo Haneda to JFK, still airborne: 979 track points spanning 11 hours 23 minutes, a median of 30 seconds apart, with altitude and groundspeed on 846 of them, peaking at 37,000 feet and 593 knots.
An airport's live picture, one flight's real timeline against its scheduled one, and the full flown path — with no AeroAPI plan and no per-call subscription tier.
curl -X POST https://api.reefapi.com/flightaware/v1/airport_board \
-H "x-api-key: $REEF_KEY" \
-H "content-type: application/json" \
-d '{"airport":"KJFK","board":"arrivals"}'{
"ok": true,
"data": { … },
"meta": {
"api": "flightaware",
"endpoint": "airport_board",
"mode": "live",
"latency_ms": …,
"record_count": …
},
"error": null
}Flight identifiers, timestamps and status values
The most common failed call here is an IATA flight number. The identifier format, the time base and the status vocabulary are all different from what a booking site shows you. Every row was measured on 2026-08-26 and 2026-08-27 against live flights and the KJFK activity boards.
| Item | What we measured | Evidence |
|---|---|---|
| ident that works | ICAO airline code plus the number | UAL100, AAL100, BAW178 and DAL47 all resolved to a flight |
| ident that fails | IATA airline code plus the number | UA100, AA100, BA178 and DL47 each returned NOT_FOUND, "no live flight found" |
| iata_ident | The IATA form is returned in the response but is not accepted as input | UAL100 came back with iata_ident "UA100", which itself fails as an ident |
| registration as ident | A tail number works, and is the only case where aircraft.tail is filled | N628JB returned tail "N628JB"; all four airline flights returned tail null |
| Time fields | Unix epoch SECONDS in UTC, never local | gate_departure.scheduled 1774659000 for UAL100 |
| Time phases | gate_departure, takeoff, landing and gate_arrival, each with scheduled / estimated / actual | UAL100: gate_departure scheduled 1774659000, estimated and actual both 1774659600, ten minutes late off the gate |
| status values seen | "airborne", "arrived", and an empty string before departure | DAL353 before pushback returned status "", not "scheduled" |
| airport_board airport | ICAO or IATA both accepted | KJFK and JFK both returned the John F Kennedy Intl boards |
| board enum | arrivals, departures, enroute, scheduled. Anything else is rejected outright | board=cargo returned INVALID_PARAM with the allowed list in error.detail |
| Board row times | Local clock strings with a zone abbreviation and no date, each side in its own airport's zone | One JFK arrivals row read departure_time "03:48p BST" and arrival_time "06:05p EDT" |
| Board size | limit is capped at 20 rows per board | The parameter range is 1-20, and a logged-out board renders about 20 rows |
Board rows and flight_status speak different dialects. A board gives you ident, aircraft_type, the other airport as an IATA code and those local time strings; flight_status gives you epoch seconds and full airport objects with gate, terminal, timezone and coordinates. The ident on a board is already in ICAO form, so you can feed it straight back into flight_status.
Which identifier form actually works, how live 'live' is, and what the track really contains
Measured on 2026-08-28 against four ICAO/IATA identifier pairs, two long-haul flights in the air and four board types. Two of these lines go against us.
Against us, and it is the first thing that will break your integration. We tried four flights in both forms within the same minutes: DAL915, ANA110, AAL365 and JBU264 all resolved; DL915, NH110, AA365 and B6264 all returned NOT_FOUND. Four for four against zero for four. The parameter description says IATA is auto-resolved — today it is not. Use the ICAO form, and the simplest way to always have it is to take the identifier off an airport_board row, which returns them in that form already.
Asking for BAW178 while that leg was not operating returned NOT_FOUND rather than a schedule. A flight number resolves while its leg is in the air or has just landed — a flight we opened with status 'arrived' still returned its full record — and stops resolving otherwise. If you need a flight that has not taken off yet, find it on the scheduled board rather than by guessing an identifier.
Each of push-back, take-off, landing and gate arrival comes back as its own block of scheduled, estimated and actual epoch seconds, so a delay is a subtraction rather than a judgement. One Los Angeles to JFK flight had pushed back 5,820 seconds late and got airborne 6,300 seconds late, with the landing estimate 11,520 seconds past its schedule. A Tokyo to JFK flight the same afternoon pushed back 120 seconds EARLY and still took off 1,020 seconds late — which is the sort of split you cannot see from a single 'delayed' flag.
A Tokyo to New York flight returned 979 position points covering 11 hours and 23 minutes, a median of 30 seconds between consecutive points, each with a timestamp, latitude and longitude. Altitude and groundspeed were filled on 846 of the 979 — the earliest points near the departure airport carry position only — and the filled ones peaked at 37,000 feet and 593 knots.
flight_status returns the record without the history; live_position returns the identical record plus the track array, and reports the point count in its meta so you can size the response before you parse it. Use status for a dashboard and position when you need the path.
Both airports come back with a name, IATA and ICAO codes, city, timezone, coordinates, and the gate and terminal actually assigned. Beside them sits the filed flight plan — the full route string of waypoints and airways, the filed altitude and speed, the planned distance against the direct distance, and the estimated en-route time in seconds. Progress is reported as miles flown, miles remaining and a percentage.
Against you if you write one parser. arrivals rows carry the origin airport plus a departure time and an arrival time; departures and scheduled rows carry the destination airport instead; enroute rows carry the origin and a single free-text status string with no times at all. All four return the identifier, the aircraft type and the flight's own page link. Twenty is the ceiling on every board, so this is a live snapshot rather than a full day's movements.
The aircraft block resolves the type code into something readable — B77W becomes 'BOEING 777-300ER (twin-jet)', with the manufacturer, model, engine count and engine type as separate fields, plus a heavy flag. The tail number came back null on both flights we opened, so do not build a fleet tracker on the registration from this action.
Nothing in this engine quotes a fare, a seat or an availability. If the question is what a ticket costs or which day of the month is cheapest, that is the flights engine next door — and it in turn carries no gate, no actual time and no position. The two are complements, not alternatives.
Public flight tracking: the operating airline, the aircraft type, both airports with their gates and terminals, the published and the actual times, the filed route and the broadcast position history. Not a passenger, not a booking, not a manifest, and no AeroAPI key or subscription tier in the path — what you send is a ReefAPI key.
What people build with FlightAware
The jobs this data is most often used for.
endpoints
credit per call
Travel apps call flight_status to show a passenger's live flight state.
Logistics tracks cargo flights with live_position.
Airport apps use airport_board for departures and arrivals.
What FlightAware data costs
The cheapest call here is 1 credit, so $15/mo (Pro) buys 10,000 of them — $1.50 per 1,000 credits. Credits roll over and never expire, and failed or blocked calls are not charged.
Full pricing →- 1,000 free credits on signup, no card
- One key, all 185 APIs, one credit pool
- Failed and blocked calls are never charged
- Credits roll over and never expire
Call it in two lines
Sign up, get 1,000 credits and one key that works on every engine. Then this is the whole protocol.
curl -X POST https://api.reefapi.com/flightaware/v1/airport_board \
-H "x-api-key: $REEF_KEY" \
-H "content-type: application/json" \
-d '{"airport":"KJFK","board":"arrivals"}'import requests
r = requests.post(
"https://api.reefapi.com/flightaware/v1/airport_board",
headers={"x-api-key": REEF_KEY},
json={
"airport": "KJFK",
"board": "arrivals"
},
)
print(r.json()["data"])Have a question? We got answers.
The questions people actually ask before wiring up FlightAware.
Get a free key →Does ident accept an IATA flight number like UA100 or BA178?▾
No. Measured on 2026-08-26: UAL100, AAL100, BAW178 and DAL47 all resolved, while UA100, AA100, BA178 and DL47 each came back NOT_FOUND with "no live flight found". Use the three-letter ICAO airline prefix. The response then hands you the IATA form back in iata_ident (UAL100 returns "UA100"), which is useful for display but will not work as an input.
Are the timestamps UTC or local time?▾
flight_status and live_position return Unix epoch seconds, which are UTC by definition; there is no local-time field and no offset to apply. airport_board is the exception: its rows are local clock strings with a zone abbreviation and no date at all, like "03:46p EDT" or "12:26p +08", and each side is in its own airport's zone. One measured JFK arrival departed London at "03:48p BST" and landed at "06:05p EDT".
What is the difference between scheduled, estimated and actual?▾
Each of the four phases (gate_departure, takeoff, landing, gate_arrival) is an object with up to those three keys. scheduled is the published time, estimated is the current prediction, actual is what happened. UAL100 measured on 2026-08-26 had gate_departure scheduled 1774659000 with estimated and actual both 1774659600, so it left the gate ten minutes late. Before a flight departs, the actual key is absent from the object rather than present and null.
Which fields are empty before a flight has departed?▾
Measured on two JFK departures still at the gate: status is an empty string rather than a word, position is null, and every field in progress (flown_miles, remaining_miles, actual_miles, percent_complete) is null. The time objects hold only scheduled and sometimes estimated. One of the two, AZA603, had gate_departure and gate_arrival null entirely while takeoff and landing still carried times. flight_plan is partly filled: route and filed_speed were present, planned_distance was null.
Why is aircraft.tail null?▾
Airline flights looked up by flight number do not carry a registration in this response. tail came back null for UAL100, AAL100, BAW178 and DAL47. Looking a flight up by its registration instead does fill it: N628JB returned tail "N628JB". The aircraft object is otherwise populated either way, with type (B789), friendly_type ("Boeing 787-9 Dreamliner (twin-jet)"), manufacturer, model, engines and a heavy boolean.
Why did live_position return an empty track for an airborne flight?▾
Because status flips to airborne on schedule before any position has been logged for the leg. AAL100 read status "airborne" with meta.track_points 0 and position null, measured a minute after its scheduled gate departure. Three genuinely en-route flights checked at the same moment returned 624, 1490 and 152 track points with a live position. Read meta.track_points before you trust the track, and remember the track covers this leg only: the SIA24 track started at Singapore Changi and ran to the New Jersey coast.
What unit is altitude_100ft, and what is in a track point?▾
Hundreds of feet, as the name says: a measured value of 30 is 3,000 feet and 61 is 6,100 feet. A track point holds timestamp, latitude, longitude, altitude_100ft and groundspeed_kts. It does not include heading. heading exists only on the current position object, alongside the same five fields.
Why did I get a flight from months ago?▾
flight_status returns the most recent leg it has for that identifier, and if the route no longer runs, the most recent leg can be old. On 2026-08-27 UAL100 returned a Sydney to Houston leg with a scheduled gate departure of 2026-03-28 and status "arrived". There is no date parameter to pin a day, so always read gate_departure.scheduled and last_updated to see which day you actually got. flight_id encodes an epoch too, in the form IDENT-epoch-source-suffix.
What is the FlightAware API?▾
FlightAware API is a ReefAPI endpoint group for flightaware It returns live JSON through POST requests under /flightaware/v1.
Is the FlightAware API free to try?▾
Yes. ReefAPI starts with 1,000 free credits, no card required. FlightAware calls use the same shared credit balance as every other ReefAPI engine.
Do I need a FlightAware login or account?▾
No login to FlightAware is needed for the API response. You call ReefAPI with your x-api-key header, and the playground can run live examples before you create a production key.
How fresh is the FlightAware data?▾
The page example is captured from a live flight_status call, and production requests fetch live data through ReefAPI rather than a static sample.
How many credits does the FlightAware API use?▾
FlightAware actions currently cost 1 credit per successful call. Failed or blocked calls are free, and all APIs draw from one credit pool.
Can I call FlightAware from an AI assistant or MCP client?▾
Yes. Connect ReefAPI once through MCP and your assistant can call flightaware actions with the same key, credit pool and JSON envelope used by normal REST requests.
8 Travel & Lodging APIs on the same key
One key, one credit pool, one response envelope. If you are pulling FlightAware, you are one call away from the rest of the category — no second contract, no second integration.
Need something this API does not do?
Name the endpoint, the field, or a source we do not carry yet. We ship new APIs every week and you would be first to get the key. Real people read every message and reply the same day.
Try it on your own data before you pay anything
The call above is the real endpoint, not a recording. A free key gives you 1,000 credits, the other 184 APIs, and the same envelope everywhere.
Endpoints, parameters and credit costs on this page are read from the live catalog and cannot drift from what the API accepts. Field notes were captured on 2026-08-28.