# CMS Physician Compare Scraper | Medicare Doctors Directory (`parseforge/cms-physician-compare-scraper`) Actor

Export Medicare physician and clinician data from the official CMS Physician Compare database. Includes name, NPI, credentials, specialty, group affiliation, hospital affiliation, and practice address. Filter by state. Download as CSV, Excel, JSON, or XML.

- **URL**: https://apify.com/parseforge/cms-physician-compare-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Other, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🩺 CMS Physician Compare Scraper

> 🚀 **Export Medicare Care Compare physician records with NPI, specialty, credentials, location, and facility data in seconds.**

> 🕒 **Last updated:** 2026-05-25 · **📊 22 fields** per record · **🩺 US-wide · 1.3M+ Medicare clinicians** · **NPI, specialty, location, gender, credentials, facility**

The CMS Physician Compare Scraper extracts records from the official Centers for Medicare & Medicaid Services (CMS) Care Compare Doctors and Clinicians dataset. Every record includes NPI, name, gender, credentials, medical school, graduation year, primary and secondary specialties, telehealth flag, facility, address, city, state, ZIP, and phone — exported as CSV, Excel, JSON, or XML.

The scraper supports filtering by US state, last name, specialty (Family Practice, Cardiology, Internal Medicine, Clinical Psychologist, etc.), and city. Covers every Medicare-enrolled clinician across all 50 states + territories.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Healthcare recruiters, MedTech sales teams, pharma reps, market researchers, healthcare-data journalists | Physician outreach, lead generation, market sizing, recruitment, competitive intelligence |

### 📋 What the CMS Physician Compare Scraper does

- Connects to the official CMS Care Compare (Doctors & Clinicians) dataset.
- Paginates through every record matching your filters.
- Normalises each record into a flat, analysis-ready row.
- Exports as CSV, Excel, JSON or XML — directly from your Apify dataset.
- Refreshes on demand or on schedule (hourly, daily, weekly).

> 💡 **Why it matters:** stop copy-pasting from a portal that paginates 100 records at a time. One click, full dataset, your format.

### 🎬 Full Demo

_🚧 Coming soon_

### ⚙️ Input

<table>
<thead><tr><th>Field</th><th>Type</th><th>Description</th></tr></thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td>Max clinicians to export. Free: 10. Paid: up to 1,000,000.</td></tr>
<tr><td><code>state</code></td><td>string</td><td>Two-letter US state code (e.g. CA, NY, TX).</td></tr>
<tr><td><code>lastName</code></td><td>string</td><td>Filter by clinician last name.</td></tr>
<tr><td><code>specialty</code></td><td>string</td><td>Primary specialty filter (e.g. CARDIOLOGY).</td></tr>
<tr><td><code>city</code></td><td>string</td><td>City filter.</td></tr>
</tbody>
</table>

