# CMS Nursing Home Compare Scraper (`automation-lab/cms-nursing-home-compare-scraper`) Actor

🏥 Export CMS Care Compare nursing home facilities with ratings, ownership, bed counts, penalties, chains, and contact data.

- **URL**: https://apify.com/automation-lab/cms-nursing-home-compare-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

from $0.01 / 1,000 nursing home facility saveds

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

## CMS Nursing Home Compare Scraper

Export CMS Care Compare nursing home facility records from the official CMS Provider Data API.

### What does CMS Nursing Home Compare Scraper do?

This actor downloads nursing home facility data from CMS dataset `4pq5-n9py`.
It returns one normalized row per facility.
It includes CMS certification numbers, provider names, addresses, phone numbers, ownership type, certified beds, average residents, chain details, ratings, inspection fields, penalties, latitude, longitude, and source metadata.

### Who is it for?

- Healthcare market researchers building facility universes.
- Senior-care lead generation teams looking for operators by geography.
- Compliance teams monitoring CMS ratings and penalty indicators.
- Real estate and healthcare investors mapping bed supply.
- Data analysts who need repeatable CMS exports in a dataset or API.

### Why use this actor?

CMS publishes the source data, but analysts still need repeatable filtering, typed output, and Apify-ready exports.
This actor gives you a clean dataset without opening spreadsheets manually.
It is API-first and does not use a browser.
It can run nationwide or with focused filters.

### Data source

The actor uses the CMS Provider Data / Care Compare API.
The source dataset id is `4pq5-n9py`.
The source is public and requires no login.
Every output item includes `sourceDatasetId`, `sourceUrl`, and `fetchedAt`.

### What data can you extract?

| Field group | Examples |
| --- | --- |
| Identifiers | CCN, provider name, legal business name |
| Location | address, city, state, ZIP, county, phone, coordinates |
| Ownership | ownership type, provider type, chain name, chain id |
| Capacity | certified beds, residents per day |
| Ratings | overall, inspection, staffing, quality-measure ratings |
| Compliance | deficiencies, infection-control citations, fines, payment denials |
| Metadata | processing date, source URL, fetched timestamp |

### How much does it cost to scrape CMS nursing home data?

The actor uses pay-per-event pricing.
You pay a small start fee and a per-facility event for saved records.
Use low `maxResults` values for exploratory runs.
Use larger values for scheduled analytics exports.

### Input options

You can filter by state, CCN, provider name, city, ZIP, ownership type, special-focus status, rating range, and certified-bed range.
All filters are optional.
If you leave filters empty, the actor scans CMS records until it reaches `maxResults`.

### Example input

```json
{
  "states": ["CA"],
  "minOverallRating": 4,
  "maxResults": 100,
  "includeRaw": false
}
````

### Example output

```json
{
  "ccn": "055010",
  "providerName": "EXAMPLE NURSING CENTER",
  "city": "LOS ANGELES",
  "state": "CA",
  "ownershipType": "For profit - Corporation",
  "certifiedBeds": 99,
  "overallRating": 4,
  "sourceDatasetId": "4pq5-n9py",
  "fetchedAt": "2026-06-25T00:00:00.000Z"
}
```

### How to scrape nursing homes by state

1. Open the actor input.
2. Add one or more two-letter states to `states`.
3. Set `maxResults` to the number of facilities you need.
4. Run the actor.
5. Export the dataset as JSON, CSV, Excel, XML, or via API.

### How to monitor ratings

Run the actor on a schedule with your state or CCN list.
Store each dataset in your BI tool.
Compare `overallRating`, `healthInspectionRating`, `staffingRating`, and penalty fields over time.

### How to build lead lists

Filter by state, city, ZIP, ownership type, certified beds, or chain name from the output.
Use phone, address, owner type, and capacity fields to prioritize outreach.
Combine the results with your CRM or enrichment workflow.

### Tips for better results

- Use `states` when you only need a regional export.
- Use `ccns` for exact facility monitoring.
- Use `providerNames` for brand or operator searches.
- Use `includeRaw` when you want all CMS source columns.
- Keep `maxResults` low while testing.

### Integrations

Send the dataset to Google Sheets, BigQuery, Snowflake, S3, Make, Zapier, or your own API.
The Apify dataset API lets you fetch results programmatically after each run.
Scheduled runs can power dashboards and compliance checks.

### 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/cms-nursing-home-compare-scraper').call({
  states: ['NY'],
  maxResults: 250
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/cms-nursing-home-compare-scraper').call(run_input={
    'states': ['TX'],
    'maxResults': 250,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(len(items))
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~cms-nursing-home-compare-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"states":["FL"],"maxResults":100}'
```

