# US Storm Reports API: Hail, Wind & Tornado (NWS) (`japan-open-data/us-storm-reports-live`) Actor

Get U.S. hail, wind, tornado and flood reports from official NWS Local Storm Reports within hours (last 7 days): time, hail size or wind speed, lat/lon, county. Filter by state or radius for roofing storm leads, insurance and AI agents. No API key; JSON/CSV, API or MCP; $3 per 1,000.

- **URL**: https://apify.com/japan-open-data/us-storm-reports-live.md
- **Developed by:** [Japan Open Data](https://apify.com/japan-open-data) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 storm report rows

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## US Storm Reports API: Hail, Wind & Tornado Reports from the NWS (Last 7 Days)

**Get the latest U.S. hail, wind, tornado and flood reports from the National Weather Service as clean JSON, one row per report, within hours of the storm.** Each row has time, event type, hail size or wind speed, latitude/longitude, county, state and report source, taken from the NWS's preliminary Local Storm Reports (LSR); filter by state, point and radius, event type or minimum size. Last 7 days, no API key, no login.

- **Storm reports within hours, not months.** NWS offices publish Local Storm Reports during and right after a storm, from trained spotters, emergency managers, law enforcement, mesonet stations and the public. This Actor reads them straight from the official NWS API (api.weather.gov).
- **Every storm type in one flat table:** hail (inches), thunderstorm wind gusts (mph or knots) and wind damage, tornadoes, funnel clouds, floods and flash floods, heavy rain, snow and ice.
- **Search where it matters:** by state (`["TX", "OK"]`), or around your office, a customer or a property with `latitude`, `longitude` and `radiusMiles` — each row then shows its distance in miles.
- **Clean, de-duplicated rows.** Corrected and summary NWS products repeat earlier reports; each report is returned once, in its newest version.
- **Pay only for reports found.** "Nothing found" and error rows are free.

### What can you do with US Storm Reports?

1. **Roofing, siding and restoration contractors — storm leads the next morning.** Run it after a storm night to see where 1"+ hail or 60+ mph winds and tree damage were reported, which counties and towns were hit, and how far they are from your office. Schedule it daily and send the rows to Google Sheets, a CRM or Slack.
2. **Insurance, adjusters and claims teams — early loss triage.** See which counties had hail, wind damage, tornadoes or flash floods in the last few days, before official damage surveys and the NOAA Storm Events Database are published (that takes months). Use `productUrl` to open the original NWS report.
3. **Utilities, logistics, property managers and AI agents — "what happened near me?"** Check storm reports around sites, warehouses, routes or rental properties. An AI agent can answer "Was there hail or wind damage within 25 miles of Denver in the last 48 hours?" with one call.

Need **hail history for past years** at a specific address instead of the last 7 days? Use [US Hail History by Location](https://apify.com/japan-open-data/us-hail-history) (radar-based hail days back to 1995). The two Actors work well together: this one tells you where storms hit this week, US Hail History tells you how often a place was hit before.

### How to use

1. Click **Start** with the default input: you get the 50 newest hail and wind reports in the U.S. from the last 72 hours.
2. Narrow it down: set `states`, or a point (`latitude`, `longitude`) and `radiusMiles`.
3. Pick `eventTypes` (e.g. only `hail`) and minimum sizes (e.g. `minHailInches: 1`, `minWindMph: 58`).
4. Download the results as JSON, CSV or Excel, or call the Actor from the API / MCP (see below).
5. For daily storm leads, create a **Schedule** in Apify Console (e.g. every morning at 7:00 with `hoursBack: 24`).

### Input

Nothing is required. Every field has a default.

| Input | Type | Default | What it does |
|---|---|---|---|
| `states` | list of 2-letter codes | all states | e.g. `["TX", "OK", "KS"]` |
| `latitude`, `longitude` | number | none | Center of a search circle in decimal degrees (U.S. longitudes are negative) |
| `radiusMiles` | number | `50` | Radius around the point, 1–500 miles |
| `eventTypes` | list | `["hail", "wind"]` | `hail`, `wind`, `tornado`, `flood`, `rain`, `winter`, `other`; empty list = all |
| `hoursBack` | integer | `72` | How far back to look, 1–168 hours (7 days) |
| `minHailInches` | number | `0` | e.g. `1` (quarter size) or `1.75` (golf ball) |
| `minWindMph` | number | `0` | e.g. `58` (severe); when set, wind damage reports without a speed are left out |
| `maxResults` | integer | `50` | Newest reports first, 1–5000 |

#### Input example

Hail of 1 inch or larger within 250 miles of Denver, CO, in the last 7 days:

```json
{
  "latitude": 39.7392,
  "longitude": -104.9903,
  "radiusMiles": 250,
  "eventTypes": ["hail"],
  "minHailInches": 1,
  "hoursBack": 168,
  "maxResults": 5
}
```

### Output

One row per storm report, newest first. Every row has `status` (`ok`, `not_found` or `error`).

#### Output example

Real output from the input above (cloud run on 2026-09-19, 3 reports found). The first row:

```json
{
  "status": "ok",
  "eventTime": "2026-09-18T23:45:00Z",
  "eventTimeLocal": "2026-09-18T17:45:00-06:00",
  "eventType": "Hail",
  "eventCategory": "hail",
  "eventCode": "Hail",
  "magnitude": 1,
  "magnitudeUnit": "inch",
  "magnitudeQualifier": "measured",
  "latitude": 40.31,
  "longitude": -108.65,
  "location": "6 NNW Massadona",
  "county": "Moffat",
  "state": "CO",
  "source": "Cocorahs",
  "remarks": "Maximum hail size 1.00 inch, average hail size 0.50 inch.",
  "distanceMiles": 197.59,
  "wfo": "GJT",
  "productId": "29077392-94f0-4958-b65f-cf9a0dd07594",
  "productUrl": "https://api.weather.gov/products/29077392-94f0-4958-b65f-cf9a0dd07594",
  "issuedAt": "2026-09-19T00:35:00Z",
  "dataSource": "NOAA National Weather Service, preliminary Local Storm Reports (api.weather.gov); public domain; not affiliated with or endorsed by NOAA/NWS"
}
```

All 3 rows of that run:

| Event time (local) | Type | Size | Place | County, state | Source | Distance |
|---|---|---|---|---|---|---|
| 2026-09-18 17:45 MDT | Hail | 1.0 in (measured) | 6 NNW Massadona | Moffat, CO | Cocorahs | 197.6 mi |
| 2026-09-18 16:30 MDT | Hail | 1.0 in (measured) | Dinosaur | Moffat, CO | Cocorahs | 215.6 mi |
| 2026-09-17 19:56 MDT | Hail | 1.5 in (measured) | 9 ESE Broadwater | Morrill, NE | Storm Chaser | 172.9 mi |

With the **default input** (all states, hail + wind, 72 hours), the same day's cloud run returned 50 rows (46 wind, 4 hail) from SC, WY, KS, CO, TN, NE, NC and KY, for example:

| Event time (UTC) | Type | Size | Place | County, state | Source | Remarks |
|---|---|---|---|---|---|---|
| 2026-09-19 02:40 | Thunderstorm Wind Damage | — | 7 NW Troy | Abbeville, SC | Law Enforcement | Tree in roadway on Highway 28 near intersection of Bethia Road. Time estimated. |
| 2026-09-19 01:59 | Thunderstorm Wind Gust | 62 mph (measured) | 2 SW Harrison | Sioux, NE | Public | Personal weather station. |
| 2026-09-19 01:47 | Thunderstorm Wind Gust | 60 mph (measured) | 2 E Torrington | Goshen, WY | ASOS | ASOS station KTOR Torrington Airport - Tor. |
| 2026-09-19 00:09 | Thunderstorm Wind Gust | 69 mph (measured) | 9 NNW Mcdonald | Cheyenne, KS | Public | — |
| 2026-09-18 23:23 | Thunderstorm Wind Damage | — | 7 S Wheeler | Cheyenne, KS | Emergency Mngr | EM reports several power poles snapped with lines in the road. … |
| 2026-09-18 22:30 | Hail | 1.0 in (measured) | Dinosaur | Moffat, CO | Cocorahs | Maximum hail size of 1.00 inch, did cause some damage to car roofs … |

When nothing matches, or the input is invalid, you get one **free** row that says what to change (real output):

```json
{
  "status": "not_found",
  "error": "No NWS Local Storm Reports matched (hail reports in the last 72 hours in HI hail at least 5 in); widen \"eventTypes\", \"hoursBack\" (max 168), the area or the minimum sizes.",
  "dataSource": "NOAA National Weather Service, preliminary Local Storm Reports (api.weather.gov); public domain; not affiliated with or endorsed by NOAA/NWS"
}
```

#### Output fields

| Field | Meaning |
|---|---|
| `status` | `ok`, `not_found` or `error` |
| `eventTime`, `eventTimeLocal` | When the event happened, in UTC and in the NWS office's local time |
| `eventType`, `eventCategory`, `eventCode` | Readable NWS event name (e.g. "Thunderstorm Wind Gust"), the filter category (`hail`, `wind`, `tornado`, `flood`, `rain`, `winter`, `other`) and the original NWS code (e.g. `Tstm Wnd Gst`) |
| `magnitude`, `magnitudeUnit`, `magnitudeQualifier` | Hail size (inch), wind speed (mph or knot), EF rating, rain/snow amount etc.; `measured` or `estimated`. Empty for damage reports without a number |
| `latitude`, `longitude`, `location`, `county`, `state` | Where it happened (NWS gives coordinates to 0.01°, about 1 km) |
| `source` | Type of reporter, e.g. "Trained Spotter", "Mesonet", "Law Enforcement", "Public" — never a person's name |
| `remarks` | NWS free-text remarks (see privacy note below) |
| `distanceMiles` | Distance from your point, when you search around a point |
| `wfo`, `productId`, `productUrl`, `issuedAt` | NWS office, and the original NWS product the report came from |
| `dataSource` | Source and license note |
| `error` | On `not_found` / `error` rows: one sentence explaining what to change |

### How much does it cost to get storm reports?

This Actor uses **Pay per event** pricing — you pay for storm reports returned, not for compute time.

| Event | Price | When |
|---|---|---|
| Storm report row (`result-row`) | **$0.003** per row ($3 per 1,000) | Each `ok` row = one storm report |
| Actor start (`apify-actor-start`) | **$0.001** per run | Once at the start of each run |

- `not_found` and `error` rows are **free**.
- Default run (50 newest U.S. hail and wind reports): about **$0.15**.
- "Hail near Denver this week" (the example above, 3 reports): about **$0.01**.
- A daily storm-lead check for one state, 30 reports a day: about **$0.09 per day, $2.80 per month** — no monthly subscription.
- 1,000 storm reports: **$3**.
- Set a **maximum cost per run** when you start the Actor to cap spending; if it is reached, the Actor stops cleanly and says so in the status message.

### Use via API / MCP (AI agents)

**Apify API (HTTP).** Run the Actor and get the rows in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/japan-open-data~us-storm-reports-live/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"states": ["TX", "OK"], "eventTypes": ["hail"], "minHailInches": 1, "hoursBack": 48}'
```

**Python (apify-client):**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("japan-open-data/us-storm-reports-live").call(run_input={
    "latitude": 32.7767, "longitude": -96.797, "radiusMiles": 50,
    "eventTypes": ["hail", "wind", "tornado"], "hoursBack": 24,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["status"], row.get("eventTime"), row.get("eventType"), row.get("magnitude"), row.get("location"), row.get("distanceMiles"))
```

**MCP (Claude, ChatGPT, Cursor and other AI agents).** Add this Actor as a tool through the Apify MCP server (https://mcp.apify.com), for example with `?tools=japan-open-data/us-storm-reports-live`. No field is required, so an agent can call it with `{}` or with just a state or a point.

Recommended agent settings:

- "Any hail near X recently?" → `{"latitude": <lat>, "longitude": <lon>, "radiusMiles": 25, "eventTypes": ["hail"], "hoursBack": 72}`.
- "Where was the damage last night in Texas?" → `{"states": ["TX"], "eventTypes": ["hail", "wind", "tornado"], "hoursBack": 24, "maxResults": 100}`.
- Damaging storms only → `minHailInches: 1` and `minWindMph: 58`.
- Keep `maxResults` small (10–50) for chat answers; each row is charged.
- Always check `status`; on `not_found` / `error` show the `error` sentence to the user. Tell users these are **preliminary** reports.
- For past years at one address, call [US Hail History by Location](https://apify.com/japan-open-data/us-hail-history) instead.

### FAQ

**How far back can I get storm reports?**
About 7 days (`hoursBack` up to 168). That is how long the NWS API keeps Local Storm Report products. For older hail data use [US Hail History by Location](https://apify.com/japan-open-data/us-hail-history); for older confirmed events of all types, NOAA's Storm Events Database is published months later.

**How fresh is the data?**
NWS offices issue Local Storm Reports during and shortly after storms, usually within minutes to a few hours. Each run reads the current NWS product list, so you get what has been published up to that moment.

**Are the reports official and final?**
They are official NWS products but **preliminary**: sizes, times and places can be corrected, and they are later quality-controlled for the Storm Events Database. When NWS issues a correction, this Actor returns the corrected version.

**Can I search by street address?**
Not directly. Convert the address to latitude/longitude first (for example with the free U.S. Census Bureau geocoder) and use `latitude`, `longitude` and `radiusMiles`.

**Is it legal to use this data commercially?**
Yes. Information from the NWS API is published as open data, free to use for any purpose, and NWS information is in the public domain. This Actor only reads the official API, identifies itself in the User-Agent and keeps its request count small.

### Known limitations

- **Last 7 days only** (see FAQ). This is not a historical archive.
- **Preliminary reports.** Not every storm is reported, and a missing report does not mean nothing happened.
- **Up to 400 NWS products per run.** Very wide searches (all states, all event types, 7 days) may stop before the oldest reports; the status message then says so. Narrow the area (`states` or a point + radius) to go further back.
- **Corrections.** Corrected reports are matched by NWS office, event category and place name; in rare cases where NWS also changes the place name, both versions may appear.
- **Remarks privacy filter.** `remarks` is left empty (null) when it contains something that looks like a street address, contact details, a personal weather station or radio ID (e.g. Ambient, WeatherLink, CWOP, call signs) or a person's name. This cautious filter drops roughly 3–4% of remarks, some of them harmless.
- **Coordinates are rounded by NWS** to 0.01° (about 1 km), and `location` is given as "distance + direction + town" (e.g. "7 NW Troy"), not a street address.

### Data source and license

- **Source:** NOAA National Weather Service API, Local Storm Report (LSR) products — https://api.weather.gov/products/types/LSR ([API documentation](https://www.weather.gov/documentation/services-web-api)).
- **License:** NWS information is in the public domain ([NWS disclaimer](https://www.weather.gov/disclaimer)). Every row includes `dataSource`, and `productUrl` links to the original NWS product.
- **Not affiliated:** this Actor is an independent project and is **not affiliated with, endorsed by or sponsored by NOAA or the National Weather Service**. It does not use NOAA or NWS logos. The data is reformatted (parsed, filtered, de-duplicated) and is not an official NWS publication.
- **No personal data:** `source` is a reporter type only, and remarks that look like personal information are removed (see above).

### More from Japan Open Data

- [US Hail History by Location](https://apify.com/japan-open-data/us-hail-history) — hail history for any U.S. latitude/longitude from NOAA NEXRAD radar, back to 1995: one row per hail day with max hail size and distance. **Use it for the long-term hail history of a place; use US Storm Reports for all storm types in the last 7 days.**
- [TSA Checkpoint Travel Numbers (Daily, Weekly & YoY)](https://apify.com/japan-open-data/tsa-checkpoint-throughput) — daily U.S. TSA airport checkpoint traveler counts as clean JSON, with weekly averages and year-over-year change.
- [Japan Postal Code & Address in English](https://apify.com/japan-open-data/japan-postal-code-english) — look up Japanese postal codes and addresses in English/romaji, kanji and kana, from Japan Post's official data.
- [Mexico Gas Prices API by Station (Official CNE)](https://apify.com/japan-open-data/mexico-fuel-station-prices) — today's regular, premium and diesel prices at every Mexican gas station from the official CNE feed, with coordinates and distance.

### Feedback

Found a wrong value, a missing report type, or need another filter (e.g. by county or NWS office)? Open an issue on the Actor's **Issues** tab with your input and what you expected. If the Actor is useful to you, a short review helps others find it.

# Actor input Schema

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

Two-letter U.S. state codes to keep, e.g. \["TX", "OK", "KS"]. Leave empty for all states.

## `latitude` (type: `number`):

Center of a search circle in decimal degrees, e.g. 35.4676 (Oklahoma City). Use together with longitude and radius; leave empty for no location filter.

## `longitude` (type: `number`):

Center of a search circle in decimal degrees; U.S. longitudes are negative, e.g. -97.5164.

## `radiusMiles` (type: `number`):

Only reports within this distance of the latitude/longitude are returned (1 to 500 miles). Ignored without a point.

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

Report categories to keep: hail, wind (thunderstorm and non-thunderstorm gusts and damage), tornado (tornado, funnel cloud, waterspout), flood (flood, flash flood, coastal flood), rain, winter (snow, ice, blizzard) or other. Empty = all.

## `hoursBack` (type: `integer`):

How far back to look, 1 to 168 hours (the NWS API keeps about 7 days of reports).

## `minHailInches` (type: `number`):

Keep only hail reports at least this large, e.g. 1 (quarter size) or 1.75 (golf ball). 0 = all hail reports.

## `minWindMph` (type: `number`):

Keep only wind reports with a reported speed of at least this many mph, e.g. 58 (severe). 0 = all wind reports, including damage reports without a speed.

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

Maximum number of report rows to return, newest first (1 to 5000).

## Actor input object example

```json
{
  "states": [],
  "radiusMiles": 50,
  "eventTypes": [
    "hail",
    "wind"
  ],
  "hoursBack": 72,
  "minHailInches": 0,
  "minWindMph": 0,
  "maxResults": 50
}
```

# Actor output Schema

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

Event time, type, hail size or wind speed, coordinates, county, state, source and remarks per report. Table view: overview.

# 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": [],
    "eventTypes": [
        "hail",
        "wind"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("japan-open-data/us-storm-reports-live").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": [],
    "eventTypes": [
        "hail",
        "wind",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("japan-open-data/us-storm-reports-live").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "states": [],
  "eventTypes": [
    "hail",
    "wind"
  ]
}' |
apify call japan-open-data/us-storm-reports-live --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,japan-open-data/us-storm-reports-live"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/bia3gBttkuvfSvdYh/builds/Lbj3Zogf3JhtfOobU/openapi.json