# NC LCMHC License Scraper (`robust_obsidian/nc-lcmhc-license-scraper`) Actor

Extract every Licensed Clinical Mental Health Counselor in North Carolina with one run. Returns name, license number, status, city, and disciplinary flag from the official NCBLCMHC board database.

- **URL**: https://apify.com/robust\_obsidian/nc-lcmhc-license-scraper.md
- **Developed by:** [John Bolognino](https://apify.com/robust_obsidian) (community)
- **Categories:** Lead generation, Jobs
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 licensee\_returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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

## North Carolina LCMHC License Scraper

Extract every Licensed Clinical Mental Health Counselor in North Carolina with one run. Returns name, license number, license type, status, city, and disciplinary flag for every counselor licensed by the NC Board of Licensed Clinical Mental Health Counselors (NCBLCMHC).

Built for SaaS companies, marketing agencies, and B2B teams targeting therapists. Public records, sourced live from the official board database.

### What you get

Each licensee returned as one structured record:

| Field | Example | Notes |
|---|---|---|
| `license_number` | `12345` | License ID. Associates prefixed with `A`, supervisors with `S`. |
| `license_type` | `LCMHC` | One of: LCMHC, LCMHCA, LCMHCS, Qualified Supervisor |
| `full_name` | `Jane Smith` | Display name on the board |
| `first_name` | `Jane` |  |
| `last_name` | `Smith` |  |
| `status` | `Active` | Active, Inactive, Expired, Suspended, Revoked |
| `issue_date` | `2018-04-12` | ISO 8601 |
| `expiration_date` | `2026-04-30` | ISO 8601 |
| `city` | `Raleigh` |  |
| `state` | `NC` |  |
| `has_disciplinary_action` | `false` | Boolean derived from the detail record |
| `disciplinary_summary` | `null` | Short text when applicable |
| `source_url` | `https://portal.ncblcmhc.org/...` | Direct link to the board record |
| `scraped_at` | `2026-05-08T19:42:00Z` | ISO 8601 timestamp |

Output is delivered to your Apify dataset as JSON. Export to CSV, Excel, or JSON-Lines through the Apify Console or API.

### Who uses this

- **Mental health SaaS companies** — Build prospect lists for EHR, billing, and telehealth platforms. Filter by license type to target solo practitioners or supervisors.
- **B2B marketing agencies** — Power outreach campaigns to licensed therapists in North Carolina. Combine with email-enrichment tools to build full contact records.
- **Recruiters** — Find supervisors and senior practitioners for telehealth platforms and group practices.
- **Compliance and verification teams** — Bulk-validate license status across employee or contractor populations.
- **Researchers and journalists** — Analyze the licensed mental health workforce in NC, including disciplinary trends.

### Why this beats doing it yourself

The NCBLCMHC verification page caps results at 100 per query. To get the full population by hand, you'd run dozens of queries by last-name prefix and stitch the results together — and the site's undocumented JSON API requires knowing the right endpoint and payload format to call correctly.

This actor handles all of that:

- Walks the alphabet automatically and auto-deepens prefixes when the 100-cap is hit
- Uses a JSON API endpoint instead of standard form submission — works without session state or cookies
- Polite by default — one request per second, single concurrency, no hammering
- Returns clean structured JSON instead of HTML you have to parse
- Surfaces failed queries instead of silently dropping them

### Pricing

Pay-per-event. You're charged per licensee record returned. No subscription, no minimum.

- **First 100 records: free** — verify the data quality before you commit.
- **$0.005 per licensee record after that.**

A complete dump of all NC LCMHCs is approximately 30,000 records ≈ $150. Tight filters (one license type, one city) cost a few cents.

Apify platform compute is billed separately by Apify; typical full run uses a small fraction of the free monthly platform credit.

### Input

Open the input schema in the Apify Console UI for inline help. Quick summary:

| Field | Type | Description |
|---|---|---|
| `searchMode` | enum | `enumerate_all` for full population, `specific_query` for filtered search |
| `licenseTypes` | array | Subset of `[LCMHC, LCMHCA, LCMHCS, Qualified Supervisor]`. Default: all four. |
| `lastName` | string | Last-name filter (prefix match). Used in `specific_query` mode. |
| `firstName` | string | First-name filter. |
| `licenseNumber` | string | Exact license number lookup. |
| `city` | string | City filter. |
| `state` | string | State filter (mailing-address state, not licensure state). |
| `includeDetailPages` | boolean | Fetch each licensee's detail page for richer data. Default: `true`. |
| `maxRecords` | integer | Stop after N records. Useful for testing. Default: unlimited. |
| `politeDelaySeconds` | number | Seconds between requests. Default: 1.0. |

Three common usage patterns:

```json
// Full NC LCMHC dump
{ "searchMode": "enumerate_all" }

// Just supervisors, for recruiter targeting
{ "searchMode": "enumerate_all", "licenseTypes": ["LCMHCS"] }

// Verify a specific license
{ "searchMode": "specific_query", "licenseNumber": "12345" }
````

### Data freshness

Data is fetched live from the NCBLCMHC board database on every run. There is no cached intermediate database — what you get reflects the board's records at the moment of the run.

Recommended cadence for prospect lists: monthly refresh.
Recommended cadence for compliance verification: re-run on demand.

You can schedule recurring runs from the Apify Console with one click.

### Legal and ethical notes

This actor accesses **publicly available license records** from the official NCBLCMHC verification portal. North Carolina General Statutes Chapter 132 (the Public Records Act) explicitly classifies professional licensure data as public information available to citizens free or at minimal cost.

What this actor returns is exactly what any member of the public can see by visiting the board's website. We don't bypass logins, we don't access private data, and we don't fetch records that aren't already published by the state.

That said: if you use this data for outreach, you're responsible for compliance with CAN-SPAM, TCPA, and any state-specific rules. We provide the data; how you contact people is on you.

### Troubleshooting

**The actor returned fewer records than I expected.**
The actor returns all license statuses (Active, Inactive, Expired, Surrendered, Revoked) — there is no status filter. Note that the LCMHCA (associate) population is large (~11,500 records) because it includes both current and historical licenses across all statuses. Use the `status` field on each record to filter down to Active-only in your own pipeline.

**A specific known licensee is missing.**
Check the board's public site directly. New licenses can take 4-6 weeks to appear; recently-changed licenses may take a few days. If the license is on the board's site but not in our output, please open an issue.

**The actor failed mid-run.**
Apify's run logs show which queries failed. Most often this is a transient board-side hiccup. Re-run; you'll only be charged for new records.

**I need other states / other license types.**
We're building scrapers for adjacent NC boards (LMFT, LCSW) and other states' mental health boards. Check our publisher page for the full catalog.

### Maintenance

The NCBLCMHC verification page is a stable government site, but state agencies do occasionally change their search interfaces. We monitor the actor and patch within 48 hours if the site structure changes.

If you hit something broken, please open an issue on the Apify listing — we're notified immediately.

### Related actors from this publisher

- *(coming soon)* North Carolina LMFT License Scraper — Marriage and Family Therapists
- *(coming soon)* North Carolina LCSW License Scraper — Clinical Social Workers
- *(coming soon)* Florida LMHC License Scraper

### Changelog

#### v1.0.0 — Initial release

- Full enumeration of all four NCBLCMHC license types
- ASP.NET WebForms session handling
- Auto-deepening alphabet walk for 100-result cap
- Detail page enrichment
- Pay-per-event pricing

# Actor input Schema

## `searchMode` (type: `string`):

How to run the search. Choose 'Enumerate all' to dump the full population matching your filters. Choose 'Specific query' for a single targeted search.

## `licenseTypes` (type: `array`):

Which license types to include. Defaults to all four. Filter to a subset to reduce cost when you only need specific roles (e.g., only supervisors for recruiting).

## `lastName` (type: `string`):

Filter by last name. The board uses 'starts with' matching. Used in 'Specific query' mode; ignored in 'Enumerate all' mode.

## `firstName` (type: `string`):

Filter by first name. 'Starts with' matching.

## `licenseNumber` (type: `string`):

Exact license number lookup. Examples: '12345', 'A12345' (associate), 'S12345' (supervisor).

## `city` (type: `string`):

Filter by mailing-address city.

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

Filter by mailing-address state (2-letter). Most NC LCMHCs have NC mailing addresses, but some practice cross-border or moved.

## `includeDetailPages` (type: `boolean`):

Fetch each licensee's detail page for richer data including issue/expiration dates and disciplinary flags. Disable for faster, cheaper runs that return only list-view fields.

## `maxRecords` (type: `integer`):

Stop after this many records. Useful for testing. Leave at 0 for unlimited.

## `politeDelaySeconds` (type: `number`):

Seconds to wait between HTTP requests. Default 1.0 is courteous to the state agency website. Lower values risk rate limiting and aren't recommended.

## `maxPrefixDepth` (type: `integer`):

Advanced. How deep to recurse alphabet prefixes when the 100-result cap is hit. 4 is required for full coverage of NC's LCMHC population. Increase to 5 only if you see capped-query warnings in the run log.

## Actor input object example

```json
{
  "searchMode": "enumerate_all",
  "licenseTypes": [
    "LCMHC",
    "LCMHCA",
    "LCMHCS",
    "Qualified Supervisor"
  ],
  "includeDetailPages": true,
  "maxRecords": 0,
  "politeDelaySeconds": 1,
  "maxPrefixDepth": 4
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("robust_obsidian/nc-lcmhc-license-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("robust_obsidian/nc-lcmhc-license-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 '{}' |
apify call robust_obsidian/nc-lcmhc-license-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=robust_obsidian/nc-lcmhc-license-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NC LCMHC License Scraper",
        "description": "Extract every Licensed Clinical Mental Health Counselor in North Carolina with one run. Returns name, license number, status, city, and disciplinary flag from the official NCBLCMHC board database.",
        "version": "1.0",
        "x-build-id": "roU0UHqkDmlBoSS65"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/robust_obsidian~nc-lcmhc-license-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-robust_obsidian-nc-lcmhc-license-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/robust_obsidian~nc-lcmhc-license-scraper/runs": {
            "post": {
                "operationId": "runs-sync-robust_obsidian-nc-lcmhc-license-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/robust_obsidian~nc-lcmhc-license-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-robust_obsidian-nc-lcmhc-license-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": [
                    "searchMode"
                ],
                "properties": {
                    "searchMode": {
                        "title": "Search mode",
                        "enum": [
                            "enumerate_all",
                            "specific_query"
                        ],
                        "type": "string",
                        "description": "How to run the search. Choose 'Enumerate all' to dump the full population matching your filters. Choose 'Specific query' for a single targeted search.",
                        "default": "enumerate_all"
                    },
                    "licenseTypes": {
                        "title": "License types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which license types to include. Defaults to all four. Filter to a subset to reduce cost when you only need specific roles (e.g., only supervisors for recruiting).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "LCMHC",
                                "LCMHCA",
                                "LCMHCS",
                                "Qualified Supervisor"
                            ]
                        },
                        "default": [
                            "LCMHC",
                            "LCMHCA",
                            "LCMHCS",
                            "Qualified Supervisor"
                        ]
                    },
                    "lastName": {
                        "title": "Last name (prefix match)",
                        "type": "string",
                        "description": "Filter by last name. The board uses 'starts with' matching. Used in 'Specific query' mode; ignored in 'Enumerate all' mode."
                    },
                    "firstName": {
                        "title": "First name (prefix match)",
                        "type": "string",
                        "description": "Filter by first name. 'Starts with' matching."
                    },
                    "licenseNumber": {
                        "title": "License number",
                        "type": "string",
                        "description": "Exact license number lookup. Examples: '12345', 'A12345' (associate), 'S12345' (supervisor)."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Filter by mailing-address city."
                    },
                    "state": {
                        "title": "State",
                        "pattern": "^[A-Z]{2}$",
                        "type": "string",
                        "description": "Filter by mailing-address state (2-letter). Most NC LCMHCs have NC mailing addresses, but some practice cross-border or moved."
                    },
                    "includeDetailPages": {
                        "title": "Include detail pages",
                        "type": "boolean",
                        "description": "Fetch each licensee's detail page for richer data including issue/expiration dates and disciplinary flags. Disable for faster, cheaper runs that return only list-view fields.",
                        "default": true
                    },
                    "maxRecords": {
                        "title": "Max records",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many records. Useful for testing. Leave at 0 for unlimited.",
                        "default": 0
                    },
                    "politeDelaySeconds": {
                        "title": "Polite delay (seconds)",
                        "minimum": 0.5,
                        "maximum": 10,
                        "type": "number",
                        "description": "Seconds to wait between HTTP requests. Default 1.0 is courteous to the state agency website. Lower values risk rate limiting and aren't recommended.",
                        "default": 1
                    },
                    "maxPrefixDepth": {
                        "title": "Max alphabet prefix depth",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Advanced. How deep to recurse alphabet prefixes when the 100-result cap is hit. 4 is required for full coverage of NC's LCMHC population. Increase to 5 only if you see capped-query warnings in the run log.",
                        "default": 4
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```