# NOAA Aviation Weather METAR TAF Scraper (`parseforge/aviationweather-metar-taf-scraper`) Actor

Pull live METAR observations and TAF terminal forecasts from the NOAA Aviation Weather Center for any airport by ICAO code. Returns temperature, wind, visibility, cloud layers, altimeter, and flight category. Great for pre flight briefings, dispatch, and drone launch checks.

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

## Pricing

from $4.00 / 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/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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🛫 NOAA Aviation Weather METAR TAF Scraper

> 🚀 **Export live airport weather in seconds.** Pull current METAR observations and TAF terminal forecasts for any airport worldwide straight from the NOAA Aviation Weather Center, with 23 clean fields per record.

> 🕒 **Last updated:** 2026-06-04 · **📊 23 fields** per METAR record · global ICAO coverage · keyless public source

Track real flying weather the way pilots and dispatchers do. This Actor reads the official NOAA Aviation Weather Center (AWC) data service and returns decoded METAR surface observations or TAF terminal aerodrome forecasts for any list of airport ICAO codes you provide. No API key, no login, no scraping tricks. Just the same data feed that powers flight planning, normalized into tidy rows.

**Coverage:** Any airport that reports to the global METAR/TAF network is supported, from US fields like KJFK and KLAX to international ones like EGLL (London Heathrow). You pass ICAO identifiers, pick METAR or TAF, and get back temperature, wind, visibility, cloud layers, altimeter, flight category (VFR/MVFR/IFR/LIFR), the original raw report, and station coordinates.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Pilots and flight instructors | Pre-flight weather briefings |
| Dispatchers and flight ops teams | Go / no-go decision support |
| Drone and UAV operators | Checking ceilings and visibility before launch |
| Aviation app and dashboard builders | Feeding live weather into a product |
| Data scientists and researchers | Building aviation weather datasets |

### 📋 What the AviationWeather METAR TAF Scraper does

- Pulls **current METAR observations** for a list of airport ICAO codes (temperature, dewpoint, wind, gusts, visibility, altimeter, sea level pressure, cloud layers, flight category, raw report).
- Pulls **TAF terminal forecasts** with every forecast period decoded into a clean nested array (valid window, wind, visibility, cloud cover per period, plus the raw TAF text).
- Normalizes observation and forecast times from epoch to ISO timestamps.
- Summarizes cloud layers into a readable string like `FEW900 SCT1800`.
- Returns station name, latitude, longitude, and elevation for mapping.
- Lets you control how many hours back to search for METAR reports.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `ids` | array | yes | List of 4-letter ICAO airport codes (for example KJFK, KLAX, EGLL). |
| `reportType` | select | yes | `METAR` for current observations or `TAF` for terminal forecasts. |
| `hours` | integer | no | Lookback window in hours for METAR search. Default 1. Ignored for TAF. |
| `maxItems` | integer | no | Cap on returned records. Free plan is limited to 10. |

