# FEMA Disaster Declarations Scraper (`maximedupre/fema-disaster-declarations-scraper`) Actor

Collect official OpenFEMA disaster declaration records. Filter by state, incident type, declaration type, dates, fiscal year, and max results, then export FEMA IDs, areas, dates, program flags, codes, and source metadata.

- **URL**: https://apify.com/maximedupre/fema-disaster-declarations-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** News, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.01 / 1,000 disaster declarations

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

### 🌪️ FEMA disaster declarations scraper for OpenFEMA records

FEMA Disaster Declarations Scraper collects official OpenFEMA disaster declaration area records from historical records back to 1953 through current records when available. It is built for researchers, emergency management teams, public-sector analysts, journalists, and developers who need structured declaration records without writing OData queries or using a FEMA API key.

Each result is one disaster declaration area record with FEMA identifiers, dates, incident type, state, designated area, assistance program flags, geography codes, source refresh metadata, and an official source URL when available.

- Build a [FEMA disaster declarations dataset](https://apify.com/maximedupre/fema-disaster-declarations-scraper/examples/fema-disaster-declarations-state-historical-export) for a state, territory, tribal area, or national historical export.
- Track [recent disaster declarations](https://apify.com/maximedupre/fema-disaster-declarations-scraper/examples/fema-disaster-declarations-recent-incident-tracker) by incident type, declaration type, date range, or fiscal year.
- Audit which counties or designated areas received [Individual Assistance, Public Assistance, Hazard Mitigation](https://apify.com/maximedupre/fema-disaster-declarations-scraper/examples/fema-disaster-declarations-assistance-program-audit), or related program declarations.
- Join [FEMA declaration numbers, FIPS-style codes, place codes, and designated areas](https://apify.com/maximedupre/fema-disaster-declarations-scraper/examples/fema-disaster-declarations-emergency-management-codes) into emergency management or public policy workflows.
- Export [OpenFEMA disaster declaration records](https://apify.com/maximedupre/fema-disaster-declarations-scraper/examples/fema-disaster-declarations-openfema-export-automation) to spreadsheets, dashboards, databases, or downstream Apify automations.

#### 📦 What data you get

The actor returns one row per accepted FEMA disaster declaration area record. Common fields include:

| Field | Description |
| --- | --- |
| `id` | Stable OpenFEMA disaster declaration area record identifier. |
| `disasterNumber` | FEMA disaster declaration number. |
| `state` | Official FEMA state, territory, or tribal area code. |
| `designatedArea` | County, parish, municipality, tribal area, or other covered area. |
| `declarationTitle` | Official FEMA declaration title. |
| `incidentType` | Official FEMA incident type. |
| `declarationType` | FEMA declaration type code, such as DR, EM, or FM. |
| `declarationDate` | Date when the declaration was issued. |
| `fiscalYear` | FEMA fiscal year for the declaration. |
| `incidentBeginDate` / `incidentEndDate` | Official incident dates when provided. |
| `ihProgramDeclared`, `iaProgramDeclared`, `paProgramDeclared`, `hmProgramDeclared` | FEMA assistance program availability flags when available. |
| `tribalRequest` | Whether the declaration was requested by a tribal government when available. |
| `fipsStateCode`, `fipsCountyCode`, `placeCode` | Official geographic codes supplied by FEMA when available. |
| `lastRefresh` | OpenFEMA source refresh timestamp when available. |
| `sourceUrl` | Official OpenFEMA source URL for auditability. |

#### ▶️ How to run

1. Open the actor on Apify.
2. Set optional filters such as states, incident types, declaration types, declaration dates, fiscal years, or maximum results.
3. Start the run.
4. Download results from the dataset as JSON, CSV, Excel, XML, RSS, or HTML, or send them to another workflow.

You can run a broad export with no filters, or narrow the search to a state, incident type, declaration type, date range, year range, fiscal year, and maximum result count.

#### 🎛️ Input options

| Input | Use it to |
| --- | --- |
| `states` | Filter by state, territory, or tribal area. Common state names and two-letter codes are supported where practical. |
| `incidentTypes` | Filter by official FEMA incident type, such as Hurricane, Flood, Fire, or Severe Storm. |
| `declarationTypes` | Filter by FEMA declaration type code, such as DR, EM, or FM. |
| `declarationDateFrom` / `declarationDateTo` | Limit results by declaration date range. |
| `declarationYearFrom` / `declarationYearTo` | Limit results by declaration year range. |
| `fiscalYears` | Filter by FEMA fiscal year. |
| `maxResults` | Stop after a chosen number of declaration records. |

#### 🧾 Output example

```json
{
  "id": "DR-4702-TX-201",
  "disasterNumber": 4702,
  "declarationRequestNumber": "23020",
  "state": "TX",
  "designatedArea": "Harris (County)",
  "declarationTitle": "Severe Storms, Straight-line Winds, and Tornadoes",
  "incidentType": "Severe Storm",
  "declarationType": "DR",
  "declarationDate": "2023-04-21T00:00:00.000Z",
  "fiscalYear": 2023,
  "incidentBeginDate": "2023-03-31T00:00:00.000Z",
  "incidentEndDate": "2023-04-01T00:00:00.000Z",
  "disasterCloseoutDate": "2024-06-12T00:00:00.000Z",
  "region": 6,
  "ihProgramDeclared": true,
  "iaProgramDeclared": true,
  "paProgramDeclared": true,
  "hmProgramDeclared": true,
  "tribalRequest": false,
  "fipsStateCode": "48",
  "fipsCountyCode": "201",
  "placeCode": "990201",
  "lastRefresh": "2024-03-18T14:22:41.000Z",
  "sourceUrl": "https://www.fema.gov/openfema-data-page/disaster-declarations-summaries-v2"
}
````

#### 💳 Pricing

This actor uses pay-per-event pricing. You are charged only when the actor saves an accepted disaster declaration to the dataset. Empty runs and setup checks should not be described as charged unless the pricing handoff says otherwise.

#### 🔌 Integrations

https://www.youtube.com/watch?v=bNACk1\_S\_6w\&list=PLObrtcm1Kw6MUrlLNDbK9QRg8VDJg0gOW\&index=4

Use this actor with Apify integrations, API clients, webhooks, scheduled runs, and dataset exports. Send results to spreadsheets, BI tools, databases, or your own app after each run.

#### ❓ FAQ

##### Can I collect FEMA disaster declarations without a FEMA API key?

Yes. The actor uses the official OpenFEMA disaster declarations source and does not require you to provide FEMA credentials, an API key, or OData syntax.

##### What happens when my filters return no records?

The run completes successfully and does not emit misleading rows. You can adjust the filters and run it again.

##### Does this include every FEMA aid or recovery program?

No. This actor focuses on disaster declaration area records. It does not collect broader FEMA aid, housing assistance, NFIP flood insurance, underwriting, risk scores, or policy analysis.

##### Can I filter by county or designated area?

The current public inputs focus on state, incident type, declaration type, declaration dates, declaration years, fiscal years, and maximum results. County or designated area values are returned in the output when FEMA provides them.

##### Can I use it for historical disaster declaration research?

Yes. The product contract covers historical OpenFEMA disaster declaration records back to 1953 through current records when available from the source.

##### Is the data official FEMA data?

The output is collected from the official OpenFEMA disaster declarations data source and includes source traceability fields such as `sourceUrl` and `lastRefresh` when available.

### 📝 Changelog

- 0.0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~fema-disaster-declarations-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Disease Outbreak News Scraper ↗](https://apify.com/maximedupre/disease-outbreak-news-scraper) - Collect public health outbreak notices for related emergency monitoring workflows.
- [FEC Campaign Finance Scraper ↗](https://apify.com/maximedupre/fec-campaign-finance-scraper) - Export official campaign finance records for public-sector research.
- [Harris County Court Records Scraper ↗](https://apify.com/maximedupre/harris-county-court-records-scraper) - Gather county-level public court records for government data workflows.
- [Hospital Price Transparency Scraper ↗](https://apify.com/maximedupre/hospital-price-transparency-scraper) - Collect public hospital price transparency data for compliance analysis.
- [EU Funding Tenders Scraper ↗](https://apify.com/maximedupre/eu-funding-tenders-scraper) - Track public funding and tender records for procurement research.
  **Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

Enter two-letter state codes or state names, such as TX, California, or Puerto Rico.

## `incidentTypes` (type: `array`):

Enter FEMA incident types to include, such as Hurricane, Severe Storm, Flood, Fire, or Snowstorm.

## `declarationTypes` (type: `array`):

Enter declaration type codes or names to include, such as DR for major disaster, EM for emergency, or FM for fire management assistance.

## `declarationDateFrom` (type: `string`):

Collect records declared on or after this date.

## `declarationDateTo` (type: `string`):

Collect records declared on or before this date.

## `declarationYearFrom` (type: `integer`):

Collect records declared in this year or later. Use this when a year range is easier than exact dates.

## `declarationYearTo` (type: `integer`):

Collect records declared in this year or earlier. Use this when a year range is easier than exact dates.

## `fiscalYears` (type: `array`):

Enter FEMA fiscal years to include, such as 2023 or 2024.

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

Stop after this many disaster declaration records. Increase for larger historical exports.

## Actor input object example

```json
{
  "states": [
    "TX",
    "California"
  ],
  "incidentTypes": [
    "Hurricane",
    "Flood"
  ],
  "declarationTypes": [
    "DR",
    "EM"
  ],
  "fiscalYears": [
    "2024"
  ],
  "maxResults": 100
}
```

# Actor output Schema

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

View the default dataset rows with FEMA declaration identifiers, dates, areas, program flags, geography codes, and source metadata.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "states": [
        "TX",
        "California"
    ],
    "incidentTypes": [
        "Hurricane",
        "Flood"
    ],
    "declarationTypes": [
        "DR",
        "EM"
    ],
    "fiscalYears": [
        "2024"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/fema-disaster-declarations-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "states": [
        "TX",
        "California",
    ],
    "incidentTypes": [
        "Hurricane",
        "Flood",
    ],
    "declarationTypes": [
        "DR",
        "EM",
    ],
    "fiscalYears": ["2024"],
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/fema-disaster-declarations-scraper").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 '{
  "states": [
    "TX",
    "California"
  ],
  "incidentTypes": [
    "Hurricane",
    "Flood"
  ],
  "declarationTypes": [
    "DR",
    "EM"
  ],
  "fiscalYears": [
    "2024"
  ]
}' |
apify call maximedupre/fema-disaster-declarations-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/fema-disaster-declarations-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FEMA Disaster Declarations Scraper",
        "description": "Collect official OpenFEMA disaster declaration records. Filter by state, incident type, declaration type, dates, fiscal year, and max results, then export FEMA IDs, areas, dates, program flags, codes, and source metadata.",
        "version": "0.1",
        "x-build-id": "ezv9dDZEUmDTs5swU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~fema-disaster-declarations-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-fema-disaster-declarations-scraper",
                "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/maximedupre~fema-disaster-declarations-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-fema-disaster-declarations-scraper",
                "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/maximedupre~fema-disaster-declarations-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-fema-disaster-declarations-scraper",
                "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": {
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "Enter two-letter state codes or state names, such as TX, California, or Puerto Rico.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "incidentTypes": {
                        "title": "Incident types",
                        "type": "array",
                        "description": "Enter FEMA incident types to include, such as Hurricane, Severe Storm, Flood, Fire, or Snowstorm.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "declarationTypes": {
                        "title": "Declaration types",
                        "type": "array",
                        "description": "Enter declaration type codes or names to include, such as DR for major disaster, EM for emergency, or FM for fire management assistance.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "declarationDateFrom": {
                        "title": "Declaration date from",
                        "type": "string",
                        "description": "Collect records declared on or after this date."
                    },
                    "declarationDateTo": {
                        "title": "Declaration date to",
                        "type": "string",
                        "description": "Collect records declared on or before this date."
                    },
                    "declarationYearFrom": {
                        "title": "Declaration year from",
                        "minimum": 1953,
                        "type": "integer",
                        "description": "Collect records declared in this year or later. Use this when a year range is easier than exact dates."
                    },
                    "declarationYearTo": {
                        "title": "Declaration year to",
                        "minimum": 1953,
                        "type": "integer",
                        "description": "Collect records declared in this year or earlier. Use this when a year range is easier than exact dates."
                    },
                    "fiscalYears": {
                        "title": "Fiscal years",
                        "type": "array",
                        "description": "Enter FEMA fiscal years to include, such as 2023 or 2024.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Stop after this many disaster declaration records. Increase for larger historical exports.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
