# FlightAware Flight Tracking Scraper (`crawlerbros/flightaware-flight-tracking-scraper`) Actor

Track live and scheduled flights on FlightAware by flight number or tail number, pull recent flight history for a route, fetch an airport's live arrivals/departures/en-route/scheduled board, or pull a flight's waypoint-by-waypoint track log.

- **URL**: https://apify.com/crawlerbros/flightaware-flight-tracking-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Travel, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 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

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

#### Example: track an aircraft by tail number

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

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

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

#### Example: live arrivals and departures for an airport

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

#### Example: only this airline's departures from an airport

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

#### Example: full waypoint track log for a flight

```json
{
  "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.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `flightIdent` (type: `string`):

Flight number (e.g. `AAL100`, `UAL1`) or aircraft tail/N-number (e.g. `N12345`). Used by mode=flightStatus, mode=flightHistory, and mode=flightTrackLog.

## `airportCode` (type: `string`):

ICAO (4-letter, e.g. `KJFK`) or IATA (3-letter, e.g. `JFK`) airport code. Used by mode=airportBoard.

## `boardType` (type: `string`):

Which section(s) of the airport board to scrape (mode=airportBoard).

## `includeCancelled` (type: `boolean`):

When off, drop history rows whose status is `Cancelled` (mode=flightHistory).

## `aircraftType` (type: `string`):

Only keep rows for a specific ICAO aircraft type code, e.g. `B738`, `A321`, `B789` (mode=flightHistory, mode=airportBoard).

## `originIcao` (type: `string`):

Only keep rows departing from this ICAO airport code, e.g. `KJFK` (mode=flightHistory, mode=airportBoard).

## `destinationIcao` (type: `string`):

Only keep rows arriving at this ICAO airport code, e.g. `EGLL` (mode=flightHistory, mode=airportBoard).

## `airlineIcao` (type: `string`):

Only keep board rows operated by this airline's ICAO code, e.g. `AAL`, `DAL`, `UAL`, `BAW` (mode=airportBoard).

## `maxItems` (type: `integer`):

Hard cap on emitted records.

## `proxyConfiguration` (type: `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.

## Actor input object example

```json
{
  "mode": "flightStatus",
  "flightIdent": "AAL100",
  "airportCode": "KJFK",
  "boardType": "all",
  "includeCancelled": true,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `flights` (type: `string`):

Dataset containing all scraped flight status / history / airport board records.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

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

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/flightaware-flight-tracking-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

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

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/flightaware-flight-tracking-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "flightStatus",
  "flightIdent": "AAL100",
  "airportCode": "KJFK",
  "boardType": "all",
  "includeCancelled": true,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/flightaware-flight-tracking-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/flightaware-flight-tracking-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/RHdO1NWGqQ0Q7aF1l/builds/7JQwq4oBVYcepJEla/openapi.json