# CMS Medicare Physician Payments Scraper (`automation-lab/cms-medicare-physician-payments-scraper`) Actor

Extract official CMS Medicare physician payment, utilization, provider, HCPCS, and geography data for reimbursement and market analysis.

- **URL**: https://apify.com/automation-lab/cms-medicare-physician-payments-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 cms payment record extracteds

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 Medicare Physician Payments Scraper

Extract Medicare Physician & Other Practitioners payment, utilization, provider, HCPCS, and geography data from official CMS public data APIs.

### What does CMS Medicare Physician Payments Scraper do?

CMS Medicare Physician Payments Scraper turns the public CMS Medicare Physician & Other Practitioners files into clean Apify dataset rows.

It reads the official `data.cms.gov` catalog, discovers the current API endpoint, applies practical filters, and saves normalized records.

Use it when you need provider reimbursement, submitted charge, allowed amount, payment amount, service volume, beneficiary count, specialty, and source metadata.

### Who is it for?

- 🏥 Healthcare market analysts benchmarking provider reimbursement.
- 💳 Revenue-cycle teams comparing submitted charges and Medicare allowed amounts.
- 📊 Consulting teams sizing specialty, state, or HCPCS service markets.
- 🧾 Compliance researchers auditing provider/service utilization patterns.
- 🧬 Data enrichment teams adding Medicare payment context to NPI lists.
- 🏢 Healthcare sales teams segmenting providers by services and geography.

### Why use this scraper?

- ✅ Uses official CMS public APIs, not browser scraping.
- ✅ Supports provider/service, provider summary, and geography/service modes.
- ✅ Normalizes numeric charge, allowed, payment, utilization, and beneficiary fields.
- ✅ Includes source dataset/version metadata for reproducible analysis.
- ✅ Keeps the raw CMS row so analysts can audit every normalized value.
- ✅ Works without accounts, cookies, proxies, or manual CSV downloads.

### Data source

The actor uses CMS `data.cms.gov/data.json` and the CMS Data API endpoints linked from the catalog.

The default source is the latest Medicare Physician & Other Practitioners release available in the CMS catalog.

You can also select recent years when CMS exposes them in the catalog distributions.

### Dataset modes

#### Provider and service

Use `provider-service` to extract rows by rendering NPI and HCPCS service.

This is the default mode and is best for reimbursement benchmarking by code.

#### Provider summary

Use `provider-summary` to extract provider-level summary rows.

This is useful for broad provider profiling and NPI enrichment.

#### Geography and service

Use `geography-service` to extract service-level geography rows.

This is useful for state-level or market-level demand and reimbursement research.

### What data can you extract?

| Field group | Examples |
| --- | --- |
| Source metadata | dataset mode, CMS dataset title, API URL, CSV URL, modified date, dataset year |
| Provider identity | NPI, provider name, first name, last name, credentials, entity code |
| Provider location | address, city, state, ZIP5, country |
| Provider profile | specialty, Medicare participation indicator |
| Service details | HCPCS code, HCPCS description, drug indicator, place of service |
| Utilization | beneficiaries, services, beneficiary-day services |
| Payment fields | average submitted charge, Medicare allowed amount, payment amount, standardized amount |
| Audit data | raw CMS row |

### How much does it cost to extract CMS Medicare physician payment data?

This actor uses pay-per-event pricing.

You pay a small start fee plus a per-record fee for each CMS record saved to the dataset.

Use narrow filters during exploration, then increase `maxRecords` when you are ready for production exports.

### Input options

- `datasetMode` — choose provider-service, provider-summary, or geography-service.
- `datasetYear` — choose latest or a specific data year if CMS exposes it.
- `maxRecords` — cap how many rows to save.
- `npi` — filter to one rendering provider NPI.
- `providerName` — local contains filter over provider first/last/organization name.
- `state` — two-letter rendering provider state abbreviation.
- `specialty` — exact CMS provider type such as Internal Medicine.
- `zip5` — five-digit provider ZIP code.
- `hcpcsCode` — HCPCS/CPT service code such as 99213.
- `placeOfService` — facility (`F`) or office/non-facility (`O`).

### Example input

