# CMS Medicare Provider Utilization & Payment Crawler (`jungle_synthesizer/cms-provider-utilization-crawler`) Actor

Crawl Medicare provider data from the CMS Provider Data API. Access 2.8M+ clinician records with credentials, specialties, and addresses. Get utilization data, MIPS quality scores, and office visit costs. Filter by state, specialty, and provider name.

- **URL**: https://apify.com/jungle\_synthesizer/cms-provider-utilization-crawler.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Lead generation, Business, Other
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Provider Utilization & Payment Data Crawler

Extract Medicare provider records from the [CMS Provider Data API](https://data.cms.gov/provider-data/api/1/). Four dataset modes in one actor: clinician directory with 2.8M provider records, procedure utilization data, MIPS quality scores, and office visit costs by specialty and ZIP code. No authentication, no proxies, no scraping — pure JSON API.

### CMS Medicare Provider Crawler Features

- Pull from four CMS datasets in a single actor: clinician directory, utilization, MIPS performance, and office visit costs
- Clinician directory covers 2.8M+ Medicare providers with credentials (MD, DO, NP, PA), specialties, practice addresses, and phone numbers
- Filter clinician records by state, primary specialty, and provider last name — filters applied server-side where the API supports it
- MIPS performance data for 541K+ clinicians including final composite score, quality, cost, and promoting interoperability components
- Office visit cost data broken out by specialty (55 specialties covered) and ZIP code — min/max Medicare pricing and copay ranges for new and established patients
- Utilization data shows procedure category and volume range per provider across 314K+ records
- Reads CMS's structured JSON API directly — 500 records per page, no HTML parsing, no rate-limit issues
- Pay-per-event pricing at roughly $0.001 per record

### Who Uses CMS Medicare Provider Data?

- **Healthcare recruiters and staffing firms** — build targeted contact lists of physicians, NPs, and PAs filtered by specialty and state, with formatted phone numbers ready to import
- **Medical device and pharma sales teams** — identify high-volume providers in target specialties by cross-referencing clinician directory and utilization data
- **Health plan and network analysts** — audit Medicare assignment acceptance across states and specialties, or assess telehealth adoption by region
- **Revenue cycle and consulting firms** — benchmark office visit costs against Medicare rates by specialty and ZIP code for contract negotiation or patient cost estimation
- **Policy researchers and academics** — analyze MIPS performance score distributions by specialty or geography for quality measurement research
- **Healthcare marketplaces and directories** — seed or refresh provider databases with verified NPI, credential, address, and contact data from the authoritative government source

### How CMS Medicare Provider Crawler Works

1. You select a dataset type and optionally set filters: one or more states, a primary specialty, or a provider last name.
2. For clinician, utilization, and MIPS datasets, the crawler paginates through the CMS API at 500 records per request with a 150ms delay between calls. State filters generate parallel queries — one per state — which run sequentially.
3. For office visit costs, the specialty selection maps to one of 55 specialty-specific CMS datasets. The crawler fetches that dataset in full.
4. Records are normalized into a consistent output schema regardless of which dataset you ran.

### Input

#### Clinician directory: all cardiologists in Texas and Florida

```json
{
  "datasetType": "clinician",
  "states": ["TX", "FL"],
  "specialty": "Cardiology",
  "maxItems": 500,
  "sp_intended_usage": "Lead generation for a medical device company",
  "sp_improvement_suggestions": "none"
}
````

#### MIPS performance: national run, no filters

```json
{
  "datasetType": "mips_performance",
  "maxItems": 1000,
  "sp_intended_usage": "Quality score benchmarking study",
  "sp_improvement_suggestions": "none"
}
```

#### Office visit costs: Internal Medicine pricing by ZIP

```json
{
  "datasetType": "office_visit_costs",
  "specialty": "Internal Medicine",
  "maxItems": 500,
  "sp_intended_usage": "Patient cost estimation tool",
  "sp_improvement_suggestions": "none"
}
```

#### Input Parameters

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| datasetType | string | `clinician` | Dataset to query: `clinician`, `utilization`, `mips_performance`, or `office_visit_costs` |
| states | string\[] | `[]` (all states) | One or more U.S. state abbreviations. Applies to clinician and MIPS datasets. |
| specialty | string | `""` (all) | Primary specialty filter. For office visit costs, selects the specialty-specific dataset. |
| providerName | string | `""` | Filter by provider last name. Case-insensitive partial match. Applies to clinician and utilization datasets. |
| maxItems | integer | `100` | Maximum number of records to return. |
| proxyConfiguration | object | disabled | Proxy settings. Not required — the CMS API is a public government service. |
| sp\_intended\_usage | string | — | Required. Describe how you plan to use this data. |
| sp\_improvement\_suggestions | string | — | Required. Feedback or suggestions for this actor. |

### CMS Medicare Provider Crawler Output Fields

Output fields are shared across all four datasets. A given record will only have fields populated that apply to its dataset type. The `dataset_type` field always indicates which mode produced the record.

#### Clinician Directory Output

```json
{
  "npi": "1234567890",
  "provider_name": "SMITH, JENNIFER",
  "provider_credentials": "MD",
  "provider_gender": "F",
  "provider_specialty": "CARDIOLOGY",
  "provider_secondary_specialties": "INTERNAL MEDICINE",
  "facility_name": "Houston Heart Center",
  "provider_street_address": "1200 Binz St, Suite 400",
  "provider_city": "HOUSTON",
  "provider_state": "TX",
  "provider_zip": "77004-6832",
  "provider_phone": "(713) 555-0192",
  "medicare_assignment": "Y",
  "telehealth": "Y",
  "dataset_type": "clinician"
}
```

| Field | Description |
|-------|-------------|
| npi | National Provider Identifier — the 10-digit unique provider ID |
| provider\_name | Provider full name formatted as LAST, FIRST |
| provider\_credentials | Professional credentials (MD, DO, NP, PA, etc.) |
| provider\_gender | Provider gender (M or F) |
| provider\_specialty | Primary specialty as listed in CMS |
| provider\_secondary\_specialties | Secondary specialties, comma-separated |
| facility\_name | Facility or organization name |
| provider\_street\_address | Street address (may include suite) |
| provider\_city | City |
| provider\_state | Two-letter state abbreviation |
| provider\_zip | ZIP code formatted as XXXXX or XXXXX-XXXX |
| provider\_phone | Phone number formatted as (XXX) XXX-XXXX |
| medicare\_assignment | Whether provider accepts Medicare assignment (Y/N) |
| telehealth | Whether provider offers telehealth services (Y/N) |
| dataset\_type | Always `clinician` for this mode |

#### Utilization Data Output

```json
{
  "npi": "1234567890",
  "provider_name": "JONES, MICHAEL",
  "procedure_category": "Major Joint Replacement or Reattachment of Lower Extremity",
  "procedure_count": "51-100",
  "dataset_type": "utilization"
}
```

| Field | Description |
|-------|-------------|
| npi | National Provider Identifier |
| provider\_name | Provider full name formatted as LAST, FIRST |
| procedure\_category | Procedure category name |
| procedure\_count | Procedure volume range (e.g. `1-10`, `11-20`, `51-100`) |
| dataset\_type | Always `utilization` for this mode |

#### MIPS Performance Output

```json
{
  "npi": "1234567890",
  "provider_name": "PATEL, ANITA",
  "mips_final_score": 87.4,
  "quality_score": 45.0,
  "cost_score": 18.2,
  "pi_score": 25.0,
  "ia_score": 0.0,
  "dataset_type": "mips_performance"
}
```

| Field | Description |
|-------|-------------|
| npi | National Provider Identifier |
| provider\_name | Provider full name formatted as LAST, FIRST |
| mips\_final\_score | MIPS composite score (0–100) for performance year 2023 |
| quality\_score | Quality performance category score |
| cost\_score | Cost performance category score |
| pi\_score | Promoting interoperability category score |
| ia\_score | Improvement activities category score |
| dataset\_type | Always `mips_performance` for this mode |

#### Office Visit Costs Output

```json
{
  "specialty": "Internal Medicine",
  "zip_code": "77004",
  "new_patient_cost_min": 112.50,
  "new_patient_cost_max": 209.75,
  "established_patient_cost_min": 68.30,
  "established_patient_cost_max": 154.00,
  "new_patient_copay_min": 28.13,
  "new_patient_copay_max": 52.44,
  "established_patient_copay_min": 17.08,
  "established_patient_copay_max": 38.50,
  "dataset_type": "office_visit_costs"
}
```

| Field | Description |
|-------|-------------|
| specialty | Specialty name as used by CMS |
| zip\_code | ZIP code for this pricing row |
| new\_patient\_cost\_min | Minimum Medicare pricing for a new patient office visit (USD) |
| new\_patient\_cost\_max | Maximum Medicare pricing for a new patient office visit (USD) |
| established\_patient\_cost\_min | Minimum Medicare pricing for an established patient office visit (USD) |
| established\_patient\_cost\_max | Maximum Medicare pricing for an established patient office visit (USD) |
| new\_patient\_copay\_min | Minimum patient copay for a new patient office visit (USD) |
| new\_patient\_copay\_max | Maximum patient copay for a new patient office visit (USD) |
| established\_patient\_copay\_min | Minimum patient copay for an established patient office visit (USD) |
| established\_patient\_copay\_max | Maximum patient copay for an established patient office visit (USD) |
| dataset\_type | Always `office_visit_costs` for this mode |

### FAQ

**How many providers does the CMS clinician directory cover?**
The CMS National Downloadable File contains 2.8 million Medicare provider records — every clinician enrolled in Medicare, including physicians, nurse practitioners, physician assistants, dentists, and other practitioners.

**Can I get the full dataset without filters?**
Yes. Leave `states` and `specialty` empty and the actor will paginate through the entire dataset up to your `maxItems` limit. A full national clinician pull at 2.8M records will take several hours. Use state or specialty filters if you only need a subset.

**Do I need proxies to run this actor?**
No. The CMS Provider Data API is a U.S. government public service that requires no authentication and imposes no strict rate limits. The actor runs proxy-disabled by default and adds a 150ms delay between requests as a courtesy.

**What is the difference between utilization and clinician data?**
The clinician dataset contains contact and credential information — who providers are, where they practice, and whether they accept Medicare. The utilization dataset shows what procedures they perform and in what volume. Both records carry the NPI key, so you can join them if needed.

**Which specialties are available for office visit costs?**
55 specialties are covered, including Internal Medicine, Family Practice, Cardiology, Orthopedic Surgery, Neurology, Psychiatry, Nurse Practitioner, Physician Assistant, and others. The specialty filter maps directly to a specialty-specific CMS dataset. If a specialty is not in the dropdown, it is not available in the underlying CMS data.

**What performance year does MIPS data cover?**
The MIPS performance dataset covers performance year 2023 (PY 2023) — the most recent CMS public reporting data at time of build.

**Can I filter utilization or MIPS data by state?**
State filtering applies to the clinician dataset only. The CMS API exposes a state field on that dataset but not on utilization or MIPS schemas. For those modes, filter by provider last name or run the full national dataset and post-filter on your side.

### Need More Features?

Need a specialty not in the list, a different filter combination, or a scheduled run that refreshes on CMS update cycles? [File an issue](https://console.apify.com/actors/issues) or get in touch.

### Why Use CMS Medicare Provider Crawler?

- **Four datasets, one actor** — Clinician directory, utilization, MIPS performance, and office visit costs are all accessible from a single configured run, not four separate tools to manage and pay for separately.
- **Government source, no intermediary** — Data comes directly from the CMS Provider Data API, the same source that powers Medicare's official provider search tools. No reseller markup, no stale cache.
- **Priced per record** — A targeted state-specialty filter returning 2,000 cardiologists in Texas costs a fraction of a full national pull. Both are priced per event, not per subscription seat.

# Actor input Schema

## `sp_intended_usage` (type: `string`):

Please describe how you plan to use the data extracted by this crawler.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

Provide your email address so we can get in touch with you.

## `datasetType` (type: `string`):

Select which Medicare dataset to query. Clinician Directory shows provider credentials, specialties, and practice addresses (2.8M records). Utilization shows procedure categories and volumes per provider. MIPS Performance shows clinician quality scores. Office Visit Costs shows specialty-level pricing by ZIP code.

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

Select one or more U.S. states. Defaults to all states if empty. Applies to Clinician Directory and MIPS Performance datasets.

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

Filter by provider specialty. For Clinician Directory and Utilization, filters on the primary specialty field. For Office Visit Costs, selects the specialty-specific dataset.

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

Search by provider last name. Applies to Clinician Directory and Utilization datasets. Case-insensitive partial match.

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

Maximum number of records to return.

## `proxyConfiguration` (type: `object`):

Select proxies. The CMS Provider Data API is a government service and typically does not require proxies.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "datasetType": "clinician",
  "states": [],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "datasetType": "clinician",
    "states": [],
    "specialty": "",
    "providerName": "",
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/cms-provider-utilization-crawler").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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "datasetType": "clinician",
    "states": [],
    "specialty": "",
    "providerName": "",
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/cms-provider-utilization-crawler").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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "datasetType": "clinician",
  "states": [],
  "specialty": "",
  "providerName": "",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call jungle_synthesizer/cms-provider-utilization-crawler --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=jungle_synthesizer/cms-provider-utilization-crawler",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CMS Medicare Provider Utilization & Payment Crawler",
        "description": "Crawl Medicare provider data from the CMS Provider Data API. Access 2.8M+ clinician records with credentials, specialties, and addresses. Get utilization data, MIPS quality scores, and office visit costs. Filter by state, specialty, and provider name.",
        "version": "1.0",
        "x-build-id": "XjhJ0H2S2A3oT9PhG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~cms-provider-utilization-crawler/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-cms-provider-utilization-crawler",
                "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/jungle_synthesizer~cms-provider-utilization-crawler/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-cms-provider-utilization-crawler",
                "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/jungle_synthesizer~cms-provider-utilization-crawler/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-cms-provider-utilization-crawler",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "sp_intended_usage",
                    "sp_improvement_suggestions"
                ],
                "properties": {
                    "sp_intended_usage": {
                        "title": "What is the intended usage of this data?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Please describe how you plan to use the data extracted by this crawler."
                    },
                    "sp_improvement_suggestions": {
                        "title": "How can we improve this crawler for you?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide any feedback or suggestions for improvements."
                    },
                    "sp_contact": {
                        "title": "Contact Email",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide your email address so we can get in touch with you."
                    },
                    "datasetType": {
                        "title": "Dataset Type",
                        "enum": [
                            "clinician",
                            "utilization",
                            "mips_performance",
                            "office_visit_costs"
                        ],
                        "type": "string",
                        "description": "Select which Medicare dataset to query. Clinician Directory shows provider credentials, specialties, and practice addresses (2.8M records). Utilization shows procedure categories and volumes per provider. MIPS Performance shows clinician quality scores. Office Visit Costs shows specialty-level pricing by ZIP code."
                    },
                    "states": {
                        "title": "State Filter",
                        "type": "array",
                        "description": "Select one or more U.S. states. Defaults to all states if empty. Applies to Clinician Directory and MIPS Performance datasets.",
                        "items": {
                            "type": "string",
                            "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"
                            ],
                            "enumTitles": [
                                "Alabama",
                                "Alaska",
                                "Arizona",
                                "Arkansas",
                                "California",
                                "Colorado",
                                "Connecticut",
                                "Delaware",
                                "District of Columbia",
                                "Florida",
                                "Georgia",
                                "Hawaii",
                                "Idaho",
                                "Illinois",
                                "Indiana",
                                "Iowa",
                                "Kansas",
                                "Kentucky",
                                "Louisiana",
                                "Maine",
                                "Maryland",
                                "Massachusetts",
                                "Michigan",
                                "Minnesota",
                                "Mississippi",
                                "Missouri",
                                "Montana",
                                "Nebraska",
                                "Nevada",
                                "New Hampshire",
                                "New Jersey",
                                "New Mexico",
                                "New York",
                                "North Carolina",
                                "North Dakota",
                                "Ohio",
                                "Oklahoma",
                                "Oregon",
                                "Pennsylvania",
                                "Rhode Island",
                                "South Carolina",
                                "South Dakota",
                                "Tennessee",
                                "Texas",
                                "Utah",
                                "Vermont",
                                "Virginia",
                                "Washington",
                                "West Virginia",
                                "Wisconsin",
                                "Wyoming"
                            ]
                        }
                    },
                    "specialty": {
                        "title": "Provider Specialty",
                        "enum": [
                            "",
                            "Internal Medicine",
                            "Family Practice",
                            "Cardiology",
                            "Orthopedic Surgery",
                            "General Surgery",
                            "Dermatology",
                            "Ophthalmology",
                            "Psychiatry",
                            "Neurology",
                            "Gastroenterology",
                            "Urology",
                            "Pulmonary Disease",
                            "Nephrology",
                            "Endocrinology",
                            "Rheumatology",
                            "Emergency Medicine",
                            "Anesthesiology",
                            "Pathology",
                            "Nurse Practitioner",
                            "Physician Assistant",
                            "Dentist",
                            "Optometry",
                            "Podiatry",
                            "Hospitalist"
                        ],
                        "type": "string",
                        "description": "Filter by provider specialty. For Clinician Directory and Utilization, filters on the primary specialty field. For Office Visit Costs, selects the specialty-specific dataset."
                    },
                    "providerName": {
                        "title": "Provider Last Name",
                        "type": "string",
                        "description": "Search by provider last name. Applies to Clinician Directory and Utilization datasets. Case-insensitive partial match."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "type": "integer",
                        "description": "Maximum number of records to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies. The CMS Provider Data API is a government service and typically does not require proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
