# Property Hazard Data API - Wildfire, Flood, Hail Risk (`nabeelbaghoor/property-hazard-risk-api`) Actor

Property risk data for any US address: wildfire risk and special hazard zones, flood zone determination, hail risk and damage scores, hurricane catastrophe hazard, earthquake and brush fire zones, sinkhole, crime risk, public fire protection class, distance to coast and homeowner data.

- **URL**: https://apify.com/nabeelbaghoor/property-hazard-risk-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** Real estate, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 hazard report returneds

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

## Property Hazard Data API - Wildfire, Flood, Hail Risk

Ask what could happen to a property, one US street address at a time, from the hazard models insurers actually underwrite on.

### What it collects

- **Wildfire**: risk scores in detailed, abbreviated and expanded forms, with or without special hazard zones, plus Firewise community status and the California brush fire report.
- **Water**: flood zone determination in guaranteed and non-guaranteed forms, hurricane catastrophe hazard, distance to coast and actual distance to coast, windpool eligibility, and lava and tsunami zones.
- **Storm and ground**: hail risk score, hail damage score, sinkhole risk and the California Department of Insurance earthquake zone.
- **Fire protection**: public protection class in detailed and abbreviated forms and its future effective version, which is the 1 to 10 grade for how well the local fire service could actually respond, plus the building code effectiveness grading schedule for the jurisdiction.
- **Crime**: the abbreviated crime risk report for the location.
- **Territory and placement**: property and auto rating territories, Citizens territory, premium tax jurisdiction, latitude and longitude, and a geocode accuracy check.
- **Property and homeowner data**: the property characteristics and owner data the provider holds for US residences, plus the UK replacement valuation and the Hong Kong property report.

### FAQ

#### What is property hazard data used for?

Pricing and placing risk. An insurer needs the wildfire score, flood zone and fire protection class before it can quote; a lender needs the flood determination before it can close; a real estate investor wants to know what the hazard picture is before it shows up in the premium. All of it is keyed on the street address rather than on a parcel identifier, which is why it fits into workflows that only ever have an address.

#### Which hazards are covered?

Wildfire, flood, hurricane, hail, earthquake, sinkhole, lava and tsunami, brush fire, crime and coastal exposure, plus the two ratings that describe how well a place is defended rather than how exposed it is: the public protection class for the fire service, and the building code effectiveness grading schedule for the local code regime.

#### What is a public protection class?

A grade from 1 to 10 for the fire suppression capability covering a location, where 1 is exemplary and 10 means the area does not meet the programme's minimum criteria. It is one of the strongest single predictors of a property insurance rate in the US. This actor passes the grade through exactly as the provider publishes it, never rescaled or inverted, because the hazard scores in the same dataset run the other way and quietly flipping one to match the other would be worse than leaving both alone.

#### How do I give it an address?

One per line, as street, city, state and optionally postcode, separated by commas: `1 Main St, Austin, TX, 78703`. The state has to be its two-letter code. A line without one is refused rather than sent, because this API answers on whatever it is given, and a report for an address it had to guess at would look exactly like a real answer.

#### Can I run a whole list of addresses?

Yes, and the actor paces it for you. This API takes one address per request with no batch form, so a long list is a long series of calls; the requests-per-minute setting is there because your contract may cap throughput, and the maximum results setting is there because every row is a separately metered lookup on your own provider account.

#### Which fields come back?

Whatever the provider publishes for that report, unchanged. The provider does not publish its response schemas openly, directing customers to their account manager for them, so this actor invents no field names: the whole answer travels on the row under `reportData`, and only the address echoed back and the status code the provider documents are lifted into their own columns. That way a field the provider adds tomorrow arrives without an actor change, and no column here is a guess.

#### What is the difference between the test and production gateways?

They are separate environments with separate credentials and separate data. The customer integration gateway is for building against; production is the real thing. Tick the test environment box to point at the former. A production key will be refused there and the other way round, which is the single most common reason a correct-looking credential does not work.

#### Why does it ask for an organisation id and a shipping id?

Because this API carries them inside every request body rather than as HTTP headers, and it will not answer without them. Your provider issues both alongside your credentials. They identify the account a lookup is billed to, which is separate from the credentials that prove who you are.

#### Do I need my own API key?

