# NLM ICD-10-CM Clinical Tables Lookup Scraper (`automation-lab/nlm-icd10cm-clinical-tables-lookup-scraper`) Actor

Look up ICD-10-CM diagnosis codes from the public NLM Clinical Tables API by clinical term, code prefix, or billing keyword.

- **URL**: https://apify.com/automation-lab/nlm-icd10cm-clinical-tables-lookup-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **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

## NLM ICD-10-CM Clinical Tables Lookup Scraper

Look up ICD-10-CM diagnosis codes from the public NLM Clinical Tables API and export clean, auditable results for billing, coding, EHR, analytics, and clinical data workflows.

The actor accepts diagnosis phrases, medical keywords, or code fragments such as `diabetes`, `hypertension`, `asthma`, or `E11` and returns ICD-10-CM code matches with names, ranks, source URLs, timestamps, and raw NLM rows.

### What does this ICD-10-CM scraper do?

It calls the official NLM Clinical Tables ICD-10-CM JSON endpoint.

It converts the array-based API response into typed dataset rows.

It preserves the source request URL for every result.

It can run small autocomplete checks or larger terminology exports.

It does not require a login, browser session, or third-party medical account.

### Who is it for?

🏥 Healthcare billing teams can map common diagnosis terms before claim preparation.

🧾 Medical coding teams can create repeatable lookup exports for ICD-10-CM review.

🧑‍⚕️ EHR and health-app teams can prototype autocomplete and search experiences.

📊 Healthcare analytics teams can normalize free-text condition labels into candidate codes.

🤖 AI and data-labeling teams can enrich clinical labels with official code suggestions.

### Why use this actor?

The NLM endpoint is public, fast, and reliable, but its response is a compact array format.

This actor gives you spreadsheet-friendly rows instead of nested API tuples.

You also get the original raw tuple for audit and QA.

Runs are lightweight because the actor uses direct HTTP requests only.

### Data source

Source: National Library of Medicine Clinical Tables.

Endpoint: `https://clinicaltables.nlm.nih.gov/api/icd10cm/v3/search`.

Dataset: ICD-10-CM diagnosis codes.

Authentication: none required.

Anti-bot risk: low for normal lookup volumes.

### What data can I extract?

| Field | Description |
| --- | --- |
| `inputTerm` | Search term submitted by the user |
| `code` | ICD-10-CM diagnosis code |
| `name` | NLM diagnosis name |
| `diagnosisDescription` | Human-readable diagnosis description |
| `rank` | Result position for that term |
| `totalMatchesForTerm` | NLM total match count |
| `source` | Source label |
| `sourceUrl` | Exact API request URL |
| `searchFields` | Effective NLM search fields |
| `fetchedAt` | ISO timestamp |
| `rawRow` | Raw NLM tuple |
| `rawCodeList` | Raw code list from the response |

### How much does it cost to look up ICD-10-CM codes?

This actor uses pay-per-event pricing.

There is a small start charge per run.

There is a per-result charge for every ICD-10-CM row saved.

The default pricing is designed for inexpensive recurring lookups.

Final live tier prices are visible in the Apify Store pricing panel.

### Input options

`terms` is the main input.

Use one term or many terms.

Examples: `diabetes`, `hypertension`, `chronic kidney disease`, `E11`, `asthma`.

`maxResults` controls how many matches are returned per term.

`searchFields` controls the NLM `sf` parameter.

`displayFields` optionally passes an NLM `df` parameter.

`includeRaw` keeps raw tuples for auditability.

### Example input

