# NOAA Storm Events Peril Climatology — County Risk Scores (`malonestar/noaa-storm-events-peril-climatology`) Actor

County-level severe-weather climatology from NOAA's Storm Events Database. For any US county or state and year range, get per-peril event frequency, casualties, and property/crop damage, plus a composite peril risk score. Built for P\&C underwriting, reinsurance, and catastrophe siting. Keyless.

- **URL**: https://apify.com/malonestar/noaa-storm-events-peril-climatology.md
- **Developed by:** [Kyle Maloney](https://apify.com/malonestar) (community)
- **Categories:** Agents, Developer tools, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.40 / 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Peril Climatology — County Risk Scores

Turn 25+ years of the **NOAA / NCEI Storm Events Database** into a clean, per-county **severe-weather climatology**. For any US state (and optional county filter) over a chosen year range, this actor aggregates every recorded storm event into **one row per (county × peril type)** with event frequency, casualties, property/crop damage, and a composite **peril risk score**.

Keyless. Public-domain NOAA data. No scraping of a UI — it reads NOAA's official bulk `csv.gz` files directly.

### Who it's for

- **P&C insurance underwriters** — pull hail / wind / flood / tornado frequency and loss history for a book of counties before quoting.
- **Reinsurers & cat modelers** — build a fast county-level peril baseline to sanity-check vendor cat models.
- **Roofing, restoration & storm-chasing lead-gen** — rank counties by hail and wind-storm frequency and recent worst years.
- **CRE & site-selection / catastrophe risk teams** — screen candidate sites for the perils that actually hit that county.

### What it does (the transform)

NOAA publishes ~60,000 raw storm events per year nationally. This actor:
1. Resolves and downloads NOAA's official yearly `StormEvents_details` bulk files (gunzipped in-memory).
2. Filters to your states/counties/perils and year range.
3. Rolls events up into a stable **(county × peril)** climatology row and sorts by peril score.

### Example input

```json
{
  "states": ["Colorado"],
  "startYear": 2023,
  "endYear": 2025,
  "eventTypes": ["Hail", "Tornado", "Flash Flood"],
  "includeZones": false,
  "maxResults": 2000
}
````

Leave `eventTypes` empty for all perils, add `counties: ["08031", "Denver"]` to narrow to specific counties (5-digit FIPS or a name substring), and set `includeZones: true` to also aggregate NWS forecast-zone events (many winter-weather and marine perils are logged by zone rather than county).

### Output fields

Each row is one **county × peril type**:

| Field | Meaning |
|---|---|
| `county_fips` | 5-digit state+county FIPS (`pad2(STATE_FIPS)+pad3(CZ_FIPS)`) |
| `county_name`, `state`, `state_abbr` | County/zone name and state |
| `event_type` | The peril (Hail, Tornado, Flash Flood, Thunderstorm Wind, ...) |
| `years_covered`, `n_years` | Year range label and count of years that had data |
| `event_count`, `events_per_year` | Total events and annualized frequency |
| `deaths`, `injuries`, `casualties` | Direct+indirect human impact |
| `property_damage_usd`, `crop_damage_usd`, `total_damage_usd` | Reported damage in USD (K/M/B/T expanded) |
| `damage_per_year_usd` | Annualized total damage |
| `worst_year` | Year with the highest total damage for this county × peril |
| `peril_score` | Composite 0–100 peril risk score (see below) |
| `source_files`, `source_url` | Exact NOAA files used |

#### About `peril_score` (editorial model)

`peril_score` is a **transparent editorial composite (0–100)**, not an actuarial loss number. It blends three saturating, log-scaled components:

- **Annualized frequency** — weight 40%, saturates at 50 events/year
- **Casualties** — weight 25%, saturates at 1,000
- **Total damage** — weight 35%, log-scaled, saturates at $1B

Use it to **triage and rank** counties/perils; use the underlying raw fields (`events_per_year`, `total_damage_usd`, `casualties`) for anything quantitative.

### Use as an MCP tool

This actor is a clean, chainable tool for AI agents via [mcp.apify.com](https://mcp.apify.com). Every input and output field is self-describing, so an agent (Claude, Cursor, etc.) can call it to answer questions like "how often does Denver County get damaging hail, and what was the worst year?" and feed the structured result into an underwriting or siting workflow.

### FAQ

**How do I get hail frequency by county?** Set `states` to your state(s), `eventTypes` to `["Hail"]`, pick a year range, and read `events_per_year` and `total_damage_usd` per county.

**What's the data source?** The NOAA / NCEI **Storm Events Database** (public domain), read from the official bulk `csvfiles` directory at `ncei.noaa.gov`. No API key required.

**How far back does it go?** NOAA Storm Events data is available from **1996** onward. Set `startYear` accordingly.

**County vs. forecast zone?** By default only county events (`CZ_TYPE="C"`) are aggregated. Enable `includeZones` to also include NWS forecast-zone events (`CZ_TYPE="Z"`).

**Is the peril score an insurance loss estimate?** No — it's an editorial relative-risk heuristic for ranking. Use the raw frequency/damage/casualty fields for quantitative work.

**How is it billed?** Pay-per-result: one event per output row (one county × peril climatology record).

# Actor input Schema

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

US states to profile, as 2-letter postal codes or full names (e.g. "CO" or "Colorado"). At least one is required for the run to return data; if empty the actor exits with zero results.

## `counties` (type: `array`):

Optional. Narrows the States above to specific counties. Each entry is either a 5-digit county FIPS (e.g. "08031") or a bare county name matched case-insensitively as a substring (e.g. "Denver"). Leave empty for all counties in the selected states.

## `startYear` (type: `integer`):

First calendar year of NOAA Storm Events data to include (inclusive). Data is available from 1996 onward.

## `endYear` (type: `integer`):

Last calendar year of NOAA Storm Events data to include (inclusive). The most recent year is partial and updated by NCEI throughout the year.

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

Optional peril filter. Keep only these NOAA event types (case-insensitive exact match), e.g. \["Hail","Tornado","Flash Flood","Thunderstorm Wind"]. Leave empty to include every peril type.

## `includeZones` (type: `boolean`):

By default only county-based events (CZ\_TYPE="C") are aggregated. Enable to also include forecast-zone events (CZ\_TYPE="Z", e.g. many winter-weather and marine perils are recorded by NWS zone rather than county).

## `maxResults` (type: `integer`):

Maximum number of output rows returned (each is one billed result). One row = one (county x peril type) climatology record, sorted by peril score descending.

## Actor input object example

```json
{
  "states": [
    "Colorado"
  ],
  "startYear": 2023,
  "endYear": 2025,
  "includeZones": false,
  "maxResults": 2000
}
```

# Actor output Schema

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

The default dataset.

# 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 = {
    "states": [
        "Colorado"
    ],
    "startYear": 2023,
    "endYear": 2025,
    "maxResults": 2000
};

// Run the Actor and wait for it to finish
const run = await client.actor("malonestar/noaa-storm-events-peril-climatology").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 = {
    "states": ["Colorado"],
    "startYear": 2023,
    "endYear": 2025,
    "maxResults": 2000,
}

# Run the Actor and wait for it to finish
run = client.actor("malonestar/noaa-storm-events-peril-climatology").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 '{
  "states": [
    "Colorado"
  ],
  "startYear": 2023,
  "endYear": 2025,
  "maxResults": 2000
}' |
apify call malonestar/noaa-storm-events-peril-climatology --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NOAA Storm Events Peril Climatology — County Risk Scores",
        "description": "County-level severe-weather climatology from NOAA's Storm Events Database. For any US county or state and year range, get per-peril event frequency, casualties, and property/crop damage, plus a composite peril risk score. Built for P&C underwriting, reinsurance, and catastrophe siting. Keyless.",
        "version": "1.0",
        "x-build-id": "p2FjLQ8SQZFsNepAZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/malonestar~noaa-storm-events-peril-climatology/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-malonestar-noaa-storm-events-peril-climatology",
                "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/malonestar~noaa-storm-events-peril-climatology/runs": {
            "post": {
                "operationId": "runs-sync-malonestar-noaa-storm-events-peril-climatology",
                "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/malonestar~noaa-storm-events-peril-climatology/run-sync": {
            "post": {
                "operationId": "run-sync-malonestar-noaa-storm-events-peril-climatology",
                "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": {
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "US states to profile, as 2-letter postal codes or full names (e.g. \"CO\" or \"Colorado\"). At least one is required for the run to return data; if empty the actor exits with zero results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "counties": {
                        "title": "Counties (optional filter)",
                        "type": "array",
                        "description": "Optional. Narrows the States above to specific counties. Each entry is either a 5-digit county FIPS (e.g. \"08031\") or a bare county name matched case-insensitively as a substring (e.g. \"Denver\"). Leave empty for all counties in the selected states.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startYear": {
                        "title": "Start year",
                        "minimum": 1996,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "First calendar year of NOAA Storm Events data to include (inclusive). Data is available from 1996 onward.",
                        "default": 2023
                    },
                    "endYear": {
                        "title": "End year",
                        "minimum": 1996,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "Last calendar year of NOAA Storm Events data to include (inclusive). The most recent year is partial and updated by NCEI throughout the year.",
                        "default": 2025
                    },
                    "eventTypes": {
                        "title": "Event types (optional filter)",
                        "type": "array",
                        "description": "Optional peril filter. Keep only these NOAA event types (case-insensitive exact match), e.g. [\"Hail\",\"Tornado\",\"Flash Flood\",\"Thunderstorm Wind\"]. Leave empty to include every peril type.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeZones": {
                        "title": "Include forecast zones",
                        "type": "boolean",
                        "description": "By default only county-based events (CZ_TYPE=\"C\") are aggregated. Enable to also include forecast-zone events (CZ_TYPE=\"Z\", e.g. many winter-weather and marine perils are recorded by NWS zone rather than county).",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum number of output rows returned (each is one billed result). One row = one (county x peril type) climatology record, sorted by peril score descending.",
                        "default": 2000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
