# NWS Settlement Weather: Official Daily High/Low by Station (`studded_lantana/settlement-weather`) Actor

Official NWS daily climate report (CLI) high, low and precipitation for the US stations that weather prediction markets and daily temperature contracts settle on, plus live observations. Each record says whether the value is final.

- **URL**: https://apify.com/studded_lantana/settlement-weather.md
- **Developed by:** [amit ashkenazi](https://apify.com/studded_lantana) (community)
- **Categories:** Developer tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 station-day records

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

## NWS Settlement Weather: Official Daily High/Low by Station

**What it does:** returns the official NWS daily climate values used to settle weather contracts: the daily high, low and precipitation from the National Weather Service *Daily Climate Report* (CLI). You get them for the exact climate stations in major US cities (Central Park for New York, Midway for Chicago, and so on), plus a live running max/min from today's station observations. Each record has a `settled` flag. It is `true` only once the NWS has issued the final CLI for that day; a same-day afternoon report is labelled `preliminary`.

Why use it instead of scraping weather sites: the values come straight from the NWS products (no third-party weather site), the day boundaries follow the CLI's **local standard time** rule (midnight to midnight standard time, even during daylight saving time), and the issuance time and product id of the report behind each value are included so you can audit it.

### Use cases

- **Check how a daily temperature contract settled.** Weather contracts on prediction markets and weather derivatives are commonly settled on the NWS Daily Climate Report for one named station. This Actor returns that report's high, low and precipitation, and tells you whether the value is final.
- **Track the day as it happens.** The running max/min from live station observations shows where today's high and low stand before the official report is out.
- **Audit a value.** Each record carries the product id, issuance time and source URLs of the NWS report behind it.
- **Give an AI agent the official number.** One call returns a small JSON record per station and day.

**Tutorial:** [Why the "official" daily high is not what your weather app says](https://dev.to/kim_kelsi_b2078fa69a/why-the-official-daily-high-is-not-what-your-weather-app-says-3km)

### Supported stations

| ICAO | City | CLI code | | ICAO | City | CLI code |
|---|---|---|---|---|---|---|
| KNYC | New York (Central Park) | NYC | | KATL | Atlanta | ATL |
| KMDW | Chicago (Midway) | MDW | | KDFW | Dallas/Fort Worth | DFW |
| KORD | Chicago (O'Hare) | ORD | | KSEA | Seattle | SEA |
| KMIA | Miami | MIA | | KSFO | San Francisco (SFO) | SFO |
| KAUS | Austin (Bergstrom) | AUS | | KLAS | Las Vegas | LAS |
| KLAX | Los Angeles (LAX) | LAX | | KDCA | Washington DC (Reagan National) | DCA |
| KDEN | Denver | DEN | | KMSY | New Orleans | MSY |
| KPHL | Philadelphia | PHL | | KPHX | Phoenix | PHX |
| KHOU | Houston (Hobby) | HOU | | KMSP | Minneapolis | MSP |
| KBOS | Boston | BOS | | KSAT | San Antonio | SAT |
| | | | | KOKC | Oklahoma City | OKC |

You can pass the ICAO id, the CLI code, or the city name. "Chicago" means Midway (KMDW), and "Houston" means Hobby (KHOU). Use "KORD" for O'Hare.

### Input

```json
{
  "locations": ["KNYC", "Chicago", "Austin"],
  "startDate": "yesterday",
  "endDate": "today",
  "includeObservations": false
}
```

- `locations`: up to 25 cities or station ids.
- `startDate` / `endDate`: `YYYY-MM-DD`, `today` or `yesterday`, in each station's local standard time. `endDate` defaults to `startDate`. Dates must be within the last 7 days and not in the future.
- `includeObservations`: also return every observation of the day (time, °F, raw METAR when present).

### Output

One record per station per date (a "station-day"). Real example (KNYC, 2026-10-08):

```json
{
  "station": "KNYC",
  "city": "New York (Central Park)",
  "cli_station_name": "CENTRAL PARK NY",
  "date": "2026-10-08",
  "day_timezone": "UTC-5 (local standard time, as the CLI uses)",
  "settled": true,
  "status": "settled",
  "cli_report_type": "final",
  "cli_valid_as_of": null,
  "cli_high_f": 73,
  "cli_high_time_lst": "251 PM",
  "cli_low_f": 57,
  "cli_low_time_lst": "626 AM",
  "cli_precip_in": 0.0,
  "cli_precip_trace": false,
  "cli_record_high": false,
  "cli_record_low": false,
  "cli_product_id": "11381994-8a82-44f7-a5f5-1e40d6d5d94b",
  "cli_issued_at": "2026-10-09T06:32:00Z",
  "obs_high_f": 73.0,
  "obs_low_f": 57.0,
  "obs_count": 24,
  "obs_first_utc": "2026-10-08T05:51:00Z",
  "obs_last_utc": "2026-10-09T04:51:00Z",
  "obs_source": "api.weather.gov",
  "source_urls": [
    "https://api.weather.gov/products/11381994-8a82-44f7-a5f5-1e40d6d5d94b",
    "https://api.weather.gov/stations/KNYC/observations?start=2026-10-08T05%3A00%3A00Z&end=2026-10-09T05%3A00%3A00Z&limit=500"
  ],
  "fetched_at": "2026-10-09T14:21:40Z"
}
```

| Field | Meaning |
|---|---|
| `settled` | `true` when the final CLI for that date has been issued (normally early the next morning, local time). |
| `status` | Why the row is or isn't settled, in plain words: `settled`; `preliminary as of 7 AM` (a same-day CLI that covers only part of the day); `pending: day not over, final report expected after midnight local standard time` (today, no CLI yet, so the `cli_*` columns are empty); `pending: final report not issued yet` (yesterday, final still to come); or `no report: NWS has not issued a CLI for this date`. |
| `cli_report_type` | `final`, `preliminary` (a same-day CLI "valid as of" a local time), or `null` when no CLI for that date has been issued yet. |
| `cli_high_f`, `cli_low_f`, `cli_precip_in` | Values from that CLI. `null` if the report shows them as missing (`MM`). A trace of precipitation is `0.0` with `cli_precip_trace: true`. |
| `cli_high_time_lst`, `cli_low_time_lst` | Time of the extreme as printed in the CLI (local standard time). |
| `cli_record_high`, `cli_record_low` | `true` if the CLI marks the value as a record (`R`). |
| `obs_high_f`, `obs_low_f` | Running max/min of the reported observation temperatures for that local-standard-time day, so far. |
| `obs_source` | `api.weather.gov`, or `aviationweather.gov` if the NWS observations endpoint was down and the METAR fallback was used. |

### FAQ

**Which station is used for New York's daily high temperature?**
Contracts that reference the NWS Daily Climate Report for New York use Central Park (`KNYC`). Chicago contracts usually name Midway (`KMDW`), not O'Hare. Always check the station named in your own contract's rules; this Actor returns whichever supported station you ask for.

**Why is the official high different from my weather app?**
Two reasons. The climate day runs midnight to midnight local **standard** time, so during daylight saving time it runs from 1 AM to 1 AM on the clock. And the official value comes from the station's continuous record, while apps usually show periodic observations or a nearby station.

**When is the final value available?**
The morning after. In our October 2026 tests, NWS offices issued the final report between about 1 AM and 5 AM local time. Until then `settled` is `false`.

**What does `settled: false` mean?**
The final Daily Climate Report for that date has not been issued yet. `status` says why: the day is not over, the final report is still to come, a same-day preliminary report is all there is, or the NWS has issued no report.

**Can I use the `obs_*` values for settlement?**
No. They are a running max/min from reported observations and can differ from the official value by a degree or so. Use the `cli_*` fields for settlement and `obs_*` for intraday tracking.

**Can I get dates older than a week?**
No. The NWS API keeps these reports and observations for about 7 days.

**Does it return market prices or odds?**
No. It returns weather data only.

### Pricing

Pay per event:

- **$0.005 per run** (start).
- **$0.002 per station-day record.**

Example: 3 cities for yesterday and today = 6 records = $0.005 + 6 × $0.002 = **$0.017**. You are only charged for records returned.

### Limits

- **7-day window.** The NWS API keeps CLI reports and observations for about 7 days. Older dates are refused, and no station-day records are charged for them (the per-run start fee still applies).
- **Final values arrive the next morning.** Until the final CLI is issued, `settled` is `false` and `status` says why. For today the `cli_*` columns are often empty (no CLI yet) or hold a partial morning/afternoon report; for settled values, ask for `yesterday`. NWS offices issue it at different times; in our October 2026 tests, between about 1 AM and 5 AM local time. Offices occasionally re-issue or correct a CLI later; this Actor always returns the latest final report it finds.
- **Observation max/min is not the official value.** The CLI high/low comes from the station's continuous record. The running max/min comes from the reported observations (usually every 5 minutes, hourly for some stations, converted from °C to °F to one decimal). It can differ from the official value by a degree or so. Use `cli_*` fields for settlement and `obs_*` for intraday tracking.
- **Raw METAR text** is present only on the hourly/special observations, not on 5-minute ones.
- **Only the stations listed above.** Other stations are refused.
- **Upstream outages.** If api.weather.gov is down for the CLI, that location is skipped with a warning and no station-day records are charged for it. If only the observations endpoint is down, observations come from aviationweather.gov instead.

### Data source

All data comes from US federal government sources and is in the **public domain**:

- National Weather Service API, `api.weather.gov`: CLI daily climate report products and station observations.
- NOAA Aviation Weather Center data API, `aviationweather.gov`: METAR observations, as a fallback.

This Actor is not affiliated with or endorsed by NOAA or the NWS. It returns weather data only, no market data.

# Actor input Schema

## `locations` (type: `array`):

The climate stations to report on, as city names (e.g. "New York", "Austin") or ICAO station ids (e.g. "KNYC"). "New York" is Central Park (KNYC), "Chicago" is Midway (KMDW; use "KORD" for O'Hare) and "Houston" is Hobby (KHOU). Supported: KNYC, KMDW, KORD, KMIA, KAUS, KLAX, KDEN, KPHL, KHOU, KBOS, KATL, KDFW, KSEA, KSFO, KLAS, KDCA, KMSY, KPHX, KMSP, KSAT, KOKC. Other stations are refused. Up to 25 per run.

## `startDate` (type: `string`):

First day to report: YYYY-MM-DD, "today" or "yesterday", in each station's local standard time. For the official settled high and low, ask for "yesterday" or earlier; the final report for a day is issued the next morning. "today" gives the running max/min from live observations and usually no final report yet. At most 7 days back.

## `endDate` (type: `string`):

Last day to report: YYYY-MM-DD, "today" or "yesterday". Leave empty for a single day (the start date). Cannot be in the future. One record is returned, and charged, per station per day.

## `includeObservations` (type: `boolean`):

Leave false unless you need the intraday temperature series. When true, each record also carries the full list of the day's observations (time, °F, raw METAR), usually 5-minute data, about 300 per station-day, which makes records much larger.

## Actor input object example

```json
{
  "locations": [
    "KNYC",
    "Chicago"
  ],
  "startDate": "yesterday",
  "includeObservations": false
}
```

# Actor output Schema

## `stationDays` (type: `string`):

One record per station per date: settled flag, status, official CLI high/low/precipitation and the observed running max/min, with source URLs.

# 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 = {
    "locations": [
        "KNYC",
        "Chicago"
    ],
    "startDate": "yesterday"
};

// Run the Actor and wait for it to finish
const run = await client.actor("studded_lantana/settlement-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 = {
    "locations": [
        "KNYC",
        "Chicago",
    ],
    "startDate": "yesterday",
}

# Run the Actor and wait for it to finish
run = client.actor("studded_lantana/settlement-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 '{
  "locations": [
    "KNYC",
    "Chicago"
  ],
  "startDate": "yesterday"
}' |
apify call studded_lantana/settlement-weather --silent --output-dataset

```

## MCP server setup

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