# FAA Data Scraper (`crawlerbros/faa-data-scraper`) Actor

Fetch FAA aviation data - airport info (runways, frequencies, ownership) and live METAR weather observations - for any US or international airport. Uses the public Aviation Weather Center API, no authentication required.

- **URL**: https://apify.com/crawlerbros/faa-data-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## FAA Data Scraper

Extract FAA (Federal Aviation Administration) aviation data for any US airport — static airport information (runways, ownership, radio frequencies) and live METAR weather observations updated hourly.

Data is sourced from the **FAA via the Aviation Weather Center public REST API** (`aviationweather.gov`) — no API key or authentication required.

### Features

- **Airport static data** — ICAO/IATA codes, name, state, coordinates, elevation, runway count/dimensions/surface, owner type, tower/beacon status, radio frequencies, annual passengers
- **Live METAR weather** — temperature, dewpoint, wind, visibility, altimeter setting, sky cover, cloud layers, flight category (VFR/IFR/MVFR/LIFR)
- **Browse mode** — 80+ major US airports pre-curated, filterable by state
- **Flexible input** — accepts both 3-letter IATA codes (ATL) and 4-letter ICAO codes (KATL)
- **No proxy required** — fully public API
- **Batch fetching** — up to 500 records per run

### Input

| Field | Type | Description | Example |
|-------|------|-------------|---------|
| `mode` | select | `searchAirports`, `getAirportInfo`, or `getWeather` | `getAirportInfo` |
| `airportCodes` | array | IATA or ICAO airport codes | `["ATL", "LAX", "JFK"]` |
| `state` | string | US state filter for `searchAirports` mode | `"CA"` |
| `maxItems` | integer | Max records to return | `50` |

#### Modes

- **`searchAirports`** — Browse 80+ major US airports. Optionally filter by `state`. Provide `airportCodes` to override with specific airports.
- **`getAirportInfo`** — Fetch static FAA data for specific airports by IATA/ICAO code.
- **`getWeather`** — Fetch current METAR weather observations for specific airports.

### Output (Airport Info)

| Field | Type | Description |
|-------|------|-------------|
| `airportId` | string | IATA code (e.g. `ATL`) |
| `icaoId` | string | ICAO code (e.g. `KATL`) |
| `iataId` | string | IATA code |
| `airportName` | string | Airport name |
| `state` | string | US state code |
| `country` | string | Country code |
| `latitude` | float | WGS84 latitude |
| `longitude` | float | WGS84 longitude |
| `elevation` | float | Elevation in feet MSL |
| `ownerType` | string | Ownership type |
| `runwayCount` | integer | Number of runways |
| `runwayLengthCategory` | string | Short/Medium/Long |
| `primarySurface` | string | Primary runway surface |
| `runways` | array | Detailed runway info |
| `annualPassengers` | integer | Annual passenger count |
| `hasTower` | boolean | Has control tower |
| `hasBeacon` | boolean | Has rotating beacon |
| `radioFrequencies` | array | Radio frequency list |
| `sourceUrl` | string | API source URL |
| `recordType` | string | `"airport"` |
| `scrapedAt` | string | ISO 8601 timestamp |

### Output (Weather / METAR)

| Field | Type | Description |
|-------|------|-------------|
| `airportId` | string | IATA code |
| `icaoId` | string | ICAO code |
| `stationName` | string | Station name |
| `observationTime` | string | Observation timestamp (UTC) |
| `metarType` | string | `METAR` or `SPECI` |
| `tempC` | float | Temperature in Celsius |
| `dewpointC` | float | Dewpoint in Celsius |
| `windDirectionDeg` | integer | Wind direction (degrees true) |
| `windSpeedKt` | integer | Wind speed in knots |
| `visibilityMiles` | string | Visibility in statute miles |
| `altimeterHPA` | float | Altimeter setting (hPa) |
| `seaLevelPressureHPA` | float | Sea level pressure (hPa) |
| `flightCategory` | string | VFR / MVFR / IFR / LIFR |
| `flightCategoryName` | string | Full flight category name |
| `skyCover` | string | Sky cover code |
| `cloudLayers` | array | Cloud layers with cover and base |
| `latitude` | float | Station latitude |
| `longitude` | float | Station longitude |
| `elevation` | float | Station elevation (ft) |
| `rawMETAR` | string | Raw METAR string |
| `sourceUrl` | string | API source URL |
| `recordType` | string | `"weather"` |
| `scrapedAt` | string | ISO 8601 timestamp |

### Example Output (Airport)