**METAR example**
```json
{
  "ids": ["KJFK", "KLAX", "KORD", "EGLL", "KSFO"],
  "reportType": "METAR",
  "hours": 1,
  "maxItems": 10
}
````

**TAF example**

```json
{
  "ids": ["KJFK", "KLAX", "KSFO"],
  "reportType": "TAF",
  "maxItems": 10
}
```

> ⚠️ **Good to Know:** Use valid 4-letter ICAO identifiers, not 3-letter IATA codes. Los Angeles is `KLAX`, not `LAX`. Some fields such as wind gust, sea level pressure, and weather phenomena only appear when the airport actually reports them, so they can be null on a calm, clear day. That is the real report, not a missing value.

### 📊 Output

Each METAR record contains these fields:

| Field | Description |
|---|---|
| 🛫 `stationId` | Airport ICAO identifier |
| 📌 `stationName` | Airport name and location |
| 🚦 `flightCategory` | VFR, MVFR, IFR, or LIFR |
| 🏷 `reportSubtype` | METAR or SPECI |
| 📡 `rawObservation` | Original raw METAR text |
| 🕒 `observedAt` | Observation time (ISO) |
| 🕒 `reportTime` | Reported time (ISO) |
| 🌡 `temperatureC` | Temperature in Celsius |
| 💧 `dewpointC` | Dewpoint in Celsius |
| 🧭 `windDirection` | Wind direction in degrees |
| 💨 `windSpeedKt` | Wind speed in knots |
| 🌀 `windGustKt` | Wind gust in knots (when reported) |
| 👁 `visibility` | Visibility in statute miles |
| 📐 `altimeterHpa` | Altimeter setting in hectopascals |
| 🌊 `seaLevelPressureHpa` | Sea level pressure (when reported) |
| 🌧 `weather` | Active weather phenomena (when present) |
| ☁ `cloudCover` | Dominant cloud cover code |
| ☁ `cloudLayers` | Readable cloud layer summary |
| 📍 `latitude` | Station latitude |
| 📍 `longitude` | Station longitude |
| ⛰ `elevationM` | Station elevation in meters |
| 🕒 `scrapedAt` | When the record was collected |
| ❌ `error` | Error message, null on success |

**Real sample records (METAR):**

```json
{
  "stationId": "EGLL",
  "stationName": "London/Heathrow Intl, EN, GB",
  "flightCategory": "VFR",
  "reportSubtype": "METAR",
  "rawObservation": "METAR EGLL 041920Z AUTO 26020KT 9999 FEW037/// //////TCU 17/08 Q1002",
  "observedAt": "2026-06-04T19:20:00.000Z",
  "reportTime": "2026-06-04T19:20:00.000Z",
  "temperatureC": 17,
  "dewpointC": 8,
  "windDirection": 260,
  "windSpeedKt": 20,
  "windGustKt": null,
  "visibility": "6+",
  "altimeterHpa": 1002,
  "seaLevelPressureHpa": null,
  "weather": null,
  "cloudCover": "FEW",
  "cloudLayers": "FEW3700",
  "latitude": 51.477,
  "longitude": -0.461,
  "elevationM": 26,
  "scrapedAt": "2026-06-04T19:50:20.925Z",
  "error": null
}
```

```json
{
  "stationId": "KLAX",
  "stationName": "Los Angeles Intl, CA, US",
  "flightCategory": "VFR",
  "reportSubtype": "SPECI",
  "rawObservation": "SPECI KLAX 041902Z 27009G16KT 7SM FEW009 SCT018 21/15 A2991 RMK AO2 T02110150 $",
  "observedAt": "2026-06-04T19:02:00.000Z",
  "reportTime": "2026-06-04T19:02:00.000Z",
  "temperatureC": 21.1,
  "dewpointC": 15,
  "windDirection": 270,
  "windSpeedKt": 9,
  "windGustKt": 16,
  "visibility": 7,
  "altimeterHpa": 1013,
  "seaLevelPressureHpa": null,
  "weather": null,
  "cloudCover": "SCT",
  "cloudLayers": "FEW900 SCT1800",
  "latitude": 33.9382,
  "longitude": -118.3866,
  "elevationM": 30,
  "scrapedAt": "2026-06-04T19:50:20.978Z",
  "error": null
}
```

```json
{
  "stationId": "KSFO",
  "stationName": "San Francisco Intl, CA, US",
  "flightCategory": "VFR",
  "reportSubtype": "METAR",
  "rawObservation": "METAR KSFO 041856Z 31014KT 10SM FEW006 19/11 A2994 RMK AO2 SLP139 T01890106",
  "observedAt": "2026-06-04T18:56:00.000Z",
  "reportTime": "2026-06-04T19:00:00.000Z",
  "temperatureC": 18.9,
  "dewpointC": 10.6,
  "windDirection": 310,
  "windSpeedKt": 14,
  "windGustKt": null,
  "visibility": "10+",
  "altimeterHpa": 1014,
  "seaLevelPressureHpa": 1013.9,
  "weather": null,
  "cloudCover": "FEW",
  "cloudLayers": "FEW600",
  "latitude": 37.6196,
  "longitude": -122.3656,
  "elevationM": 2,
  "scrapedAt": "2026-06-04T19:50:21.003Z",
  "error": null
}
```

In TAF mode, each record adds `rawForecast`, `issuedAt`, `validFrom`, `validTo`, `remarks`, and a `forecastPeriods` array where every period carries its own `timeFrom`, `timeTo`, `changeType`, wind, visibility, and cloud summary.

### ✨ Why choose this Actor

- **Official source.** Data comes straight from the NOAA Aviation Weather Center, the same authority pilots brief from.
- **Two report types, one Actor.** Switch between live METAR observations and TAF forecasts with a single setting.
- **Clean per-type rows.** METAR and TAF each return a purpose-built shape instead of a wide table full of empty columns.
- **Readable and machine-friendly.** Times are ISO, clouds are summarized, and the original raw report is always preserved.
- **Global reach.** Any reporting airport worldwide by ICAO code.

### 📈 How it compares to alternatives

| Approach | Setup | Decoded output | METAR + TAF | Cost |
|---|---|---|---|---|
| This Actor | ICAO codes only | Yes, normalized rows | Both | Pay per use |
| Raw AWC API | Manual requests and parsing | You parse it | Both | Free but DIY |
| Generic weather APIs | Account and key | Often surface weather only | Rarely TAF | Subscription |
| Manual lookup | One airport at a time | Read raw text yourself | Both | Time |

### 🚀 How to use

1. Sign up or log in to Apify using [this link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the AviationWeather METAR TAF Scraper.
3. Enter your airport ICAO codes in `ids` and choose `METAR` or `TAF`.
4. Optionally set `hours` for the METAR lookback and `maxItems` for the cap.
5. Run the Actor and download your results.

### 💼 Business use cases

#### Flight operations

| Need | How this helps |
|---|---|
| Dispatch briefings | Pull current METAR and TAF for the whole route at once |
| Go / no-go calls | Read flight category and ceilings for every field |

#### Aviation products

| Need | How this helps |
|---|---|
| Weather widgets | Feed live observations into an app or dashboard |
| Alerting | Watch for IFR or LIFR conditions at key airports |

#### Drone and UAV operations

| Need | How this helps |
|---|---|
| Launch checks | Verify wind, gusts, and visibility before flying |
| Site planning | Compare conditions across multiple sites |

#### Research and analytics

| Need | How this helps |
|---|---|
| Trend studies | Build historical weather samples by station |
| Model inputs | Use decoded fields as features for forecasting |

### 🔌 Automating AviationWeather METAR TAF Scraper

Connect this Actor to the tools you already use:

- **Make** and **Zapier** to trigger runs on a schedule and route results.
- **Slack** to post severe weather alerts to a channel.
- **Airbyte** to sync records into your warehouse.
- **GitHub** Actions to run briefings before a planned flight window.
- **Google Drive** to archive daily weather snapshots.

### 🌟 Beyond business use cases

- **Research:** study how flight categories shift across a day or season.
- **Personal:** check conditions at your home field before heading out.
- **Non-profit:** support search and rescue or disaster response planning.
- **Experimentation:** learn to decode METAR and TAF by comparing raw text to parsed fields.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to summarize the flying weather, flag any airports below VFR, or explain a raw report in plain language.

### ❓ Frequently Asked Questions

**Q: Do I need an API key or account with NOAA?**
No. The Aviation Weather Center data service is public and keyless. You only need an Apify account to run the Actor.

**Q: What is the difference between METAR and TAF?**
METAR is a current surface weather observation. TAF is a Terminal Aerodrome Forecast covering the next 24 to 30 hours in defined periods.

**Q: Should I use ICAO or IATA codes?**
ICAO, the 4-letter codes. Los Angeles is `KLAX`, London Heathrow is `EGLL`. IATA codes like `LAX` will not match.

**Q: Why is `windGustKt` or `weather` null on some records?**
Those fields only appear when the airport actually reports gusts or active weather. On a calm, clear day they are genuinely absent, which is the correct report.

**Q: What does `flightCategory` mean?**
It is the standard flight rules category derived from ceiling and visibility: VFR, MVFR, IFR, or LIFR.

**Q: How fresh is the data?**
METAR reports update roughly hourly with special updates (SPECI) when conditions change. TAF is reissued several times a day. You always get the latest available.

**Q: How many airports can I request at once?**
Pass as many ICAO codes as you like in `ids`. Output volume is bounded by your `maxItems` setting and plan.

**Q: What does the `hours` setting do?**
For METAR it sets how far back to search for reports. Use 1 for the most recent only. It is ignored for TAF.

**Q: Are the raw reports included?**
Yes. METAR records keep `rawObservation` and TAF records keep `rawForecast` so you can verify or re-parse them.

**Q: Can I map the airports?**
Yes. Every record includes latitude, longitude, and elevation.

**Q: Is this affiliated with NOAA?**
No. It is an independent tool that reads publicly available NOAA data.

**Q: Can I schedule recurring runs?**
Yes. Use Apify Schedules or an integration like Make to run briefings automatically.

### 🔌 Integrate with any app

Results are available through the Apify API, so you can pull them into spreadsheets, databases, BI tools, or any custom application. Combine with Apify Schedules and integrations to build a hands-off aviation weather pipeline.

### 🔗 Recommended Actors

- [NOAA Weather Scraper](https://apify.com/parseforge/noaa-weather-scraper) for general US forecasts and observations.
- [Open-Meteo Weather Scraper](https://apify.com/parseforge/open-meteo-weather-scraper) for free global weather forecasts by coordinates.
- [OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) for a global airport reference database.
- [OpenSky Flights Scraper](https://apify.com/parseforge/opensky-flights-scraper) for live aircraft positions.
- [Met.no Weather Forecast Scraper](https://apify.com/parseforge/met-no-weather-forecast-scraper) for European weather forecasts.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with NOAA or the National Weather Service. Only publicly available data is collected.

# Actor input Schema

## `ids` (type: `array`):

List of 4-letter ICAO airport identifiers to pull weather for (for example KJFK, KLAX, EGLL). Each code returns its latest METAR observation or TAF forecast.

## `reportType` (type: `string`):

METAR returns current surface weather observations. TAF returns Terminal Aerodrome Forecasts with multiple forecast periods.

## `hours` (type: `integer`):

How many hours back to search for METAR observations. Use 1 for the most recent only. Ignored for TAF.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "ids": [
    "KJFK",
    "KLAX",
    "KORD",
    "EGLL",
    "KSFO"
  ],
  "reportType": "METAR",
  "hours": 1,
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "ids": [
        "KJFK",
        "KLAX",
        "KORD",
        "EGLL",
        "KSFO"
    ],
    "reportType": "METAR",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/aviationweather-metar-taf-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 = {
    "ids": [
        "KJFK",
        "KLAX",
        "KORD",
        "EGLL",
        "KSFO",
    ],
    "reportType": "METAR",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/aviationweather-metar-taf-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 '{
  "ids": [
    "KJFK",
    "KLAX",
    "KORD",
    "EGLL",
    "KSFO"
  ],
  "reportType": "METAR",
  "maxItems": 10
}' |
apify call parseforge/aviationweather-metar-taf-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NOAA Aviation Weather METAR TAF Scraper",
        "description": "Pull live METAR observations and TAF terminal forecasts from the NOAA Aviation Weather Center for any airport by ICAO code. Returns temperature, wind, visibility, cloud layers, altimeter, and flight category. Great for pre flight briefings, dispatch, and drone launch checks.",
        "version": "0.1",
        "x-build-id": "aYkq3lNeLpX8RhgZ8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~aviationweather-metar-taf-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-aviationweather-metar-taf-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/parseforge~aviationweather-metar-taf-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-aviationweather-metar-taf-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/parseforge~aviationweather-metar-taf-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-aviationweather-metar-taf-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": [
                    "ids",
                    "reportType"
                ],
                "properties": {
                    "ids": {
                        "title": "Airport ICAO Codes",
                        "type": "array",
                        "description": "List of 4-letter ICAO airport identifiers to pull weather for (for example KJFK, KLAX, EGLL). Each code returns its latest METAR observation or TAF forecast.",
                        "default": [
                            "KJFK",
                            "KLAX",
                            "KORD",
                            "EGLL",
                            "KSFO"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "reportType": {
                        "title": "Report Type",
                        "enum": [
                            "METAR",
                            "TAF"
                        ],
                        "type": "string",
                        "description": "METAR returns current surface weather observations. TAF returns Terminal Aerodrome Forecasts with multiple forecast periods.",
                        "default": "METAR"
                    },
                    "hours": {
                        "title": "Lookback Hours (METAR only)",
                        "minimum": 1,
                        "maximum": 72,
                        "type": "integer",
                        "description": "How many hours back to search for METAR observations. Use 1 for the most recent only. Ignored for TAF.",
                        "default": 1
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
