# Flight Tracker — Live Aircraft Data for AI Agents (`haketa/flight-tracker`) Actor

Real-time flight tracking tool for AI agents & LLMs. Look up live aircraft position, altitude, speed, heading & on-ground status by flight/callsign, region or airport — plus airport departures/arrivals. MCP-callable real-time grounding for travel assistants & RAG.

- **URL**: https://apify.com/haketa/flight-tracker.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** AI, Travel
- **Features:** Limited permissions
- **Stats:** 5 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Flight Tracker — Live Aircraft Position, Altitude & Speed for AI Agents

[![Flight Tracker](https://img.shields.io/badge/Aviation-Live%20Flight%20Tracker-0284c7?style=for-the-badge)](#what-this-flight-tracker-does)
[![AI & MCP Ready](https://img.shields.io/badge/AI%20%26%20MCP-Real--Time%20Grounding-8250df?style=for-the-badge)](#how-to-use)
[![Global Airspace](https://img.shields.io/badge/Coverage-Worldwide%20ADS--B%20%26%20MLAT-2da44e?style=for-the-badge)](#output)
[![Export](https://img.shields.io/badge/Bulk%20Export-JSON%20%7C%20CSV%20%7C%20Excel%20%7C%20API-fb8500?style=for-the-badge)](#how-to-use)

**A real-time flight tracker, aviation data extractor, and live aircraft status API built for AI agents, LLMs, RAG pipelines, and B2B aviation intelligence.** This **flight tracker** lets you **scrape flight data** and pull **live aircraft position, barometric & geometric altitude, ground speed, true heading, vertical climb/descent rate, transponder squawk, and on-ground status** by flight number / callsign, airline prefix, continental region, or airport — live telemetry that no language model knows from its training data.

Export flight data in bulk to **JSON, CSV, Excel, or API** — or call the actor directly as an **MCP / tool-call grounding source** from any AI agent.

> **✈️ Built for AI travel assistants, LLM copilots, aviation operations dashboards, cargo & supply-chain logistics, OSINT researchers, and travel-tech teams** who need real-time flight tracking from **100 to 1,000+ live aircraft per run** without manual radar scraping.

***

### ⚡ At a glance

| Feature | Details |
|---|---|
| **Data coverage** | Live global ADS-B, MLAT, ASTERIX & FLARM air-traffic telemetry + airport arrivals/departures |
| **Search modes** | Flight / Callsign lookup (`DLH717`, `LH717`), Airline fleet filter (`DLH`, `BAW`, `UAL`), Regional bounding boxes (`europe`, `north-america`, `asia`, `worldwide`, etc.), and 45+ Airport ICAO feeds |
| **Core extracted fields** | 23 fields: `callsign`, `icao24`, `originCountry`, `latitude`, `longitude`, `baroAltitudeM`, `geoAltitudeM`, `velocityMs`, `velocityKmh`, `headingDeg`, `verticalRateMs`, `onGround`, `squawk`, `timePosition`, `lastContact`, `positionSource`, `departureAirport`, `arrivalAirport` |
| **1,000+ scale** | Single bulk snapshot or multi-region expansion returns **100 to 5,000+ unique live aircraft** in seconds |
| **Execution modes** | Standard Batch Actor run (Dataset export) + warm **Standby HTTP API** / **MCP Server** |
| **Export formats** | JSON, CSV, Excel (XLSX), HTML, XML, Apify REST API, MCP, Webhooks, Make & Zapier |

***

### 🔎 Why scrape live flight data?

Flight telemetry is **live, high-value, and perishable**. A commercial jet's position, altitude, and ground speed change every few seconds, so any static dataset is obsolete within minutes. Large language models have a fixed training cutoff and **zero visibility into current airspace** — ask an ungrounded chatbot where a flight is right now and it will guess or refuse. The only way to answer accurately is to query a **real-time flight tracker** at runtime.

Manual radar websites throttle automation, lock data behind heavy WebGL maps, and are not structured for AI agents or bulk analytics. This **flight data extractor** turns live global air-traffic state vectors into clean, token-efficient JSON records — one object per aircraft — that drop straight into an LLM context window, an operational map, a logistics pipeline, or an Excel workbook.

**Common reasons teams use this flight tracker:**

- ✈️ **Ground AI travel assistants & chatbots** — answer *"Where is flight LH717 right now?"* with live coordinates, altitude in metres, and ground speed in km/h.
- 🤖 **Equip LLM agents with a real-time MCP tool** — give Claude, ChatGPT, LangChain, or CrewAI agents on-demand access to live sky telemetry.
- 🏢 **Airline fleet & competitor monitoring (B2B intelligence)** — filter live airspace by airline prefixes (`LH`, `BA`, `UA`, `EK`, `QR`, `TK`) to count active airborne fleet size and regional deployment.
- 📦 **Air cargo & freight logistics visibility** — track cargo callsigns (`FDX`, `UPS`, `CLX`, `BOX`) across continents to estimate freight arrival windows.
- 🗺️ **Power live aviation maps & ops dashboards** — pull 1,000+ live aircraft across Europe, North America, Asia, or Worldwide into BI dashboards and geospatial tools.
- 🛫 **Monitor airport arrivals & departures** — inspect recent arrival and departure activity across 45+ major international hub airports by ICAO code.
- 🔍 **OSINT, journalism & academic research** — capture verifiable snapshots of airspace density, aircraft registration countries, and flight tracks.

***

### ✨ What this flight tracker does

- ✅ **Smart Flight & Callsign Lookup (IATA ↔ ICAO auto-mapping)** — pass one or more flight numbers (`DLH717`, `BA123`, `UAL456`) or airline prefixes (`LH`, `BA`, `DLH`). Standard 2-letter **IATA** flight numbers like `LH717` are automatically resolved to their 3-letter **ICAO** air-traffic callsign (`DLH717`).
- ✅ **Airline Fleet Filtering (`airlines`)** — filter any regional or worldwide snapshot by one or more airline IATA/ICAO prefixes (e.g. `["LH", "BA", "AF", "KL"]`) to extract all currently airborne aircraft for specific carriers.
- ✅ **Regional & Worldwide Airspace Snapshots** — retrieve every live aircraft flying over **Europe, North America, South America, Asia, Oceania, Africa, the Middle East**, or **Worldwide**.
- ✅ **Unlocked 1,000+ Aircraft Scale** — when `maxItems` is set to `1,000+` (or `0` for unlimited), the actor pulls full bulk snapshots and automatically expands across regional bounding boxes if a single region has fewer aircraft than requested.
- ✅ **Airport Departures & Arrivals (45+ Hubs + Custom ICAO)** — select from 45+ major global airports (`EGLL`, `KJFK`, `EDDF`, `LFPG`, `OMDB`, `RJTT`, `WSSS`, `LTFM`, etc.) or add any custom 4-letter ICAO code under `airportsCustom`.
- ✅ **Complete 17-point ADS-B State Vector Normalization** — extracts WGS-84 `latitude` & `longitude`, `baroAltitudeM` & `geoAltitudeM`, `velocityMs` & `velocityKmh`, `headingDeg`, `verticalRateMs`, `onGround`, `squawk`, `originCountry`, `icao24` hex address, `timePosition`, `lastContact`, and `positionSource` (`ADS-B`, `MLAT`, `ASTERIX`, `FLARM`).
- ✅ **Dual Execution: Batch + Warm Standby HTTP API** — run as a standard Apify batch job for bulk JSON/CSV/Excel exports, or query instantly over HTTP in Standby / MCP mode.
- ✅ **Zero Duplicates** — every record is strictly de-duplicated by `icao24` + `source` + `firstSeen`.

***

### 🎯 Use cases

| Audience | How they use this Flight Tracker |
|---|---|
| **AI & LLM Engineers** | Connect via MCP (`mcp.apify.com`) or Standby HTTP API so conversational travel agents can verify live flight positions and speeds in real time. |
| **Supply Chain & Freight Forwarders** | Track long-haul air freight callsigns and monitor congestion around key cargo hubs (`EDDF`, `VHHH`, `KMEM`, `KANC`). |
| **Aviation Analysts & B2B Intelligence** | Sample 1,000+ airborne aircraft on a schedule to measure carrier utilization, route density, and fleet activity by country of registration. |
| **Travel-Tech & Hospitality Apps** | Trigger automated hotel/chauffeur notifications when an inbound flight descends below 3,000m or enters a regional bounding box. |
| **OSINT & Investigative Teams** | Log verifiable timestamps, transponder squawk codes (`7700`/`7600`), and ICAO24 hex addresses across regions of interest. |
| **Data Science & Geospatial Teams** | Export clean CSV/JSON airspace snapshots into PostGIS, BigQuery, Snowflake, Tableau, or Kepler.gl for 3D flight path visualization. |

***

### 📥 Input parameters

All input fields are optional. By default (and in prefill), the actor runs a fast **Europe live airspace snapshot** returning 100 live aircraft in a few seconds.

| Parameter | Type | Default / Prefill | Description |
|---|---|---|---|
| `flights` | `array` | `[]` | Specific flight numbers, callsigns, or airline prefixes to locate live (e.g. `["DLH717", "BA123", "LH400"]`). IATA codes (`LH717`) are auto-converted to ICAO (`DLH717`). Leave empty for regional/worldwide snapshot mode. |
| `region` | `string` | `"worldwide"` (prefill: `"europe"`) | Airspace bounding box when `flights` is empty: `worldwide`, `europe`, `north-america`, `south-america`, `asia`, `oceania`, `africa`, `middle-east`, or `none`. |
| `airlines` | `array` | `[]` | Optional airline IATA or ICAO prefixes (e.g. `["LH", "BA", "UAL", "THY"]`) to filter live aircraft by carrier. |
| `airports` | `array` | `[]` | Select from 45+ major international airports by ICAO code (`EDDF`, `EGLL`, `LFPG`, `KJFK`, `KLAX`, `OMDB`, `LTFM`, `WSSS`, `RJTT`, etc.) to list recent departures or arrivals. |
| `airportsCustom` | `array` | `[]` | Additional airport ICAO codes not in the dropdown (e.g. `["KSEA", "EGKK", "LIMC"]`). |
| `airportDirection` | `string` | `"arrival"` | For airport mode: fetch `"arrival"` or `"departure"` flights. |
| `openSkyClientId` | `string` | `""` | Optional OpenSky OAuth2 client ID (enables authenticated airport history & higher rate quotas). |
| `openSkyClientSecret` | `string` | `""` | Optional OpenSky OAuth2 client secret (stored securely as a secret field). |
| `maxItems` | `integer` | `100` (prefill: `100`) | Maximum number of aircraft / flights to return. Set `1000`+ for large snapshots or `0` for unlimited. |
| `proxyConfiguration` | `object` | `{ "useApifyProxy": true }` | Apify Proxy configuration. Enabled by default so requests route cleanly without shared-IP throttling. |

#### Example 1 — Fast Regional Airspace Snapshot (Prefill / 100+ Live Aircraft)

```json
{
  "flights": [],
  "region": "europe",
  "maxItems": 100,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

#### Example 2 — 1,500+ Worldwide Live Aircraft Bulk Export

```json
{
  "flights": [],
  "region": "worldwide",
  "maxItems": 1500,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

#### Example 3 — Track Specific Flights or Airline Fleets (IATA / ICAO)

```json
{
  "flights": ["LH717", "BA123", "UAL", "THY"],
  "maxItems": 250,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

#### Example 4 — Filter European Airspace by Major Carriers

```json
{
  "region": "europe",
  "airlines": ["DLH", "BAW", "AFR", "KLM", "RYR", "EZY"],
  "maxItems": 500,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

***

### 📤 Output format & field reference

Each aircraft or flight record is written as a structured JSON object.

#### ✈️ Identity & Registration Fields

| Field | Coverage | Description |
|---|---|---|
| `callsign` | 🟢 High (~98%) | Active air-traffic callsign broadcast by the aircraft transponder (e.g. `"DLH717"`, `"UAL70"`). |
| `icao24` | 🟢 High (100%) | Unique 24-bit ICAO transponder hex address (e.g. `"3c6675"`, `"aa9321"`). Natural primary key. |
| `originCountry` | 🟢 High (100% live) | Country of aircraft registration derived from the ICAO24 address allocation (e.g. `"Germany"`, `"United States"`). |
| `matchedQuery` | 🟡 Conditional | The input query string that matched this aircraft when running in `flights` lookup mode; `null` in regional snapshot mode. |
| `squawk` | 🟡 Conditional (~65%) | 4-digit octal transponder squawk code assigned by Air Traffic Control (e.g. `"7107"`). |

#### 🌍 Live Position, Altitude & Velocity Telemetry

| Field | Coverage | Description |
|---|---|---|
| `latitude` | 🟢 High (~99.6% live) | Current WGS-84 latitude in decimal degrees (e.g. `44.5102`). |
| `longitude` | 🟢 High (~99.6% live) | Current WGS-84 longitude in decimal degrees (e.g. `-66.7877`). |
| `baroAltitudeM` | 🟢 High (~88% airborne) | Barometric altitude in metres above mean sea level (`null` when aircraft is on the ground). |
| `geoAltitudeM` | 🟢 High (~88% airborne) | Geometric (GNSS/GPS) altitude in metres (`null` when on the ground). |
| `velocityMs` | 🟢 High (100% live) | Ground speed in metres per second (e.g. `234.6`). |
| `velocityKmh` | 🟢 High (100% live) | Ground speed converted to kilometres per hour (e.g. `845`). |
| `headingDeg` | 🟢 High (~99% live) | True track angle in degrees clockwise from geographic north (`0°`–`360°`). |
| `verticalRateMs` | 🟢 High (~88% airborne) | Vertical climb (`+`) or descent (`-`) rate in metres per second (`0` in level cruise). |
| `onGround` | 🟢 High (100% live) | Boolean (`true` / `false`) indicating whether the surface switch is active. |

#### ⏱️ Data Freshness, Sensor Source & Airport Fields

| Field | Coverage | Description |
|---|---|---|
| `timePosition` | 🟢 High (~99.6% live) | ISO 8601 timestamp of the latest coordinate fix from the aircraft. |
| `lastContact` | 🟢 High (100% live) | ISO 8601 timestamp of the most recent transponder message of any type. |
| `positionSource` | 🟢 High (100% live) | Telemetry receiver technology: `"ADS-B"`, `"MLAT"`, `"ASTERIX"`, or `"FLARM"`. |
| `departureAirport` | 🟡 Conditional (Airport) | Estimated 4-letter ICAO departure airport code (populated in airport mode). |
| `arrivalAirport` | 🟡 Conditional (Airport) | Estimated 4-letter ICAO arrival airport code (populated in airport mode). |
| `firstSeen` / `lastSeen` | 🟡 Conditional (Airport) | ISO 8601 timestamps for departure/arrival window in airport mode. |
| `source` | 🟢 High (100%) | Record origin: `"live-position"`, `"airport-arrival"`, or `"airport-departure"`. |
| `scrapedAt` | 🟢 High (100%) | ISO 8601 timestamp when the record was captured by the actor. |

#### Sample JSON output (Live Position Record)

```json
{
  "callsign": "UAL70",
  "icao24": "aa9321",
  "matchedQuery": null,
  "originCountry": "United States",
  "latitude": 44.5102,
  "longitude": -66.7877,
  "baroAltitudeM": 10058.4,
  "geoAltitudeM": 10142.22,
  "velocityMs": 234.6,
  "velocityKmh": 845,
  "headingDeg": 58.54,
  "verticalRateMs": 0,
  "onGround": false,
  "squawk": "7107",
  "timePosition": "2026-11-02T00:12:08.000Z",
  "lastContact": "2026-11-02T00:12:08.000Z",
  "positionSource": "ADS-B",
  "departureAirport": null,
  "arrivalAirport": null,
  "firstSeen": null,
  "lastSeen": null,
  "source": "live-position",
  "scrapedAt": "2026-11-02T00:12:14.397Z"
}
```

#### Sample JSON output (Airport Mode Record)

```json
{
  "callsign": "DLH441",
  "icao24": "3c6675",
  "matchedQuery": null,
  "originCountry": null,
  "latitude": null,
  "longitude": null,
  "baroAltitudeM": null,
  "geoAltitudeM": null,
  "velocityMs": null,
  "velocityKmh": null,
  "headingDeg": null,
  "verticalRateMs": null,
  "onGround": null,
  "squawk": null,
  "timePosition": null,
  "lastContact": null,
  "positionSource": null,
  "departureAirport": "EDDF",
  "arrivalAirport": "KIAD",
  "firstSeen": "2026-11-02T12:05:11.000Z",
  "lastSeen": "2026-11-02T13:58:40.000Z",
  "source": "airport-departure",
  "scrapedAt": "2026-11-02T14:00:02.000Z"
}
```

***

### 🔁 Scale, Bulk Snapshots & Multi-Region Expansion

- **Single-call bulk airspace extraction:** Unlike traditional web scrapers that crawl one page at a time, live airspace state vectors are retrieved in bulk — returning hundreds to **5,000+ active aircraft** in a single snapshot.
- **Automatic multi-region expansion for 1,000+ runs:** If you select a quiet region (such as `oceania` or `africa` overnight) with `maxItems: 1000+`, the actor automatically expands across neighboring regional bounding boxes (`europe`, `north-america`, `asia`, etc.) so your run reliably reaches the requested `maxItems` volume.
- **Airline fleet prefix matching:** Pass 2-letter IATA (`LH`, `BA`, `UA`, `EK`, `TK`) or 3-letter ICAO (`DLH`, `BAW`, `UAL`, `UAE`, `THY`) carrier codes in `airlines` or `flights` to extract entire airborne airline fleets (100–500+ aircraft) in seconds.

***

### ⚙️ How to use (Batch, API & AI Agent / MCP)

#### 1. Apify Console (No-Code)

1. Open the actor on the **Apify Console**.
2. Choose a `region` (e.g. `europe` or `worldwide`), or enter `flights` / `airlines`, and set `maxItems` (e.g. `100` or `1000`).
3. Click **Start** and export your dataset as **JSON, CSV, Excel, HTML, or XML**.

#### 2. Python API Client

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("haketa/flight-tracker").call(run_input={
    "region": "europe",
    "airlines": ["DLH", "BAW", "AFR", "KLM"],
    "maxItems": 200,
})

for flight in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{flight['callsign']} ({flight['originCountry']}): {flight['baroAltitudeM']}m @ {flight['velocityKmh']} km/h")
```

#### 3. JavaScript / TypeScript API Client

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('haketa/flight-tracker').call({
    region: 'worldwide',
    maxItems: 500,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Captured ${items.length} live aircraft`);
```

#### 4. AI Agent / MCP Tool Integration

Register this actor with **Claude Desktop, Cursor, VS Code, LangChain, CrewAI, or LlamaIndex** via `mcp.apify.com` or query its **Standby HTTP endpoint** (`?region=europe&maxItems=50` or `?flights=DLH717,BA123`) for sub-second JSON responses.

##### Example MCP Server Configuration (`claude_desktop_config.json`)

```json
{
  "mcpServers": {
    "apify-flight-tracker": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server",
        "--actors",
        "haketa/flight-tracker"
      ],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

##### Example Standby HTTP Query (`cURL`)

```bash
curl -s -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  "https://haketa--flight-tracker.apify.actor/?region=europe&airlines=DLH,BAW&maxItems=50"
```

***

### 📊 Regional Bounding Boxes & Coverage Reference

When you select a `region` from the input dropdown, the flight tracker queries the corresponding geographic bounding box (`lamin`, `lomin`, `lamax`, `lomax`):

| Region Code | Geographic Area | Bounding Box (`Lat Min, Lon Min` → `Lat Max, Lon Max`) | Typical Live Aircraft Count |
|---|---|---|---|
| `worldwide` | Global Airspace (All Continents) | `-90, -180` → `90, 180` | 4,000 – 6,500+ aircraft |
| `europe` | European Airspace (UK, EU, EEA, Turkey) | `35, -15` → `72, 40` | 1,200 – 2,500+ aircraft |
| `north-america` | USA, Canada, Mexico & Caribbean | `15, -170` → `72, -50` | 2,000 – 3,500+ aircraft |
| `asia` | East, South & Southeast Asia | `5, 60` → `55, 150` | 600 – 1,400+ aircraft |
| `middle-east` | Gulf Hubs (DXB, DOH, RUH, IST) & Levant | `12, 34` → `42, 63` | 250 – 600+ aircraft |
| `south-america` | Brazil, Argentina, Andes & Southern Cone | `-56, -82` → `13, -34` | 200 – 500+ aircraft |
| `oceania` | Australia, New Zealand & South Pacific | `-50, 110` → `0, 180` | 150 – 400+ aircraft |
| `africa` | North, West, East & Southern Africa | `-35, -18` → `37, 52` | 150 – 400+ aircraft |

***

### 🛫 Built-In IATA ↔ ICAO Airline Prefix Mapping

You can pass either 2-letter IATA codes or 3-letter ICAO prefixes in `flights` and `airlines`:

| Carrier | IATA Code | ICAO Callsign Prefix | Example Input |
|---|---|---|---|
| Lufthansa | `LH` | `DLH` | `LH717` or `DLH717` |
| British Airways | `BA` | `BAW` | `BA123` or `BAW123` |
| United Airlines | `UA` | `UAL` | `UA456` or `UAL456` |
| American Airlines | `AA` | `AAL` | `AA100` or `AAL100` |
| Delta Air Lines | `DL` | `DAL` | `DL200` or `DAL200` |
| Air France / KLM | `AF` / `KL` | `AFR` / `KLM` | `AF11` / `KL601` |
| Emirates / Qatar / Etihad | `EK` / `QR` / `EY` | `UAE` / `QTR` / `ETD` | `EK201` / `QR1` |
| Turkish Airlines | `TK` | `THY` | `TK1` or `THY1` |
| Ryanair / easyJet / Wizz Air | `FR` / `U2` / `W6` | `RYR` / `EZY` / `WZZ` | `FR101` / `U2800` |
| Singapore / Cathay / Qantas | `SQ` / `CX` / `QF` | `SIA` / `CPA` / `QFA` | `SQ25` / `QF1` |

***

### 💡 Pro tips for best results

- **Looking for 100+ or 1,000+ guaranteed results?** Leave `flights` empty (or pass airline prefixes like `["DLH", "UAL", "BAW"]`) and use `region: "europe"` or `region: "worldwide"`. Specific individual flight numbers only appear while that exact flight is airborne.
- **IATA vs. ICAO callsigns:** The scraper maps 65+ major airline 2-letter IATA codes (`LH`, `BA`, `AA`, `UA`, `DL`, `AF`, `KL`, `EK`, `QR`, `TK`, `SQ`, `FR`, `U2`, `W6`, etc.) to their 3-letter ICAO callsigns automatically. For regional airlines, pass the 3-letter ICAO callsign directly.
- **On-ground vs. airborne altitude:** When `onGround` is `true`, `baroAltitudeM` and `geoAltitudeM` are naturally `null`. Filter on `onGround: false` if you only want cruising aircraft.
- **Keep Apify Proxy enabled:** Leaving `proxyConfiguration: { "useApifyProxy": true }` prevents shared-IP rate limiting and ensures fast, uninterrupted responses.

***

### ❓ Frequently Asked Questions (FAQ)

**Do I need an API key or account to track live flights?**
No! Live flight lookup (`flights`), airline filtering (`airlines`), and regional/worldwide snapshots (`region`) work out of the box with **zero credentials**. Optional OpenSky OAuth2 credentials are only used if you want historical 6-hour airport arrival/departure logs.

**How many live aircraft can I extract in one run?**
A single worldwide snapshot typically contains **4,000 to 6,500+ live airborne aircraft**. Set `maxItems: 100` for a fast sample, `1000` for large-scale analytics, or `0` to export the entire global sky at once.

**Why did a single flight number return 0 results?**
Aircraft transponders only broadcast live ADS-B state vectors **while the plane is airborne** (or taxiing with transponder active). If a specific flight number hasn't departed yet or has already landed, it won't be in the live sky snapshot. Use regional mode (`region: "europe"` / `"worldwide"`) or airline prefixes (`"DLH"`, `"UAL"`) when you always want a populated dataset.

**How fresh is the telemetry?**
Positions are updated every few seconds. Check the `timePosition` and `lastContact` ISO timestamps on each record to see the exact second the coordinate fix was received.

**Can I schedule recurring runs?**
Yes — use Apify Schedules (e.g. every 5 minutes or hourly) to build a time-series flight trajectory database in BigQuery, S3, PostgreSQL, or Google Sheets.

***

### 🔗 Related Live Tracking & Enrichment Scrapers

Pair this flight tracker with other real-time grounding and B2B intelligence actors:

- [Vessel Tracker — Live Ship Position & AIS Data](https://apify.com/haketa/vessel-tracker) — real-time maritime vessel positions, speed, course, and MMSI/IMO telemetry.
- [Wikidata Resolver](https://apify.com/haketa/wikidata-resolver) — resolve airlines, airports, cities, and corporations to structured knowledge-graph entities.
- [GLEIF LEI Lookup](https://apify.com/haketa/gleif-lei) — verify corporate Legal Entity Identifiers and parent/subsidiary ownership trees.
- [Sanctions Screening](https://apify.com/haketa/sanctions-screening) — screen companies, aircraft operators, vessels, and individuals against global sanctions lists.
- [SEC EDGAR Scraper](https://apify.com/haketa/sec-edgar-scraper) — corporate filings and financial disclosures for public airlines and aerospace companies.

***

### 📋 Changelog

- **v1.2 (2026-11)** — Added `airlines` carrier prefix filtering (IATA & ICAO), prefix matching in `flights`, automatic multi-region bounding-box expansion when `maxItems > 1,000`, and live-snapshot fallback for unauthenticated airport queries; updated prefill to `region: "europe"` (`maxItems: 100`) for guaranteed 100-item `<15s` prefill runs.
- **v1.1 (2026-11)** — Added `timePosition` and human-readable `positionSource` (`ADS-B`, `MLAT`, `ASTERIX`, `FLARM`) fields; verified 500-aircraft worldwide snapshot with 0 duplicates.
- **v1.0 (2026-07)** — Initial release with Batch and warm Standby HTTP API modes, IATA-to-ICAO callsign mapping, and regional bounding-box snapshots.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/flight-tracker/changelog.md

# Actor input Schema

## `flights` (type: `array`):

Type one or more flight numbers or callsigns to locate live, e.g. "DLH717", "BA123", "UAL456". Airline IATA numbers such as "LH717" are matched to their ICAO callsign automatically. Leave empty to get a live regional or worldwide snapshot instead.

## `region` (type: `string`):

Return every live aircraft currently flying over the chosen region. Pick "Worldwide" for a global mixed sample. Used whenever no specific flight numbers are entered above.

## `airlines` (type: `array`):

Optional airline prefixes to filter live aircraft by operator (e.g. "LH", "DLH", "BA", "UAL", "THY"). Leave empty to include all airlines.

## `airports` (type: `array`):

Choose airports to list their recent departures or arrivals. Requires OpenSky credentials below. Need an airport that is not listed? Add its ICAO code under "Other airports".

## `airportsCustom` (type: `array`):

Optional. Add any extra airports by ICAO code, e.g. "EDDF", "KSEA", "OMAA". These are combined with the airports selected above.

## `airportDirection` (type: `string`):

For the airports above: list departures or arrivals from the last couple of hours.

## `openSkyClientId` (type: `string`):

Optional OpenSky Network OAuth2 client ID. Enables airport departures/arrivals and a higher rate limit. Get one free at opensky-network.org (Account → API Client).

## `openSkyClientSecret` (type: `string`):

OpenSky OAuth2 client secret (paired with the client ID).

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

Maximum number of aircraft / flights to return. Set 0 for no limit.

## `proxyConfiguration` (type: `object`):

Apify Proxy settings. Recommended and on by default so lookups stay fast and reliable.

## Actor input object example

```json
{
  "flights": [],
  "region": "europe",
  "airlines": [],
  "airports": [],
  "airportsCustom": [],
  "airportDirection": "arrival",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `callsign` (type: `string`):

Aircraft callsign (e.g. DLH717)

## `icao24` (type: `string`):

Unique ICAO 24-bit aircraft address

## `matchedQuery` (type: `string`):

The flight/callsign query this record matched

## `originCountry` (type: `string`):

Country of registration

## `latitude` (type: `string`):

Current latitude (WGS84)

## `longitude` (type: `string`):

Current longitude (WGS84)

## `baroAltitudeM` (type: `string`):

Barometric altitude in metres

## `geoAltitudeM` (type: `string`):

Geometric altitude in metres

## `velocityMs` (type: `string`):

Ground speed in m/s

## `velocityKmh` (type: `string`):

Ground speed in km/h

## `headingDeg` (type: `string`):

True track / heading in degrees

## `verticalRateMs` (type: `string`):

Climb/descent rate in m/s

## `onGround` (type: `string`):

True if the aircraft is on the ground

## `squawk` (type: `string`):

Transponder squawk code

## `timePosition` (type: `string`):

Timestamp of the last position (coordinate) update

## `lastContact` (type: `string`):

Timestamp of the last update of any kind for this aircraft

## `positionSource` (type: `string`):

Origin of the position fix: ADS-B, ASTERIX, MLAT or FLARM

## `departureAirport` (type: `string`):

Estimated departure airport (airport mode)

## `arrivalAirport` (type: `string`):

Estimated arrival airport (airport mode)

## `firstSeen` (type: `string`):

First seen time (airport mode)

## `lastSeen` (type: `string`):

Last seen time (airport mode)

## `source` (type: `string`):

live-position or airport-departure/arrival

## `scrapedAt` (type: `string`):

Extraction timestamp

# 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 = {
    "flights": [],
    "region": "europe",
    "airportsCustom": [],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/flight-tracker").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 = {
    "flights": [],
    "region": "europe",
    "airportsCustom": [],
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/flight-tracker").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "flights": [],
  "region": "europe",
  "airportsCustom": [],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/flight-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/flight-tracker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/zBoHFux6bG7h6w5ow/builds/Jju77t4ve2nS0cwKY/openapi.json