FEMA Disaster Declaration Search

What does FEMA Disaster Declaration Search do?

FEMA Disaster Declaration Search connects directly to the U.S. Federal Emergency Management Agency (FEMA) OpenFEMA v2 API to retrieve structured disaster declaration data. Every time the President declares a major disaster, emergency, or fire management assistance event, FEMA creates a formal record. This actor lets you search, filter, and export those records at scale.

The actor queries the DisasterDeclarationsSummaries endpoint, which contains every federal disaster declaration going back to 1953. Each record includes the disaster number, declaration type, incident type, affected state and designated area, incident begin and end dates, which federal assistance programs were activated (Individual & Households, Individual Assistance, Public Assistance, Hazard Mitigation), and whether it was a tribal request. Results are returned in reverse chronological order with configurable maximum count.

Why use FEMA Disaster Declaration Search on Apify?

• No OData syntax required -- The FEMA API uses OData query syntax ($filter, $orderby, $top, $skip). This actor translates a simple form into the correct OData query automatically.
• Automatic pagination -- The FEMA API returns up to 1,000 records per page. The actor handles multi-page fetches seamlessly with 300 ms delays.
• Clean field names -- Raw FEMA field names are transformed into readable camelCase output. Declaration types are decoded (DR → "Major Disaster"). Dates are cleaned to YYYY-MM-DD.
• Schedule for monitoring -- Run daily or weekly to track new disaster declarations, with webhook alerts to Slack, email, or any endpoint.
• No API key required -- Uses the free, public OpenFEMA API with no authentication.

Key features

• Comprehensive coverage from 1953 to present, including Major Disasters (DR), Emergencies (EM), and Fire Management Assistance (FM) declarations
• State filter using standard 2-letter state codes (all 50 states and U.S. territories)
• Incident type filter for Fire, Hurricane, Flood, Tornado, Severe Storm(s), Earthquake, Snow, Drought, Biological, Coastal Storm, or Other
• Declaration type filter for DR (Major Disaster), EM (Emergency), or FM (Fire Management)
• Fiscal year filter to focus on declarations from a specific federal fiscal year
• Date range filter on declaration date with ISO format dates
• Assistance program flags showing which federal programs (IH, IA, PA, HM) were activated
• Up to 10,000 results per run with automatic pagination

How to use FEMA Disaster Declaration Search

1. Navigate to the FEMA Disaster Declaration Search on the Apify Store.
2. Click Try for free to open the actor in Apify Console.
3. Optionally set a state filter, incident type, declaration type, fiscal year, or date range.
4. Click Start and wait for the run to complete.
5. Download your results from the Dataset tab in JSON, CSV, or Excel format.

Input parameters

Input examples

Recent California wildfires:

{
    "state": "CA",
    "incidentType": "Fire",
    "fyDeclared": 2025,
    "maxResults": 200
}

All hurricane declarations in 2024:

{
    "incidentType": "Hurricane",
    "declarationDateStart": "2024-01-01",
    "declarationDateEnd": "2024-12-31",
    "maxResults": 500
}

Major disasters in Florida:

{
    "state": "FL",
    "declarationType": "DR",
    "maxResults": 500
}

All disaster types in 2025:

{
    "fyDeclared": 2025,
    "maxResults": 1000
}

Input tips

• Combine filters for precision -- Use state + incidentType together to narrow results. Searching for hurricanes in Florida returns a focused dataset rather than thousands of records.
• Use fiscal year for annual analysis -- The fyDeclared filter is useful for year-over-year comparison of disaster frequency by state or type.
• Note on designated areas -- Each declaration record corresponds to a specific county or designated area. A single disaster event (e.g., DR-4806) will have multiple records, one for each affected county.
• Schedule regular runs -- Set up daily or weekly schedules to automatically capture new declarations.
• Leave all filters empty to get the most recent declarations across all states and types.

Output example

{
    "femaDeclarationString": "DR-4806-CA",
    "disasterNumber": 4806,
    "state": "CA",
    "declarationType": "DR",
    "declarationTypeName": "Major Disaster",
    "declarationDate": "2025-01-08",
    "fiscalYear": 2025,
    "incidentType": "Fire",
    "declarationTitle": "WILDFIRES AND STRAIGHT-LINE WINDS",
    "incidentBeginDate": "2025-01-07",
    "incidentEndDate": null,
    "closeoutDate": null,
    "designatedArea": "Los Angeles (County)",
    "region": 9,
    "ihProgram": true,
    "iaProgram": true,
    "paProgram": true,
    "hmProgram": true,
    "tribalRequest": false,
    "extractedAt": "2025-06-15T14:30:00.000Z"
}

Output fields

Declaration types

Assistance programs

Use cases

• Emergency management -- Monitor new disaster declarations in real time. Schedule daily runs with webhooks to alert your team when new declarations are issued.
• Insurance and risk analysis -- Analyze historical disaster frequency by state, type, and severity to inform underwriting decisions and catastrophe models.
• Government contracting -- Track where federal disaster assistance is being deployed to identify contracting opportunities for recovery services.
• Journalism and research -- Investigate disaster trends, climate change impacts, and federal response patterns across decades of data.
• Nonprofit planning -- Identify areas receiving disaster declarations to coordinate relief efforts and grant applications.
• Academic analysis -- Study disaster patterns by type, geography, and fiscal year for climate science and public policy research.

Programmatic access (API)

