# FDIC BankFind Scraper (`automation-lab/fdic-bankfind-scraper`) Actor

Extract FDIC BankFind institution records by name, CERT, state, city, status, assets, deposits, offices, and websites for analysis.

- **URL**: https://apify.com/automation-lab/fdic-bankfind-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## FDIC BankFind Scraper

Extract FDIC BankFind institution records from the public FDIC BankFind API.

Use this actor to search banks by name, FDIC certificate number, state, city, and active status, then export clean institution rows for compliance, enrichment, monitoring, and lead-generation workflows.

### What does FDIC BankFind Scraper do?

FDIC BankFind Scraper collects public institution records from FDIC BankFind.

It returns one dataset item per institution.

Each record includes identifiers, location, status, financial summary fields, website, and source metadata.

The actor is HTTP/API based and does not require a browser.

It uses the public FDIC endpoint at `banks.data.fdic.gov`.

### Who is it for?

- 🏦 Bank analysts building institution lookup tables.
- ✅ Compliance teams validating FDIC certificate numbers.
- 📊 Fintech data teams enriching customer or prospect records.
- 🧾 B2B lead generation teams finding bank websites and branches.
- 🔎 Researchers monitoring active and inactive bank institutions.
- 🧩 Data engineers feeding FDIC records into warehouses and CRMs.

### Why use this actor?

FDIC BankFind is authoritative, but teams often need export-ready data.

This actor turns FDIC API responses into normalized Apify dataset rows.

You can schedule it, call it from code, or connect it to integrations.

You also get run metadata and source URLs for audit trails.

### What data can you extract?

| Field | Description |
| --- | --- |
| `institutionName` | FDIC institution name |
| `cert` | FDIC certificate number |
| `fdicId` | FDIC API ID |
| `active` | Active institution flag |
| `city` | Institution city |
| `state` | Two-letter state abbreviation |
| `stateName` | Full state name |
| `zip` | ZIP code |
| `county` | County |
| `class` | Institution class when available |
| `assetsUsdThousands` | Assets from FDIC API, in thousands of USD |
| `depositsUsdThousands` | Domestic deposits from FDIC API, in thousands of USD |
| `offices` | Office count |
| `website` | Normalized website URL |
| `runDate` | FDIC source run date |
| `sourceUrl` | Exact FDIC API URL used |
| `scrapedAt` | Actor scrape timestamp |

### How much does it cost to extract FDIC BankFind data?

This actor uses pay-per-event pricing.

You pay a small start fee for each run.

You also pay per institution record saved.

The default input is intentionally small enough for a cheap first run.

For large exports, set `maxItems` to the number of institutions you need.

### Input options

`search` searches institution names with FDIC wildcard matching.

`certs` fetches exact FDIC certificate numbers.

`states` filters by two-letter state abbreviation.

`cities` filters by exact city name.

`activeStatus` can be `active`, `inactive`, or `all`.

`maxItems` controls the maximum number of rows saved.

`sortBy` and `sortOrder` control FDIC API ordering.

`includeRaw` adds the selected raw FDIC row to each output item.

### Example input

