# Airport Delays Today: FAA Ground Stops & METAR/TAF (`data-done-right/airport-delays-weather`) Actor

Get live US airport delays from the FAA (ground stops, ground delay programs, arrival and departure delays, closures) plus METAR and TAF weather for any airport. Monitor mode reports only new, updated and cleared events since the last run.

- **URL**: https://apify.com/data-done-right/airport-delays-weather.md
- **Developed by:** [Data Done Right](https://apify.com/data-done-right) (community)
- **Categories:** Travel, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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

## Airport Delays Today: FAA Ground Stops & METAR/TAF Weather

This **airport delays tracker** gives you live **US airport disruption data straight from the FAA**: ground stops, ground delay programs, arrival and departure delays, closures and airspace flow programs. Add **METAR and TAF aviation weather** for any airport in the world, and turn on **monitor mode** to get only what changed since your last run (new, updated, and **cleared** events, e.g. "the SFO ground stop was lifted").

No API key, no login, no scraping of commercial flight trackers. Both sources are official US government feeds.

### What data can you get on airport delays

- **Every active FAA program** for the US National Airspace System, or only for the airports you list.
- **Ground stops** with reason, end time, ARTCC center, included facilities, probability of extension and the FAA advisory link.
- **Ground delay programs** with average and maximum delay in minutes.
- **Arrival / departure delays** with min/max minutes and trend (increasing / decreasing).
- **Closures and NOTAM notices** with full NOTAM text and reopen time. Full closures are `closure`. Partial closures and restrictions (e.g. "closed to non-scheduled transient GA aircraft") are `notice`, so they don't flag an airport as disrupted.
- Optional: **runway configuration and arrival rate**, **deicing** status.
- **Weather row per airport**: flight category (VFR/MVFR/IFR/LIFR), wind and gusts, visibility, ceiling, present weather, clouds, raw METAR, plus an optional **TAF** (raw text and decoded periods). Each weather row also says whether the FAA reports a disruption at that airport (`faaStatus`).
- **Monitor mode** (`onlyChanges`): each row has `change` = `new` | `updated` | `cleared`. Timestamps-only refreshes are ignored, so you are not billed for noise. Schedule it every 5 to 15 minutes and connect a webhook, Slack or Sheets.
- **Codes the way you have them**: `SFO`, `KSFO`, `HNL`, `PHNL`, `SJU`, `TJSJ`, or a foreign ICAO code like `EGLL` (weather only).
- **Reliable**: the FAA JSON feed is read first and the FAA XML feed fills gaps (and stands in if the JSON feed is down). Problems are listed in the `NOTES` record, never hidden. If every source fails, the run fails and nothing is charged.

### How to check airport delays today

List the airports you care about (for example `SFO`, `JFK`), or leave **Airports** empty to see every US airport with an active FAA event right now. Add current weather (METAR) and forecast (TAF) if you want it. To get alerts, turn on **Only changes since my last run (monitor)** and schedule the Actor every 5 to 15 minutes.

### Input

```json
{
  "airports": ["SFO", "JFK", "ORD", "ATL", "DEN"],
  "includeFaa": true,
  "eventTypes": ["ground_stop", "ground_delay", "arrival_delay", "departure_delay", "closure", "airspace_flow"],
  "includeMetar": true,
  "includeTaf": false,
  "onlyChanges": false,
  "maxRows": 1000
}
```

Leave `airports` empty to get every US airport that has an active FAA event right now (weather needs a list of airports).

### Output

FAA event row:

```json
{
  "rowType": "faa_event", "change": null, "eventType": "ground_stop",
  "airport": "SFO", "icao": "KSFO", "airportName": "San Francisco International", "latitude": 37.6213, "longitude": -122.379,
  "reason": "low ceilings", "avgDelayMinutes": null, "minDelayMinutes": null, "maxDelayMinutes": null, "trend": null,
  "startTime": "2026-10-19T03:00:00Z", "endTime": "2026-10-19T04:15:00Z", "center": "ZOA",
  "advisoryUrl": "https://www.fly.faa.gov/adv/adv_otherdis.jsp?advn=10&...", "probabilityOfExtension": "MEDIUM",
  "includedFacilities": ["ZLA", "ZLC", "ZOA", "ZSE"], "notamText": null,
  "faaUpdatedAt": "2026-10-19T03:03:19Z", "source": "faa-json", "fetchedAt": "2026-10-19T03:20:00Z"
}
```

Weather row:

```json
{
  "rowType": "weather", "change": null, "airport": "SFO", "icao": "KSFO", "airportName": "San Francisco Intl, CA, US",
  "latitude": 37.6196, "longitude": -122.3656, "observedAt": "2026-10-19T02:56:00Z", "flightCategory": "MVFR",
  "temperatureC": 15, "dewpointC": 11.1, "windDirectionDeg": 280, "windSpeedKt": 12, "windGustKt": null,
  "visibilityMiles": "10+", "altimeterHpa": 1016, "weather": null, "clouds": "SCT012 BKN016", "ceilingFt": 1600,
  "rawMetar": "METAR KSFO 190256Z 28012KT 10SM SCT012 BKN016 15/11 A3000 RMK AO2 SLP159 T01500111 53005 $",
  "tafIssuedAt": "2026-10-19T02:59:00.000Z", "tafValidFrom": "2026-10-19T03:00:00Z", "tafValidTo": "2026-10-20T06:00:00Z",
  "rawTaf": "TAF KSFO 190259Z 1903/2006 28015KT P6SM BKN015 FM191600 28015G25KT P6SM FEW015 FM200400 24005KT P6SM SCT015",
  "tafForecast": [{"from": "2026-10-19T03:00:00Z", "to": "2026-10-19T16:00:00Z", "change": null, "windDirectionDeg": 280,
                   "windSpeedKt": 15, "visibilityMiles": "6+", "weather": null, "clouds": "BKN015", "ceilingFt": 1500}],
  "faaStatus": "delays or closures active", "faaActiveEvents": ["ground_stop"],
  "source": "aviationweather.gov", "fetchedAt": "2026-10-19T03:20:00Z"
}
```

All rows of a type always have the same fields (missing values are `null`). In monitor mode a `cleared` row repeats the last known values of the event that ended.

### Use cases

- **Travel apps and chatbots**: "Is my airport delayed, and why?"
- **Logistics, ground transport, hotels, crew scheduling**: react to ground stops and delay programs early.
- **Alerting**: scheduled monitor that posts new and lifted ground stops to Slack, email or a webhook.
- **Analytics**: build your own history of FAA delay programs and weather by running it on a schedule.

### Limits (honest)

- FAA data covers **US airports only** and only what the FAA publishes as delay programs. It does **not** give individual flight status, airline cancellations or gate delays. Quiet hours (often at night) can legitimately return zero FAA events.
- The FAA NAS Status endpoints are public but not formally documented and can change without notice. Unknown new sections are passed through in `details` and reported in `NOTES`.
- Arrival/departure delays are FAA 15-minute buckets, not exact averages.
- Weather comes from aviationweather.gov (NOAA). Small airports may have no TAF, and some have no METAR.
- Airspace flow programs are not tied to one airport, so they are returned only when `airports` is empty.
- Monitor memory is tied to your airport list and settings (or to `monitorId`). The first monitor run returns everything as `new`.

### Data sources

- FAA National Airspace System Status, https://nasstatus.faa.gov (US government work, public domain).
- NOAA / NWS Aviation Weather Center, https://aviationweather.gov (public domain, per https://www.weather.gov/disclaimer).

This Actor is unofficial and is not affiliated with or endorsed by the FAA, NOAA or the NWS. The data is not official material, and it is not for operational flight planning or navigation.

### How much does it cost

Pay per event: a small fee per delivered row (FAA event or weather row), plus the standard start fee. In monitor mode you only pay for rows that changed.

### FAQ

#### How are airport delays today?

Run the Actor with **Airports** empty. You get every US airport that has an active FAA ground stop, ground delay program, arrival or departure delay, or closure at that moment. No rows can also be a good sign: quiet hours often have none.

#### What is a ground stop?

A ground stop is an FAA program that holds flights bound for an airport on the ground at their origin for a set period, usually because of weather, volume or equipment problems. Each row gives the reason, end time and probability of extension.

#### What is a ground delay program?

A ground delay program spaces out departures to an airport so arrivals stay within capacity. Rows show the average and maximum delay in minutes.

#### Does it show individual flight delays or cancellations?

No. It covers airport-level FAA programs and weather. It does not give individual flight status, airline cancellations or gate delays.

#### Does it cover airports outside the US?

Weather (METAR and TAF) works for airports worldwide with an ICAO code such as `EGLL`. FAA delay programs cover US airports only.

#### Is there an airport delays map?

There is no built-in map. Each row has latitude and longitude, so you can plot the results in your own map or dashboard.

#### Do I need an API key?

No. Both sources are official US government feeds.

### Related tools

- **Send Data to Slack, Discord, Email, Notion & Postgres**: send new and cleared ground stops to Slack, Discord or Notion.
- **Google Sheets Import & Export**: log delay programs to a Google Sheet.
- **[Google Hotels Prices](https://apify.com/data-done-right/google-hotels-scraper)**: hotel rates by date for trip planning.

# Actor input Schema

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

3-letter FAA/IATA codes (SFO, JFK, HNL) or 4-letter ICAO codes (KSFO, PHNL, EGLL). Leave empty to get every US airport with an active FAA event (weather needs airports). Non-US ICAO codes get weather only.

## `includeFaa` (type: `boolean`):

Live US National Airspace System status from the FAA (nasstatus.faa.gov).

## `eventTypes` (type: `array`):

Which FAA events to return. Runway configuration and deicing are off by default (they are informational, not delays).

## `includeMetar` (type: `boolean`):

Latest observation per airport from aviationweather.gov: flight category (VFR/MVFR/IFR/LIFR), wind, visibility, ceiling, weather, raw METAR. One row per airport, which also carries a summary of its FAA status.

## `includeTaf` (type: `boolean`):

Adds the latest terminal forecast (raw TAF plus decoded periods) to each weather row. Only airports that issue TAFs have one.

## `onlyChanges` (type: `boolean`):

Returns only new, updated and cleared events (e.g. a ground stop was lifted), and weather rows only when the flight category, weather or TAF changed. Each row has change = new | updated | cleared. Schedule it every 5-15 minutes for alerts.

## `monitorId` (type: `string`):

Optional. Runs with the same name share memory. By default the memory is tied to your airports and settings, so different tasks never mix.

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

Upper limit of rows per run. Also caps cost.

## Actor input object example

```json
{
  "airports": [
    "SFO",
    "JFK",
    "ORD",
    "ATL",
    "DEN"
  ],
  "includeFaa": true,
  "eventTypes": [
    "ground_stop",
    "ground_delay",
    "arrival_delay",
    "departure_delay",
    "closure",
    "airspace_flow"
  ],
  "includeMetar": true,
  "includeTaf": false,
  "onlyChanges": false,
  "maxRows": 1000
}
```

# Actor output Schema

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

All result items of this run (the default dataset), as JSON, CSV, Excel and more.

## `records` (type: `string`):

Key-value store records: the run summary, notes on any problems, and any files.

# 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 = {
    "airports": [
        "SFO",
        "JFK",
        "ORD",
        "ATL",
        "DEN"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("data-done-right/airport-delays-weather").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 = { "airports": [
        "SFO",
        "JFK",
        "ORD",
        "ATL",
        "DEN",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("data-done-right/airport-delays-weather").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 '{
  "airports": [
    "SFO",
    "JFK",
    "ORD",
    "ATL",
    "DEN"
  ]
}' |
apify call data-done-right/airport-delays-weather --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,data-done-right/airport-delays-weather"
        }
    }
}
```

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/LX2OvDvbbWnOQICUc/builds/3JRTk94RsxNVaEZRT/openapi.json