# EPA FRS Facility Registry Scraper (`parseforge/epa-frs-facility-registry-scraper`) Actor

Tap the US EPA Facility Registry Service for regulated facilities in any state. Returns registry ID, facility name, street address, city, county, ZIP, EPA region, and program system acronym. Filter by state or program for compliance research, site screening, and mapping.

- **URL**: https://apify.com/parseforge/epa-frs-facility-registry-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏭 EPA FRS Facility Registry Scraper

> 🚀 **Export regulated facilities in seconds.** Pull EPA Facility Registry Service records for any US state, with registry ID, standardized name, full address, county, and program system acronym.

> 🕒 **Last updated:** 2026-06-05 · **📊 15 fields** per record · all 50 states plus DC and territories · sourced from the official US EPA `data.epa.gov` service

The EPA Facility Registry Service (FRS) is the federal master index of facilities, sites, and places that are subject to environmental regulation. This Actor turns that registry into a clean, structured feed of facility records you can drop straight into a database, a map, or a compliance workflow.

Coverage spans every US state, the District of Columbia, and US territories. You pick a state, optionally narrow to a single EPA program system (water permits, hazardous waste, air, Superfund, and more), and get back one row per facility with names, standardized addresses, county, EPA region, and the program acronym that ties the facility to a regulatory dataset.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Environmental consultants and EHS teams | Building facility master lists for a state or region |
| GIS and data analysts | Mapping regulated sites by county and program |
| Compliance and due-diligence researchers | Screening addresses against the federal registry |
| Journalists and NGOs | Investigating regulated facilities in a community |

### 📋 What the EPA FRS Facility Registry Scraper does

It queries the public EPA `efservice` endpoint for the `FRS_PROGRAM_FACILITY` table, pages through the results for your chosen state, normalizes blank and placeholder values to null, and writes one tidy record per facility. You control the state, an optional program filter, and how many records to pull.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `stateCode` | string (select) | Yes | US state or territory to pull facilities for. Defaults to California (CA). |
| `programAcronym` | string (select) | No | Optional EPA program system to filter by (NPDES, RCRAINFO, AIR, SEMS, and more). Leave on Any for all programs. |
| `maxItems` | integer | No | How many facilities to return. Free plan is capped at 10. |

Example 1 — all programs in Texas:

