# ADS-B Flight Tracker API: Live Aircraft Data (`flyitalyadsb/adsb-flight-tracker`) Actor

Live aircraft positions worldwide from FlyItalyADSB's own ADS-B and MLAT receiver network: search by area, ICAO hex, callsign or registration, or get all military aircraft. Plus daily flight tracks since 2022, overflights and emergencies. Export JSON, CSV or Excel, schedule runs or call it via API.

- **URL**: https://apify.com/flyitalyadsb/adsb-flight-tracker.md
- **Developed by:** [FlyitalyADSB](https://apify.com/flyitalyadsb) (community)
- **Categories:** Travel, Developer tools, Open source
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.12 / 1,000 live aircraft or notable-traffic events

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

**ADS-B Flight Tracker** gives you **live aircraft positions anywhere in the world**, **daily flight tracks since 2022**, **observed flights** (where a callsign flies, an aircraft's flight log, an airport's departures and arrivals), the **aircraft that flew over a place** and **notable traffic** such as emergencies and military aircraft, as clean datasets. The data is first-party. It comes from **[FlyItalyADSB](https://flyitalyadsb.com)**'s own network of community ADS-B receivers and MLAT servers, born in Italy and now all over the world, and is not scraped from another flight-tracking website.

**Try it in one click.** The prefilled input lists every aircraft within 100 km of London Heathrow right now. On Apify's free plan, the $5 monthly credit covers about 33,000 aircraft.

### What can this ADS-B flight tracker do?

| Mode | What it returns | One row is |
| --- | --- | --- |
| **Live: aircraft in an area** | Every aircraft within a radius of a point, nearest first, up to the whole world (20,040 km) | an aircraft |
| **Live: specific aircraft** | The aircraft you name by ICAO hex address, callsign or registration, if they are in the air now | an aircraft |
| **Live: military / PIA / LADD** | All military, PIA or LADD aircraft our receivers see now, worldwide | an aircraft |
| **History: daily track** | An aircraft's full recorded track for a UTC day, since 2022 | an aircraft-day, with every position |
| **History: aircraft profile** | Identity, live status and a summary of an aircraft's history | an aircraft |
| **History: flew over a place** | Every aircraft that passed within up to 50 km of a point in a window of up to 24 hours: closest point, lowest altitude, time in and out | an aircraft |
| **History: notable traffic** | Emergencies (squawk 7500/7600/7700), military and interesting aircraft that entered an area, up to 7 days back | an event |
| **History: observed flights** | Flights our receivers saw, by callsign or flight number (its last 1–14 days and usual routes), by aircraft (its flight log over up to 31 days) or by airport (a day's departures and arrivals): departure and arrival airport, times, duration | a flight |

With the Apify platform you also get:

- 📤 **Exports** to JSON, CSV, Excel or XML.
- 🔌 **An API** for every run.
- ⏰ **Scheduled runs**, for example a snapshot of an area every hour.
- 🔗 **Integrations** with Make, Zapier, n8n, Google Sheets and webhooks.
- 🤖 **AI agents**, which can call the Actor through the Apify MCP server.

### What ADS-B data can you get?

Live rows keep the [readsb](https://github.com/wiedehopf/readsb/blob/dev/README-json.md) field names, the same ones tar1090 uses: `hex`, `flight`, `r` (registration), `t` (type), `lat`, `lon`, `alt_baro` (ft, or `"ground"`), `gs` (kt), `track`, `squawk`, `category`, `seen_pos` (seconds since the position was received), and the rest. A few fields are added in front of them:

- `callsign`: the trimmed callsign;
- `distanceKm`: the distance from the centre of the area;
- `onGround`, and `military`, `interesting`, `pia`, `ladd` from the database flags;
- `positionSource`: `adsb`, `mlat`, `tisb`, `adsr` or `other`;
- `positionTime`, `retrievedAt`: ISO 8601 times;
- `mapUrl`: the aircraft on our live map;
- `query`: what produced the row.

```json
{
  "hex": "781f74", "callsign": "CSN674", "distanceKm": 0.6, "onGround": false, "military": false,
  "positionSource": "adsb", "positionTime": "2026-10-26T21:39:58.453Z",
  "mapUrl": "https://map.flyitalyadsb.com/?icao=781f74",
  "r": "B-32EE", "t": "A359", "lat": 51.464895, "lon": -0.454178, "alt_baro": 275, "gs": 122,
  "track": 270, "baro_rate": -192, "squawk": "2021", "category": "A5", "seen_pos": 5.488, "rssi": -32.8
}
```

Other modes:

- **Daily tracks** carry `trace`, readsb's list of positions. Each one is `[seconds after timestamp, lat, lon, altitude ft or "ground", ground speed kt, track, flags, vertical rate, details, source, ...]`. The row also has `points`, `firstPositionTime` and `lastPositionTime`.
- **Overflights and notable traffic** are flat rows.
- **Observed flights** are flat rows too: `hex`, `r`, `t`, `callsign`, then `fromAirport`, `fromIata`, `fromName`, `fromCountry`, `fromTime`, `fromSeen` and the same six for `to`, then `firstSeen`, `lastSeen`, `durationMin`, `day`. `fromSeen`/`toSeen` say how the airport was recognised: `ground` (on the ground within 6 km), `low` (at most 2,500 ft above it within 15 km) or `approach` (at most 6,000 ft within 30 km). An end our receivers didn't see is empty. A callsign's usual routes, with how many times each was flown, go in the run's `OUTPUT` record.

```json
{
  "hex": "4d2247", "r": "9H-QDF", "t": "B738", "callsign": "RYR791K",
  "fromAirport": "EGGD", "fromIata": "BRS", "fromName": "Bristol Airport", "fromCountry": "GB",
  "fromTime": "2026-11-05T12:49:00Z", "fromSeen": "ground",
  "toAirport": "EPKK", "toIata": "KRK", "toName": "Kraków John Paul II International Airport", "toCountry": "PL",
  "toTime": "2026-11-05T15:18:00Z", "toSeen": "low",
  "firstSeen": "2026-11-05T12:49:00Z", "lastSeen": "2026-11-05T15:18:00Z", "durationMin": 149, "day": "2026-11-05"
}
```

The run's `OUTPUT` record says whether the window was fully indexed and whether there were more results.

### How to use the ADS-B Flight Tracker

1. Click **Try for free** (or **Start** in Apify Console).
2. In **What to get**, pick a mode.
3. Fill in its section:
   - **Area** for a point and a radius;
   - **Aircraft** for ICAO hex addresses, callsigns or registrations;
   - **History** for days and time windows;
   - **Observed flights** for airports, how many days back a callsign goes, and departures or arrivals.
4. Optionally, narrow the results under **Filters and limits**.
5. Run it, then download the dataset or read it through the API.

#### Input examples

Aircraft within 50 km of London Heathrow:

```json
{ "mode": "area", "latitude": 51.47, "longitude": -0.45, "radiusKm": 50 }
```

The whole world, only aircraft above 30,000 ft:

```json
{ "mode": "area", "latitude": 0, "longitude": 0, "radiusKm": 20040, "minAltitudeFt": 30000 }
```

Specific aircraft:

```json
{ "mode": "aircraft", "icao": ["4952cd"], "callsigns": ["BAW123"], "registrations": ["EI-DCL"] }
```

An aircraft's track on two days (leave `dates` empty for its most recent day):

```json
{ "mode": "history", "icao": ["4952cd"], "dates": ["2026-10-24", "2026-10-25"] }
```

What flew over a house in the last hour, below 3,000 ft:

```json
{ "mode": "overflights", "latitude": 51.47, "longitude": -0.45, "radiusKm": 3, "maxAltitudeFt": 3000 }
```

Use `from` and `to` (ISO 8601 or Unix seconds) for another window.

Where a flight number flies, and an aircraft's flight log for October (a flight number such as `FR5518` is matched to the callsign the aircraft transmits):

```json
{ "mode": "flights", "callsigns": ["FR5518"], "flightDays": 14, "registrations": ["EI-DCL"], "from": "2026-10-01", "to": "2026-10-31" }
```

Yesterday's departures from London Heathrow (leave `dates` empty for the latest day, or give several):

```json
{ "mode": "flights", "airports": ["LHR"], "airportFlights": "departures" }
```

Emergencies around Rome in the last 3 days:

```json
{ "mode": "events", "latitude": 41.9, "longitude": 12.5, "radiusKm": 300, "sinceHours": 72, "eventKinds": ["emergency"] }
```

### How much does flight tracking data cost?

**Without your own key**, you pay per result:

| Result | Free plan | Bronze | Silver | Gold and above |
| --- | --- | --- | --- | --- |
| Live aircraft, or a notable-traffic event, per 1,000 | **$0.15** | $0.14 | $0.13 | $0.12 |
| Daily track, aircraft profile or overflight, per 1,000 | **$2.00** | $1.90 | $1.80 | $1.60 |
| Observed flight, per 1,000 | **$0.50** | $0.47 | $0.44 | $0.40 |

Your Apify plan sets your price. There is no fee for starting a run. Rows we don't find are free, and so are failed lookups. Two runs on an October evening, at the Free plan price, for scale:

- 50 km around London Heathrow returned 44 aircraft, about $0.007.
- The whole world returned 10,381 aircraft, about $1.56.

FlyItalyADSB is a community network: these prices help cover the cost of running it.

**With your own FlyItalyADSB API key** in *Your flyitalyadsb API key*, results are not charged. The limits of your plan apply: radius, requests per minute and per month. A Free key is enough to start, and you can [get one here](https://flyitalyadsb.com/en/data/api/).

If you query the same area every few seconds, for a display, an app or a dashboard, call the [REST API](https://flyitalyadsb.com/en/data/api/) directly instead: its [plans](https://flyitalyadsb.com/en/data/api/#piani) cost less for that.

### Limits and coverage

- **Live data** is a snapshot taken at the moment of the run. `seen_pos` tells how old each position is.
- **Coverage** depends on where our receivers are. It is densest in Europe and North America; check an area on the [live map](https://map.flyitalyadsb.com/).
- **Overflights:** up to 50 km and 24 hours per run. The last few minutes may not be indexed yet.
- **Notable traffic:** up to 7 days back.
- **Observed flights:** built every night from our own tracks, so yesterday and earlier, not today. They are what our receivers saw, not airline schedules: over oceans or where receivers are few, one end of a flight can be missing. Up to 14 days back for a callsign, 31 days per run for an aircraft, and up to 500 flights per callsign or aircraft (`OUTPUT` lists the lookups that had more).
- **History:** since 2022.
- **Per run:** up to 1,000 lookups (ICAO, callsign, registration) or aircraft-days. An area has no cap: the whole world is about 10,000 rows. Set *Maximum results* to cap a run.

### FAQ

#### Where does the ADS-B data come from?

From FlyItalyADSB's own network:

- community ADS-B receivers, born in Italy and now all over the world;
- MLAT servers, which locate aircraft that don't broadcast their position.

It is not scraped from Flightradar24, FlightAware or any other flight-tracking website.

#### Can I use the data commercially?

Yes. The data is published under **[CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)**. If you reuse it:

- credit "FlyItalyADSB" with a link to [flyitalyadsb.com](https://flyitalyadsb.com);
- share derivative works under the same licence.

The [terms of service](https://flyitalyadsb.com/en/terms/) apply. In particular, the data must not be used:

- for safety of life, air traffic control or navigation;
- to follow or harass people.

#### How do I get ADS-B data in Python or JavaScript?

Run the Actor with the Apify client. Your Apify token is under Settings → API & Integrations.

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("flyitalyadsb/adsb-flight-tracker").call(
    run_input={"mode": "area", "latitude": 51.47, "longitude": -0.45, "radiusKm": 50}
)
for aircraft in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(aircraft["hex"], aircraft.get("callsign"), aircraft.get("alt_baro"))
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('flyitalyadsb/adsb-flight-tracker').call({
    mode: 'area', latitude: 51.47, longitude: -0.45, radiusKm: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Can I schedule runs or get alerts?

Yes. A schedule in Apify Console runs the Actor, for example every hour, and integrations or webhooks pass the results on to Slack, Google Sheets, Make, Zapier or n8n.

For push alerts the moment an emergency or a military aircraft shows up in an area, our [REST API](https://flyitalyadsb.com/en/data/api/) has webhooks on its paid plans.

#### Can AI agents use it?

Yes. Agents connected to the Apify MCP server can find this Actor and run it as a tool. For assistants like Claude and ChatGPT there is also our own [MCP server](https://flyitalyadsb.com/en/data/mcp/), with a live map in the chat.

#### Why is an aircraft missing?

There are three usual reasons:

- it isn't transmitting;
- it is outside our coverage;
- it was left out by a filter, such as *Include aircraft on the ground* or an altitude band.

The [live map](https://map.flyitalyadsb.com/) shows what our receivers see right now.

### Support

Questions, bugs or a missing feature: open an issue in the **Issues** tab or write to <info@flyitalyadsb.com>.

# Actor input Schema

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

Live data: aircraft in an area, specific aircraft, or military / PIA / LADD aircraft worldwide. History: an aircraft's daily track, its profile, the aircraft that flew over a place, notable traffic (emergencies, military, interesting aircraft) in an area, or observed flights (a callsign's routes, an aircraft's flight log, an airport's departures and arrivals).

## `latitude` (type: `number`):

Centre of the area, in decimal degrees (-90 to 90). For the area, overflights and notable-traffic modes.

## `longitude` (type: `number`):

Centre of the area, in decimal degrees (-180 to 180).

## `radiusKm` (type: `number`):

Up to 20,040 km (the whole world) for live aircraft and notable traffic; up to 50 km for overflights.

## `icao` (type: `array`):

24-bit transponder addresses, 6 hex characters (e.g. 4ca7b4). For specific aircraft, daily tracks, profiles and observed flights. Up to 1,000.

## `callsigns` (type: `array`):

Callsigns as transmitted (e.g. RYR4TJ); a flight number such as FR5518 is tried too. For specific aircraft and observed flights.

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

Tail numbers (e.g. EI-DCL), dashes optional. For specific aircraft and observed flights.

## `dates` (type: `array`):

YYYY-MM-DD, UTC days. Daily track: since 2022; empty = the most recent day with a track. Observed flights at an airport: one lookup per day; empty = the latest day available (yesterday).

## `from` (type: `string`):

Overflights: ISO 8601 (e.g. 2026-10-25T08:00:00Z; no zone = UTC) or Unix seconds; empty = one hour before "to"; the window can be at most 24 hours. Observed flights of an aircraft: the first UTC day (YYYY-MM-DD); empty = the last 7 days; at most 31 days.

## `to` (type: `string`):

Overflights: ISO 8601 or Unix seconds; empty = now. Observed flights of an aircraft: the last UTC day, included.

## `sinceHours` (type: `integer`):

Up to 168 hours (7 days).

## `eventKinds` (type: `array`):

Empty: all three.

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

ICAO (e.g. EGLL) or IATA (e.g. LHR) codes: the departures and/or arrivals the network observed there on the days in "Days (UTC)".

## `flightDays` (type: `integer`):

How many days back a callsign's flights go, up to yesterday.

## `airportFlights` (type: `string`):

Departures, arrivals or both.

## `includeOnGround` (type: `boolean`):

Live modes.

## `minAltitudeFt` (type: `integer`):

Live modes: barometric altitude; aircraft without one are left out when set.

## `maxAltitudeFt` (type: `integer`):

Live modes and overflights.

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

Stop after this many rows. Empty: no limit beyond the run's spending limit.

## `apiKey` (type: `string`):

Optional. With your own key (free at https://flyitalyadsb.com/en/data/api/) results are not charged here and your plan's limits apply (radius, requests per minute, per month). Without it, results are charged per item.

## Actor input object example

```json
{
  "mode": "area",
  "latitude": 51.47,
  "longitude": -0.45,
  "radiusKm": 100,
  "sinceHours": 24,
  "flightDays": 7,
  "airportFlights": "both",
  "includeOnGround": true
}
```

# Actor output Schema

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

One row per live aircraft, daily track, aircraft profile, overflight, notable-traffic event or observed flight, depending on the mode. Live rows keep readsb's field names (hex, flight, r, t, lat, lon, alt_baro, gs, ...) with callsign, distanceKm, positionSource, positionTime and mapUrl added in front.

## `summary` (type: `string`):

The OUTPUT record: the mode, how many rows, the lookups that found nothing, whether more results existed or the overflights window was not fully indexed yet, the usual routes of the callsigns asked for observed flights, which key was used, and the licence (CC BY-SA 4.0) with the attribution to give.

# 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 = {
    "latitude": 51.47,
    "longitude": -0.45,
    "radiusKm": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("flyitalyadsb/adsb-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 = {
    "latitude": 51.47,
    "longitude": -0.45,
    "radiusKm": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("flyitalyadsb/adsb-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 '{
  "latitude": 51.47,
  "longitude": -0.45,
  "radiusKm": 100
}' |
apify call flyitalyadsb/adsb-flight-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,flyitalyadsb/adsb-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/OoxQffYrTqy2GqWFy/builds/WbxZPdZy2xvejhrfl/openapi.json