# Flight Status Tracker (`apt_marble/flight-status-tracker`) Actor

Live status for any flight number or tail number: delay in minutes, gate, terminal, aircraft, and scheduled versus actual times. Every row also carries how that flight number has really performed over its recent operations. Up to 100 flights per run, no account needed.

- **URL**: https://apify.com/apt\_marble/flight-status-tracker.md
- **Developed by:** [Hamza](https://apify.com/apt_marble) (community)
- **Categories:** Travel, Automation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 flight status checkeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Flight Status Tracker

Give it a flight number and get back everything a traveller, an ops desk or a claims team actually needs to know: whether the flight is running, where it is, how late it is in minutes, which gate and terminal it is using at both ends, what aircraft is operating it, and the scheduled, estimated and actual times for pushback, take-off, landing and arrival at the stand. Every row also carries the punctuality record of that same flight number over its recent operations — roughly the last ten to thirty times it flew, each with its own delay — so you get today's status and the flight's real track record in one table. Up to 100 flights per run, aircraft registrations accepted as well as flight numbers, and no account or login of any kind.

### What you can do with it

- **Tell customers the truth before they ask.** Feed the flight numbers on tomorrow's bookings into a run and get status, gate, terminal and delay minutes for all of them in one table.
- **Support delay and cancellation claims** with the two numbers a claim turns on: the scheduled arrival and the actual arrival, with the row stating plainly whether the arrival was measured or still only estimated.
- **Judge a flight before you book it.** `punctuality.onTimePct`, the average delay and the worst delay across the flight number's recent operations tell you whether the 07:20 is reliably the 07:20.
- **Watch a flight to the gate.** Switch on *Keep watching* and the run publishes a fresh row every time the estimated time, the gate, the terminal or the outcome changes — and stops by itself the moment the flight arrives, is cancelled or is diverted.
- **Track a specific aircraft** by registration, including where it has been and what it flew as.
- **Reconstruct a past day.** Set a date and get that day's operation of the flight number, with the times it actually achieved.
- **Feed a dashboard or an alerting rule** with `arrivalDelayMinutes`, `isCancelled`, `isDiverted` and the gate fields, all in one flat row per check.

### What you get

One row per flight check. A real row, abridged (`UA1`, collected while it was over the Pacific):

```json
{
  "requestedFlight": "UA1",
  "flightIdentifier": "UAL1",
  "identifierType": "flight-number",
  "identifierTranslated": true,
  "marketingFlight": "UA1",
  "airlineName": "United Air Lines Inc.",
  "airlineCode": "UA",
  "flightNumber": "1",
  "flightStatus": "airborne",
  "isAirborne": true,
  "isCancelled": false,
  "isDiverted": false,
  "originIata": "SFO",
  "originAirport": "San Francisco Int'l",
  "originCity": "San Francisco",
  "originCountry": "United States",
  "originTerminal": "I",
  "originGate": "G5",
  "originTimeZone": "America/Los_Angeles",
  "destinationIata": "SIN",
  "destinationCity": "Singapore",
  "destinationTerminal": "2",
  "destinationGate": "E11",
  "scheduledDeparture": "2026-08-16T05:50:00.000Z",
  "scheduledDepartureLocal": "2026-08-15T22:50:00-07:00",
  "actualDeparture": "2026-08-16T06:02:00.000Z",
  "actualTakeoff": "2026-08-16T06:25:00.000Z",
  "departureDelayMinutes": 12,
  "departureDelayBasis": "actual",
  "scheduledArrival": "2026-08-16T22:15:00.000Z",
  "scheduledArrivalLocal": "2026-08-17T06:15:00+08:00",
  "estimatedArrival": "2026-08-16T22:28:00.000Z",
  "actualArrival": null,
  "arrivalDelayMinutes": 13,
  "arrivalDelayBasis": "estimated",
  "routeAverageArrivalDelayMinutes": 12,
  "aircraftType": "B789",
  "aircraftTypeName": "Boeing 787-9 Dreamliner (twin-jet)",
  "registration": null,
  "registrationWithheld": true,
  "latitude": 8.3567,
  "longitude": 128.1903,
  "positionObservedAt": "2026-08-16T19:02:49.000Z",
  "altitudeFeet": 40000,
  "groundspeedKnots": 526,
  "distanceRemainingMiles": 1508,
  "previousFlightOfSameAircraft": "UAL28-1786598143-fa-843p:0",
  "punctuality": {
    "legsTotal": 13,
    "legsMeasured": 10,
    "onTimeCount": 6,
    "lateCount": 4,
    "onTimePct": 60,
    "avgArrivalDelayMin": 11.8,
    "maxArrivalDelayMin": 44,
    "minArrivalDelayMin": -7,
    "cancelledCount": 0,
    "divertedCount": 0,
    "onTimeThresholdMin": 15
  },
  "recentFlights": [
    {
      "date": "2026-08-14",
      "originIata": "SFO",
      "destinationIata": "SIN",
      "aircraftType": "B789",
      "scheduledDeparture": "2026-08-15T05:50:00.000Z",
      "actualDeparture": "2026-08-15T06:00:00.000Z",
      "scheduledArrival": "2026-08-15T22:15:00.000Z",
      "actualArrival": "2026-08-15T22:07:00.000Z",
      "departureDelayMinutes": 10,
      "arrivalDelayMinutes": -8,
      "delayBasis": "actual",
      "cancelled": false,
      "diverted": false
    }
  ],
  "recentFlightsCount": 13,
  "recordType": "current",
  "observationNumber": 1,
  "collectedAt": "2026-08-16T19:03:13.697Z"
}
```

An aircraft registration comes back the same way: ask for `D-ABYT` and you get `DLH402`, Frankfurt to Newark, a Boeing 747-8, 36,000 ft, 38 minutes late off the gate, 81.3% on time over its last 16 measured operations.

Write a registration the way registrations are written, with the hyphen it has: `B-6521`, `RA-89001`, `D-ABYT`. Most of the world's tail numbers are one or two letters and then digits, which is also exactly what a flight number looks like — `B6521` reads first as JetBlue flight 521, `B-6521` is the Airbus in China and nothing else. Registrations whose mark is not an airline at all — `HL7612`, `JA8089`, `N154QS` — are understood either way. Whenever an identifier is genuinely both, the row says so in `identifierType`, `identifierAmbiguous` and `identifierNote` instead of quietly answering the other question.

### Input reference

| Field | Type | Default | What it does |
| --- | --- | --- | --- |
| `flights` | array | `["UA1"]` | The flights to check. Use the number on a ticket — `UA1`, `BA117`, `LH402`, `EK202` — or an aircraft registration such as `N154QS`, `D-ABYT` or `B-6521`. Spaces, dots and hyphens are fine, and case does not matter. Write a registration with its hyphen where it has one: `B-6521` is an aircraft, while `B6521` reads first as JetBlue flight 521. Up to 100 per run. |
| `date` | string | empty | Leave empty for the operation running now or next. Set `YYYY-MM-DD` to get that day's operation instead. |
| `market` | string | `US` | The regional edition asked for when a flight is checked. Every check in a run asks for the same one, including the follow-up checks made while `trackUntilLanded` is on. It is a preference the source is free to ignore: the wording of a free-text delay notice is the only thing it could change, and most of it is published in English whatever is asked for. It never changes a time, a number, a code or an airport — every time is given twice, once in UTC and once on the clock at the airport it happens at. |
| `includeHistory` | boolean | `true` | Attaches `recentFlights` and `punctuality`: the flight number's recent operations with their own delays, plus the on-time percentage, the average delay and the best and worst arrival across them. It arrives together with the status, so it does not slow the run down. |
| `maxHistoryLegs` | integer | `25` | How many recent operations to **list** per row, newest first. Between roughly 8 and 30 are published depending on how often the flight runs. The on-time figures are computed over all of them whatever this is set to — `punctuality.legsTotal` says how many. |
| `onTimeThresholdMinutes` | integer | `15` | How many minutes past the scheduled arrival still counts as on time in `punctuality.onTimePct`. 15 is the industry standard. |
| `includeTrack` | boolean | `false` | Adds `positions`: the points the flight has been observed at, in order, with time, latitude, longitude, altitude and speed. Makes each row much larger. |
| `maxTrackPoints` | integer | `500` | Ceiling on how many observed positions are attached. When a flight has been seen more times than this, the **most recent** points are kept — the ones that end where the aircraft actually is — and the row says so in `positionsTruncated` and `positionsObservedTotal`. A long-haul flight routinely runs past the default of 500. |
| `includeRoute` | boolean | `false` | Adds the route the crew filed, the planned cruising altitude and speed, the planned flight time and the planned fuel burn, where they are published. |
| `trackUntilLanded` | boolean | `false` | Keep checking and publish a new row whenever something a traveller would act on changes — estimated time, gate, terminal, departure, landing, cancellation, diversion. A change of position alone never produces a row. Ignored when `date` is set. |
| `refreshIntervalSec` | integer | `120` | How long to wait between checks while watching a flight. Minimum 30, maximum 900. |
| `maxTrackingMinutes` | integer | `120` | Stop watching a flight after this long even if it has not landed. Watching also stops on its own the moment the flight arrives, is cancelled or is diverted. |
| `maxUpdatesPerFlight` | integer | `30` | Ceiling on how many update rows one watched flight can produce. |
| `maxRecordAgeDays` | integer | `30` | If the newest thing published for a flight is older than this, the run reports that there is no current record rather than returning a stale one. Raise it when looking up flights that have not operated recently. |
| `maxRows` | integer | `1000` | Hard ceiling on rows for the whole run, update rows included. |

### Output fields

| Field | Type | What it is |
| --- | --- | --- |
| `requestedFlight` | string | Exactly what you asked for, so you can join the result back to your own list. |
| `flightIdentifier` | string | The identifier the flight is published under, which is often not the one on the ticket. |
| `marketingFlight`, `airlineName`, `airlineCode`, `airlineCodeIcao`, `flightNumber` | string | Who operates it and under which numbers. |
| `identifierType` | string | `flight-number` or `aircraft-registration` — for the identifier that **answered**, not for the one typed. |
| `identifierTranslated` | boolean | `true` when the identifier that answered is not the one typed, which is the normal case for a ticketed number: `UA1` is published as `UAL1`. |
| `identifierAmbiguous`, `identifierNote` | boolean / string | Some identifiers are two things at once. `B6521` is both JetBlue flight 521 and the Chinese aircraft registration B-6521; `RA1234` and `YV3016` are the same story in Russia and Venezuela. When that happens the row says so and `identifierNote` says in words which reading answered. Writing a registration the way registrations are written — `B-6521`, with the hyphen — asks for the aircraft and nothing else. |
| `flightStatus` | string | `scheduled`, `airborne`, `arrived`, `cancelled`, `diverted`. `scheduled` is used for a flight that has not moved yet. |
| `isAirborne`, `hasLanded`, `isCancelled`, `isDiverted` | boolean | The same thing as plain flags, for filtering. |
| `scheduledDeparture`, `estimatedDeparture`, `actualDeparture` | string | Off the stand, in UTC. Each also has a `…Local` twin on the departure airport's clock. |
| `scheduledTakeoff`, `estimatedTakeoff`, `actualTakeoff` | string | Off the runway — a different moment from leaving the stand, and kept separate. |
| `scheduledLanding`, `estimatedLanding`, `actualLanding` | string | On the runway. |
| `scheduledArrival`, `estimatedArrival`, `actualArrival` | string | On to the stand, in UTC, each with a `…Local` twin on the arrival airport's clock. |
| `departureDelayMinutes`, `arrivalDelayMinutes` | number | Minutes against schedule. Negative means early. |
| `departureDelayBasis`, `arrivalDelayBasis` | string | `actual` or `estimated` — whether the delay was measured or is still a forecast. Never mixed. |
| `routeAverageDepartureDelayMinutes`, `routeAverageArrivalDelayMinutes` | number | What this route typically runs, for context. |
| `originIata`, `originIcao`, `originAirport`, `originCity`, `originCountry`, `originCountryCode`, `originTerminal`, `originGate`, `originTimeZone`, `originLatitude`, `originLongitude` | string / number | The departure airport. `destination…` is the identical set for the arrival airport. |
| `originDelayNotes`, `destinationDelayNotes` | array | Any delay notice in force at that airport, as `type`, `averageDelayMinutes`, `trend` and `reason` — for example 38 minutes on inbound flights due to low clouds. |
| `originRunway`, `destinationRunway`, `taxiOutMinutes`, `taxiInMinutes` | string / number | Where published. |
| `aircraftType`, `aircraftTypeName`, `aircraftManufacturer`, `aircraftModel`, `aircraftEngineCount` | string / number | The aircraft operating the flight. |
| `registration`, `registrationWithheld` | string / boolean | The tail number. Many operators withhold it; when they do, `registration` is empty and `registrationWithheld` is `true`, so an empty field is never mistaken for missing data. |
| `latitude`, `longitude`, `positionObservedAt`, `altitudeFeet`, `groundspeedKnots`, `groundspeedKmh`, `headingDegrees` | number / string | Where the aircraft was last seen, and when. For a flight that has already landed this is where it landed. |
| `distanceFlownMiles`, `distanceRemainingMiles`, `distanceRemainingKm`, `distanceTotalMiles` | number | How far along it is. |
| `previousFlightOfSameAircraft` | string | The leg this aircraft flew immediately before — how a delay travels through a day. |
| `codeshareFlight`, `codeshareMarketingFlight`, `codeshareAirline` | string | Another number the same seat is sold under, when there is one. |
| `punctuality` | object | `onTimePct`, `avgArrivalDelayMin`, `maxArrivalDelayMin`, `minArrivalDelayMin`, `onTimeCount`, `lateCount`, `cancelledCount`, `divertedCount`, `legsTotal`, `legsMeasured`, `onTimeThresholdMin`. Every rate is empty rather than `0` when nothing could be measured. |
| `recentFlights`, `recentFlightsCount` | array / number | The flight number's most recent operations, newest first, each with its own date, route, aircraft, times and delay — at most `maxHistoryLegs` of them. `punctuality` is computed over **every** operation the source published for that flight number, which can be more than are listed here; `punctuality.legsTotal` and `legsMeasured` state how many it actually used. |
| `plannedRoute`, `plannedCruiseAltitudeFeet`, `plannedSpeedKnots`, `plannedFlightTimeMinutes`, `plannedFuelBurnGallons` | string / number | Only when the planned route is switched on. |
| `positions`, `positionCount`, `positionsObservedTotal`, `positionsTruncated` | array / number / boolean | Only when the flight path is switched on. `positionCount` is how many points the row carries and `positionsObservedTotal` how many the source published; when they differ, `positionsTruncated` is `true` and the points kept are the newest, so the path always ends where `latitude`/`longitude` say the aircraft is. |
| `recordType`, `recordDate` | string | `current` for the operation running now, `selected-date` for a chosen day. |
| `observationNumber`, `isStatusUpdate`, `previousStatus` | number / boolean / string | Which check this row came from while watching, and what changed. |
| `collectedAt`, `observedAt` | string | When the row was produced, and when the source last saw the flight. |

### Pricing

Pay per event. You pay for what the run produces, not for how long it takes.

| What you pay for | Price |
| --- | --- |
| **Flight status checked** — one row published | **$3.00 per 1,000 rows** |
| **Punctuality history added** — a row that carries the flight number's recent operations and their on-time figures | **$1.20 per 1,000 rows** |

**Worked example.** You check 500 flights with the punctuality record left on. That is 500 rows at $3.00 per 1,000 = **$1.50**, plus 500 punctuality records at $1.20 per 1,000 = **$0.60**. **$2.10 for the run.**

Watching a flight is the same price as checking it: each published update is one more row at $3.00 per 1,000, and the punctuality record is charged once per flight, not once per update. A flight with no earlier operations published is never charged the second event, because nothing was added.

A flight the source does not recognise, and a flight it has no current record for, produce no row and cost nothing.

### Limits & what this actor cannot do

- **Statuses and positions are a snapshot at the moment of collection** and can lag the aircraft. A position on a row that has already landed is where the flight was last seen, not where it is now.
- **This actor reports what the source publishes to the public.** It cannot book, change, cancel or check in for a flight, and it is not an official airline notification.
- **An estimated time is not an achieved time.** Every delay says which it is, and an estimate is never presented as a measurement. Use `arrivalDelayBasis` before acting on `arrivalDelayMinutes`.
- **Predicted times are not available** and are always empty. No scheduled or estimated value is ever substituted for one.
- **Many operators withhold the aircraft registration.** Those rows carry `registrationWithheld: true` rather than an invented tail number.
- **The recent record of a flight number is not a full history.** It reaches roughly ten days back and a couple of days forward, and it is what the source chooses to publish rather than a complete archive. A date outside it is reported as not published, and the run tells you which dates are available.
- **A flight number that has not operated recently has no current record.** Rather than return a stale entry that looks current, the run says there is no current record; raise `maxRecordAgeDays` if you want older entries.
- **The number on your ticket is not always the number the flight is published under.** The run translates the common ones automatically and reports both, but an unusual airline code may come back as not recognised. `identifierType` always describes the identifier that answered, not the one that was typed.
- **Some identifiers are two things at once.** `B6521` is both a JetBlue flight number and a Chinese aircraft registration; typed without its hyphen the flight number is checked first and the row says so rather than presenting one as the other. Hyphenate a registration to ask for the aircraft.
- **The region is a preference, not a guarantee.** It is asked for on every check in the run, and the source is free to answer in English anyway. It never changes a time, a number, a code or an airport.
- **A check the source refuses to complete is reported as a failed check, never as "no flight found".** The run summary counts statuses collected, flights with no current record, flights not recognised and failed checks as four separate numbers, and a run in which every check failed ends as a failed run.
- **Cancelled and diverted flights carry less detail** — there may be no arrival time, no gate and no position, and those fields are left empty rather than filled in.
- **Speed depends on the size of the job and on how quickly the source answers.** No fixed throughput is promised.
- **The source's terms govern automated access.** You are responsible for using the data lawfully and in line with those terms.

### FAQ

**Do I need an account on the source site?**
No. Nothing is signed into and nothing is signed up for.

**Does it need my login or password?**
No. There is no credential of any kind to supply — put in a flight number and press start.

**Can I schedule it?**
Yes. A common setup is a run every few minutes over the flights you care about, with *Keep watching* off, so each run gives you one fresh row per flight.

**Is this an official airline status?**
No. It is the publicly published status, which is what airport boards and travel apps show, but it is not a notification from the airline and it is not a guarantee.

**Why did my flight come back as "not recognised"?**
Either the number does not exist, or it is an unusual code the run could not translate. Try the number the operating airline uses — for a codeshare, that is the airline actually flying the aircraft rather than the one that sold you the ticket.

**I asked for a tail number and got a flight from another airline. Why?**
That was possible in an earlier version and is not any more. Write the registration with its hyphen — `B-6521`, not `B6521` — and only that aircraft is looked up. Without the hyphen the identifier is ambiguous, the ticketed reading is checked first, and the row states which reading answered.

**Why is `onTimePct` empty on some flights?**
Because nothing could be measured. A flight whose recent operations are all still in the future, or a private aircraft with no published arrival times, has no on-time percentage — and reporting 0% for it would be a made-up statistic.

**Why does `punctuality` not match the operations listed in `recentFlights`?**
Because `punctuality` is computed over every operation the source published for that flight number, while `recentFlights` lists at most `maxHistoryLegs` of them, newest first. `punctuality.legsTotal` and `legsMeasured` state exactly how many operations the figures came from. Raise `maxHistoryLegs` to list them all.

**What counts as "on time"?**
Arriving no more than 15 minutes after schedule, which is the industry convention. Change `onTimeThresholdMinutes` if your contract uses a different one.

# Actor input Schema

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

The flights to check. Use the flight number printed on a ticket — UA1, BA117, LH402, EK202 — or an aircraft registration such as N154QS, D-ABYT or B-6521. Spaces and hyphens are fine. Write a registration with its hyphen where it has one: B-6521 asks for that aircraft, while B6521 reads first as JetBlue flight 521. Up to 100 in one run.

## `date` (type: `string`):

Leave empty for the operation running now or next. Set a date as YYYY-MM-DD to get that day's operation instead. The recent record of a flight number usually reaches about ten days back and a couple of days forward; a date outside it is reported as not published, and the run tells you which dates are available.

## `market` (type: `string`):

The regional edition asked for when a flight is checked, used identically on every check in a run. It is a preference the source is free to ignore — the wording of a free-text delay notice is the only thing it could change, and most of that is published in English whatever is asked for. It never changes a time, a number, a code or an airport: every time is given twice, once in UTC and once on the clock at the airport it happens at.

## `includeHistory` (type: `boolean`):

Attaches the recent operations of the same flight number — each with its scheduled and actual times, delay in minutes, and whether it was cancelled or diverted — plus an on-time percentage, an average delay and the best and worst arrival. The figures are computed over every operation the source published for that flight number, which can be more than are listed when the list is capped; the row states the count they used. It arrives together with the status, so it does not slow the run down.

## `maxHistoryLegs` (type: `integer`):

How many earlier operations of the flight number to LIST on each row, newest first. The source publishes roughly 8 to 30 of them depending on how often the flight runs; the on-time figures are computed over all of them whatever this is set to, and the row states the count they used.

## `onTimeThresholdMinutes` (type: `integer`):

How many minutes past the scheduled arrival still counts as on time when the on-time percentage is worked out. The industry standard is 15.

## `includeTrack` (type: `boolean`):

Adds the positions the flight has actually been observed at, in order — time, latitude, longitude, altitude and speed — for drawing a map. It makes each row considerably larger.

## `maxTrackPoints` (type: `integer`):

Upper limit on how many observed positions are attached when the flight path is switched on. Past that limit the most recent positions are kept, so the path always ends where the aircraft actually is, and the row states how many were published in total.

## `includeRoute` (type: `boolean`):

Adds the route the crew filed, the planned cruising altitude and speed, the planned flight time and the planned fuel burn, where the source publishes them.

## `trackUntilLanded` (type: `boolean`):

Instead of one status per flight, keep checking and publish a new row every time something a traveller would act on changes — the estimated time, the gate, the terminal, a departure, a landing, a cancellation or a diversion. Position changes alone never produce a row. Ignored when a date is set, because a past flight has already finished.

## `refreshIntervalSec` (type: `integer`):

How long to wait between checks while watching a flight. Shorter means fresher updates and a longer run.

## `maxTrackingMinutes` (type: `integer`):

Stop watching a flight after this long, even if it has not landed. Watching also stops on its own as soon as the flight arrives, is cancelled or is diverted.

## `maxUpdatesPerFlight` (type: `integer`):

Upper limit on how many update rows a single watched flight can produce, so a long run stays predictable.

## `maxRecordAgeDays` (type: `integer`):

If the newest thing the source publishes for a flight is older than this, the run reports that there is no current record instead of returning a stale one. Raise it if you are looking up flights that have not operated for a while.

## `maxRows` (type: `integer`):

Hard ceiling on the rows this run produces across every flight, including update rows. Use it to keep a long watch predictable.

## Actor input object example

```json
{
  "flights": [
    "UA1",
    "BA117"
  ],
  "market": "US",
  "includeHistory": true,
  "maxHistoryLegs": 25,
  "onTimeThresholdMinutes": 15,
  "includeTrack": false,
  "maxTrackPoints": 500,
  "includeRoute": false,
  "trackUntilLanded": false,
  "refreshIntervalSec": 120,
  "maxTrackingMinutes": 120,
  "maxUpdatesPerFlight": 30,
  "maxRecordAgeDays": 30,
  "maxRows": 1000
}
```

# Actor output Schema

## `flightStatus` (type: `string`):

One result per flight check: status, scheduled and actual times, delay in minutes, gate, terminal, aircraft and the recent on-time record of the flight number.

## `flightStatusCsv` (type: `string`):

The same results as a spreadsheet-ready file.

## `runSummary` (type: `string`):

How many flights were checked, how many have no current record, how many were not recognised, how many checks failed, and how many update rows were published.

# 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": [
        "UA1",
        "BA117"
    ],
    "date": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("apt_marble/flight-status-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": [
        "UA1",
        "BA117",
    ],
    "date": "",
}

# Run the Actor and wait for it to finish
run = client.actor("apt_marble/flight-status-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": [
    "UA1",
    "BA117"
  ],
  "date": ""
}' |
apify call apt_marble/flight-status-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apt_marble/flight-status-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/wCUnHkgfrpIzo9rsD/builds/4xr4x3CVdguz6xb4J/openapi.json