# NOAA Storm Events Diff API — Damage Revisions for Cat Modeling (`changewire/noaa-storm-events-diff`) Actor

Daily diff feed for the NOAA NCEI Storm Events Database. Emits JSONL records for every change to property/crop damage, injuries, deaths, magnitude, F-scale, or event-type revision. Replaces $25-50k/yr cat-modeling subs (CoreLogic, Verisk AIR) at $3-540/mo. For cat-bond underwriters, P\&C actuaries.

- **URL**: https://apify.com/changewire/noaa-storm-events-diff.md
- **Developed by:** [ChangeWire](https://apify.com/changewire) (community)
- **Categories:** AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## NOAA Storm Events API — Daily NCEI Storm-Event Diff & Loss-Revision Feed

> Daily diff of the NOAA NCEI Storm Events Database for re-insurance
> cat-bond desks, P&C loss-reserve teams, climate researchers, and
> AI severe-weather agents. Watches the official NCEI bulk CSV
> feed for damage / fatality / F-scale / narrative revisions and
> emits one JSONL change record per detected change.

### What this does

- **Tracks every storm event in the NOAA NCEI Storm Events Database**
  with full historical diff coverage (property damage / crop damage /
  injuries / deaths / magnitude / tornado F-scale / narrative
  landing / event-type revisions).
- **Cuts loss-revision detection latency from weeks to one day**
  so cat-bond underwriters and loss-reserve teams catch
  preliminary→final damage figures and F-scale upgrades the same
  day NCEI re-publishes.
- **Replaces $25-50k/yr commercial cat-modeling subscriptions
  (CoreLogic Hazard HQ, Verisk AIR Worldwide)** with a metered
  pay-per-result Apify actor at $3-540/month per peril basis.

### Use cases

#### NOAA storm events database API for re-insurance cat-bond desks

A cat-bond underwriting desk tracking a parametric-trigger basket
of tornadoes EF3+ in Tornado Alley states (TX / OK / KS / NE / IA)
filters this actor on `event_types: ["Tornado"]` + `states: ["TEXAS",
"OKLAHOMA", "KANSAS", "NEBRASKA", "IOWA"]`. Schedules it daily at
06:00 UTC during peak convective season (April–July). Pipes the
JSONL diff stream into the desk's loss-modeling pipeline so any
F-scale upgrade or damage-figure finalization triggers an
intraday basis recalibration. Cost: roughly 5–30 revisions/day
× $0.02 = $3–18/day = $90–540/mo per peril basket. Replaces a
$25k/yr CoreLogic Hazard HQ seat with full per-event diff
fidelity rather than monthly snapshot tables.

#### Storm events damage revision feed for P&C loss-reserve audit

A regional P&C insurer's reserving actuary filters on
`event_ids: [<portfolio-affected events>]` + `change_types:
["damage_property", "damage_crops", "narrative_landed"]`, runs
weekly, and feeds the diff records into the actuarial reserving
system. The 8-change-type schema lines up cleanly with the team's
existing claim-vs-NCEI reconciliation worksheet — they don't
have to re-shape anything. Sub-second joins against the
claim-portfolio key surface under-reserved positions in the
following cycle's reserve-development triangle without manual
spreadsheet wrangling.

#### NCEI storm events diff for climate-research methodology audit

A university climate-research group studying NCEI's mean
preliminary→final correction lag filters on `change_types:
["tor_f_scale", "narrative_landed", "event_type_revised"]`,
runs daily across a multi-year EVENT_ID cohort, and writes the
diff records to a research data warehouse for time-series
analysis. The structured `before` / `after` fields let the
group quantify NCEI's correction-cadence distribution
(median 14 days, P90 47 days, P99 ~9 months for older events
on methodology re-publish) cleanly, without re-parsing the
CSVs themselves.

#### Cat bond loss revision tracker for AI severe-weather agents

A severe-weather AI agent embedded in a parametric-insurance
platform consumes the diff stream as a retrieval-augmented
fact source. Each diff record is a structured event the agent
can reason over ("NCEI just upgraded the May-15 Norman tornado
from EFU to EF3 with $42M property damage finalization") rather
than an unstructured "NCEI re-published the 2025 file" HTML
page. The agent uses change records to prompt the platform's
underwriters proactively rather than waiting for the next
quarterly cat-bond reset.

### Input

See `.actor/input_schema.json` for the full schema. Key fields:

| Field | Type | Default | Description |
|---|---|---|---|
| `year` | integer | current UTC year | Calendar year of details file |
| `watchlist` | array of EVENT_IDs | `[]` | Specific NCEI EVENT_IDs (e.g. `["1234567"]`) |
| `states` | array of strings | `[]` | State name filter (case-insensitive, e.g. `["TEXAS"]`) |
| `event_types` | array of strings | `[]` | EVENT_TYPE filter (e.g. `["Tornado", "Hurricane (Typhoon)"]`) |
| `change_types` | array of strings | all eight | Subset of {damage_property, damage_crops, injuries_total, deaths_total, magnitude, tor_f_scale, narrative_landed, event_type_revised} |
| `snapshot_key` | string | `snapshot-<year>-latest` | Key-value-store key for previous snapshot |
| `details_url` | string | `""` | Explicit CSV URL override (skips listing-page resolution) |
| `rate_limit_rps` | int | 1 | Polite RPS for listing page + CSV fetch |

Realistic example input (Tornado Alley severe-season basket):

```json
{
  "event_types": ["Tornado"],
  "states": ["TEXAS", "OKLAHOMA", "KANSAS", "NEBRASKA", "IOWA"],
  "change_types": ["damage_property", "tor_f_scale", "deaths_total", "narrative_landed"],
  "year": 2026
}
````

### Output

JSONL dataset; one record per detected change:

```json
{
  "actor": "actor-4-noaa-storm-events-diff",
  "schema_version": "1.0.0",
  "extracted_at": "2026-05-22T12:00:00Z",
  "source_url": "https://www.ncei.noaa.gov/stormevents/listevents.jsp?eventType=ALL&eventId=1234567",
  "event_id": "1234567",
  "episode_id": "200001",
  "state": "Texas",
  "event_type": "Tornado",
  "begin_date": "10-MAY-26 17:32:00",
  "change_type": "tor_f_scale",
  "before": {"scale": "EFU"},
  "after":  {"scale": "EF2"},
  "detected_at": "2026-05-22T12:00:00Z"
}
```

Apify Console preview shows a 7-column table view (event ID /
state / event type / begin date / change type / detected at /
source URL) so non-engineers can sanity-check runs before piping
into BI.

### Pricing & limits

- **$0.02 per result** (per detected diff record).
- **Free 7-day trial** so you can verify the diff fidelity against
  your own EVENT\_ID watchlist before committing.
- **Recommended schedule:** daily during US severe-weather season
  (April–November); weekly off-season for older-year retroactive
  re-publishes.
- **Estimated monthly cost:**
  - Low-end research user (~30 EVENT\_IDs, weekly cadence): **$0.50–$1/mo**
  - Mid-market loss-reserve audit (~200 events, daily cadence): **$90–540/mo**
  - Re-insurance cat-bond desk (~2,000 events, daily cadence): **$360–2,700/mo**
  - Replaces CoreLogic Hazard HQ ($25k/yr) and Verisk AIR Worldwide
    ($50k+/yr) at substantially lower cost with full per-event diff
    fidelity rather than monthly aggregate tables.

### Data source & freshness

- **Source:** NOAA NCEI Storm Events Database public bulk CSV feed
  (`StormEvents_details-ftp_v1.0_dYYYY_cYYYYMMDD.csv.gz` files at
  <https://www.ncei.noaa.gov/pub/data/swdi/stormevents/csvfiles/>).
- **Update cadence (source-side):** NCEI re-publishes the current
  year's file roughly every 2–4 weeks during severe-weather
  season as NWS field offices submit damage surveys, narrative
  finalizations, and F-scale upgrades. Older years (5+ years
  back) re-publish 1–2× per year on methodology updates.
- **Actor cadence (recommended):** Daily 06:00 UTC during severe
  season; weekly off-season. The actor compares against the
  previous snapshot — running more often than NCEI re-publishes
  is harmless but emits zero records.
- **Public-domain license:** NOAA NCEI Storm Events Database is
  US government public-domain under 17 USC §105 (no copyright on
  government works). NCEI imposes no programmatic-redistribution
  restriction. Actor self-limits to a polite 1-rps default.

### FAQ

#### What's the difference between the NOAA Storm Events Database and the NWS Storm Prediction Center API?

The **Storm Events Database** is NCEI's authoritative
post-event archive — every confirmed severe-weather event
with finalized damage / fatality / F-scale data. The **SPC API**
emits forecast/preliminary products (convective outlooks, watches,
tornado-warning polygons) in near-real-time. This actor consumes
the post-event archive, not the forecast feed. For real-time
warning ingestion, use a separate watch-and-warning actor or
the official NWS API.

#### How does this compare to the NCEI Search API?

The NCEI Search API (`ncei.noaa.gov/cdo-web/api/v2/`) returns
metadata records, not bulk event detail rows. The bulk CSV
feed this actor consumes carries the full ~50-column event
record including `DAMAGE_PROPERTY` / `DAMAGE_CROPS` /
`NARRATIVE_*` fields the Search API does not expose. Use the
Search API to discover event IDs by station / location / date
range; use this actor to track diffs over time.

#### What's an NCEI publish-stamp and why does it matter?

NCEI's filename embeds a `cYYYYMMDD` stamp marking the publish
date. When NCEI re-publishes a year's file, the stamp changes
and the filename is the only signal that the underlying data
shifted. The actor records the chosen stamp in its run summary
so buyers can correlate diff records with publish events
end-to-end.

#### How is `DAMAGE_PROPERTY` formatted?

NCEI uses a `1.50K` / `200M` / `2.5B` shorthand encoding
(K=thousand, M=million, B=billion). The actor's
`parse_damage()` normalizes to integer dollars but preserves
the raw cell so buyers see what NCEI actually wrote. A diff
record's `before` / `after` blocks carry both the parsed
integer and the raw shorthand.

#### What's the F-scale finalization workflow?

NWS uses `EFU` (unrated) for tornado preliminary values that
will later be upgraded to `EF0`–`EF5` after a damage survey
team visits the path. The actor's `tor_f_scale` change-type
catches this finalization event. Mean preliminary→final lag
is about 14 days; P90 is roughly 47 days.

#### Does this cover storm-event sub-tables (locations, fatalities)?

No — v1 covers only the main `details` table (one row per
event). The companion `StormEvents_locations-*.csv.gz` (per-
location lat/lon detail) and `StormEvents_fatalities-*.csv.gz`
(per-fatality age/sex breakdowns) are NOT joined here. Buyers
who need those should request a v2 follow-up actor — open a
GitHub issue or email and we'll prioritize.

#### What about events NCEI drops on re-publish?

NCEI does occasionally drop events when re-publishing (most
commonly duplicate CWA reports). v1 does NOT emit those as
diff records; a `retracted` change\_type is on the v2 roadmap
if buyers ask. Run-summary line counts surface the implicit
retraction count if you need to flag it manually.

#### Can I run multiple independent watchlists from one Apify account?

Yes. Each watchlist gets its own `snapshot_key` value. The
actor reads/writes the previous snapshot from `snapshot_key`
in your Apify Key-Value Store, so a "Tornado Alley" run and a
"Hurricane corridor" run from the same account don't trample
each other.

#### Is older-year coverage sparse?

Pre-1996 coverage has fewer columns populated. The parser
tolerates missing columns and emits empty dicts where the
NCEI source itself has nothing to diff. Buyers tracking
methodology-update re-publishes on older years should expect
fewer change records but cleaner signal.

#### Is there a rate-limit risk?

The actor self-limits to roughly 1 req/s and respects standard
NCEI politeness conventions. We've never hit a rate limit at
typical filter sizes. The bulk CSV is a single GET; the bulk
of runtime is local CSV parsing, not network.

### Companion actors in this portfolio

`changewire` maintains a portfolio of federal-data diff actors. All
share the same daily-snapshot + JSONL change-record pattern, watchlist
filtering, and per-record change-type semantics. Pick the data domain
you need; mix and match across a single Apify account:

- [`changewire/clinicaltrials-protocol-diff`](https://apify.com/changewire/clinicaltrials-protocol-diff) — NIH-registered trial protocol diffs.
- [`changewire/grantsgov-opportunity-alert`](https://apify.com/changewire/grantsgov-opportunity-alert) — Daily diff of federal grant opportunities (status, deadline, award amount, eligibility).
- [`changewire/fda-orange-book-extraction`](https://apify.com/changewire/fda-orange-book-extraction) — FDA Orange Book pharmaceutical applications + patent listings, daily diff. *(currently hard-blocked at the Akamai WAF; awaiting routing fix)*
- [`changewire/uspto-ttab-docket-extractor`](https://apify.com/changewire/uspto-ttab-docket-extractor) — USPTO TTAB trademark docket records + filings + parties + deadlines.
- [`changewire/epa-echo-compliance`](https://apify.com/changewire/epa-echo-compliance) — EPA ECHO facility compliance status + violations + enforcement cases.
- [`changewire/samgov-contracts-diff`](https://apify.com/changewire/samgov-contracts-diff) — SAM.gov federal contract opportunities, daily diff. *(currently hard-blocked on identity-tied SAM.gov API key; awaiting user-machine key generation)*

### Running locally (for contributors)

```bash
cd actors/actor-4-noaa-storm-events-diff
apify run --purge  ## uses .actor/input_schema.json defaults
```

State-scoped run:

```bash
apify run --input '{"states": ["OKLAHOMA", "KANSAS"], "year": 2025}'
```

Event-type run:

```bash
apify run --input '{"event_types": ["Tornado", "Hurricane (Typhoon)"]}'
```

### Legal

NOAA NCEI Storm Events Database is US government public-domain
(17 USC §105 — no copyright on government works) with no NCEI
ToS restriction on programmatic redistribution. Actor obeys a
polite 1-rps default. No PII in output (NCEI itself redacts
narrative fields below privacy thresholds before publication).

# Actor input Schema

## `year` (type: `integer`):

Calendar year of the Storm Events details file to diff. Defaults to the current UTC year.

## `watchlist` (type: `array`):

Specific NCEI EVENT\_IDs to track. If empty, falls through to states + event\_types filters; if all three are empty, the actor processes the full year.

## `states` (type: `array`):

State-name filter, case-insensitive (e.g. TEXAS, FLORIDA, OKLAHOMA).

## `event_types` (type: `array`):

EVENT\_TYPE filter, case-insensitive (e.g. Tornado, Flash Flood, Hurricane (Typhoon), Wildfire).

## `change_types` (type: `array`):

Subset of: damage\_property, damage\_crops, injuries\_total, deaths\_total, magnitude, tor\_f\_scale, narrative\_landed, event\_type\_revised.

## `snapshot_key` (type: `string`):

Key-value store key holding the previous snapshot. Default: 'snapshot-<year>-latest'.

## `details_url` (type: `string`):

Explicit https://www.ncei.noaa.gov/...StormEvents\_details-...csv.gz URL. If empty, the actor scrapes the access/ directory listing to auto-discover the most recent re-publish for the requested year.

## `rate_limit_rps` (type: `integer`):

NCEI does not publish an RPS limit. We default to 1 rps as polite-default.

## Actor input object example

```json
{
  "year": 2025,
  "watchlist": [],
  "states": [],
  "event_types": [],
  "change_types": [
    "damage_property",
    "damage_crops",
    "injuries_total",
    "deaths_total",
    "magnitude",
    "tor_f_scale",
    "narrative_landed",
    "event_type_revised"
  ],
  "snapshot_key": "",
  "details_url": "",
  "rate_limit_rps": 1
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("changewire/noaa-storm-events-diff").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("changewire/noaa-storm-events-diff").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 '{}' |
apify call changewire/noaa-storm-events-diff --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=changewire/noaa-storm-events-diff",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NOAA Storm Events Diff API — Damage Revisions for Cat Modeling",
        "description": "Daily diff feed for the NOAA NCEI Storm Events Database. Emits JSONL records for every change to property/crop damage, injuries, deaths, magnitude, F-scale, or event-type revision. Replaces $25-50k/yr cat-modeling subs (CoreLogic, Verisk AIR) at $3-540/mo. For cat-bond underwriters, P&C actuaries.",
        "version": "0.1",
        "x-build-id": "hH58UIMRTflI9mnqa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/changewire~noaa-storm-events-diff/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-changewire-noaa-storm-events-diff",
                "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/changewire~noaa-storm-events-diff/runs": {
            "post": {
                "operationId": "runs-sync-changewire-noaa-storm-events-diff",
                "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/changewire~noaa-storm-events-diff/run-sync": {
            "post": {
                "operationId": "run-sync-changewire-noaa-storm-events-diff",
                "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",
                "properties": {
                    "year": {
                        "title": "Year",
                        "minimum": 1950,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Calendar year of the Storm Events details file to diff. Defaults to the current UTC year.",
                        "default": 2025
                    },
                    "watchlist": {
                        "title": "Watchlist (Event IDs)",
                        "type": "array",
                        "description": "Specific NCEI EVENT_IDs to track. If empty, falls through to states + event_types filters; if all three are empty, the actor processes the full year.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "State-name filter, case-insensitive (e.g. TEXAS, FLORIDA, OKLAHOMA).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "event_types": {
                        "title": "Event types",
                        "type": "array",
                        "description": "EVENT_TYPE filter, case-insensitive (e.g. Tornado, Flash Flood, Hurricane (Typhoon), Wildfire).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "change_types": {
                        "title": "Change types to emit",
                        "type": "array",
                        "description": "Subset of: damage_property, damage_crops, injuries_total, deaths_total, magnitude, tor_f_scale, narrative_landed, event_type_revised.",
                        "default": [
                            "damage_property",
                            "damage_crops",
                            "injuries_total",
                            "deaths_total",
                            "magnitude",
                            "tor_f_scale",
                            "narrative_landed",
                            "event_type_revised"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "snapshot_key": {
                        "title": "Snapshot key",
                        "type": "string",
                        "description": "Key-value store key holding the previous snapshot. Default: 'snapshot-<year>-latest'.",
                        "default": ""
                    },
                    "details_url": {
                        "title": "Details CSV URL override",
                        "type": "string",
                        "description": "Explicit https://www.ncei.noaa.gov/...StormEvents_details-...csv.gz URL. If empty, the actor scrapes the access/ directory listing to auto-discover the most recent re-publish for the requested year.",
                        "default": ""
                    },
                    "rate_limit_rps": {
                        "title": "Polite rate limit (requests per second)",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "NCEI does not publish an RPS limit. We default to 1 rps as polite-default.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
