FlightAware Flight Tracking Scraper

Track live and scheduled flights on FlightAware by flight number or aircraft tail number, pull a flight's recent history, fetch an airport's live arrivals/departures/en-route/scheduled board, or pull a flight's full waypoint-by-waypoint track log. HTTP-only, no login, no API key. A free Apify (AUTO/datacenter) proxy fallback is built in and kicks in automatically only if FlightAware rate-limits a direct request.

What this actor does

• Four modes: flightStatus, flightHistory, airportBoard, flightTrackLog
• Flight status: origin/destination airports with gate + terminal, scheduled/estimated/actual takeoff, landing, gate-departure and gate-arrival times, aircraft type + manufacturer/model, flight-plan route/speed/distance/fuel burn, live position (altitude, groundspeed, heading, lat/lon) for airborne flights, cancelled/diverted flags
• Flight history: the last ~2 weeks of instances of a flight number or tail number, with local departure/arrival times, timezones, duration, and status (Scheduled / Cancelled / Landed)
• Airport board: live arrivals, departures, en-route (inbound), and scheduled-departures sections for any airport, with route, aircraft, airline, and local times
• Flight track log: the waypoint-by-waypoint position history (lat/lon, course, groundspeed, altitude, vertical rate) for the most recently tracked instance of a flight, plus its Left Gate / Departure / Arrival / Gate Arrival / taxi-time milestones
• Works with flight numbers (AAL100, UAL1) and tail/N-numbers (N12345)
• Airport codes accepted as ICAO (KJFK) or IATA (JFK)
• Empty fields are omitted — a field only appears on a record when FlightAware actually published a value for it

Output: flight status (mode = flightStatus)

• flightIdent, iataIdent, friendlyIdent — flight number in FlightAware/IATA/human-friendly form
• flightStatus — e.g. airborne, arrived (omitted for not-yet-departed scheduled flights)
• cancelled, diverted, isHistorical, generalAviation, blocked — status flags
• airlineName, airlineShortName, airlineIcao, airlineIata, airlineCallsign, airlineUrl
• aircraftType, aircraftTypeFriendly, aircraftManufacturer, aircraftModel, aircraftClass, aircraftEngineCount, aircraftEngineType
• tailNumber, aircraftOwner, aircraftOwnerLocation — when the registration isn't privacy-blocked
• originIcao, originIata, originAirportName, originCity, originGate, originTerminal, originTimeZone, originLatitude, originLongitude
• destinationIcao, destinationIata, destinationAirportName, destinationCity, destinationGate, destinationTerminal, destinationTimeZone, destinationLatitude, destinationLongitude
• scheduledTakeoffTime, estimatedTakeoffTime, actualTakeoffTime (ISO UTC)
• scheduledLandingTime, estimatedLandingTime, actualLandingTime (ISO UTC)
• scheduledDepartureTime, estimatedDepartureTime, actualDepartureTime — gate times (ISO UTC)
• scheduledArrivalTime, estimatedArrivalTime, actualArrivalTime — gate times (ISO UTC)
• averageDepartureDelayMinutes, averageArrivalDelayMinutes — historical average for this route (negative = usually early)
• flightPlanSpeedKts, flightPlanAltitudeFl, flightPlanRoute, flightPlanDistanceMiles, flightPlanEteMinutes, flightPlanFuelBurnGallons, flightPlanFuelBurnPounds
• distanceElapsedMiles, distanceRemainingMiles — for flights currently en route
• distanceActualMiles — total great-circle distance actually flown, once a flight has landed
• groundspeedKts, headingDegrees, altitudeFl, currentLatitude, currentLongitude — live position, only present while airborne
• taxiInMinutes, taxiOutMinutes
• permalink, trackLogUrl, flightHistoryUrl — FlightAware page links
• registrationPhotoUrl, registrationPhotoPageUrl — a community-submitted aircraft photo, if one exists
• sourceUrl, recordType: "flightStatus", scrapedAt

Output: flight history (mode = flightHistory)

