# Hospital Compare Medicare Scraper (`automation-lab/hospital-compare-medicare-scraper`) Actor

Extract CMS Care Compare hospital locations, ownership, ratings, and Medicare quality fields from the public CMS Provider Data API.

- **URL**: https://apify.com/automation-lab/hospital-compare-medicare-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

## Hospital Compare Medicare Scraper

Extract CMS Care Compare / Medicare Hospital Compare data from the public CMS Provider Data API. Get hospital names, CCNs, addresses, ownership, emergency services, overall ratings, quality fields, and source metadata in a clean Apify dataset.

### What does Hospital Compare Medicare Scraper do?

Hospital Compare Medicare Scraper downloads structured hospital/provider records from CMS Provider Data. It is built for repeatable healthcare data workflows where teams need current public Medicare hospital data without manually downloading CSV files.

The default run uses the CMS **Hospital General Information** dataset (`xubh-q36u`). Advanced users can provide any compatible CMS Provider Data dataset ID and still receive normalized fields plus the full CMS row in `cmsRow`.

### Who is it for?

- 🏥 Healthcare analytics teams building hospital benchmarks
- 💳 Payers and provider-network teams checking facility coverage
- 📊 Consultants preparing CMS quality and compliance reports
- 🧭 Hospital strategy teams tracking ratings and ownership data
- 🔎 SEO and reputation teams creating local hospital directories
- ⚖️ Compliance teams that need repeatable public-source evidence

### Why use this scraper?

CMS data is public, but the export workflow can be repetitive. This actor turns the CMS Provider Data API into a reusable Apify workflow with filters, normalized output, charging, API access, scheduling, webhooks, and integrations.

### Data source

The actor uses CMS Provider Data API endpoints under:

`https://data.cms.gov/provider-data/api/1`

Default dataset:

`xubh-q36u` — Hospital General Information

### Example use cases

- Export all hospitals in a state for market sizing
- Monitor overall hospital ratings for local competitors
- Build a provider directory with CCNs and contact details
- Join CMS hospital data with internal claims or network data
- Pull raw CMS rows for a downstream BI warehouse

### How much does it cost to scrape CMS hospital compare data?

Pricing is pay-per-event. A small start fee is charged per run and a per-record fee is charged for each hospital/provider record saved. The default input is set to 100 records so first runs stay inexpensive.

Use `maxItems` to control cost. For large nationwide exports, start with a state filter or a few hundred records, verify the output, then increase the limit.

### Input options

| Field | Description |
| --- | --- |
| `datasetPreset` | Choose `hospital_general` or `raw_dataset` |
| `datasetId` | CMS Provider Data dataset ID when using `raw_dataset` |
| `maxItems` | Maximum records saved to the dataset |
| `state` | Optional two-letter state filter |
| `facilityNameContains` | Optional hospital name substring filter |
| `facilityIds` | Optional list of CMS CCNs / facility IDs |
| `pageSize` | CMS API page size |
| `includeRawRecord` | Include the full CMS row in `rawRecord` |

### Output fields

| Field | Description |
| --- | --- |
| `datasetId` | CMS dataset identifier |
| `datasetPreset` | Selected preset |
| `sourceDatasetUrl` | CMS API URL used as source |
| `providerCcn` | CMS certification number / facility ID |
| `facilityName` | Hospital or facility name |
| `address`, `city`, `state`, `zipCode`, `county` | Location fields |
| `phone` | Telephone number |
| `hospitalType` | CMS hospital type |
| `hospitalOwnership` | Ownership category |
| `emergencyServices` | Emergency services flag |
| `overallRating` | Overall hospital rating when present |
| `measureId`, `measureName`, `score` | Measure fields for compatible datasets |
| `comparedToNational` | National comparison where present |
| `footnote` | CMS footnote text/code where present |
| `reportingPeriod` | Reporting period/date field where present |
| `cmsRow` | Complete source CMS row |
| `scrapedAt` | ISO timestamp of extraction |

### Sample output