```json
{
    "stateCode": "TX",
    "maxItems": 100
}
````

Example 2 — only water discharge permit facilities in California:

```json
{
    "stateCode": "CA",
    "programAcronym": "NPDES",
    "maxItems": 50
}
```

> ⚠️ **Good to Know:** FRS is a registry index, so a single physical facility can appear under more than one program system. Some records carry sparse address detail (for example a missing county or suite line). Those values are returned as null rather than guessed.

### 📊 Output

Each facility is one record. Fields:

| 🏷 Field | Description |
|---|---|
| 📌 `facilityName` | Primary facility name from the registry |
| 🆔 `registryId` | EPA FRS Registry ID (unique facility identifier) |
| 🏷 `programSystemAcronym` | EPA program system the record belongs to |
| 🔖 `programSystemId` | Program system identifier for the facility |
| 🏠 `streetAddress` | Location street address |
| 🏷 `supplementalLocation` | Suite, unit, or extra address line (often null) |
| 🏙 `city` | City name |
| 🗺 `stateCode` | Two letter state code |
| 🗺 `stateName` | State name as stored in the registry |
| 📮 `postalCode` | ZIP / postal code |
| 📍 `countyName` | County name |
| 🌐 `countryName` | Country name |
| 🌎 `epaRegionCode` | EPA region code (01 to 10) |
| 🗂 `sourceOfData` | Originating data program for the record |
| ✅ `publicIndicator` | Whether the record is public |
| 🕒 `scrapedAt` | ISO timestamp of collection |
| ❌ `error` | Error message, null on success |

Three real sample records:

```json
{
    "facilityName": "MEISSNER HQ",
    "registryId": "110070095086",
    "programSystemAcronym": "SSTS",
    "streetAddress": "1001 FLYNN RD",
    "city": "CAMARILLO",
    "stateCode": "CA",
    "postalCode": "93012",
    "countyName": "VENTURA COUNTY",
    "epaRegionCode": "09"
}
```

```json
{
    "facilityName": "UPPER AIR SOLUTIONS FACTORY",
    "registryId": "110070921985",
    "programSystemAcronym": "SSTS",
    "streetAddress": "10050 MARATHON PKWY",
    "city": "LAKESIDE",
    "stateCode": "CA",
    "postalCode": "92040",
    "countyName": "SAN DIEGO COUNTY",
    "epaRegionCode": "09"
}
```

```json
{
    "facilityName": "XT 2000 INC",
    "registryId": "110067115507",
    "programSystemAcronym": "SSTS",
    "streetAddress": "10054 PROSPECT AVE SUITE P",
    "city": "SANTEE",
    "stateCode": "CA",
    "postalCode": "92071",
    "countyName": "SAN DIEGO COUNTY",
    "epaRegionCode": "09"
}
```

### ✨ Why choose this Actor

- Sources directly from the official US EPA `data.epa.gov` service, no third party middleman.
- Clean field mapping with blank and placeholder values normalized to null.
- State and program filters that match the registry's own query parameters.
- One record per facility, ready for mapping, joins, or screening.
- Stable output schema with a dataset view for quick browsing.

### 📈 How it compares to alternatives

| Approach | Effort | Coverage | Structured output |
|---|---|---|---|
| This Actor | Pick a state and run | All states and territories | Yes, one row per facility |
| EPA Envirofacts web search | Manual page by page | National | No, screen scraping needed |
| Raw `efservice` URLs | Build and page URLs yourself | National | Partial, raw nested fields |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the EPA FRS Facility Registry Scraper.
3. Pick a `stateCode` and, if you want, a `programAcronym`.
4. Set `maxItems` and click Start.
5. Browse the results in the dataset or pull them through the Apify API.

### 💼 Business use cases

#### Environmental compliance

| Goal | How this helps |
|---|---|
| Build a facility master list | Pull every registered facility in a state in one run |
| Screen a portfolio of addresses | Match holdings against the federal registry |

#### GIS and analytics

| Goal | How this helps |
|---|---|
| Map regulated sites | County and region fields drive choropleths and clusters |
| Segment by program | Filter to NPDES, RCRAINFO, AIR, and more |

#### Due diligence

| Goal | How this helps |
|---|---|
| Site assessment prep | Confirm whether a site is in the EPA registry |
| Counterparty checks | Look up a company's regulated facilities |

#### Research and reporting

| Goal | How this helps |
|---|---|
| Community studies | List regulated facilities in a county |
| Trend tracking | Compare program coverage across states |

### 🔌 Automating EPA FRS Facility Registry Scraper

Connect runs to Make, Zapier, Slack, Airbyte, GitHub Actions, or Google Drive using Apify integrations and webhooks. Trigger a run on a schedule, then route the output into a sheet, a warehouse, or a notification channel.

### 🌟 Beyond business use cases

- **Research:** academic studies of environmental regulation by region.
- **Personal:** check what regulated facilities exist near a home.
- **Non-profit:** community and watchdog groups mapping local sites.
- **Experimentation:** practice geocoding and data joins on real public records.

### 🤖 Ask an AI assistant

Paste the output into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to cluster facilities by county, summarize program coverage, or draft a screening report.

### ❓ Frequently Asked Questions

**What is the EPA FRS?** The Facility Registry Service is the EPA's master index of facilities subject to environmental regulation.

**Where does the data come from?** The official public `data.epa.gov` efservice endpoint for the `FRS_PROGRAM_FACILITY` table.

**Which states are covered?** All 50 states, the District of Columbia, and US territories such as Puerto Rico and Guam.

**Can I filter by program?** Yes. Use `programAcronym` to limit results to a single EPA program system.

**Why do some facilities repeat names?** A facility can be registered under multiple program systems, so it can appear once per program.

**Why are some fields null?** When the registry has no value, or only a placeholder, the field is returned as null instead of a guess.

**Does it return latitude and longitude?** This Actor returns the standardized address fields from the program facility table. Coordinates are not part of this table.

**How many records can I get?** Free plan returns up to 10. Paid plans can pull far more.

**Is there an API key needed for EPA?** No. The EPA endpoint is public and keyless.

**Is this affiliated with the EPA?** No. It is an independent tool that reads publicly available data.

### 🔌 Integrate with any app

Use the Apify API, webhooks, and scheduling to wire results into your stack. Output flows cleanly into sheets, databases, dashboards, and automation platforms.

### 🔗 Recommended Actors

- [ParseForge collection](https://apify.com/parseforge) for more public data scrapers.
- OpenStreetMap and government registry scrapers for location enrichment.
- Geocoding actors to add coordinates to facility addresses.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with the US EPA. Only publicly available data is collected.

# Actor input Schema

## `stateCode` (type: `string`):

US state or territory to pull regulated facilities for.

## `programAcronym` (type: `string`):

Optional EPA program system to filter facilities by. Leave on Any to include all programs.

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "stateCode": "CA",
  "programAcronym": "",
  "maxItems": 10
}
```

# Actor output Schema

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

No description

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/epa-frs-facility-registry-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/epa-frs-facility-registry-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 '{
  "maxItems": 10
}' |
apify call parseforge/epa-frs-facility-registry-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/epa-frs-facility-registry-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EPA FRS Facility Registry Scraper",
        "description": "Tap the US EPA Facility Registry Service for regulated facilities in any state. Returns registry ID, facility name, street address, city, county, ZIP, EPA region, and program system acronym. Filter by state or program for compliance research, site screening, and mapping.",
        "version": "0.1",
        "x-build-id": "jkt6KWfiLNkEaAuIM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~epa-frs-facility-registry-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-epa-frs-facility-registry-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/parseforge~epa-frs-facility-registry-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-epa-frs-facility-registry-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/parseforge~epa-frs-facility-registry-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-epa-frs-facility-registry-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",
                "required": [
                    "stateCode"
                ],
                "properties": {
                    "stateCode": {
                        "title": "State Code",
                        "enum": [
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "DC",
                            "FL",
                            "GA",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NC",
                            "ND",
                            "OH",
                            "OK",
                            "OR",
                            "PA",
                            "RI",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY",
                            "PR",
                            "VI",
                            "GU",
                            "AS",
                            "MP"
                        ],
                        "type": "string",
                        "description": "US state or territory to pull regulated facilities for.",
                        "default": "CA"
                    },
                    "programAcronym": {
                        "title": "Program System Acronym",
                        "enum": [
                            "",
                            "NPDES",
                            "RCRAINFO",
                            "AIRS/AFS",
                            "AIR",
                            "CAMDBS",
                            "ICIS",
                            "SEMS",
                            "TRIS",
                            "FFEIS",
                            "RMP",
                            "SSTS",
                            "EGRID",
                            "OIL",
                            "SDWIS",
                            "E-GGRT",
                            "FRS",
                            "PCS",
                            "TSCA"
                        ],
                        "type": "string",
                        "description": "Optional EPA program system to filter facilities by. Leave on Any to include all programs.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```