**Example 1 — California cardiologists**
```json
{
  "maxItems": 500,
  "state": "CA",
  "specialty": "CARDIOLOGY"
}
````

**Example 2 — NYC psychologists**

```json
{
  "maxItems": 200,
  "state": "NY",
  "city": "NEW YORK",
  "specialty": "CLINICAL PSYCHOLOGIST"
}
```

> ⚠️ **Good to Know:** free users are capped at 10 records per run as a preview. Upgrade to any paid plan to unlock full exports (up to 1,000,000 records). Data is collected directly from the official public source — no login or API key required.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼 imageUrl | `string` | Always null |
| 📌 title | `string` | Clinician full name |
| 🔗 url | `string` | Care Compare physician detail URL |
| 🆔 id | `string` | NPI |
| 🪪 npi | `string` | 10-digit National Provider Identifier |
| 👤 provider\_first\_name | `string` | First name |
| 👤 provider\_last\_name | `string` | Last name |
| 🚻 gndr | `string` | Gender (M/F) |
| 🎓 cred | `string` | Credentials (MD, DO, PhD, etc.) |
| 🏫 med\_sch | `string` | Medical school |
| 📅 grd\_yr | `string` | Graduation year |
| 🩺 pri\_spec | `string` | Primary specialty |
| 🩺 sec\_spec\_all | `string` | All secondary specialties |
| 💻 telehlth | `string` | Telehealth offered (Y/N) |
| 🏥 facility\_name | `string` | Practicing facility name |
| 🔢 org\_pac\_id | `string` | Organization PAC ID |
| 🏙 citytown | `string` | City |
| 🗺 state | `string` | State |
| 📮 zip\_code | `string` | ZIP code |
| ☎️ telephone\_number | `string` | Phone |
| 🕒 scrapedAt | `string` | ISO scrape timestamp |
| ❌ error | `string` | Populated on failure |

**Sample record (real run output):**

```json
{
  "title": "DANIEL FENTON",
  "url": "https://www.medicare.gov/care-compare/details/physician/1154875961",
  "id": "1154875961",
  "npi": "1154875961",
  "provider_last_name": "FENTON",
  "provider_first_name": "DANIEL",
  "gndr": "M",
  "grd_yr": "2020",
  "pri_spec": "CLINICAL PSYCHOLOGIST",
  "telehlth": "Y",
  "facility_name": "EXTRA YEARS PSYCHOLOGY CALIFORNIA PC",
  "citytown": "LOS ANGELES",
  "state": "CA",
  "zip_code": "90004",
  "telephone_number": "4252707631",
  "scrapedAt": "2026-05-25T22:25:28.098Z",
  "error": null
}
```

### ✨ Why choose this Actor

| ✅ | What you get |
|---|---|
| 🎯 | Direct extraction from the official CMS Care Compare (Doctors & Clinicians) portal |
| 📊 | 22 normalised fields per record |
| ⚡ | Run on-demand or on schedule |
| 📁 | CSV, Excel, JSON, XML — your choice |
| 🔌 | Integrates with Make, Zapier, Slack, Airbyte, Google Drive |
| 🆓 | Free preview (10 records) — no credit card |
| 🌍 | Public data only — no login or API key required |
| 🚀 | Maintained and updated as the source schema evolves |

### 📈 How it compares to alternatives

| Approach | Speed | Maintenance | Cost | Export formats |
|---|---|---|---|---|
| Copy-paste from portal | 🐌 Hours | 🛠 High | Free | Limited |
| Build your own scraper | 🐢 Days | 🛠 Ongoing | Dev time | DIY |
| Generic SaaS scraper | 🚶 Slow | 🛠 Manual config | $$$ | Generic |
| **This Actor** | 🚀 **Minutes** | ✅ **Maintained** | 💸 **From free** | **CSV / Excel / JSON / XML** |

### 🚀 How to use

1. [Create a free Apify account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) — no credit card required.
2. Open the **CMS Physician Compare Scraper** page in Apify Store and click **Try for free**.
3. Configure the input (see Input section above).
4. Click **Start** — the run will produce a downloadable dataset.
5. Export as CSV, Excel, JSON or XML, or stream to your destination via integrations.

### 💼 Business use cases

#### Lead generation & sales

| 🎯 | Example |
|---|---|
| 📞 | Build target lists filtered by category, region, or status |
| 🧠 | Enrich CRM records with up-to-date public attributes |

#### Compliance & risk

| 🎯 | Example |
|---|---|
| 🔍 | Continuous monitoring of changes in official records |
| 📋 | Audit-trail-friendly exports for compliance teams |

#### Market research

| 🎯 | Example |
|---|---|
| 📊 | Track market dynamics over time |
| 🌍 | Benchmark across regions, categories, or operators |

#### Operations & automation

| 🎯 | Example |
|---|---|
| 🔄 | Schedule recurring pulls and pipe straight into your BI tool |
| 🚨 | Alert on threshold or status changes |

### 🔌 Automating CMS Physician Compare Scraper

- **Make** — receive new records into a scenario and route them anywhere.
- **Zapier** — trigger on new dataset rows and push to 6,000+ apps.
- **Slack** — post fresh records into a channel for the team.
- **Airbyte** — sync the dataset into your warehouse (BigQuery, Snowflake, Redshift, Postgres).
- **GitHub** — store snapshots in a repo for diffing over time.
- **Google Drive / Sheets** — auto-append rows to a spreadsheet.

### 🌟 Beyond business use cases

#### Research

- Academic studies on CMS Care Compare (Doctors & Clinicians) trends, distributions and outliers.

#### Personal projects

- Hobbyist data viz, dashboards, blog posts and side-projects.

#### Non-profit

- Open-data journalism, transparency audits, civic-tech tools.

#### Experimentation

- Train ML models on a clean, structured slice of public data.

### 🤖 Ask an AI assistant about this scraper

- [ChatGPT](https://chat.openai.com)
- [Claude](https://claude.ai)
- [Perplexity](https://www.perplexity.ai)
- [Microsoft Copilot](https://copilot.microsoft.com)

Paste this README into any of them and ask: *"How would I use the CMS Physician Compare Scraper to solve X?"*

### ❓ Frequently Asked Questions

#### ❓ Is the data accurate?

Yes — the scraper pulls directly from the official CMS Care Compare (Doctors & Clinicians) public dataset. Accuracy mirrors the source.

#### ❓ Do I need an API key or login?

No. Everything is public data. Just run the actor.

#### ❓ How fresh is the data?

Each run fetches the latest available records from data.cms.gov at request time.

#### ❓ How many records can I export?

Free users: 10 (preview). Paid users: up to 1,000,000 per run.

#### ❓ Can I export to Excel?

Yes — choose CSV, Excel, JSON or XML on the dataset page.

#### ❓ Can I schedule recurring runs?

Yes — Apify Schedules supports hourly/daily/weekly/cron. Pair with integrations for auto-delivery.

#### ❓ Is this affiliated with CMS Care Compare (Doctors & Clinicians)?

No. This is an independent tool that exposes publicly available data via a structured interface.

#### ❓ What happens if the source goes down?

The actor surfaces a clean error record. Re-run when the source is back up.

#### ❓ Can I filter the output?

Yes — the input section above lists every supported filter, exposed as a typed input field.

#### ❓ Can I use it for commercial purposes?

Yes, subject to the source dataset's terms of use. Always review the original publisher's license.

#### ❓ Where can I get help?

[Open our contact form](https://tally.so/r/BzdKgA) — we usually respond within one business day.

### 🔌 Integrate with any app

Make · Zapier · Slack · Airbyte · GitHub · Google Drive · Google Sheets · BigQuery · Snowflake · Redshift · Postgres · MySQL · MongoDB · Kafka · Webhooks · REST API.

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [OurAirports Global Airport Database Scraper](https://apify.com/parseforge/ourairports-scraper) | Worldwide airport reference dataset |
| [FINRA BrokerCheck Scraper](https://apify.com/parseforge/finra-brokercheck-scraper) | US broker & advisor licensing records |
| [FAA Aircraft Registry Scraper](https://apify.com/parseforge/faa-aircraft-registry-scraper) | US civil aircraft registration records |
| [SEC EDGAR Filings Scraper](https://apify.com/parseforge/sec-edgar-scraper) | Public company filings & financials |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 50+ data-export actors.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** This is an independent tool and is not affiliated with, endorsed by, or sponsored by CMS Care Compare (Doctors & Clinicians). It only collects publicly available data published by the source. Always review the source's terms of use before commercial deployment.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Filter by 2-letter state code.

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

Filter providers by exact last name.

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

Filter by primary specialty (e.g. CARDIOLOGY, FAMILY PRACTICE).

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

Filter by city/town.

## Actor input object example

```json
{
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

Scraped records

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/cms-physician-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/cms-physician-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 '{
  "maxItems": 10
}' |
apify call parseforge/cms-physician-compare-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CMS Physician Compare Scraper | Medicare Doctors Directory",
        "description": "Export Medicare physician and clinician data from the official CMS Physician Compare database. Includes name, NPI, credentials, specialty, group affiliation, hospital affiliation, and practice address. Filter by state. Download as CSV, Excel, JSON, or XML.",
        "version": "0.1",
        "x-build-id": "XLXpJZfDD6erydg9i"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~cms-physician-compare-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-cms-physician-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/parseforge~cms-physician-compare-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-cms-physician-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/parseforge~cms-physician-compare-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-cms-physician-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "state": {
                        "title": "State",
                        "enum": [
                            "",
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "DC",
                            "FL",
                            "GA",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NC",
                            "ND",
                            "OH",
                            "OK",
                            "OR",
                            "PA",
                            "RI",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY",
                            "PR",
                            "VI"
                        ],
                        "type": "string",
                        "description": "Filter by 2-letter state code."
                    },
                    "lastName": {
                        "title": "Provider Last Name",
                        "type": "string",
                        "description": "Filter providers by exact last name."
                    },
                    "specialty": {
                        "title": "Primary Specialty",
                        "type": "string",
                        "description": "Filter by primary specialty (e.g. CARDIOLOGY, FAMILY PRACTICE)."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Filter by city/town."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```