FlightAware Flight Tracking Scraper: Up to 1,000 Free Results a Month

Each flight status record carries up to 82 fields covering gate assignments, takeoff times, flight-plan telemetry, and live coordinates. Priced at $5.00 per 1,000 results on the free plan, the scraper operates across four modes: live tracking, historical instances, airport boards, and waypoint track logs. The data serves logistics teams and aviation hobbyists requiring real-time status and airframe details. It is not for teams looking for ticket pricing or fare classes, which these tracking records do not include.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 1,000 results at $0.005 each before platform usage. Open FlightAware Flight Tracking Scraper on Apify and run the prefilled example.

How reliable is FlightAware Flight Tracking Scraper in production?

Across the last 30 days of public runs on the Apify platform, FlightAware Flight Tracking Scraper recorded 66 runs with the following outcomes.

No run failed or timed out in the last 30 days. Keep a retry and an alert on scheduled runs all the same: a clean month is a record, not a guarantee.

What does it cost to run FlightAware Flight Tracking Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Worked example: collecting 10,000 results costs $50.00 in result charges before run-start fees and platform usage. No run failed or timed out in the last 30 days, so the list price is a fair budget; keep a retry in place all the same.

The primary billing driver is maxItems alongside your selected mode, because result charges scale directly with the quantity of emitted dataset records. Keep maxItems set to 1 on single-flight status checks to avoid paying for excess records. You can test your ident query with the default cap of 10 items before scaling up track log or airport board extractions.

How do you run FlightAware Flight Tracking Scraper from the API?

The schema marks 1 of its 11 controls as required: mode. Nothing in the payload below is illustrative. Those are the schema's prefilled defaults for FlightAware Flight Tracking Scraper, so the request works once your token is in place.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~flightaware-flight-tracking-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"flightStatus","flightIdent":"AAL100","airportCode":"KJFK","boardType":"all","includeCancelled":true,"maxItems":10,"proxyConfiguration":{"useApifyProxy":true}}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "flightStatus",
  "flightIdent": "AAL100",
  "airportCode": "KJFK",
  "boardType": "all",
  "includeCancelled": True,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": True
  }
}