Python:

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("ryanclinton/fema-disaster-search").call(run_input={
    "state": "CA",
    "incidentType": "Fire",
    "fyDeclared": 2025,
    "maxResults": 200,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"[{item['declarationType']}] {item['femaDeclarationString']}")
    print(f"  {item['declarationTitle']} — {item['designatedArea']}")
    print(f"  Date: {item['declarationDate']} | Programs: IH={item['ihProgram']}, PA={item['paProgram']}")

JavaScript:

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("ryanclinton/fema-disaster-search").call({
    state: "CA",
    incidentType: "Fire",
    fyDeclared: 2025,
    maxResults: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    console.log(`[${item.declarationTypeName}] ${item.femaDeclarationString}`);
    console.log(`  ${item.declarationTitle} — ${item.designatedArea}`);
}

cURL:

# Start a run
curl "https://api.apify.com/v2/acts/ryanclinton~fema-disaster-search/runs" \
    -X POST \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer YOUR_API_TOKEN" \
    -d '{
        "state": "CA",
        "incidentType": "Fire",
        "fyDeclared": 2025,
        "maxResults": 200
    }'

# Fetch results (after run completes)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json" \
    -H "Authorization: Bearer YOUR_API_TOKEN"

How it works -- technical details

Input (state, incidentType, declarationType, fyDeclared, dates)
  │
  ▼
┌─────────────────────────────────────────────┐
│  1. OData Filter Builder                    │
│  • state → state eq 'CA' (uppercased)      │
│  • incidentType → incidentType eq 'Fire'   │
│  • declarationType → declarationType eq    │
│    'DR'                                     │
│  • fyDeclared → fyDeclared eq 2025         │
│  • dateStart → declarationDate ge          │
│    '2024-01-01T00:00:00.000Z'              │
│  • dateEnd → declarationDate le            │
│    '2024-12-31T23:59:59.999Z'              │
│  • All parts joined with ' and '           │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────────┐
│  2. Paginated Fetcher                       │
│  • GET fema.gov/api/open/v2/               │
│    DisasterDeclarationsSummaries            │
│  • $orderby=declarationDate desc           │
│  • $top=1000 (API max per page)            │
│  • $skip incremented each page             │
│  • $filter=<OData expression>              │
│  • 300 ms delay between pages              │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────────┐
│  3. Transform                               │
│  • Declaration type: DR→Major Disaster,    │
│    EM→Emergency, FM→Fire Management        │
│  • Dates: ISO timestamp → YYYY-MM-DD      │
│  • null for missing end/closeout dates     │
│  • Program flags preserved as booleans     │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────────┐
│  4. Output & Summary                        │
│  • Each declaration → Apify dataset        │
│  • Summary: incident type breakdown,        │
│    top 5 states, declaration type counts    │
└─────────────────────────────────────────────┘

OData query syntax

The FEMA API uses OData (Open Data Protocol) for filtering. The actor constructs these filters automatically:

Multiple filters are joined with and (OData AND operator).

FEMA regions

How much does it cost to use?

The OpenFEMA API is completely free. Apify's free tier includes $5 of monthly platform usage.

Limitations

1. 10,000 result maximum -- The actor caps at 10,000 results per run. Use date ranges or state filters to split larger datasets.
2. Designated area granularity -- Each record represents a single county/area. A major disaster affecting 50 counties generates 50 records with the same disaster number.
3. No financial data -- This endpoint provides declaration metadata only. For actual spending amounts, use the USAspending Federal Spending actor.
4. Incident types are fixed -- The API supports a specific set of incident types. Custom or sub-categories cannot be searched.
5. Date format required -- Dates must be entered in YYYY-MM-DD format. Other formats will not match.
6. No full-text search -- You cannot search by declaration title text. Use state, type, and date filters to narrow results.
7. Data lag -- There may be a short delay between when a disaster is declared and when the record appears in the API.
8. Tribal requests -- Tribal disaster declarations are included but may have different designation patterns than state-level declarations.

Responsible use

• FEMA disaster data is public information. Use it for emergency management, research, and planning.
• Follow the OpenFEMA Terms of Service when using the data.
• When building public-facing applications, present disaster information accurately and with sensitivity to affected communities.
• Do not use disaster data to target vulnerable populations for predatory commercial purposes.

FAQ

Do I need a FEMA API key? No. The OpenFEMA API is publicly accessible without authentication.

How far back does the data go? The FEMA database includes records from 1953 to the present -- over 70 years of U.S. disaster history.

What is the difference between DR, EM, and FM? DR (Major Disaster) is the most common and unlocks the widest federal aid. EM (Emergency) is for shorter-duration events. FM (Fire Management) is specifically for wildfire suppression.

Why do some disasters have dozens of records? Each record represents a specific county or designated area. A major hurricane affecting 50 counties produces 50 records, all sharing the same disaster number.

Can I get data for U.S. territories? Yes. The API includes Puerto Rico (PR), U.S. Virgin Islands (VI), Guam (GU), American Samoa (AS), and other territories.

What does the region field mean? FEMA divides the U.S. into 10 administrative regions. The region number indicates which FEMA regional office oversees the affected state.

Integrations and related actors

The output dataset can be exported in JSON, CSV, or Excel format, or accessed programmatically via the Apify API. Use webhooks to trigger automated workflows when a run completes.

Connect with any Apify integration including Google Sheets, Slack, Zapier, Make (Integromat), Amazon S3, and custom API endpoints to build automated disaster monitoring workflows.