```json
{
  "search": "JPMorgan",
  "activeStatus": "all",
  "maxItems": 25,
  "sortBy": "NAME",
  "sortOrder": "ASC",
  "includeRaw": false
}
````

### Search by certificate number

Use `certs` when you already know FDIC certificate numbers.

```json
{
  "certs": ["628", "3510"],
  "activeStatus": "all",
  "maxItems": 10
}
```

This is useful for compliance checks and enrichment.

### Search by state or city

Use `states` to build state-level bank lists.

Use `cities` to narrow a list to a city.

```json
{
  "states": ["CA"],
  "activeStatus": "active",
  "maxItems": 100
}
```

For broad state exports, keep `search` empty.

### Output example

```json
{
  "institutionName": "JPMorgan Chase Bank, National Association",
  "cert": 628,
  "fdicId": "628",
  "active": true,
  "city": "Columbus",
  "state": "OH",
  "stateName": "Ohio",
  "zip": "43240",
  "county": "Delaware",
  "class": "N",
  "assetsUsdThousands": 4000000000,
  "depositsUsdThousands": 2000000000,
  "offices": 4000,
  "website": "https://www.chase.com",
  "runDate": "06/26/2026",
  "source": "FDIC BankFind API / institutions",
  "sourceUrl": "https://banks.data.fdic.gov/api/institutions?...",
  "searchQuery": "JPMorgan",
  "scrapedAt": "2026-06-29T00:00:00.000Z"
}
```

### Tips for best results

Use exact certificate numbers for direct lookup.

Use short bank-name keywords for name discovery.

Set `activeStatus` to `all` if you are researching historical institutions.

Use `includeRaw` when you need to audit FDIC source fields.

Increase `maxItems` gradually for large exports.

### Integrations

Send FDIC BankFind data to Google Sheets for analyst review.

Export JSON or CSV to a warehouse for enrichment joins.

Trigger the actor from Zapier or Make when a new bank lead enters your CRM.

Schedule a weekly run to monitor changes in active institutions.

Use webhooks to notify your compliance system when a run finishes.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fdic-bankfind-scraper').call({
  search: 'community bank',
  states: ['TX'],
  activeStatus: 'active',
  maxItems: 100
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/fdic-bankfind-scraper').call(run_input={
    'states': ['NY'],
    'activeStatus': 'active',
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~fdic-bankfind-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"search":"JPMorgan","activeStatus":"all","maxItems":25}'
```

### MCP usage

