# NOAA Storm Events Database Scraper (`compute-edge/noaa-storm-events-scraper`) Actor

Historical storm events from NOAA (1950-present). Filter by year, event type (tornado, hail, flood, hurricane), state, and damage. Returns location, damages, casualties, and meteorology for risk modeling, insurance, and research.

- **URL**: https://apify.com/compute-edge/noaa-storm-events-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## NOAA Storm Events Database Scraper — Tornadoes, Hurricanes, Hail, Floods

Extract historical **storm event records** from NOAA's authoritative [Storm Events Database](https://www.ncdc.noaa.gov/stormevents/) covering tornadoes, hurricanes, hail, floods, blizzards, wildfires, droughts, and other severe weather events from **1950 to the present**. Filter by year, event type, US state, and minimum property damage. Records include geographic coordinates, casualties, damage estimates, meteorological details, and narrative descriptions.

This is the **canonical US severe weather dataset** maintained by NOAA's National Centers for Environmental Information (NCEI). Originally compiled by the National Weather Service, the Storm Events Database contains over 1.8 million observations of significant weather and is the dataset of record for the insurance, reinsurance, climate-risk, and emergency-management industries.

### Features

- **Full year coverage**: Any year from 1950 to present, fetched directly from NCEI's pub-data CSV archive
- **Streaming gzip decompression**: Handles multi-hundred-MB years (e.g., 2011's Joplin/tornado-super-outbreak year) without OOM
- **Damage parsing**: Converts NOAA's encoded values like `5.00K`, `12.50M`, `1.50B` into raw USD numbers (`damagePropertyUSD`)
- **Event-type filter**: Case-insensitive partial match against `EVENT_TYPE` — e.g. "Tornado", "Hail", "Tropical Storm", "Excessive Heat"
- **State filter**: Exact match against `STATE`
- **Damage threshold**: Skip events below a configurable property-damage minimum
- **Geographic precision**: `BEGIN_LAT/LON` and `END_LAT/LON` parsed into floats for GIS pipelines
- **Casualty data**: Direct and indirect injuries / deaths per event
- **Narratives**: Full event and episode narrative text included — perfect for RAG pipelines and LLM-driven claim assessment

#### Output Fields

| Field | Description |
|------|------|
| `eventId` | NOAA event identifier |
| `beginDateTime` / `endDateTime` | Event start and end timestamps |
| `state` / `stateFips` | US state name and FIPS code |
| `year` / `month` | Year and month name |
| `eventType` | Tornado, Hail, Flash Flood, Hurricane, etc. |
| `czType` / `czName` | County/zone type and name |
| `beginLat` / `beginLon` / `endLat` / `endLon` | Geographic coordinates |
| `injuriesDirect` / `injuriesIndirect` | Casualty counts |
| `deathsDirect` / `deathsIndirect` | Fatality counts |
| `damageProperty` / `damagePropertyUSD` | Raw string + parsed USD |
| `damageCrops` / `damageCropsUSD` | Crop damage raw + parsed |
| `magnitude` / `magnitudeType` | Wind speed / hail size / etc. |
| `tornadoFScale` | EF-scale rating (EF0–EF5) |
| `source` | Reporting source (NWS, public, etc.) |
| `eventNarrative` / `episodeNarrative` | Full text narratives |

### How to Scrape NOAA Storm Events

1. Open the actor and click **Try for free**
2. Set `year` to the year you want (e.g., `2024`)
3. Optional: filter by `eventTypeFilter` (e.g., `Tornado`), `stateFilter` (e.g., `TEXAS`), or `minDamageProperty` (e.g., `1000000`)
4. Click **Start** — the actor will stream the year's gzipped CSV directly from NCEI, parse it, apply your filters, and push results to the dataset

### Pricing

This actor charges **$0.003 per result**. A typical year contains 60,000–80,000 events; with filters you typically pay for a few hundred to a few thousand. Apify compute costs are separate (the actor uses streaming so memory stays at 512MB regardless of year size).

### Input Example

```json
{
  "year": 2024,
  "eventTypeFilter": "Tornado",
  "stateFilter": "TEXAS",
  "minDamageProperty": 100000,
  "maxResults": 5000
}
````

### Output Example

```json
{
  "eventId": "1234567",
  "beginDateTime": "06-MAY-24 14:23:00",
  "state": "TEXAS",
  "eventType": "Tornado",
  "czName": "JOHNSON",
  "beginLat": 32.4156,
  "beginLon": -97.2873,
  "tornadoFScale": "EF2",
  "damagePropertyUSD": 2500000,
  "injuriesDirect": 3,
  "deathsDirect": 0,
  "eventNarrative": "A tornado touched down southwest of Cleburne..."
}
```

### Other Actors You May Like

- **NOAA Weather Alerts** — live NWS alerts
- **FEMA Disasters Scraper** — federal disaster declarations
- **NOAA NCEI Climate Scraper** — climate normals and observations

### FAQ

**Q: How current is the data?**
A: NCEI updates the database monthly. The most recent month may not yet be available.

**Q: Why do some events have $0 damage?**
A: NOAA records many events for which damage was not reported or assessed.

**Q: Can I filter by multiple event types?**
A: Currently the filter is a single partial match; run the actor multiple times for distinct types.

### Legal Disclaimer

Data is sourced from NOAA NCEI's public Storm Events Database, a US government work in the public domain. This actor extracts only publicly accessible, non-personal data and is intended for research, journalism, climate risk modeling, and insurance/actuarial use. Users are responsible for compliance with their local laws and any downstream-use obligations.

# Actor input Schema

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

Which year of storm events to download (1950–2025). Default: 2024.

## `eventTypeFilter` (type: `string`):

Filter on EVENT\_TYPE column (case-insensitive partial match). Examples: 'Tornado', 'Hail', 'Flood', 'Hurricane'. Leave empty for all types.

## `stateFilter` (type: `string`):

Filter on STATE column (case-insensitive exact match). Examples: 'TEXAS', 'FLORIDA', 'CALIFORNIA'. Leave empty for all states.

## `minDamageProperty` (type: `number`):

Minimum DAMAGE\_PROPERTY value in USD. Examples: 0, 1000, 50000, 1000000. Default: 0 (no filter).

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

Maximum number of storm event records to return. Set to 10000 for ~30 seconds per 100 events.

## Actor input object example

```json
{
  "year": 2024,
  "eventTypeFilter": "",
  "stateFilter": "",
  "minDamageProperty": 0,
  "maxResults": 10000
}
```

# Actor output Schema

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NOAA Storm Events Database Scraper",
        "description": "Historical storm events from NOAA (1950-present). Filter by year, event type (tornado, hail, flood, hurricane), state, and damage. Returns location, damages, casualties, and meteorology for risk modeling, insurance, and research.",
        "version": "0.1",
        "x-build-id": "8FtS4i8Q93SpQdlgw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~noaa-storm-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-noaa-storm-events-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/compute-edge~noaa-storm-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-noaa-storm-events-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/compute-edge~noaa-storm-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-noaa-storm-events-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",
                "properties": {
                    "year": {
                        "title": "Year",
                        "minimum": 1950,
                        "maximum": 2025,
                        "type": "integer",
                        "description": "Which year of storm events to download (1950–2025). Default: 2024.",
                        "default": 2024
                    },
                    "eventTypeFilter": {
                        "title": "Event Type Filter",
                        "type": "string",
                        "description": "Filter on EVENT_TYPE column (case-insensitive partial match). Examples: 'Tornado', 'Hail', 'Flood', 'Hurricane'. Leave empty for all types.",
                        "default": ""
                    },
                    "stateFilter": {
                        "title": "State Filter",
                        "type": "string",
                        "description": "Filter on STATE column (case-insensitive exact match). Examples: 'TEXAS', 'FLORIDA', 'CALIFORNIA'. Leave empty for all states.",
                        "default": ""
                    },
                    "minDamageProperty": {
                        "title": "Minimum Damage Property (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Minimum DAMAGE_PROPERTY value in USD. Examples: 0, 1000, 50000, 1000000. Default: 0 (no filter).",
                        "default": 0
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of storm event records to return. Set to 10000 for ~30 seconds per 100 events.",
                        "default": 10000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```