```json
{
  "datasetId": "xubh-q36u",
  "datasetPreset": "hospital_general",
  "providerCcn": "010001",
  "facilityName": "SOUTHEAST HEALTH MEDICAL CENTER",
  "city": "DOTHAN",
  "state": "AL",
  "hospitalType": "Acute Care Hospitals",
  "overallRating": "4",
  "sourceDatasetUrl": "https://data.cms.gov/provider-data/api/1/datastore/query/xubh-q36u/0",
  "scrapedAt": "2026-06-29T00:00:00.000Z"
}
````

### How to run

1. Open the actor on Apify.
2. Keep the default `hospital_general` preset or enter a CMS dataset ID.
3. Set `maxItems` and optional filters.
4. Click **Start**.
5. Download the dataset as JSON, CSV, Excel, XML, or RSS.

### Tips for best results

- Use `state` for state-level exports.
- Use `facilityIds` when you already know the CMS CCNs you need.
- Keep `includeRawRecord` off unless you need a duplicate raw object.
- For raw CMS datasets, inspect the returned `cmsRow` to see dataset-specific columns.

### Raw CMS dataset mode

Choose `raw_dataset` and provide a CMS Provider Data dataset ID such as `xubh-q36u`. The actor still normalizes common hospital fields when matching columns exist and preserves the full row in `cmsRow`.

### Scheduling

Use Apify schedules to refresh hospital data monthly or after CMS data refreshes. Scheduled runs can send datasets to a webhook, cloud storage, or an integration platform.

### Integrations

- Send output to Google Sheets for analyst review
- Push JSON to a data warehouse with Apify webhooks
- Use Make or Zapier to notify a team when ratings change
- Feed records into a provider directory or enrichment pipeline

### 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/hospital-compare-medicare-scraper').call({
  datasetPreset: 'hospital_general',
  state: 'CA',
  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/hospital-compare-medicare-scraper').call(run_input={
    'datasetPreset': 'hospital_general',
    'state': 'CA',
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~hospital-compare-medicare-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"datasetPreset":"hospital_general","state":"CA","maxItems":100}'
```

### MCP access

Use the Apify MCP server with Claude Code or Claude Desktop:

`https://mcp.apify.com/?tools=automation-lab/hospital-compare-medicare-scraper`

Claude Code setup:

```bash
claude mcp add apify-hospital-compare "https://mcp.apify.com/?tools=automation-lab/hospital-compare-medicare-scraper"
```

Claude Desktop JSON config:

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

Example prompts:

- "Run the Hospital Compare Medicare Scraper for California hospitals and summarize ownership types."
- "Extract 250 CMS hospital records and identify facilities with missing ratings."
- "Get hospital records for these CCNs and prepare a CSV export."

### Data freshness

The actor fetches directly from CMS Provider Data at run time. Freshness depends on the CMS dataset itself, not a cached copy maintained by the actor.

### Limitations

- It extracts public CMS Provider Data only.
- It does not access private Medicare systems or provider portals.
- Raw dataset mode normalizes common columns but dataset-specific fields remain in `cmsRow`.

### Legality

CMS Provider Data is public government data. You are responsible for using the data in accordance with applicable laws, CMS terms, and your organization's compliance requirements.

### FAQ

#### Can I use this for any CMS Provider Data hospital dataset?

Yes. Use `raw_dataset` with a CMS Provider Data dataset ID. Common columns are normalized and every original column remains in `cmsRow`.

#### Does this scrape private Medicare systems?

No. It extracts public CMS Provider Data only.

### Troubleshooting

#### Why do some rating fields look empty?

CMS may publish blanks, footnotes, or dataset-specific column names. Check `cmsRow` for the original source fields.

#### Why did a raw dataset ID fail?

The actor expects CMS Provider Data dataset IDs supported by the `/provider-data/api/1/datastore/query/{datasetId}/0` endpoint. Verify the dataset ID on data.cms.gov.

### Related scrapers

- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/business-data-enrichment

### Support