• flightIdent, flightDate (YYYY-MM-DD), scheduledDepartureUtc (ISO UTC)
• aircraftType
• originIcao, originIata, originAirportName, originCity
• destinationIcao, destinationIata, destinationAirportName, destinationCity
• departureTimeLocal, departureTimeZone, departureEstimated
• arrivalTimeLocal, arrivalTimeZone, arrivalEstimated
• flightDurationText (H:MM), flightDurationMinutes — only present for completed flights
• status — e.g. Scheduled, Cancelled, Landed — only present when the row isn't a completed-duration row
• cancelled — boolean
• flightPlanRoute — waypoint string, when FlightAware published one for that instance
• permalink, sourceUrl, recordType: "flightHistory", scrapedAt

Output: airport board (mode = airportBoard)

• flightIdent, scheduledDepartureUtc (ISO UTC)
• airlineIcao — derived from the flight ident prefix, e.g. AAL
• airlineName, airlineCallsign, airlineHub
• aircraftType, aircraftTypeFriendly
• direction — arrival or departure
• boardSection — arrivals, departures, enroute, or scheduled (which section of the board the row came from)
• originIcao, destinationIcao — the full route for the row
• otherAirportIcao, otherAirportIata, otherAirportName, otherAirportCity — the airport on the other end of the route
• queriedAirportIcao, queriedAirportIata, queriedAirportName, queriedAirportCity — the airport you searched for
• departureTimeLocal, departureTimeZone, departureEstimated
• progressPercent — how far along an en-route/departed flight is, when FlightAware shows a progress bar
• arrivalTimeLocal, arrivalTimeZone, arrivalEstimated
• boardStatus — e.g. Delayed; present instead of the time/progress fields for rows where FlightAware collapses that column into a status word rather than showing gate/track times
• flightDetailUrl, sourceUrl, recordType: "airportBoard", scrapedAt

Note: FlightAware's live airport-board page shows only its current on-screen rows for each section (typically up to ~20 per section, more at very busy hubs) — there's no further pagination to scrape. If maxItems is higher than the number of rows actually on the page, you'll get all available rows rather than the full maxItems count.

Output: flight track log (mode = flightTrackLog)

Two kinds of records, distinguished by recordKind:

• recordKind: "waypoint" — one per position report: sequenceIndex, timestampLocal, latitude, longitude, courseDegrees, groundspeedKts, groundspeedMph, altitudeFeet, verticalRateFpm, verticalDirection (Climbing / Descending / Level), reportingFacility
• recordKind: "event" — one per milestone: eventType (Left Gate / Taxi Time / Departure / Arrival / Gate Arrival), eventAirportCode, eventLocalTime, eventTimeZone, eventSource (for milestones), or taxiMinutes (for Taxi Time)
• Every record also carries: flightIdent, originIcao, destinationIcao, scheduledDepartureUtc, sourceUrl, recordType: "flightTrackLog", scrapedAt

Note: The actor pulls the track log for the most recently tracked instance of the flight number/tail number you searched for (the same instance mode=flightStatus returns), not an arbitrary historical instance. maxItems caps the total number of waypoint+event records emitted (up to 200); a long-haul flight can have several hundred waypoints, so raise maxItems if you want the full track.

Input

Field	Type	Default	Description
mode	string	flightStatus	flightStatus / flightHistory / airportBoard / flightTrackLog
flightIdent	string	AAL100	Flight number or tail number (mode=flightStatus, mode=flightHistory, mode=flightTrackLog)
airportCode	string	KJFK	ICAO or IATA airport code (mode=airportBoard)
boardType	string	all	all / arrivals / departures / enroute / scheduled (mode=airportBoard)
includeCancelled	bool	true	Drop Cancelled rows when off (mode=flightHistory)
aircraftType	string	–	Keep only this ICAO aircraft type, e.g. B738 (mode=flightHistory, airportBoard)
originIcao	string	–	Keep only rows departing this ICAO airport (mode=flightHistory, airportBoard)
destinationIcao	string	–	Keep only rows arriving at this ICAO airport (mode=flightHistory, airportBoard)
airlineIcao	string	–	Keep only this airline's ICAO code, e.g. AAL (mode=airportBoard)
maxItems	int	10	Hard cap on emitted records (1–200)
proxyConfiguration	object	AUTO	Apify proxy config; used automatically as a fallback only if FlightAware rate-limits/blocks a direct request