run = client.actor("crawlerbros~flightaware-flight-tracking-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "flightStatus",
  "flightIdent": "AAL100",
  "airportCode": "KJFK",
  "boardType": "all",
  "includeCancelled": true,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

const run = await client.actor('crawlerbros~flightaware-flight-tracking-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

Because the call is synchronous, your client waits for the whole run. Keep it for exploration. For scheduled work, start the run without waiting and collect the dataset afterwards, so network trouble costs you a retry rather than the results.

Which FlightAware Flight Tracking Scraper inputs matter, and which can you skip?

The crucial controls are mode and either flightIdent or airportCode depending on whether you are querying a specific airframe or an airport terminal board. Optional filters like airlineIcao, aircraftType, and boardType let you narrow airport board records directly at ingestion. Most users running single-flight checks can leave the proxy settings on their default auto configuration.

• mode (string): What to fetch. Default: "flightStatus".
• flightIdent (string): Flight number (e.g. AAL100, UAL1) or aircraft tail/N-number (e.g. N12345). Used by mode=flightStatus, mode=flightHistory, and mode=flightTrackLog. Default: "AAL100".
• airportCode (string): ICAO (4-letter, e.g. KJFK) or IATA (3-letter, e.g. JFK) airport code. Used by mode=airportBoard. Default: "KJFK".
• boardType (string): Which section(s) of the airport board to scrape (mode=airportBoard). Default: "all".
• includeCancelled (boolean): When off, drop history rows whose status is Cancelled (mode=flightHistory). Default: true.
• aircraftType (string): Only keep rows for a specific ICAO aircraft type code, e.g. B738, A321, B789 (mode=flightHistory, mode=airportBoard).
• originIcao (string): Only keep rows departing from this ICAO airport code, e.g. KJFK (mode=flightHistory, mode=airportBoard).
• destinationIcao (string): Only keep rows arriving at this ICAO airport code, e.g. EGLL (mode=flightHistory, mode=airportBoard).
• airlineIcao (string): Only keep board rows operated by this airline's ICAO code, e.g. AAL, DAL, UAL, BAW (mode=airportBoard).
• maxItems (integer): Hard cap on emitted records. Default: 10.
• proxyConfiguration (object): FlightAware occasionally rate-limits or blocks direct datacenter requests. Kept as a free Apify (AUTO / datacenter) fallback the actor auto-escalates to on a 402/403/429 response. Default: {"useApifyProxy":true}.

Fixed-choice controls: mode accepts flightStatus (Track a flight (live/scheduled status)), flightHistory (recent past instances), airportBoard (arrivals/departures/en route/scheduled), flightTrackLog (waypoint-by-waypoint position history); boardType accepts all (All sections), arrivals (Arrivals only), departures (Departures only), enroute (En route/inbound only), scheduled (Scheduled departures only).

What does FlightAware Flight Tracking Scraper return?

The extracted dataset delivers precise operational metrics including runway timestamps, delay figures, aircraft models, and waypoint-by-waypoint navigation histories. The records do not include commercial fare pricing, passenger capacity, or seat availability.

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

Output: flight track log (mode = flightTrackLog)

• 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

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open FlightAware Flight Tracking Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Select mode flightStatus and supply a known flightIdent using ICAO format such as AAL100, leaving maxItems at 10.
2. Verify that the output dataset returns an object containing recordType flightStatus along with originIcao and destinationIcao.
3. Inspect originGate, destinationGate, and estimatedLandingTime to confirm the flight instance contains active gate and ETA metrics.
4. Switch mode to flightHistory with the same flightIdent and check whether completed rows contain flightDurationMinutes and flightDate.
5. Run mode airportBoard with airportCode set to KJFK and verify that boardSection returns expected entries like arrivals or departures.
6. Execute mode flightTrackLog with maxItems set to 200 to extract full sequenceIndex position reports for the most recent flight instance.

How do you apply it? Three worked playbooks

These are FlightAware Flight Tracking Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Travel & logistics dashboards

Outcome: Show a live flight's status, gate, and ETA on your own site

Configure: Set mode to "flightStatus", flightIdent to "AAL100", and maxItems to 10.

Working method: Start with a single active flight number in ICAO format. Run the Actor and extract estimatedLandingTime, destinationGate, and currentLatitude to populate the operational board.

Deliverable: A structured JSON object with active gate coordinates, departure timestamps, and live position metrics.

Stop condition: The output contains blocked set to true with missing destinationGate data.

Use case 2: Ops monitoring

Outcome: Watch a route's on-time performance and cancellation history over recent weeks

Configure: Set mode to "flightHistory", flightIdent to "AAL100", includeCancelled to true, and maxItems to 20.

Working method: Schedule recurring runs over a target route ident. Parse flightDurationMinutes and status across each returned flightDate to calculate average historical delay and cancellation percentages.

Deliverable: A historical table of flight instances over the last two weeks with duration and cancellation flags.

Stop condition: The dataset contains zero records because the route identifier has changed.

Use case 3: Aviation research & spotting

Outcome: Pull registration/aircraft-type detail for a tail number

Configure: Set mode to "flightStatus", flightIdent to "N12345", and maxItems to 10.

Working method: Execute a lookup against an N-number registration. Map aircraftType, aircraftManufacturer, aircraftModel, and registrationPhotoUrl into the spotting repository.

Deliverable: An aircraft profile detailing airframe specifications, owner metadata, and photo references.

Stop condition: FlightAware returns blocked set to true for privacy-shielded registrations.

What breaks, and how do you design around it?

• Over the last 30 days, 0.0% of public runs failed and 0.0% timed out. Build retries and alerting around those rates rather than assuming every run completes.

FlightAware hides airframe details for privacy-blocked registrations, so your ingestion pipeline must handle records where tailNumber is missing and blocked is set to true. Airport board pages do not paginate beyond the visible on-screen rows, meaning large airports should be polled frequently rather than queried for deep historical boards. For long routes where track logs exceed small limits, set maxItems to 200 to capture every coordinate waypoint.

When should you not use FlightAware Flight Tracking Scraper?

Do not use this Actor if your objective is flight search, fare intelligence, or ticket price comparison across commercial airlines. FlightAware is an operational tracking utility and provides zero fare, seat class, or booking availability data. If you need ticket pricing and route fare matrices, use Google Flights Scraper or Skiplagged Flight Search Scraper instead. Additionally, if you only need commercial booking links and schedules for budget European carriers, Ryanair Scraper is a far better alternative. You should also look elsewhere if you require real-time ADS-B raw feeder streams, as this Actor scrapes rendered web views rather than continuous network sockets.

What should you check before trusting the output?

• Fail the batch if flightIdent fails to resolve and returns an empty dataset instead of a record carrying recordType.
• Flag records where originIcao or destinationIcao is missing from a flightStatus or airportBoard payload.
• Alert if mode flightHistory outputs rows where status is not populated and flightDurationMinutes is absent.
• Reject mode flightTrackLog executions where no recordKind waypoint entries exist for an active airborne flight.
• Check for unexpected empty responses when querying flightIdent with IATA prefixes instead of three-letter ICAO codes.

None of this proves a record is correct. It gives a scheduled FlightAware Flight Tracking Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

What is the cost to extract 1,000 flight records on Apify's free plan?

Extracting 1,000 results costs $5.00 on Apify's free plan, charged at $0.005 per dataset item. Apify also bills platform compute usage separately. The free plan provides $5.00 in monthly usage credit without a credit card.

How should flight numbers be formatted to prevent missing results?

Provide airline flight numbers in standard ICAO format, such as AAL100 rather than AA100. While some IATA codes resolve on FlightAware, three-letter ICAO carrier prefixes ensure reliable lookup across all supported airlines.

Why are some fields missing from the returned dataset items?

Empty fields are omitted rather than returned with null values. For instance, flights that have not departed will not contain actualTakeoffTime or live coordinates until FlightAware publishes them.

How far back does the flight history mode pull records?

The flightHistory mode extracts roughly the last 2 weeks of recent flight instances published on FlightAware's public history view for that specific flight number or aircraft tail registration.

Does the flight track log mode support historical flight instances?

The flightTrackLog mode extracts waypoints for the most recently tracked instance of the requested flight or tail identifier, matching the flight instance returned by the flightStatus mode.

Where to go next

When you are ready to run it, open FlightAware Flight Tracking Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the FlightAware Flight Tracking Scraper Actor page for the current input schema, pricing tier, and run history.

Other Actors we maintain for related data:

• Ryanair Scraper: Search Ryanair's price calendar for the cheapest one-way and round-trip fares on any route.
• Google Flights Scraper: Scrape Google Flights search results with price, airline, departure/arrival times, duration, stops.
• Skiplagged Flight Search Scraper: Scrape Skiplagged's flight search results - one-way, round-trip, and multi-route fare comparisons with real prices, airlines, flight numbers, durations, stops, and booking-provider data.
• Kiwi.com Scraper: Scrape Kiwi.com - flight metasearch with virtual interlining.
• Kayak Flights, Hotels & Deals Scraper: Scrape flight deals, hotel prices, and explore cheap destinations from Kayak.
• Flight Award Mileage Chart Scraper: Look up published award redemption rates (miles + taxes) between any two regions across major frequent-flyer programs (Aeroplan, British Airways Avios, LifeMiles, United, Flying Blue, etc.).
• Rome2Rio Multi-Modal Route Scraper: Scrape Rome2Rio trip-planning results - compare flight, train, bus, car, ferry, and rideshare options between any two cities or airports, with durations, price ranges, and operators.
• 17Track Package Tracking Scraper: Multi-carrier package tracking via 17track.net - track packages from FedEx, UPS, USPS, DHL, Amazon, and 2,300+ carriers worldwide.

Related guides:

• Kiwi.com Scraper: Up to 1,000 Free Results a Month (2026)
• Trainline Scraper: Up to 1,000 Free Results a Month (2026)
• VesselFinder Scraper: AIS Maritime Tracking and Use Cases
• Yahoo Finance Scraper: 48 Data Fields, Up to 2,500 Free Results/Month

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-30.

• Actor last updated by its maintainers on 2026-08-03.

• Run outcome figures cover the 30 day public window ending 2026-09-30.

• FlightAware Flight Tracking Scraper on Apify