# 🌊 OpenFEMA NFIP Flood Insurance Claims (`nexgendata/openfema-nfip-flood-claims`) Actor

NFIP flood-insurance claims (redacted) by state and year: flood zone, amounts paid on building/contents, coverage, loss date, location. For P\&C insurers, reinsurers, flood-risk and climate analysts.

- **URL**: https://apify.com/nexgendata/openfema-nfip-flood-claims.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $40.00 / 1,000 mentions

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

## 🌊 OpenFEMA NFIP Flood Insurance Claims

Pull redacted, claim-level **National Flood Insurance Program (NFIP)** loss records straight from FEMA's OpenFEMA platform — the authoritative, government-published history of what the United States actually pays out when it floods. Filter by state and year-of-loss and get one structured JSON record per claim: flood zone, building and contents amounts paid, the flood event, and the loss date. This is the granular paid-loss data that P&C insurers, reinsurers, catastrophe modelers, and climate-risk analysts use to calibrate flood pricing and exposure — sourced from the only dataset that covers the entire federal flood program rather than a single carrier's book.

> **One actor. One token. The claim-level flood-loss history behind cat-model calibration and flood-risk pricing — delivered as pay-per-record JSON, no enterprise data licence.**

### Why use this

- **Actual paid losses, not modeled estimates.** Most flood-risk products sell you a model's *prediction*. This is FEMA's record of what was *actually paid* on real NFIP claims — the ground-truth your model gets calibrated against.
- **Whole-program coverage.** The NFIP underwrites the large majority of residential flood policies in the US, so this is a near-complete federal flood-loss picture, not one carrier's slice.
- **Building vs contents split.** Each claim separates `amountPaidOnBuildingClaim` and `amountPaidOnContentsClaim` — essential for severity modeling and coverage-mix analysis.
- **Flood-zone tagged.** Every claim carries its `ratedFloodZone`, letting you analyze loss severity by zone (A/AE/VE/X) — the backbone of flood-rating work.
- **Official source, ETL-ready.** Reads FEMA's public OpenFEMA dataset; redacted for privacy at the source. Stable flat JSON loads straight into Snowflake, BigQuery, Postgres, or a notebook.

### What you get

Each record represents one redacted NFIP flood-insurance claim. Core fields:

- `state` — two-letter state of the insured property
- `dateOfLoss` — the date the flood loss occurred
- `ratedFloodZone` — the FEMA flood zone the policy was rated in (e.g. `AE`, `VE`, `X`, `A`)
- `amountPaidOnBuildingClaim` — USD paid on the building portion of the claim
- `amountPaidOnContentsClaim` — USD paid on the contents portion of the claim
- `floodEvent` — the named flood event associated with the loss (when designated)

Records are redacted at the FEMA source to protect policyholder privacy — there is no name, full address, or policy number, by design.

### Use cases