```json
{
  "airportId": "ATL",
  "icaoId": "KATL",
  "iataId": "ATL",
  "airportName": "Atlanta/Hartsfield/Jackson Atlanta Intl",
  "state": "GA",
  "country": "US",
  "latitude": 33.6367,
  "longitude": -84.4279,
  "elevation": 312.0,
  "ownerType": "Publicly Owned",
  "runwayCount": 5,
  "runwayLengthCategory": "Long (>8000 ft)",
  "primarySurface": "Concrete",
  "runways": [
    {"id": "08L/26R", "dimension": "9000x150", "surface": "Concrete", "alignmentDeg": 90}
  ],
  "annualPassengers": 93700,
  "hasTower": true,
  "hasBeacon": true,
  "recordType": "airport",
  "scrapedAt": "2025-01-01T12:00:00+00:00"
}
````

### Example Output (Weather)

```json
{
  "airportId": "ATL",
  "icaoId": "KATL",
  "stationName": "Atlanta/Hartsfield-Jackson Intl, GA, US",
  "observationTime": "2025-01-01T07:00:00.000Z",
  "metarType": "METAR",
  "tempC": 21.1,
  "dewpointC": 19.4,
  "windDirectionDeg": 170,
  "windSpeedKt": 4,
  "visibilityMiles": "10+",
  "altimeterHPA": 1014.3,
  "flightCategory": "VFR",
  "flightCategoryName": "Visual Flight Rules",
  "skyCover": "OVC",
  "cloudLayers": [{"cover": "FEW", "baseFt": 500}],
  "latitude": 33.6297,
  "longitude": -84.4422,
  "elevation": 309.0,
  "recordType": "weather",
  "scrapedAt": "2025-01-01T12:00:00+00:00"
}
```

### FAQ

**Q: Where does the data come from?**
A: Airport static data and METAR observations are sourced from the FAA via the Aviation Weather Center public REST API at `aviationweather.gov/api/data/`.

**Q: How current is the weather data?**
A: METAR observations are updated approximately every hour (or more frequently in rapidly changing conditions). The `observationTime` field shows the exact observation time.

**Q: Can I use 3-letter IATA codes or 4-letter ICAO codes?**
A: Both work. The actor automatically normalises 3-letter US codes by prepending `K` to convert to ICAO format (e.g. `ATL` → `KATL`).

**Q: Does this work for international airports?**
A: The Aviation Weather API covers ICAO airports worldwide. Provide the full 4-letter ICAO code for non-US airports (e.g. `EGLL` for London Heathrow).

**Q: How many airports can I request in one run?**
A: Up to 500 airports per run. Requests are batched in groups of 20.

# Actor input Schema

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

What data to fetch: airport static info, live weather (METAR), or browse major airports.

## `airportCodes` (type: `array`):

IATA (3-letter, e.g. ATL) or ICAO (4-letter, e.g. KATL) airport codes. Required for getAirportInfo and getWeather modes. Leave empty in searchAirports mode to browse all (or filter by state).

## `state` (type: `string`):

Filter airports by US state code (e.g. CA, TX, FL). Only used in searchAirports mode when no airportCodes are provided.

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

Maximum number of records to emit.

## Actor input object example

```json
{
  "mode": "searchAirports",
  "airportCodes": [
    "ATL",
    "ORD",
    "LAX"
  ],
  "maxItems": 50
}
```

# Actor output Schema

## `airports` (type: `string`):

Dataset containing all scraped FAA airport and weather records.

# 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 = {
    "mode": "searchAirports",
    "airportCodes": [
        "ATL",
        "ORD",
        "LAX"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/faa-data-scraper").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 = {
    "mode": "searchAirports",
    "airportCodes": [
        "ATL",
        "ORD",
        "LAX",
    ],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/faa-data-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "searchAirports",
  "airportCodes": [
    "ATL",
    "ORD",
    "LAX"
  ],
  "maxItems": 50
}' |
apify call crawlerbros/faa-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/faa-data-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FAA Data Scraper",
        "description": "Fetch FAA aviation data - airport info (runways, frequencies, ownership) and live METAR weather observations - for any US or international airport. Uses the public Aviation Weather Center API, no authentication required.",
        "version": "1.0",
        "x-build-id": "8NbDb4uKxdw1SpAPy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~faa-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-faa-data-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~faa-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-faa-data-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~faa-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-faa-data-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchAirports",
                            "getAirportInfo",
                            "getWeather"
                        ],
                        "type": "string",
                        "description": "What data to fetch: airport static info, live weather (METAR), or browse major airports.",
                        "default": "searchAirports"
                    },
                    "airportCodes": {
                        "title": "Airport Codes",
                        "type": "array",
                        "description": "IATA (3-letter, e.g. ATL) or ICAO (4-letter, e.g. KATL) airport codes. Required for getAirportInfo and getWeather modes. Leave empty in searchAirports mode to browse all (or filter by state).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "state": {
                        "title": "State Filter (searchAirports only)",
                        "type": "string",
                        "description": "Filter airports by US state code (e.g. CA, TX, FL). Only used in searchAirports mode when no airportCodes are provided."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of records to emit.",
                        "default": 50
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```