Example: track a flight by flight number

{
  "mode": "flightStatus",
  "flightIdent": "AAL100"
}

Example: track an aircraft by tail number

{
  "mode": "flightStatus",
  "flightIdent": "N12345"
}

Example: last two weeks of a route's history, excluding cancellations

{
  "mode": "flightHistory",
  "flightIdent": "AAL100",
  "includeCancelled": false,
  "maxItems": 20
}

Example: live arrivals and departures for an airport

{
  "mode": "airportBoard",
  "airportCode": "KJFK",
  "boardType": "all",
  "maxItems": 50
}

Example: only this airline's departures from an airport

{
  "mode": "airportBoard",
  "airportCode": "JFK",
  "boardType": "departures",
  "airlineIcao": "DAL"
}

Example: full waypoint track log for a flight

{
  "mode": "flightTrackLog",
  "flightIdent": "AAL100",
  "maxItems": 200
}

Use cases

• Travel & logistics dashboards — show a live flight's status, gate, and ETA on your own site
• Ops monitoring — watch a route's on-time performance and cancellation history over recent weeks
• Aviation research & spotting — pull registration/aircraft-type detail for a tail number
• Airport information displays — mirror an airport's live arrivals/departures board
• Travel alerting — poll a flight number ahead of a trip to catch delays, gate changes, or cancellations
• Fleet tracking — monitor a private/GA aircraft's public tracking status by tail number
• Flight-path visualization — plot a completed or in-progress flight's actual route on a map from its waypoint track log

FAQ

Is this affiliated with FlightAware? No. This is an independent, third-party actor that reads FlightAware's public flight-tracking pages. It is not endorsed by or affiliated with FlightAware LLC.

What flight identifiers can I use? Airline flight numbers in ICAO form (AAL100) — this always works and is the recommended format — plus aircraft tail/N-numbers (N12345). Some carriers' IATA-style idents (e.g. BA1, DL1) also resolve directly on FlightAware, but this isn't guaranteed for every airline (e.g. AA100/UA1 return no tracking data on FlightAware itself); if a search comes back empty, retry with the ICAO-prefixed form.

Why do some fields disappear from a record? Empty fields are always omitted rather than sent as null. A scheduled (not-yet-departed) flight, for example, has no actualTakeoffTime or live position yet, so those keys simply aren't present.

Why is tailNumber missing for some flights? Some aircraft owners request that FlightAware hide their registration from public tracking. Those records still return everything else that's public (aircraft type, times, route) with blocked: true.

Why do some airport-board rows have boardStatus instead of times? For a delayed en-route/inbound flight, FlightAware sometimes replaces the whole time/progress column with a single status word (currently only Delayed is observed) instead of showing gate/track times. The actor still emits that row — with boardStatus set — rather than dropping it.

What does boardSection mean on airport-board records? FlightAware's airport page shows up to four live panels: arrivals (landing here), departures (leaving here), enroute (currently in the air heading here), and scheduled (scheduled to depart here but hasn't yet). direction normalizes these to arrival or departure.

How far back does flight history go? The actor reads the same recent-activity table FlightAware shows on its public history page — typically the last ~2 weeks of instances for that flight number or tail number.

How fresh is the data? Live — every run fetches the current page directly from flightaware.com. Flight-status pages update roughly every minute while a flight is active.

How does mode=flightTrackLog pick which flight instance to track? It reads the same live tracking page mode=flightStatus uses and follows that instance's own track-log link, so it always returns the most recently tracked instance of the flight number/tail number you searched for — the currently active one if it's flying now, or the most recent completed one otherwise.

Do I need a FlightAware account, API key, or proxy? No. The actor reads FlightAware's public pages directly; no login, API key, or cookies are required. A free proxyConfiguration input (AUTO/datacenter) is included and used automatically as a fallback only if FlightAware returns a rate-limit/block response to a direct request.

Is airlineUrl always reachable? airlineUrl is the airline's own official homepage, copied verbatim from FlightAware's data (e.g. https://www.aa.com/). Some airline websites run their own bot-protection (e.g. Akamai) that blocks non-browser or automated requests independent of this actor; the URL itself is correct and will load normally in a regular browser.