# Flightradar24 Follow Flight Stream Scraper (`romy/flightradar24-follow-flight-stream`) Actor

Get live per-flight position updates — no competing actor streams a single flight from Flightradar24. Talks directly to Flightradar24's own gRPC/REST APIs, no login needed. Split from the mature, published flightradar24-all-in-one-api for a focused, single-purpose workflow.

- **URL**: https://apify.com/romy/flightradar24-follow-flight-stream.md
- **Developed by:** [Romy](https://apify.com/romy) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.20 / 1,000 position update chargeds

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

### What does Flightradar24 Follow Flight Stream do?

**Flightradar24 Follow Flight Stream** captures live position updates for **one flight** over a **bounded time window** (30 seconds by default, hard capped at 120 seconds), pushing **every update it receives as its own dataset row**.

**This is NOT a live standby stream.** It is a one-shot batch Actor: give it a `flightId` and a `durationSeconds`, it opens Flightradar24's internal gRPC live-position feed, collects whatever updates arrive during that window, then closes the connection and the run finishes — like any normal Apify batch actor. If you need continuous live tracking, run this Actor repeatedly (e.g. on a schedule); it does not keep a connection open across runs.

It talks directly to the same internal API the official [Flightradar24](https://www.flightradar24.com/) Android app uses (`data-feed.flightradar24.com`, gRPC), reverse-engineered by static decompilation and validated against real live traffic. No API key, no login.

### Why use this instead of the all-in-one API?

This Actor is a narrow spin-off of [**Flightradar24 All-in-One API**](https://apify.com/romy/flightradar24-all-in-one-api), which exposes the same gRPC feed (plus six other endpoints) as an always-on Standby REST API. Its `/follow-flight` route streams updates as `application/x-ndjson` over an open HTTP connection for up to 120 seconds per call.

Some use cases don't want to manage an open streaming HTTP connection at all — they just want "give me the position updates for this flight over the next N seconds" as a normal batch job with dataset rows, retries, and scheduling handled the Apify-platform way. That's what this Actor adapts the parent's streaming endpoint into: the same underlying gRPC call, same duration cap, but collected into a bounded batch run instead of a raw NDJSON stream.

### Input

| Field             | Type    | Default  | Description                                                                                                                                       |
| ----------------- | ------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| `flightId`        | integer | optional | Numeric Flightradar24 flight id (from a live-feed or search result). Leave empty to follow a currently airborne flight picked from the live feed. |
| `durationSeconds` | integer | 30       | Seconds to keep the stream open and collect updates. **Hard capped at 120** — values above 120 are clamped down, values below 1 are clamped up    |

```json
{
    "flightId": 1094013202,
    "durationSeconds": 60
}
```

### Output

One dataset row per position update received during the window (roughly every 1–3 seconds while the flight is airborne). Each row is the raw `FollowFlightResponse` from the gRPC feed:

```json
{
    "aircraftInfo": { "reg": "PK-PWO", "type": "A320", "fullDescription": "Airbus A320-214" },
    "scheduleInfo": { "flightNumber": "IP646", "scheduledDeparture": "1786921200" },
    "flightProgress": { "progressPct": 65, "flightStage": 3, "delayStatus": 1 },
    "flightInfo": {
        "flightId": 1094013202,
        "lat": -5.815,
        "lon": 111.413,
        "alt": 38000,
        "speed": 476,
        "callsign": "PAS646",
        "onGround": false,
        "timestampMs": "1786924707066"
    }
}
```

A run with `durationSeconds: 60` typically produces somewhere around 20-40 rows for an actively-tracked airborne flight, though this varies with how often Flightradar24 pushes updates for that particular aircraft.

### Known limitations

- **This is a bounded batch capture, not a live standby stream.** Each run opens the feed, collects updates for up to `durationSeconds` (max 120s), and exits. It does not hold an open connection between runs or across multiple calls — for continuous tracking, schedule this Actor to run repeatedly (e.g. every few minutes) rather than expecting one run to track a flight indefinitely.
- **If the flight lands, goes out of coverage, or the id is stale, updates stop arriving early.** The run still finishes normally (with fewer rows than a full window would produce, possibly zero) — it will not hang or error out just because the flight went quiet.
- **An explicit `flightId` must be a currently-live flight id** (or omit it and one is picked for you). Ids come from a live-feed/search/top-flights lookup elsewhere (e.g. the parent Actor's `/live-feed` or `/search` endpoints) — this Actor does not do flight lookup itself.
- Some `aircraftInfo` fields (`msn`, `acAge`, `acBirthDate`, `countryOfReg`) are paywalled by Flightradar24 itself and come back empty even when their `*Available` companion flags report `true` — this API calls the feed anonymously, same as the free tier of the app.

### Pricing

This Actor uses **Pay Per Event** billing, mirroring the parent Actor's per-update billing for this endpoint: you're charged $0.008 per position update pushed to the dataset (event `position-update`, FREE tier price — lower on paid plans), not per run. A run that collects zero updates (e.g. the flight had already landed) is not charged for updates.

### FAQ

**Does this require a Flightradar24 account?**
No. Same anonymous feed the Flightradar24 mobile app uses — no login, no API key.

**Why would updates stop before `durationSeconds` is up?**
The gRPC stream only pushes updates while Flightradar24 has fresh position data for the flight. If it lands, loses coverage, or the feed has nothing new to say, the stream simply goes quiet for the rest of the window — the run still finishes cleanly.

**Is this official?**
No. Independent tool using Flightradar24's internal APIs, reverse-engineered from the public Android app. Use responsibly and in accordance with Flightradar24's Terms of Service.

**Need a custom integration, or want the full all-in-one API (live feed, search, airport boards, etc.)?**
See [Flightradar24 All-in-One API](https://apify.com/romy/flightradar24-all-in-one-api), or contact me at romysaputrasihanandaa@gmail.com or [hire me on Fiverr](https://www.fiverr.com/romyssss).

# Actor input Schema

## `flightId` (type: `integer`):

Numeric Flightradar24 flight id, e.g. from a live-feed or search result. Optional: leave empty and a currently airborne flight is picked from the live feed -- a fixed id goes stale once that flight lands.

## `durationSeconds` (type: `integer`):

How long to keep the stream open and collect updates. Default 30, hard capped at 120 seconds — this is a bounded one-shot capture, not a live standby stream. For continuous tracking, schedule repeated runs.

## Actor input object example

```json
{
  "durationSeconds": 30
}
```

# Actor output Schema

## `dataset` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("romy/flightradar24-follow-flight-stream").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("romy/flightradar24-follow-flight-stream").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 '{}' |
apify call romy/flightradar24-follow-flight-stream --silent --output-dataset

```

## MCP server setup

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

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/f9LEffCGxrbQDah6S/builds/uRS9m3gLBa2FCPGtQ/openapi.json