### MCP usage

Use Apify MCP with Claude Desktop or Claude Code to run the actor from a prompt.
MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/cms-nursing-home-compare-scraper
```

Add it in Claude Code:

```bash
claude mcp add apify-cms-nursing-homes https://mcp.apify.com/?tools=automation-lab/cms-nursing-home-compare-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-cms-nursing-homes": {
      "url": "https://mcp.apify.com/?tools=automation-lab/cms-nursing-home-compare-scraper"
    }
  }
}
```

Example prompts:

- "Run the CMS Nursing Home Compare Scraper for California with 100 results."
- "Find Texas nursing homes with at least 4 overall stars."
- "Export raw CMS nursing home rows for these CCNs."

### Output schema notes

The default dataset contains normalized fields for common workflows.
When `includeRaw` is true, each item also includes the full CMS source row.
This helps when CMS adds or renames columns.

### Limitations

The actor reflects what CMS publishes in the source dataset.
It does not verify facility websites.
It does not call individual facility pages.
It does not enrich owners beyond CMS fields.
Very narrow filters may require scanning more CMS rows before matches are found.

### Legality and compliance

This actor uses a public CMS data API.
Review CMS data-use guidance and your own compliance obligations before using results for regulated workflows.
Do not use the data for unlawful discrimination, harassment, or misleading outreach.

### Troubleshooting

If you get fewer records than expected, raise `maxResults` or broaden filters.
If `providerNames` misses a facility, try a shorter keyword or exact CCN.
If you need every original CMS column, enable `includeRaw`.

### Related scrapers

- https://apify.com/automation-lab/hhs-data-breach-scraper
- https://apify.com/automation-lab/fda-food-recalls-scraper
- https://apify.com/automation-lab/propublica-nonprofit-explorer-scraper

### FAQ

#### Can I export all nursing homes?

Yes. Leave filters empty and set a high `maxResults` value.

#### Does this actor use residential proxies?

No. It uses the public CMS API directly.

#### Can I filter by owner type?

Yes. Use `ownershipTypes` with text such as `For profit`, `Non profit`, `Government`, `Corporation`, or `Partnership`.

#### Can I monitor specific facilities?

Yes. Put exact CMS certification numbers in `ccns` and schedule the actor.

#### Can I get raw CMS fields?

Yes. Set `includeRaw` to `true`.

### Changelog

- 0.1.0 Initial version with CMS API extraction, filters, normalized output, and optional raw rows.

### Field reference

The actor currently normalizes these fields:

- `ccn`
- `providerName`
- `legalBusinessName`
- `providerType`
- `address`
- `city`
- `state`
- `zipCode`
- `county`
- `phone`
- `ownershipType`
- `certifiedBeds`
- `averageResidentsPerDay`
- `chainName`
- `chainId`
- `chainFacilityCount`
- `specialFocusStatus`
- `overallRating`
- `healthInspectionRating`
- `staffingRating`
- `qualityMeasureRating`
- `longStayQualityRating`
- `shortStayQualityRating`
- `healthDeficienciesCycle1`
- `totalWeightedHealthSurveyScore`
- `infectionControlCitations`
- `numberOfFines`
- `totalFinesUsd`
- `paymentDenials`
- `latitude`
- `longitude`
- `firstApprovedDate`
- `processingDate`
- `sourceDatasetId`
- `sourceUrl`
- `fetchedAt`
- `raw`

# Actor input Schema

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

Two-letter state abbreviations to include. Leave empty for nationwide results.

## `ccns` (type: `array`):

Exact CMS certification numbers to include.

## `providerNames` (type: `array`):

Case-insensitive provider or legal-business-name keywords.

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

City names to include.

## `zipCodes` (type: `array`):

Five-digit ZIP codes to include.

## `ownershipTypes` (type: `array`):

Ownership text to match, such as nonprofit, for profit, government, corporation, partnership, or individual.

## `specialFocusStatus` (type: `array`):

Special Focus Facility status text to match, for example SFF Candidate or Special Focus Facility.

## `minOverallRating` (type: `integer`):

Minimum CMS overall 5-star rating.

## `maxOverallRating` (type: `integer`):

Maximum CMS overall 5-star rating.

## `minCertifiedBeds` (type: `integer`):

Minimum number of certified beds.

## `maxCertifiedBeds` (type: `integer`):

Maximum number of certified beds.

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

Maximum number of matching facility records to save.

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

Attach the full CMS API row for schema-drift-proof downstream analysis.

## Actor input object example

```json
{
  "states": [
    "CA"
  ],
  "maxResults": 20,
  "includeRaw": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "states": [
        "CA"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/cms-nursing-home-compare-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 = {
    "states": ["CA"],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/cms-nursing-home-compare-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 '{
  "states": [
    "CA"
  ],
  "maxResults": 20
}' |
apify call automation-lab/cms-nursing-home-compare-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CMS Nursing Home Compare Scraper",
        "description": "🏥 Export CMS Care Compare nursing home facilities with ratings, ownership, bed counts, penalties, chains, and contact data.",
        "version": "0.1",
        "x-build-id": "PuHfMBn5oQpPjfPev"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~cms-nursing-home-compare-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-cms-nursing-home-compare-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~cms-nursing-home-compare-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-cms-nursing-home-compare-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~cms-nursing-home-compare-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-cms-nursing-home-compare-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": {
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "Two-letter state abbreviations to include. Leave empty for nationwide results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ccns": {
                        "title": "CMS certification numbers (CCNs)",
                        "type": "array",
                        "description": "Exact CMS certification numbers to include.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "providerNames": {
                        "title": "Provider names",
                        "type": "array",
                        "description": "Case-insensitive provider or legal-business-name keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "City names to include.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "zipCodes": {
                        "title": "ZIP codes",
                        "type": "array",
                        "description": "Five-digit ZIP codes to include.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ownershipTypes": {
                        "title": "Ownership types",
                        "type": "array",
                        "description": "Ownership text to match, such as nonprofit, for profit, government, corporation, partnership, or individual.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "specialFocusStatus": {
                        "title": "Special focus status",
                        "type": "array",
                        "description": "Special Focus Facility status text to match, for example SFF Candidate or Special Focus Facility.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minOverallRating": {
                        "title": "Minimum overall rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Minimum CMS overall 5-star rating."
                    },
                    "maxOverallRating": {
                        "title": "Maximum overall rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Maximum CMS overall 5-star rating."
                    },
                    "minCertifiedBeds": {
                        "title": "Minimum certified beds",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of certified beds."
                    },
                    "maxCertifiedBeds": {
                        "title": "Maximum certified beds",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of certified beds."
                    },
                    "maxResults": {
                        "title": "Maximum facilities",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of matching facility records to save.",
                        "default": 20
                    },
                    "includeRaw": {
                        "title": "Include raw CMS row",
                        "type": "boolean",
                        "description": "Attach the full CMS API row for schema-drift-proof downstream analysis.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```