Yes. This actor is bring-your-own-key and never ships credentials of its own. Paste the consumer key and secret from your provider account, or set the key as the DATA\_API\_KEY environment secret. The pair is exchanged for a bearer token that the provider documents as lasting 60 minutes, so one exchange serves a whole run.

#### Why did a refusal not tell me whether my key was wrong?

Because it cannot be known from the outside. This gateway checks the credential before it looks at the path, so a refused token and an unknown route come back identically. Rather than assert one of them, the actor names both possibilities: if the same credentials work on another report, the problem is the request rather than the key.

#### What does it cost?

Pay per result. A hazard or property report costs the most, because each is a full model output for one address; a territory, tax or geocode answer costs well under half that, because placing an address is what you do before deciding whether to spend anything on the risk data about it. Platform usage is included. Addresses the provider has no report for are never charged.

### Example output

```json
{
  "recordType": "report",
  "report": "publicProtectionClassDetail",
  "reportLabel": "Public protection class, detailed",
  "requested": "1 Main St, Austin, TX, 78703",
  "found": true,
  "street": "1 Main St",
  "city": "Austin",
  "state": "TX",
  "zip": "78703",
  "environment": "production",
  "statusCode": 200,
  "reportData": { "...": "every field the provider published for this report, unchanged" }
}
```

### Keyword map

property hazard data API, wildfire risk API, flood zone determination API, hail risk score, hurricane catastrophe hazard, earthquake zone lookup, sinkhole risk data, public protection class API, PPC fire protection grade, building code effectiveness grading, distance to coast API, windpool eligibility, crime risk by address, insurance underwriting data API, property risk score by address, homeowner data API, rating territory lookup, premium tax jurisdiction, geocode accuracy check, catastrophe risk data.

# Actor input Schema

## `report` (type: `string`):

One report per run, over every address you give it. Hazard reports answer what could happen to a property. Fire protection reports answer how well the local service could respond. Territory reports answer which rating or tax area it falls in. Homeowner and property data answers what the property actually is.

## `addresses` (type: `array`):

One address per line, written as street, city, state and optionally postcode, separated by commas. The state must be its two-letter code. A line with no state is refused rather than sent, because a report for an address the provider had to guess at would look like an answer and would not be one.

## `orgId` (type: `string`):

The OrgId your provider issued with your credentials. This API carries it inside every request body rather than in a header, and it is how a lookup is attributed to your account.

## `shipId` (type: `string`):

The ShipId your provider issued with your credentials, alongside the OrgId. Both are required on every request this API serves.

## `consumerKey` (type: `string`):

Your own consumer key for the property underwriting data provider. This actor is bring-your-own-key and never ships credentials of its own. Leave blank to use the DATA\_API\_KEY environment secret instead.

## `consumerSecret` (type: `string`):

The consumer secret that pairs with your consumer key. The two are exchanged for a bearer token that the provider documents as lasting 60 minutes, so one exchange serves a whole run.

## `useTestEnvironment` (type: `boolean`):

Run against the provider's customer integration gateway instead of production. Note that the two issue different credential pairs, so a production key will be refused here and the other way round.

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

Stop after this many rows. Every row here is a separately metered lookup on your provider contract, so this cap is what keeps a long address list from spending more than you meant.

## `requestsPerMinute` (type: `integer`):

Pacing ceiling. This API takes one address per request with no batch form, so a long list is a long series of calls. Lower this if your contract sets a throughput limit.

## `baseUrl` (type: `string`):

Override the service host. Only needed if your account is served from somewhere other than the public gateway.

## `tokenUrl` (type: `string`):

Override the token host. Only needed if your account authenticates somewhere other than the public gateway's token endpoint.

## Actor input object example

```json
{
  "report": "wildfireDetail",
  "useTestEnvironment": false,
  "maxResults": 200,
  "requestsPerMinute": 30
}
```

# Actor output Schema

## `records` (type: `string`):

One row per report, alongside the address that produced it.

# 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("nabeelbaghoor/property-hazard-risk-api").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("nabeelbaghoor/property-hazard-risk-api").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 '{}' |
apify call nabeelbaghoor/property-hazard-risk-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nabeelbaghoor/property-hazard-risk-api"
        }
    }
}
```

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/zcVVEMVNJk0m9gqeq/builds/rBnUPwEjHYCC0VtFK/openapi.json