# OpenFEMA NFIP Flood Claims Scraper - Insurance Risk API (`pink_comic/openfema-nfip-flood-insurance-claims`) Actor

Search 2.7M+ official, privacy-redacted National Flood Insurance Program claim transactions by state, county FIPS, ZIP, community, flood event, year, flood zone, cause, or exact record ID. Returns payments, damage, coverage, building risk, and source evidence.

- **URL**: https://apify.com/pink\_comic/openfema-nfip-flood-insurance-claims.md
- **Developed by:** [Ava Torres](https://apify.com/pink_comic) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 claims

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

## OpenFEMA NFIP Flood Insurance Claims Scraper API

Search more than **2.7 million official, privacy-redacted National Flood Insurance Program claim transactions** for property-insurance underwriting, mortgage and collateral risk, catastrophe analytics, flood-loss research, community risk analysis, and due diligence.

Filter by state, five-digit county FIPS, ZIP code, NFIP community, named flood event, event designation, year of loss, flood zone, cause of damage, or exact OpenFEMA record ID. Results include reported payments, damage, insurance coverage, building and occupancy characteristics, flood depth/zone fields, source freshness, and direct official-record URLs.

No API key is required. FEMA updates the source approximately monthly.

> **Privacy and evidence limits:** FEMA redacts policyholder identity and reduces latitude/longitude precision to 0.1 degree. Approximate coordinates can fall in the wrong county or state. Use `state` and `countyFips` for geographic aggregation—not property-level identification. FEMA also says this lagged dataset is not intended to be and should not be considered an official federal report.

### Fast start

Empty input returns a deterministic, non-empty sample of high-value paid Hurricane Ian claims in Florida during 2022. Equivalent explicit input:

```json
{
  "state": "FL",
  "yearOfLoss": 2022,
  "paidOnly": true,
  "sortBy": "buildingPayment",
  "maxResults": 25
}
````

Search one flood event:

```json
{
  "floodEvent": "Hurricane Ian",
  "state": "FL",
  "paidOnly": true,
  "sortBy": "buildingPayment",
  "maxResults": 100
}
```

Search a county and flood zone:

```json
{
  "countyFips": "12071",
  "floodZone": "AE",
  "yearOfLoss": 2022,
  "paidOnly": true,
  "maxResults": 100
}
```

Search a reported ZIP code:

```json
{
  "zipCode": "33931",
  "yearOfLoss": 2022,
  "sortBy": "buildingDamage",
  "maxResults": 50
}
```

Exact-record lookup:

```json
{
  "claimId": "89a94ce9-777e-4492-80d9-9e47dc1d35fe"
}
```

`claimId` takes precedence over every other field and returns at most one source record.

### Inputs

| Field | Purpose |
|---|---|
| `claimId` | Exact OpenFEMA record UUID; highest precedence |
| `state` | Two-letter state or territory abbreviation |
| `countyFips` | Exact five-digit county FIPS |
| `zipCode` | Exact five-digit reported ZIP code |
| `communityId` | Exact current NFIP community identifier |
| `communityName` | NFIP community-name substring |
| `floodEvent` | Named-event substring, such as `Hurricane Ian` |
| `eventDesignationNumber` | Exact FEMA event code, such as `FL0222` |
| `yearOfLoss` | Calendar year when flood water entered the building |
| `causeOfDamage` | Exact FEMA cause code (`1` tidal, `2` river/lake, `4` rainfall/snowmelt, etc.) |
| `floodZone` | Exact current or rated NFIP flood zone |
| `paidOnly` | Require a positive building, contents, or ICC payment |
| `sortBy` | `latest`, `oldest`, `buildingPayment`, `contentsPayment`, `buildingDamage`, or `coverage` |
| `maxResults` | Total response cap, 1–500 |

At least one search field is recommended. If none is supplied, the actor uses the Hurricane Ian fallback above so automated and first-run evaluations receive useful output.

### Output

Every matching record has stable, normalized fields covering:

- source claim ID, loss date/year, flood event, and event designation
- state, county FIPS, reported ZIP, and NFIP community
- privacy-reduced coordinates with an explicit precision warning
- cause of damage, flood characteristics, water depth/duration, and flood zones
- building type, occupancy, floors, basement/crawlspace, and construction dates
- primary-residence, rental, elevation, Post-FIRM, and floodproofing indicators when reported
- building, contents, and Increased Cost of Compliance coverage
- building, contents, and ICC payments plus computed totals
- reported damage, property value, replacement cost, deductibles, and non-payment reasons
- source effective date, dataset version/update frequency, dataset URL, and exact official API URL

No-match searches return an explicit `NO_MATCHING_CLAIMS` evidence item instead of an ambiguous empty dataset. Temporary OpenFEMA failures return `SOURCE_UNAVAILABLE` after bounded retries and do not claim a search conclusion.

### Use cases

- P\&C flood-risk and underwriting research
- Mortgage, collateral, and portfolio risk analysis
- Catastrophe-event payment and severity analysis
- County, ZIP, community, and flood-zone loss benchmarking
- Insurance coverage-gap and claims trend research
- Floodplain management and mitigation planning
- Real-estate and property-risk due diligence
- Source-backed data enrichment for analytical models

### Official source

- [OpenFEMA FIMA NFIP Redacted Claims v2](https://www.fema.gov/openfema-data-page/fima-nfip-redacted-claims-v2)
- [National Flood Insurance Program](https://www.fema.gov/flood-insurance)
- [OpenFEMA terms, citation, and usage guidance](https://www.fema.gov/about/openfema/terms-conditions)

The source is privacy-redacted, updated approximately monthly, and can lag FEMA's underlying NFIP system of record. Results are transaction evidence for analysis—not proof about a named person, policyholder, or exact street address.

# Actor input Schema

## `claimId` (type: `string`):

Exact source record UUID. Takes precedence over every other filter and returns at most one record.

## `state` (type: `string`):

Two-letter abbreviation, such as FL, TX, LA, or PR.

## `countyFips` (type: `string`):

Exact five-digit county FIPS code, such as 12071 for Lee County, Florida.

## `zipCode` (type: `string`):

Exact five-digit ZIP code from the privacy-redacted source.

## `communityId` (type: `string`):

Exact current NFIP community identifier.

## `communityName` (type: `string`):

Case-sensitive source substring, such as FORT MYERS BEACH or SANIBEL.

## `floodEvent` (type: `string`):

Case-sensitive event-name substring, such as Hurricane Ian or Hurricane Harvey.

## `eventDesignationNumber` (type: `string`):

Exact FEMA event code, such as FL0222 for Hurricane Ian claims in Florida.

## `yearOfLoss` (type: `integer`):

Calendar year when flood water first entered the insured building.

## `causeOfDamage` (type: `string`):

Exact FEMA code: 1 tidal overflow, 2 river/lake overflow, 4 rainfall/snowmelt, or another documented code.

## `floodZone` (type: `string`):

Exact current or rated NFIP flood zone, such as AE, VE, A, or X.

## `paidOnly` (type: `boolean`):

Require a positive building, contents, or Increased Cost of Compliance claim payment.

## `sortBy` (type: `string`):

Order by loss date, reported payment, damage, or coverage.

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

Total response cap after all filters are applied.

## Actor input object example

```json
{
  "paidOnly": true,
  "sortBy": "latest",
  "maxResults": 25
}
```

# 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 = {
    "paidOnly": true,
    "sortBy": "latest",
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("pink_comic/openfema-nfip-flood-insurance-claims").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 = {
    "paidOnly": True,
    "sortBy": "latest",
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("pink_comic/openfema-nfip-flood-insurance-claims").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 '{
  "paidOnly": true,
  "sortBy": "latest",
  "maxResults": 25
}' |
apify call pink_comic/openfema-nfip-flood-insurance-claims --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=pink_comic/openfema-nfip-flood-insurance-claims",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenFEMA NFIP Flood Claims Scraper - Insurance Risk API",
        "description": "Search 2.7M+ official, privacy-redacted National Flood Insurance Program claim transactions by state, county FIPS, ZIP, community, flood event, year, flood zone, cause, or exact record ID. Returns payments, damage, coverage, building risk, and source evidence.",
        "version": "0.1",
        "x-build-id": "YHSJ0egQ3oqFaAobZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/pink_comic~openfema-nfip-flood-insurance-claims/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-pink_comic-openfema-nfip-flood-insurance-claims",
                "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/pink_comic~openfema-nfip-flood-insurance-claims/runs": {
            "post": {
                "operationId": "runs-sync-pink_comic-openfema-nfip-flood-insurance-claims",
                "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/pink_comic~openfema-nfip-flood-insurance-claims/run-sync": {
            "post": {
                "operationId": "run-sync-pink_comic-openfema-nfip-flood-insurance-claims",
                "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": {
                    "claimId": {
                        "title": "Exact OpenFEMA Claim Record ID",
                        "minLength": 8,
                        "type": "string",
                        "description": "Exact source record UUID. Takes precedence over every other filter and returns at most one record."
                    },
                    "state": {
                        "title": "State or Territory",
                        "pattern": "^[A-Za-z]{2}$",
                        "type": "string",
                        "description": "Two-letter abbreviation, such as FL, TX, LA, or PR."
                    },
                    "countyFips": {
                        "title": "County FIPS",
                        "pattern": "^[0-9]{5}$",
                        "type": "string",
                        "description": "Exact five-digit county FIPS code, such as 12071 for Lee County, Florida."
                    },
                    "zipCode": {
                        "title": "Reported ZIP Code",
                        "pattern": "^[0-9]{5}$",
                        "type": "string",
                        "description": "Exact five-digit ZIP code from the privacy-redacted source."
                    },
                    "communityId": {
                        "title": "NFIP Community ID",
                        "pattern": "^[A-Za-z0-9]{6,7}$",
                        "type": "string",
                        "description": "Exact current NFIP community identifier."
                    },
                    "communityName": {
                        "title": "NFIP Community Name",
                        "minLength": 2,
                        "type": "string",
                        "description": "Case-sensitive source substring, such as FORT MYERS BEACH or SANIBEL."
                    },
                    "floodEvent": {
                        "title": "Flood Event",
                        "minLength": 2,
                        "type": "string",
                        "description": "Case-sensitive event-name substring, such as Hurricane Ian or Hurricane Harvey."
                    },
                    "eventDesignationNumber": {
                        "title": "Event Designation Number",
                        "pattern": "^[A-Za-z0-9]{1,8}$",
                        "type": "string",
                        "description": "Exact FEMA event code, such as FL0222 for Hurricane Ian claims in Florida."
                    },
                    "yearOfLoss": {
                        "title": "Year of Loss",
                        "minimum": 1968,
                        "maximum": 2027,
                        "type": "integer",
                        "description": "Calendar year when flood water first entered the insured building."
                    },
                    "causeOfDamage": {
                        "title": "Cause of Damage Code",
                        "pattern": "^[A-Za-z0-9]{1,8}$",
                        "type": "string",
                        "description": "Exact FEMA code: 1 tidal overflow, 2 river/lake overflow, 4 rainfall/snowmelt, or another documented code."
                    },
                    "floodZone": {
                        "title": "Flood Zone",
                        "type": "string",
                        "description": "Exact current or rated NFIP flood zone, such as AE, VE, A, or X."
                    },
                    "paidOnly": {
                        "title": "Paid Claims Only",
                        "type": "boolean",
                        "description": "Require a positive building, contents, or Increased Cost of Compliance claim payment.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Sort Results",
                        "enum": [
                            "latest",
                            "oldest",
                            "buildingPayment",
                            "contentsPayment",
                            "buildingDamage",
                            "coverage"
                        ],
                        "type": "string",
                        "description": "Order by loss date, reported payment, damage, or coverage.",
                        "default": "latest"
                    },
                    "maxResults": {
                        "title": "Maximum Claims",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Total response cap after all filters are applied.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