If you need another CMS dataset preset or a different healthcare output shape, open an issue from the Apify actor page with an example dataset and desired fields.

# Actor input Schema

## `datasetPreset` (type: `string`):

Choose the built-in Hospital General Information dataset or use a raw CMS Provider Data dataset ID.

## `datasetId` (type: `string`):

Required only when Dataset preset is Raw CMS Provider Data dataset ID. Example: xubh-q36u.

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

Maximum records to save. Increase for statewide or nationwide benchmarking exports.

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

Optional two-letter state abbreviation, e.g. CA, TX, NY. Leave empty for nationwide data.

## `facilityNameContains` (type: `string`):

Optional case-insensitive hospital name filter.

## `facilityIds` (type: `array`):

Optional provider CCNs / facility IDs to extract, e.g. 010001.

## `pageSize` (type: `integer`):

Records requested per CMS API page. The default balances speed and reliability.

## `includeRawRecord` (type: `boolean`):

Adds rawRecord with the complete CMS row in addition to normalized fields.

## Actor input object example

```json
{
  "datasetPreset": "hospital_general",
  "datasetId": "xubh-q36u",
  "maxItems": 20,
  "state": "CA",
  "pageSize": 250,
  "includeRawRecord": 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 = {
    "datasetPreset": "hospital_general",
    "datasetId": "xubh-q36u",
    "maxItems": 20,
    "state": "CA",
    "pageSize": 250,
    "includeRawRecord": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/hospital-compare-medicare-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 = {
    "datasetPreset": "hospital_general",
    "datasetId": "xubh-q36u",
    "maxItems": 20,
    "state": "CA",
    "pageSize": 250,
    "includeRawRecord": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/hospital-compare-medicare-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 '{
  "datasetPreset": "hospital_general",
  "datasetId": "xubh-q36u",
  "maxItems": 20,
  "state": "CA",
  "pageSize": 250,
  "includeRawRecord": false
}' |
apify call automation-lab/hospital-compare-medicare-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hospital Compare Medicare Scraper",
        "description": "Extract CMS Care Compare hospital locations, ownership, ratings, and Medicare quality fields from the public CMS Provider Data API.",
        "version": "0.1",
        "x-build-id": "HsyrSwxFFp7WL291a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~hospital-compare-medicare-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-hospital-compare-medicare-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~hospital-compare-medicare-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-hospital-compare-medicare-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~hospital-compare-medicare-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-hospital-compare-medicare-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": {
                    "datasetPreset": {
                        "title": "Dataset preset",
                        "enum": [
                            "hospital_general",
                            "raw_dataset"
                        ],
                        "type": "string",
                        "description": "Choose the built-in Hospital General Information dataset or use a raw CMS Provider Data dataset ID.",
                        "default": "hospital_general"
                    },
                    "datasetId": {
                        "title": "Raw CMS dataset ID",
                        "type": "string",
                        "description": "Required only when Dataset preset is Raw CMS Provider Data dataset ID. Example: xubh-q36u."
                    },
                    "maxItems": {
                        "title": "Maximum hospital records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum records to save. Increase for statewide or nationwide benchmarking exports.",
                        "default": 20
                    },
                    "state": {
                        "title": "State filter",
                        "type": "string",
                        "description": "Optional two-letter state abbreviation, e.g. CA, TX, NY. Leave empty for nationwide data."
                    },
                    "facilityNameContains": {
                        "title": "Facility name contains",
                        "type": "string",
                        "description": "Optional case-insensitive hospital name filter."
                    },
                    "facilityIds": {
                        "title": "CMS certification numbers (CCNs)",
                        "type": "array",
                        "description": "Optional provider CCNs / facility IDs to extract, e.g. 010001.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "pageSize": {
                        "title": "CMS API page size",
                        "minimum": 10,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Records requested per CMS API page. The default balances speed and reliability.",
                        "default": 250
                    },
                    "includeRawRecord": {
                        "title": "Include raw CMS record",
                        "type": "boolean",
                        "description": "Adds rawRecord with the complete CMS row in addition to normalized fields.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
