# US Airport Delays & Weather API - FAA Status, METAR, TAF (`martin10291/airport-delays-weather`) Actor

US airport delays now and in history: FAA ground stops, ground delay programs, arrival/departure delays and closures, plus METAR/TAF weather and a delay-risk level per airport. No API key, no login, no proxy: official FAA and NOAA data. Our server stores every FAA delay event every 5 minutes, so you

- **URL**: https://apify.com/martin10291/airport-delays-weather.md
- **Developed by:** [Martin Petrov](https://apify.com/martin10291) (community)
- **Categories:** Travel, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 results

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

## US Airport Delays & Weather API - FAA Status, METAR, TAF

**Is my airport delayed right now, and will it be in the next hours?** This API answers that for any US airport in one call: official FAA ground stops, ground delay programs, arrival/departure delays and closures, plus NOAA METAR/TAF weather and a delay-risk level. No API key, no login, no proxy: official FAA and NOAA data.

What makes it different: **history**. Our server polls the FAA National Airspace System status every 5 minutes and stores every delay event with its start, end and duration. Ask "how many ground stops did ORD have in the last 30 days?" or "how long did the SAN ground delay program last?". On-demand scrapers cannot backfill that.

### What you get

| Mode | Returns |
|---|---|
| `status` (default) | One row per chosen airport (default: every US airport with an active FAA delay, ground stop or closure plus the 10 busiest): normal/delayed, ground stop, ground delay program (avg/max delay), arrival/departure delays, full closures, METAR now, TAF outlook, delay risk with reasons, local time |
| `delays` | Every US airport with an active FAA delay or ground stop right now |
| `history` | Past FAA delay events: airport, type, reason, first seen, ended, minutes, avg/max delay |
| `summary` | One row per airport over N days: events, ground stops, ground delay programs, disrupted minutes, longest event, worst delay, top reasons |

- Codes: IATA/FAA (`JFK`, `ORD`, `SJU`) or ICAO (`KJFK`, `PHNL`, `PANC`).
- Partial NOTAM closures (for example "closed to non-scheduled general aviation") are hidden by default, so normal airline operations are not reported as closed. Turn them on with `includeClosures`.
- **Only new / changed** mode with `monitorId`: schedule it every 5-15 minutes and get a row only when an airport's delay starts, changes or clears. Good for Slack/Telegram/n8n alerts.
- Unknown codes return a row with `status: "unknown airport code"` instead of failing the run.

### Example output (status)

```json
{
  "airport": "SAN", "icao": "KSAN", "name": "SAN DIEGO INTL", "state": "CA",
  "status": "delayed", "groundStop": false, "groundDelayProgram": true, "maxDelayMinutes": 88,
  "faaEvents": [{"event": "ground_delay", "reason": "airport volume", "avgDelayMinutes": 26, "maxDelayMinutes": 88}],
  "delayRisk": "high", "delayRiskReasons": ["FAA ground delay program (avg 26 min)"],
  "weatherNow": {"flightCategory": "VFR", "windSpeedKt": 8, "windGustKt": null, "ceilingFt": null, "raw": "METAR KSAN ..."},
  "forecast": {"hours": 12, "worstFlightCategory": "MVFR", "significantWeather": [], "raw": "TAF KSAN ..."},
  "localTime": "2026-11-08T08:06:46-0800"
}
```

### Use it from code or an AI agent

```bash
curl -X POST "https://api.apify.com/v2/acts/martin10291~airport-delays-weather/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode": "status", "airports": ["JFK", "ORD", "ATL"]}'
```

History of ground stops and delay programs at Chicago O'Hare in the last 30 days:

```json
{"mode": "history", "airports": ["ORD"], "days": 30, "eventTypes": ["ground_stop", "ground_delay"]}
```

AI agents (Claude, ChatGPT, Cursor, n8n) can call it as a tool through the Apify MCP server: `https://mcp.apify.com/?actors=martin10291/airport-delays-weather`.

### Sources and limits

- FAA NAS Status (nasstatus.faa.gov) public feed: airport-level programs, not individual flights. For flight-by-flight status use a flight data API.
- Weather: NOAA Aviation Weather Center (aviationweather.gov) METAR/TAF.
- `delayRisk` is a simple, transparent heuristic (FAA programs + IFR/LIFR, thunderstorms, snow, strong wind in the TAF window), not a prediction model. The reasons are always listed.
- Our history archive starts on 2026-11-08 and grows every 5 minutes; every answer says where it starts.
- Pricing: $1.00 per 1,000 rows. No row is charged when the run fails.

Related: [Airport Database API - IATA, ICAO, Flight Distance, METAR](https://apify.com/martin10291/airports-flight-distance) for airport lookups, distances and flight times.

### FAQ

**How fresh is the data?** Live modes read the FAA feed and NOAA weather at run time (the FAA feed updates every minute or two). History is polled every 5 minutes.

**What if no airport is delayed?** `delays` mode returns 0 rows and a note in `RUN_SUMMARY` (calm weather is normal, not an error). `status` mode always returns your airports with `status: "normal"`.

**What happens on errors?** A bad code gives a row with `status: "unknown airport code"`; a wrong option ends the run with a clear message; if FAA or NOAA is down the run stops cleanly and nothing is charged. `RUN_SUMMARY` always has `lastError`.

**Does it cover flights?** No: the FAA feed is per airport (programs and average/max delays). It is the official source airlines and dispatchers use for ground stops.

# Actor input Schema

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

status = one row per chosen airport (normal or delayed) with FAA status, METAR, TAF outlook and delay risk; delays = every US airport with an active FAA delay or ground stop right now; history = past FAA delay events from our 5-minute archive (start, end, duration); summary = one row per airport with event counts and disrupted minutes over the last N days.

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

US airport codes, IATA/FAA (JFK, ORD) or ICAO (KJFK, PHNL). Empty in status mode = every US airport with an active FAA delay/ground stop/closure right now plus the 10 busiest (always listed). Optional filter in delays/history/summary mode (empty = all airports).

## `includeWeather` (type: `boolean`):

Add current METAR (flight category, wind, gusts, visibility, ceiling) and a TAF outlook (worst flight category, thunderstorms, snow, strong wind) for each airport. Live modes only.

## `forecastHours` (type: `integer`):

How many hours of the TAF forecast to use for the outlook and the delay-risk level (1-30).

## `includeClosures` (type: `boolean`):

FAA also lists long-running NOTAM closures that only restrict some traffic (for example non-scheduled general aviation). Off = only full closures are shown, so airlines' normal operations are not reported as closed.

## `days` (type: `integer`):

History and summary modes: how many days back to look (1-365). Our archive started on 2026-11-08 and grows every 5 minutes.

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

Optional filter for history and summary modes: ground_stop, ground_delay, arrival_departure_delay, airspace_flow, closure, deicing. Empty = all except partial closures.

## `onlyNew` (type: `boolean`):

Live modes: return only airports whose FAA delay status changed since the last run with the same Monitor ID (new delay, longer delay, delay cleared). Schedule it every 5-15 minutes for alerts.

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

Name of the saved state for Only new mode. Use a different ID for each separate alert/watchlist.

## Actor input object example

```json
{
  "mode": "status",
  "airports": [
    "ATL",
    "DFW",
    "DEN",
    "ORD",
    "LAX",
    "JFK",
    "LAS",
    "MCO",
    "MIA",
    "CLT"
  ],
  "includeWeather": true,
  "forecastHours": 12,
  "includeClosures": false,
  "days": 7,
  "onlyNew": false,
  "monitorId": "default"
}
```

# Actor output Schema

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

One row per airport (live modes: FAA status, delays, METAR, TAF outlook, delay risk) or per FAA delay event (history mode) or per airport summary.

# 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": [
        "ATL",
        "DFW",
        "DEN",
        "ORD",
        "LAX",
        "JFK",
        "LAS",
        "MCO",
        "MIA",
        "CLT"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("martin10291/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": [
        "ATL",
        "DFW",
        "DEN",
        "ORD",
        "LAX",
        "JFK",
        "LAS",
        "MCO",
        "MIA",
        "CLT",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("martin10291/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": [
    "ATL",
    "DFW",
    "DEN",
    "ORD",
    "LAX",
    "JFK",
    "LAS",
    "MCO",
    "MIA",
    "CLT"
  ]
}' |
apify call martin10291/airport-delays-weather --silent --output-dataset

```

## MCP server setup

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