```json
{
  "datasetMode": "provider-service",
  "datasetYear": "latest",
  "state": "CA",
  "hcpcsCode": "99213",
  "maxRecords": 100
}
````

### Example output

```json
{
  "datasetMode": "provider-service",
  "datasetYear": 2024,
  "npi": "1003000142",
  "providerName": "Rashid Khalil",
  "specialty": "Anesthesiology",
  "state": "OH",
  "hcpcsCode": "99213",
  "beneficiaryCount": 20,
  "serviceCount": 45,
  "submittedChargeAmount": 120,
  "medicareAllowedAmount": 75,
  "medicarePaymentAmount": 58,
  "sourceDatasetTitle": "Medicare Physician & Other Practitioners - by Provider and Service"
}
```

### How to scrape CMS Medicare physician payment data

1. Open the actor on Apify.
2. Select the dataset mode.
3. Keep `datasetYear` as latest unless your workflow needs a historical year.
4. Add one or more filters such as state, NPI, specialty, HCPCS, or place of service.
5. Set `maxRecords`.
6. Run the actor.
7. Export the dataset as JSON, CSV, Excel, XML, or via API.

### Tips for better results

- Use `state` plus `hcpcsCode` for practical reimbursement benchmarks.
- Use `npi` when enriching a known provider list.
- Use `specialty` with `state` for provider market sizing.
- Use `providerName` with another filter because name matching is applied locally after CMS API paging.
- Use `geography-service` for market-level analysis instead of provider-level rows.

### Common workflows

#### NPI reimbursement enrichment

Run one NPI at a time or batch NPI inputs through the Apify API.

Join results to your CRM, provider master, or credentialing database.

#### HCPCS benchmarking

Filter by HCPCS and state to compare average submitted charges, allowed amounts, and payments.

Use this for reimbursement analytics and market pricing research.

#### Specialty market sizing

Filter by specialty and state, then aggregate services and beneficiaries downstream.

This helps estimate demand by specialty and geography.

#### Compliance review

Export raw and normalized rows together so reviewers can trace every value to CMS source data.

### Integrations

- Send output to Google Sheets for analyst review.
- Export to BigQuery, Snowflake, or S3 for recurring data pipelines.
- Use Apify webhooks to trigger downstream ETL jobs.
- Call the actor from Python or Node.js when enriching provider lists.
- Connect with Apify MCP for natural-language research workflows.

### 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/cms-medicare-physician-payments-scraper').call({
  datasetMode: 'provider-service',
  state: 'CA',
  hcpcsCode: '99213',
  maxRecords: 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/cms-medicare-physician-payments-scraper').call(run_input={
    'datasetMode': 'provider-service',
    'state': 'CA',
    'hcpcsCode': '99213',
    'maxRecords': 100,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~cms-medicare-physician-payments-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"datasetMode":"provider-service","state":"CA","hcpcsCode":"99213","maxRecords":100}'
```

### MCP usage

Use Apify MCP with this tool enabled:

`https://mcp.apify.com/?tools=automation-lab/cms-medicare-physician-payments-scraper`

Add it to Claude Code with:

```bash
claude mcp add apify-cms-medicare-physician-payments \
  "https://mcp.apify.com/?tools=automation-lab/cms-medicare-physician-payments-scraper"
```

Claude Desktop JSON configuration:

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

Example prompts:

- "Extract Medicare physician payment records for HCPCS 99213 in California."
- "Find Medicare provider-service rows for this NPI and summarize payment amounts."
- "Compare beneficiary and service counts for a specialty across states."

### Data freshness

The actor discovers the latest CMS catalog distribution at run time.

CMS release dates and modified dates are included in output metadata when available.

### Limitations

CMS API filters are exact-match for fields such as state, NPI, HCPCS, ZIP5, and specialty.

Provider-name search is local after CMS paging, so combine it with narrower filters for large searches.

CMS can revise datasets, field names, or release availability; source metadata is included to help track changes.

### Legality

CMS Medicare Physician & Other Practitioners files are public government datasets.

You are responsible for using healthcare data in compliance with applicable laws, payer contracts, privacy rules, and business policies.

Do not use output for unlawful discrimination, credentialing shortcuts, or unsupported clinical conclusions.

### FAQ

#### Is this official CMS data?

Yes. The actor reads public CMS Data API endpoints discovered from `data.cms.gov/data.json` and includes source metadata in every row.

#### Can I search by provider name?

Yes, but provider-name matching is applied locally after CMS API paging. Combine it with state, NPI, specialty, ZIP5, or HCPCS filters for efficient runs.

### Troubleshooting

#### Why did I get zero records?

Check exact spelling and formatting. CMS filters are exact-match. Try removing specialty or ZIP5 first, then add filters back.

#### Why is providerName slow or incomplete?

The CMS API does not provide a general contains search endpoint for provider names. The actor applies providerName locally after fetching pages.

#### Why are some fields empty?

Different CMS dataset modes expose different fields. Geography rows may not include NPI-level provider details, and summary rows may not include every service field.

### Related scrapers

Explore related healthcare and government data actors from Automation Lab:

- https://apify.com/automation-lab/cms-open-payments-scraper
- https://apify.com/automation-lab/nppes-npi-registry-scraper
- https://apify.com/automation-lab/healthgrades-scraper

### Support

If you need a missing CMS field, historical release, or workflow-specific output shape, open an issue on the actor page with an example input and expected output.

### Changelog

#### 0.1

Initial private build with CMS catalog discovery, provider/service, provider summary, geography/service modes, normalized payment fields, and raw row audit data.

# Actor input Schema