```json
{
  "terms": ["diabetes", "hypertension", "asthma"],
  "maxResults": 50,
  "searchFields": "code,name",
  "includeRaw": true
}
````

### Example output

```json
{
  "inputTerm": "diabetes",
  "code": "E23.2",
  "name": "Diabetes insipidus",
  "diagnosisDescription": "Diabetes insipidus",
  "rank": 1,
  "totalMatchesForTerm": 481,
  "source": "NLM Clinical Tables ICD-10-CM",
  "sourceUrl": "https://clinicaltables.nlm.nih.gov/api/icd10cm/v3/search?...",
  "searchFields": "code,name",
  "fetchedAt": "2026-06-30T00:00:00.000Z"
}
```

### How to run the actor

Open the actor on Apify.

Enter your ICD-10-CM search terms.

Choose the maximum results per term.

Run the actor.

Download the dataset as JSON, CSV, Excel, XML, or via API.

### Tips for better results

Use clinical phrases for diagnosis-name searches.

Use code prefixes for code-family exploration.

Keep `searchFields` as `code,name` for broad discovery.

Use `code` when you only want code-prefix matches.

Use `name` when you want diagnosis text matching.

Set `maxResults` higher for broad terms such as pain or disease.

Set `maxResults` lower for autocomplete use cases.

### Common workflows

Build a lookup table for common intake diagnoses.

Generate candidate ICD-10-CM codes from free-text labels.

Validate whether a diagnosis phrase returns expected official codes.

Export code suggestions into a claims preprocessing pipeline.

Create a repeatable EHR autocomplete seed list.

### Integrations

Send results to Google Sheets using Apify integrations.

Load the dataset into Snowflake, BigQuery, or Postgres.

Trigger runs from a clinical data pipeline with the Apify API.

Use webhooks to notify your coding QA workflow when a lookup batch finishes.

Combine with enrichment actors from `automation-lab` for larger healthcare data pipelines.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/nlm-icd10cm-clinical-tables-lookup-scraper').call({
  terms: ['diabetes', 'hypertension'],
  maxResults: 25
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/nlm-icd10cm-clinical-tables-lookup-scraper').call(run_input={
    'terms': ['diabetes', 'hypertension'],
    'maxResults': 25,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~nlm-icd10cm-clinical-tables-lookup-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"terms":["diabetes","hypertension"],"maxResults":25}'
```

