# FlightRadar24 Scraper – Live Flights & History (`rl1987/flightradar24-api-scraper`) Actor

Track live aircraft anywhere on earth: position, altitude, speed, heading, callsign, route, registration and airline. Plus flight and airframe history, airport delay stats, free-text search and recorded tracks. Tiles large regions automatically past the 1,500-aircraft per-request cap.

- **URL**: https://apify.com/rl1987/flightradar24-api-scraper.md
- **Developed by:** [R.L.](https://apify.com/rl1987) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 1,000 live aircraft rows

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## FlightRadar24 Scraper ✈️ — Live Aircraft, Flight History & Airport Data

**FlightRadar24 Scraper** pulls live aircraft positions and flight data straight from FlightRadar24's own mobile API — no HTML parsing, no headless browser, no login. Sweep an area for every aircraft in the sky, look up a flight's history, trace an airframe by registration, read an airport's delay statistics, or replay a completed flight's recorded track. Export to **JSON, CSV, Excel, or the Apify API**.

> Every aircraft over a continent, not the first 1,500 — this scraper splits large areas automatically to get past FlightRadar24's per-request cap.

***

### ❓ What does this FlightRadar24 scraper do?

It runs one of seven jobs, chosen with the **What to scrape** input:

| Mode | What you get |
| --- | --- |
| **Live aircraft in an area** | Every aircraft inside a bounding box — position, altitude, ground speed, vertical speed, heading, squawk, registration, aircraft type, route and airline |
| **Search** | Flights, airlines, airports and airframes matching free text like `BA48`, `British Airways` or `G-STBA` |
| **Flight history by flight number** | Past and scheduled operations of a flight number, with actual vs scheduled times |
| **Aircraft history by registration** | The airframe itself (model, country, Mode-S hex) plus the flights it has operated |
| **Airport details** | Name, ICAO code, coordinates, timezone and FlightRadar24's arrival/departure delay indices |
| **Most-tracked flights** | What FlightRadar24's own audience is watching right now, with viewer counts |
| **Playback** | A completed flight's recorded track — every position, altitude, speed and vertical speed |

- 🟢 **No code required** — pick a mode, click **Start**, download your data.
- 🔓 **No FlightRadar24 account** — the data it reads is the anonymous tier, so there is nothing to log into.
- 🗺️ **Whole-continent coverage** — large areas are tiled automatically (see below).
- 💸 **Charged per row, plus platform usage** — an aircraft seen in two overlapping tiles is billed once, and a request that returned nothing is not billed at all.

***

### 🌍 How do I get more than 1,500 aircraft?

FlightRadar24 returns at most **1,500 aircraft per request**, whatever area you ask for. A request covering Europe and a request covering the entire planet both come back with 1,500 rows while the true worldwide count sits around 15,000 — and nothing in the response says it was truncated.

With **Split large areas automatically** on (the default), any area that comes back at the cap is divided into four and each part fetched separately, repeating until every part fits underneath it. Measured against the live API: Europe returns **1,500** aircraft as one request and **5,433** as 13 tiled requests.

Empty airspace costs nothing extra — only tiles that actually hit the cap are split. If an area is still truncated when the depth limit is reached, the run log says so explicitly rather than letting you read a capped result as a complete one.

***

### 🚀 How do I scrape live flights? (3 steps)

1. **Pick a mode** — start with *Live aircraft in an area*.
2. **Choose the area** — a ready-made region (Europe, North America, Whole world…) or a custom box via the four latitude/longitude fields.
3. **Run & export** — click **Start**, then download JSON/CSV/Excel or fetch it through the Apify API.

Narrow the sweep with **Only this airline** (`BAW`, `DLH`, `UAE`…), **Only this flight number** (`BA48`) or **Only this registration** (`G-STBA`). These are applied by FlightRadar24 before the 1,500-row cap, so one airline worldwide is a single fast request rather than a tiled sweep.

***

### 📖 What do the live aircraft fields mean?

| Field | Meaning |
| --- | --- |
| `flightId` | FlightRadar24's 8-character id for this flight. Feed it to Playback mode, or open `flightUrl`. |
| `hex` | Mode-S / ICAO 24-bit transponder address — the airframe's hardware identity. |
| `callsign` | What ATC calls it, e.g. `BAW48Q`. Often differs from the flight number. |
| `flightNumber` | The commercial number, e.g. `BA48`. Empty for private and military traffic. |
| `altitudeFt` | Barometric altitude in feet. `0` while on the ground. |
| `groundSpeedKts` | Ground speed in knots. |
| `verticalSpeedFpm` | Rate of climb or descent in feet per minute. Negative means descending, `0` means level. |
| `onGround` | `true` when taxiing or parked. |
| `squawk` | Transponder code. `7700` is a general emergency, `7600` radio failure, `7500` hijack. |
| `radar` | Which receiver saw it — `T-MLAT1` is multilateration, `F-…` a terrestrial ADS-B feeder. |
| `originIata` / `destinationIata` | Route endpoints, when FlightRadar24 knows them. Empty for general aviation. |
| `airlineIcao` | Three-letter operator code, e.g. `BAW` for British Airways. |
| `timestampIso` | When the position was reported, UTC. |

Every record carries a `recordType`, so a run that mixes live positions with detail lookups stays easy to split.

***

### 🔍 Can I get full detail for each aircraft?

Yes — turn on **Add full detail for each flight**. Each aircraft then also gets a `flightDetail` row: full aircraft model, airline, both airports with coordinates and timezones, scheduled vs actual departure and arrival, delay in minutes, and an aircraft photo with its copyright line. **Include the recent position trail** adds the flight's recent track points.

This is one extra request per aircraft, so it is off by default and priced separately. FlightRadar24 rate-limits this endpoint more tightly than the others; the actor backs off per host automatically, but a large sweep with detail enabled will take noticeably longer than one without.

***

### 💵 How much does it cost?

Charged per event rather than per minute of compute:

| Event | Price | Charged for |
| --- | --- | --- |
| **Live aircraft row** | USD 0.0002 | Each aircraft from an area sweep. De-duplicated: an aircraft seen in two overlapping tiles is billed once. |
| **Flight row** | USD 0.001 | Each search result, flight-history row, airframe record or most-tracked row. |
| **Detail row** | USD 0.004 | Each full flight detail, airport record or playback track — one extra request each. |

A sweep of Europe returning about 5,400 aircraft costs roughly USD 1.08 in event charges.

**Apify platform usage (compute, proxy, data transfer) is billed on top of these event prices**, as your plan's rates. Nothing is charged for a request that returned no usable data — a stale flight id, an airport code that matches nothing, or a blocked request all cost zero.

***

### ⚖️ Is scraping FlightRadar24 legal?

This actor reads the same public, anonymous endpoints FlightRadar24's own app uses, without signing in and without circumventing any paywall — the Pro-only depth of history simply is not returned. Aircraft position data originates from ADS-B transponder broadcasts, which are unencrypted public radio transmissions.

You are responsible for what you do with the data. Check FlightRadar24's terms before commercial redistribution, and note that some jurisdictions restrict publishing the movements of identifiable private aircraft. Scrape at a considerate rate; the defaults here are deliberately modest.

***

### ❓ FAQ

**Do I need a FlightRadar24 account or API key?**
No. Everything this actor reads is available anonymously. There is no credential to supply.

**How current are the positions?**
Live — each row carries the timestamp of the position report, usually a few seconds old. This is a snapshot at the moment of the run, not a stream; schedule the actor to build a time series.

**Why did my area return exactly 1,500 aircraft?**
That is FlightRadar24's per-request cap. Turn on **Split large areas automatically**, or raise **Max split depth** if the log warns that an area is still truncated.

**Why are some aircraft missing a flight number or route?**
Private, business and military traffic often broadcasts a callsign and nothing else. The position, altitude and registration are still there.

**Can I track one aircraft over time?**
Yes — set **Only this registration** in live mode and schedule the run, or use *Aircraft history by registration* for flights it has already operated.

**What is the difference between callsign and flight number?**
The flight number is commercial (`BA48`); the callsign is what ATC uses on the radio (`BAW48Q`). They frequently differ, and airlines sometimes fly the same number under several callsigns.

**Does it cover military aircraft?**
It returns whatever FlightRadar24 publishes. Many military aircraft do not broadcast a position at all, and some that do are filtered out upstream.

**What about gliders, helicopters and ground vehicles?**
Included by default. Turn off **Include gliders** or **Include ground vehicles** to leave them out, and **Include aircraft on the ground** to get airborne traffic only.

***

### 🔌 Using it from code

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("rl1987/flightradar24-api-scraper").call(run_input={
    "mode": "live",
    "region": "europe",
    "airlineIcao": "BAW",
    "maxItems": 500,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["callsign"], item["altitudeFt"], item["verticalSpeedFpm"])
```

***

### 🛠️ Support

Found a bug or need a field that is not here? Open an issue on the actor's **Issues** tab. Include the run id — it makes the difference between a guess and a fix.

# Actor input Schema

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

Pick one job. Each mode uses its own inputs below — the other sections are ignored.

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

Area to sweep for live aircraft. Choose "Custom area" to use the four coordinates below; any other choice ignores them.

## `north` (type: `string`):

Top edge of a custom area, -90 to 90. Decimal degrees. Only used when Region is "Custom area".

## `south` (type: `string`):

Decimal degrees. Bottom edge of a custom area, -90 to 90. Must be less than the north latitude.

## `west` (type: `string`):

Decimal degrees. Left edge of a custom area, -180 to 180.

## `east` (type: `string`):

Decimal degrees. Right edge of a custom area, -180 to 180. Must be greater than the west longitude.

## `splitLargeAreas` (type: `boolean`):

FlightRadar24 returns at most 1,500 aircraft per request, whatever the area. With this on, an area that comes back at the cap is split into four and each part fetched separately, until every part fits — so a whole continent returns every aircraft rather than the first 1,500. Costs extra requests only where the sky is busy.

## `maxTileDepth` (type: `integer`):

How many times an area may be halved. Each level multiplies requests by up to 4. Depth 4 covers Europe comfortably; raise it only if the log warns that an area is still truncated.

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

Three-letter ICAO airline code, e.g. BAW for British Airways, DLH for Lufthansa, UAE for Emirates. Filtered by FlightRadar24 before the 1,500-row cap applies, so one airline worldwide is a single fast request.

## `flightNumberFilter` (type: `string`):

e.g. BA48. Returns just that flight if it is airborne right now.

## `registrationFilter` (type: `string`):

e.g. G-STBA. Returns just that airframe if it is airborne right now.

## `includeGrounded` (type: `boolean`):

Aircraft taxiing or parked at a stand. Turn off for airborne traffic only.

## `includeGliders` (type: `boolean`):

Sailplanes and motor gliders, which FlightRadar24 receives via FLARM as well as ADS-B.

## `includeVehicles` (type: `boolean`):

Pushback tugs, fire trucks and other airside vehicles FlightRadar24 tracks.

## `searchQueries` (type: `array`):

One query per line: a flight number (BA48), a callsign (BAW48Q), an airline name (British Airways), an airport (Heathrow) or a registration (G-STBA).

## `searchLimit` (type: `integer`):

How many matches to return for each query, 1-50.

## `flightNumbers` (type: `array`):

One flight number per line, e.g. BA48. Returns that flight's past and scheduled operations — dates, aircraft used, actual vs scheduled times.

## `registrations` (type: `array`):

One registration per line, e.g. G-STBA. Returns the airframe (model, country, Mode-S hex) plus the flights it has operated.

## `historyPages` (type: `integer`):

Each page holds up to 100 flights. Raise to go further back.

## `airportCodes` (type: `array`):

One three-letter IATA code per line, e.g. LHR, JFK, SIN. Returns name, ICAO code, coordinates, timezone and FlightRadar24's arrival/departure delay indices.

## `flightIds` (type: `array`):

One 8-character FlightRadar24 flight ID per line, e.g. 41e26079. Take these from the flightId field of a live or search run. Returns the recorded track: every position, altitude, speed and vertical speed.

## `includeFlightDetail` (type: `boolean`):

For live, search and most-tracked modes: follow each aircraft with a detail lookup — full aircraft model, airline, both airports with coordinates, scheduled vs actual times, delay and an aircraft photo. One extra request per aircraft, billed as a detail row, so leave it off for large sweeps.

## `includeTrail` (type: `boolean`):

Adds the flight's recent track points to each detail row. Only has an effect when detail is enabled.

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

Stop after this many records. 0 = no limit.

## `maxConcurrency` (type: `integer`):

Requests in parallel.

## `maxRequestsPerCrawl` (type: `integer`):

Safety cap on total requests. 0 = unlimited.

## `maxRequestRetries` (type: `integer`):

Retries per request before it is marked failed. Does NOT bound retries caused by a blocked or rate-limited status code — see Max session rotations.

## `maxSessionRotations` (type: `integer`):

Retries for a blocked or rate-limited response, each with a fresh session and proxy. Separate budget from Max request retries.

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

FlightRadar24 gates on the browser fingerprint rather than the IP, so the default datacenter proxy is usually enough. Switch to residential only if you see repeated blocks.

## Actor input object example

```json
{
  "mode": "live",
  "region": "europe",
  "north": "51.7",
  "south": "51.2",
  "west": "-0.6",
  "east": "0.3",
  "splitLargeAreas": true,
  "maxTileDepth": 4,
  "includeGrounded": true,
  "includeGliders": true,
  "includeVehicles": true,
  "searchQueries": [
    "BA48"
  ],
  "searchLimit": 30,
  "flightNumbers": [
    "BA48"
  ],
  "registrations": [
    "G-STBA"
  ],
  "historyPages": 1,
  "airportCodes": [
    "LHR"
  ],
  "includeFlightDetail": false,
  "includeTrail": false,
  "maxItems": 1000,
  "maxConcurrency": 5,
  "maxRequestsPerCrawl": 0,
  "maxRequestRetries": 5,
  "maxSessionRotations": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "north": "51.7",
    "south": "51.2",
    "west": "-0.6",
    "east": "0.3",
    "searchQueries": [
        "BA48"
    ],
    "flightNumbers": [
        "BA48"
    ],
    "registrations": [
        "G-STBA"
    ],
    "airportCodes": [
        "LHR"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("rl1987/flightradar24-api-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 = {
    "north": "51.7",
    "south": "51.2",
    "west": "-0.6",
    "east": "0.3",
    "searchQueries": ["BA48"],
    "flightNumbers": ["BA48"],
    "registrations": ["G-STBA"],
    "airportCodes": ["LHR"],
}

# Run the Actor and wait for it to finish
run = client.actor("rl1987/flightradar24-api-scraper").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 '{
  "north": "51.7",
  "south": "51.2",
  "west": "-0.6",
  "east": "0.3",
  "searchQueries": [
    "BA48"
  ],
  "flightNumbers": [
    "BA48"
  ],
  "registrations": [
    "G-STBA"
  ],
  "airportCodes": [
    "LHR"
  ]
}' |
apify call rl1987/flightradar24-api-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rl1987/flightradar24-api-scraper"
        }
    }
}
```

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/mIKf2zeoWDa4Ko0fc/builds/f8eW8qL1XYRfJhmMQ/openapi.json