- **Flood-risk pricing & rate filing** — P&C actuaries aggregate `amountPaidOnBuildingClaim` and `amountPaidOnContentsClaim` by `ratedFloodZone` and `state` to derive empirical loss-cost relativities for private-flood rate filings competing with the NFIP.
- **Catastrophe-model calibration** — Cat modelers and reinsurers backtest vendor flood models (against the actual NFIP paid-loss distribution by zone and event) to validate severity curves before binding treaty capacity.
- **Reinsurance & ILS underwriting** — Reinsurance and insurance-linked-securities desks size flood exposure and event severity (e.g. by pulling all claims tagged to a named hurricane's `floodEvent`) to price retrocession and cat-bond layers.
- **Climate-risk analytics** — Climate and ESG analysts trend flood-loss frequency and severity by state and year-of-loss to quantify physical-risk exposure for real-estate, mortgage, and municipal-bond portfolios.
- **Mortgage & real-estate risk** — Lenders and proptech firms join paid-loss intensity by zone to property portfolios to flag concentration risk and inform flood-insurance requirements.
- **Public-policy & academic research** — Researchers study NFIP loss patterns, repetitive-loss properties, and the equity of flood-zone rating using the program's own paid-claim record.
- **Disaster-response planning** — Emergency-management and resilience teams quantify historical loss footprints of major flood events to prioritize mitigation spend.

### Sample output

```json
{
  "state": "TX",
  "dateOfLoss": "2017-08-27",
  "ratedFloodZone": "AE",
  "amountPaidOnBuildingClaim": 184320.55,
  "amountPaidOnContentsClaim": 41875.00,
  "floodEvent": "Hurricane Harvey"
}
````

### Reading the data: flood zones, building vs contents, and named events

Three fields do most of the analytical work, and it helps to understand how they interact:

- **`ratedFloodZone`** is the FEMA flood zone the policy was rated in. The high-risk Special Flood Hazard Areas (`A`, `AE`, and the coastal high-velocity `VE`) carry the highest expected severity; `X` zones are moderate-to-low risk and tend to show smaller, less frequent paid losses. Grouping `amountPaidOnBuildingClaim` by `ratedFloodZone` is the single most common analysis this dataset supports — it produces empirical severity relativities by zone.
- **`amountPaidOnBuildingClaim` vs `amountPaidOnContentsClaim`** must be analyzed separately, not summed blindly. NFIP underwrites and adjusts building and contents coverage independently, and the mix varies sharply by occupancy (a slab-on-grade home vs a contents-heavy small business). Severity curves built on the building component behave very differently from contents.
- **`floodEvent`** ties a claim to a named event when one is designated. This is what lets you reconstruct the loss footprint of a specific catastrophe — pull a state and year window, then group on `floodEvent` to isolate, say, every claim attributed to a single landfalling hurricane.

### Common analysis recipes

- **Single-event severity:** `{"state": "TX", "yearOfLossFrom": 2017, "maxResults": 5000}` then group returned rows on `floodEvent` to isolate one hurricane's claims and chart the paid-loss distribution by `ratedFloodZone`.
- **Zone relativity table:** pull a state's recent years and pivot mean/percentile `amountPaidOnBuildingClaim` by `ratedFloodZone` — the empirical input to a private-flood rate filing.
- **Coastal vs inland mix:** compare `VE`/`AE` (coastal) against `A`/`X` (inland) severity to size storm-surge vs riverine exposure in a book.
- **Trend over time:** run the actor for successive `yearOfLossFrom` cuts to trend frequency and severity and quantify a warming-climate signal in the paid-loss record.

### Input parameters

| Parameter | What it does |
|-----------|--------------|
| `state` | Two-letter state code to filter claims by (e.g. `TX`, `FL`, `LA`). |
| `yearOfLossFrom` | Return only claims with a year of loss greater than or equal to this year. |
| `maxResults` | Maximum number of claim records to return. |

### How to use

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("nexgendata/openfema-nfip-flood-claims").call(run_input={
    "state": "TX",
    "yearOfLossFrom": 2017,
    "maxResults": 1000,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["dateOfLoss"], item["ratedFloodZone"],
          item["amountPaidOnBuildingClaim"], item["floodEvent"])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/nexgendata~openfema-nfip-flood-claims/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "FL",
    "yearOfLossFrom": 2020,
    "maxResults": 5000
  }'
```

#### No-code (Zapier / Make)

Use the Apify "Run actor and get dataset items" action with actor ID `nexgendata/openfema-nfip-flood-claims`, then load the rows into a spreadsheet or BI tool and pivot paid losses by `ratedFloodZone` and `state`.

### Pricing

This actor runs on Apify's **pay-per-event (PPE)** model — **$0.10 per result** (one charge per claim record returned), plus a sub-cent actor-start event. No subscription, no seat licence, no minimum.

Worked example:

- A targeted single-event pull returning 250 claims → **$25.00**
- A state-year analysis returning 500 claims → **$50.00**
- A multi-year exposure study capped at `maxResults=5000` → up to **$500.00** (use `maxResults` to bound cost precisely)

Because billing is per result, a narrow filter that returns few claims costs only for those rows — you never pay for an empty run.

### How this compares to a commercial flood-data vendor

Commercial flood-risk and catastrophe-data products (cat-model vendor data feeds, proprietary flood-score APIs, and reinsurance-broker analytics) sell flood-loss intelligence on **annual enterprise licences** running into the high five and six figures. Those products add modeled scores, parcel-level geocoding, and proprietary hazard layers you may still need. But the **actual NFIP paid-loss record** — the calibration target underneath all of them — is public FEMA data. If your workflow is **calibrating a model**, **sizing event severity**, or **trending flood losses by zone and state**, you do not need a six-figure data licence to get the claim-level paid amounts. You need this actor, queryable from your own code at pay-per-record cost.

### FAQ

**Q: Where does the data come from?**
A: FEMA's OpenFEMA platform — the official, public NFIP redacted claims dataset published by the federal government.

**Q: Is personal information exposed?**
A: No. FEMA redacts the dataset at the source to protect policyholder privacy: there are no names, full addresses, or policy numbers. The records are loss-level facts (zone, amounts, date, event).

**Q: What does `ratedFloodZone` mean?**
A: It's the FEMA flood zone the policy was rated in — e.g. `AE` and `A` (high-risk Special Flood Hazard Areas), `VE` (coastal high-velocity), and `X` (moderate-to-low risk). Severity analysis by zone is one of the most common uses of this data.

**Q: Why are building and contents split into two fields?**
A: NFIP policies cover building and contents separately, and they are adjusted and paid separately. Keeping `amountPaidOnBuildingClaim` and `amountPaidOnContentsClaim` distinct is essential for accurate severity and coverage-mix modeling.

**Q: Can I pull all claims for a specific hurricane?**
A: Filter by `state` and `yearOfLossFrom` to narrow to the relevant period, then filter the returned rows on `floodEvent` for the named event (e.g. `Hurricane Harvey`) in your downstream pipeline.

**Q: How current is it?**
A: The dataset reflects FEMA's published NFIP claims as of its latest OpenFEMA refresh. Schedule the actor periodically via Apify's scheduler to pick up newly published claims after major events.

### Schema stability & versioning

This actor follows NexGenData's **additive-only schema** contract. New fields may be added over time (appearing as new JSON keys, defaulting to `null` for older runs), but existing fields are never renamed or removed without a major-version bump and advance notice. Field semantics — currency, date formats, zone codes — are never silently changed. Build production pipelines on this output with confidence.

### Compliance & legal

- This actor reformats **public, redacted FEMA OpenFEMA data**. It is not affiliated with, endorsed by, or sponsored by FEMA or the NFIP.
- The data is redacted at the FEMA source for privacy. Nothing here is insurance, legal, or investment advice.
- For any regulated decision — rate filings, treaty pricing, underwriting — **verify against the primary OpenFEMA dataset** and apply appropriate actuarial review.
- You are responsible for ensuring your downstream use complies with applicable laws.

### Related NexGenData actors

Part of NexGenData's **Environmental / ESG and Finance** clusters — pair this actor with:

- [EPA TRI Toxic Release Facilities](https://apify.com/nexgendata/epa-tri-toxic-release-facilities?fpr=2ayu9b)
- [EPA ECHO Enforcement Scraper](https://apify.com/nexgendata/epa-echo-enforcement-scraper?fpr=2ayu9b)
- [FDIC Bank Financials & Health](https://apify.com/nexgendata/fdic-bank-financials-health?fpr=2ayu9b)
- [US Treasury Auction Results](https://apify.com/nexgendata/us-treasury-auction-results?fpr=2ayu9b)
- [Global Central-Bank Policy Rates (BIS)](https://apify.com/nexgendata/global-central-bank-policy-rates?fpr=2ayu9b)

Browse the full 200+ actor catalog at **https://apify.com/nexgendata?fpr=2ayu9b**.

# Actor input Schema

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

Two-letter state code (e.g. TX, FL, LA).

## `yearOfLossFrom` (type: `integer`):

Only claims with year of loss >= this.

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

Maximum claims to return.

## Actor input object example

```json
{
  "state": "TX",
  "maxResults": 1000
}
```

# 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 = {
    "state": "TX"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/openfema-nfip-flood-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 = { "state": "TX" }

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/openfema-nfip-flood-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 '{
  "state": "TX"
}' |
apify call nexgendata/openfema-nfip-flood-claims --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🌊 OpenFEMA NFIP Flood Insurance Claims",
        "description": "NFIP flood-insurance claims (redacted) by state and year: flood zone, amounts paid on building/contents, coverage, loss date, location. For P&C insurers, reinsurers, flood-risk and climate analysts.",
        "version": "0.0",
        "x-build-id": "cTRQk1VyGNvqmDsNw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~openfema-nfip-flood-claims/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-openfema-nfip-flood-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/nexgendata~openfema-nfip-flood-claims/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-openfema-nfip-flood-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/nexgendata~openfema-nfip-flood-claims/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-openfema-nfip-flood-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": {
                    "state": {
                        "title": "State",
                        "type": "string",
                        "description": "Two-letter state code (e.g. TX, FL, LA)."
                    },
                    "yearOfLossFrom": {
                        "title": "Year of loss from",
                        "type": "integer",
                        "description": "Only claims with year of loss >= this."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum claims to return.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```