### MCP usage

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

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/nlm-icd10cm-clinical-tables-lookup-scraper`

Claude Code command:

```bash
claude mcp add apify-icd10cm --url "https://mcp.apify.com/?tools=automation-lab/nlm-icd10cm-clinical-tables-lookup-scraper"
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-icd10cm": {
      "url": "https://mcp.apify.com/?tools=automation-lab/nlm-icd10cm-clinical-tables-lookup-scraper"
    }
  }
}
```

Example prompts:

- "Look up ICD-10-CM candidates for diabetes and hypertension."
- "Export 100 asthma-related ICD-10-CM code suggestions."
- "Find ICD-10-CM names for codes starting with E11."

### Automation ideas

Run nightly checks for new autocomplete seed terms.

Batch-normalize diagnosis labels before a model-training job.

Create QA samples for billing-code review.

Append source URLs to internal audit records.

### Limits and caveats

The actor returns matches from NLM Clinical Tables, not a medical coding decision.

Users are responsible for clinical review and compliance.

Broad terms may return many related codes.

The `description` field mirrors the NLM name for default rows.

Raw fields are included for traceability, not for end-user display.

### Legality and compliance

The actor queries a public U.S. National Library of Medicine endpoint.

It does not collect patient data.

Do not submit protected health information as search terms unless your Apify usage and downstream systems are approved for that workflow.

Always have qualified professionals review diagnosis coding decisions.

### Troubleshooting

If you get no results, try a shorter term or switch `searchFields` back to `code,name`.

If a broad term returns too many results, lower `maxResults` or use a more specific phrase.

If you need exact code lookups, use the code or prefix as the term and set `searchFields` to `code`.

### Related scrapers

Explore other `automation-lab` actors for healthcare, API, and data enrichment workflows:

- https://apify.com/automation-lab/medlineplus-scraper
- https://apify.com/automation-lab/hash-generator
- https://apify.com/automation-lab/website-contact-finder

### FAQ

#### Is this an official NLM product?

No. It is an Apify actor that uses the public NLM Clinical Tables API.

#### Does it provide medical advice?

No. It returns lookup candidates and source data only.

#### Can I use it for autocomplete?

Yes. Use small `maxResults` values and repeated terms to build autocomplete suggestions.

#### Can I export CSV?

Yes. Apify datasets can be downloaded as CSV, Excel, JSON, XML, RSS, or HTML.

#### Does it need proxies?

No. The current implementation uses direct HTTP requests to a public API.

### Support

If a run fails, share the run URL and input with support.

Include the term, max results, and search fields you used.

The raw NLM row fields make debugging easier.

### Changelog

Initial version: ICD-10-CM lookup via the NLM Clinical Tables search endpoint.

# Actor input Schema

## `terms` (type: `array`):

Clinical terms, diagnosis phrases, or ICD-10-CM code fragments to look up. Examples: diabetes, hypertension, asthma, E11.

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

Maximum ICD-10-CM matches to return for each search term. The NLM endpoint accepts up to 500.

## `searchFields` (type: `string`):

NLM sf parameter. Keep code,name for most workflows; use code for prefix lookups or name for term-only matching.

## `displayFields` (type: `string`):

Optional NLM df parameter. Leave blank to receive the default code/name row tuple.

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

Include raw tuple fields and code list for auditability and troubleshooting.

## Actor input object example

```json
{
  "terms": [
    "diabetes",
    "hypertension",
    "asthma"
  ],
  "maxResults": 20,
  "searchFields": "code,name",
  "includeRaw": true
}
```

# 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 = {
    "terms": [
        "diabetes",
        "hypertension",
        "asthma"
    ],
    "maxResults": 20,
    "searchFields": "code,name",
    "displayFields": "",
    "includeRaw": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/nlm-icd10cm-clinical-tables-lookup-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 = {
    "terms": [
        "diabetes",
        "hypertension",
        "asthma",
    ],
    "maxResults": 20,
    "searchFields": "code,name",
    "displayFields": "",
    "includeRaw": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/nlm-icd10cm-clinical-tables-lookup-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 '{
  "terms": [
    "diabetes",
    "hypertension",
    "asthma"
  ],
  "maxResults": 20,
  "searchFields": "code,name",
  "displayFields": "",
  "includeRaw": true
}' |
apify call automation-lab/nlm-icd10cm-clinical-tables-lookup-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NLM ICD-10-CM Clinical Tables Lookup Scraper",
        "description": "Look up ICD-10-CM diagnosis codes from the public NLM Clinical Tables API by clinical term, code prefix, or billing keyword.",
        "version": "0.1",
        "x-build-id": "GqRi0MKCvkaHlUsPx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~nlm-icd10cm-clinical-tables-lookup-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-nlm-icd10cm-clinical-tables-lookup-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~nlm-icd10cm-clinical-tables-lookup-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-nlm-icd10cm-clinical-tables-lookup-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~nlm-icd10cm-clinical-tables-lookup-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-nlm-icd10cm-clinical-tables-lookup-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": [
                    "terms"
                ],
                "properties": {
                    "terms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Clinical terms, diagnosis phrases, or ICD-10-CM code fragments to look up. Examples: diabetes, hypertension, asthma, E11.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum matches per term",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum ICD-10-CM matches to return for each search term. The NLM endpoint accepts up to 500.",
                        "default": 20
                    },
                    "searchFields": {
                        "title": "Search fields",
                        "enum": [
                            "code,name",
                            "code",
                            "name"
                        ],
                        "type": "string",
                        "description": "NLM sf parameter. Keep code,name for most workflows; use code for prefix lookups or name for term-only matching.",
                        "default": "code,name"
                    },
                    "displayFields": {
                        "title": "Display fields",
                        "type": "string",
                        "description": "Optional NLM df parameter. Leave blank to receive the default code/name row tuple."
                    },
                    "includeRaw": {
                        "title": "Include raw NLM rows",
                        "type": "boolean",
                        "description": "Include raw tuple fields and code list for auditability and troubleshooting.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