Use this actor through Apify MCP from Claude Code or Claude Desktop.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/fdic-bankfind-scraper
```

Claude Code setup:

```bash
claude mcp add apify-fdic-bankfind https://mcp.apify.com/?tools=automation-lab/fdic-bankfind-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-fdic-bankfind": {
      "url": "https://mcp.apify.com/?tools=automation-lab/fdic-bankfind-scraper"
    }
  }
}
```

Example prompts:

- "Find active FDIC institutions in California and return their websites."
- "Look up FDIC CERT 628 and summarize its BankFind record."
- "Create a CSV of active banks in Austin from FDIC BankFind."

### Scheduling workflows

Create a daily, weekly, or monthly schedule in Apify Console.

Use a fixed input such as one state or one list of certificate numbers.

Export each run's dataset to your destination system.

### Data source

The data source is the public FDIC BankFind API.

The actor does not bypass access controls.

It does not require login credentials.

It does not use residential proxy traffic.

### Legality and responsible use

FDIC BankFind data is public government data.

You are responsible for using exported data lawfully.

Do not present derived data as legal advice.

For regulated workflows, keep source URLs and timestamps for auditability.

### FAQ

#### Why did my run return zero records?

Broaden the name search, remove exact city filters, or set `activeStatus` to `all`.

#### Are assets and deposits in dollars?

FDIC API `ASSET` and `DEPDOM` values are reported in thousands of USD, so the output fields are named `assetsUsdThousands` and `depositsUsdThousands`.

### Troubleshooting

If you get zero results, broaden the name search or set `activeStatus` to `all`.

If a city filter returns more than expected, add a state filter.

If certificate lookup fails, make sure the CERT value contains only digits.

If you need fields not listed here, enable `includeRaw` first and inspect the source row.

### Related scrapers

Explore more Automation Lab public-data and finance actors:

- https://apify.com/automation-lab/sec-litigation-releases-scraper
- https://apify.com/automation-lab/ofac-sanctions-list-export-scraper
- https://apify.com/automation-lab/world-bank-projects-scraper
- https://apify.com/automation-lab/company-funding-tracker

### Changelog

Initial version extracts institution records from `/api/institutions`.

### Support

Open an Apify issue if the FDIC API changes or you need additional BankFind fields.

Include your input JSON and run ID so we can reproduce the request.

# Actor input Schema

## `search` (type: `string`):

Optional bank name keyword. The actor uses FDIC wildcard matching against the institution NAME field.

## `certs` (type: `array`):

Optional exact FDIC CERT numbers. Leave empty for a search/listing run.

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

Optional two-letter state filters, such as CA, NY, TX. Multiple states are combined with OR.

## `cities` (type: `array`):

Optional city filters. Multiple cities are combined with OR.

## `activeStatus` (type: `string`):

Choose active institutions, inactive institutions, or all FDIC institution history.

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

Maximum number of institution records to save to the dataset.

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

FDIC API field used for ordering results.

## `sortOrder` (type: `string`):

Ascending or descending FDIC API sort order.

## `includeRaw` (type: `boolean`):

Add the selected raw FDIC API fields to each output item for auditing and custom mapping.

## Actor input object example

```json
{
  "search": "JPMorgan",
  "certs": [],
  "states": [],
  "cities": [],
  "activeStatus": "active",
  "maxItems": 20,
  "sortBy": "NAME",
  "sortOrder": "ASC",
  "includeRaw": false
}
```

# Actor output Schema

## `overview` (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 = {
    "search": "JPMorgan",
    "certs": [],
    "states": [],
    "cities": [],
    "activeStatus": "active",
    "maxItems": 20,
    "sortBy": "NAME",
    "sortOrder": "ASC",
    "includeRaw": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fdic-bankfind-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 = {
    "search": "JPMorgan",
    "certs": [],
    "states": [],
    "cities": [],
    "activeStatus": "active",
    "maxItems": 20,
    "sortBy": "NAME",
    "sortOrder": "ASC",
    "includeRaw": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fdic-bankfind-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 '{
  "search": "JPMorgan",
  "certs": [],
  "states": [],
  "cities": [],
  "activeStatus": "active",
  "maxItems": 20,
  "sortBy": "NAME",
  "sortOrder": "ASC",
  "includeRaw": false
}' |
apify call automation-lab/fdic-bankfind-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/fdic-bankfind-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDIC BankFind Scraper",
        "description": "Extract FDIC BankFind institution records by name, CERT, state, city, status, assets, deposits, offices, and websites for analysis.",
        "version": "0.1",
        "x-build-id": "dXdcKiZKIelbYU68v"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~fdic-bankfind-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-fdic-bankfind-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/automation-lab~fdic-bankfind-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-fdic-bankfind-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/automation-lab~fdic-bankfind-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-fdic-bankfind-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": {
                    "search": {
                        "title": "Bank name contains",
                        "type": "string",
                        "description": "Optional bank name keyword. The actor uses FDIC wildcard matching against the institution NAME field."
                    },
                    "certs": {
                        "title": "FDIC certificate numbers",
                        "type": "array",
                        "description": "Optional exact FDIC CERT numbers. Leave empty for a search/listing run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "states": {
                        "title": "State abbreviations",
                        "type": "array",
                        "description": "Optional two-letter state filters, such as CA, NY, TX. Multiple states are combined with OR.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Za-z]{2}$"
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Optional city filters. Multiple cities are combined with OR.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "activeStatus": {
                        "title": "Active status",
                        "enum": [
                            "active",
                            "inactive",
                            "all"
                        ],
                        "type": "string",
                        "description": "Choose active institutions, inactive institutions, or all FDIC institution history.",
                        "default": "active"
                    },
                    "maxItems": {
                        "title": "Maximum institutions",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of institution records to save to the dataset.",
                        "default": 20
                    },
                    "sortBy": {
                        "title": "Sort by FDIC field",
                        "enum": [
                            "NAME",
                            "CERT",
                            "CITY",
                            "STALP",
                            "ASSET",
                            "DEPDOM",
                            "OFFICES"
                        ],
                        "type": "string",
                        "description": "FDIC API field used for ordering results.",
                        "default": "NAME"
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "ASC",
                            "DESC"
                        ],
                        "type": "string",
                        "description": "Ascending or descending FDIC API sort order.",
                        "default": "ASC"
                    },
                    "includeRaw": {
                        "title": "Include raw FDIC row",
                        "type": "boolean",
                        "description": "Add the selected raw FDIC API fields to each output item for auditing and custom mapping.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```