## `datasetMode` (type: `string`):

Choose the CMS Medicare Physician & Other Practitioners public use file to extract.

## `datasetYear` (type: `string`):

CMS data year to use. Leave as latest to use the newest release exposed in data.cms.gov/data.json.

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

Maximum CMS rows to save to the dataset.

## `npi` (type: `string`):

Rendering provider NPI for provider-level datasets.

## `providerName` (type: `string`):

Case-insensitive local filter over first/last/organization name. Combine with state, HCPCS, or specialty for large searches.

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

Two-letter rendering provider state such as CA, NY, TX, or MD.

## `specialty` (type: `string`):

Exact CMS rendering provider type, e.g. Internal Medicine, Family Practice, Cardiology.

## `zip5` (type: `string`):

Five-digit provider ZIP code for provider-level datasets.

## `hcpcsCode` (type: `string`):

HCPCS/CPT service code, e.g. 99213. Applies to provider-service and geography-service datasets.

## `placeOfService` (type: `string`):

Facility (F) or office/non-facility (O). Leave blank for both.

## Actor input object example

```json
{
  "datasetMode": "provider-service",
  "datasetYear": "latest",
  "maxRecords": 20,
  "state": "CA",
  "hcpcsCode": "99213",
  "placeOfService": ""
}
```

# 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 = {
    "datasetMode": "provider-service",
    "datasetYear": "latest",
    "maxRecords": 20,
    "npi": "",
    "providerName": "",
    "state": "CA",
    "specialty": "",
    "zip5": "",
    "hcpcsCode": "99213",
    "placeOfService": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/cms-medicare-physician-payments-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 = {
    "datasetMode": "provider-service",
    "datasetYear": "latest",
    "maxRecords": 20,
    "npi": "",
    "providerName": "",
    "state": "CA",
    "specialty": "",
    "zip5": "",
    "hcpcsCode": "99213",
    "placeOfService": "",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/cms-medicare-physician-payments-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 '{
  "datasetMode": "provider-service",
  "datasetYear": "latest",
  "maxRecords": 20,
  "npi": "",
  "providerName": "",
  "state": "CA",
  "specialty": "",
  "zip5": "",
  "hcpcsCode": "99213",
  "placeOfService": ""
}' |
apify call automation-lab/cms-medicare-physician-payments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CMS Medicare Physician Payments Scraper",
        "description": "Extract official CMS Medicare physician payment, utilization, provider, HCPCS, and geography data for reimbursement and market analysis.",
        "version": "0.1",
        "x-build-id": "mVZnkswDfdTTdkxiT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~cms-medicare-physician-payments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-cms-medicare-physician-payments-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-medicare-physician-payments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-cms-medicare-physician-payments-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-medicare-physician-payments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-cms-medicare-physician-payments-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": {
                    "datasetMode": {
                        "title": "Dataset mode",
                        "enum": [
                            "provider-service",
                            "provider-summary",
                            "geography-service"
                        ],
                        "type": "string",
                        "description": "Choose the CMS Medicare Physician & Other Practitioners public use file to extract.",
                        "default": "provider-service"
                    },
                    "datasetYear": {
                        "title": "Dataset year",
                        "enum": [
                            "latest",
                            "2024",
                            "2023",
                            "2022",
                            "2021",
                            "2020"
                        ],
                        "type": "string",
                        "description": "CMS data year to use. Leave as latest to use the newest release exposed in data.cms.gov/data.json.",
                        "default": "latest"
                    },
                    "maxRecords": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum CMS rows to save to the dataset.",
                        "default": 20
                    },
                    "npi": {
                        "title": "NPI",
                        "type": "string",
                        "description": "Rendering provider NPI for provider-level datasets."
                    },
                    "providerName": {
                        "title": "Provider name contains",
                        "type": "string",
                        "description": "Case-insensitive local filter over first/last/organization name. Combine with state, HCPCS, or specialty for large searches."
                    },
                    "state": {
                        "title": "State abbreviation",
                        "type": "string",
                        "description": "Two-letter rendering provider state such as CA, NY, TX, or MD."
                    },
                    "specialty": {
                        "title": "Provider specialty",
                        "type": "string",
                        "description": "Exact CMS rendering provider type, e.g. Internal Medicine, Family Practice, Cardiology."
                    },
                    "zip5": {
                        "title": "ZIP5",
                        "type": "string",
                        "description": "Five-digit provider ZIP code for provider-level datasets."
                    },
                    "hcpcsCode": {
                        "title": "HCPCS code",
                        "type": "string",
                        "description": "HCPCS/CPT service code, e.g. 99213. Applies to provider-service and geography-service datasets."
                    },
                    "placeOfService": {
                        "title": "Place of service",
                        "enum": [
                            "",
                            "F",
                            "O"
                        ],
                        "type": "string",
                        "description": "Facility (F) or office/non-facility (O). Leave blank for both.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```