# CMS Medicare Provider Payments & Utilization Scraper (`logiover/cms-medicare-provider-payments-scraper`) Actor

Export 1.29M+ CMS Medicare provider payment and utilization records by NPI, specialty, state, beneficiaries, services and reimbursement. Built for healthcare sales, pharma, payer analytics and market intelligence.

- **URL**: https://apify.com/logiover/cms-medicare-provider-payments-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Payments & Utilization Scraper

Export more than 1.29 million current CMS Medicare provider profiles with NPI, specialty, address, beneficiary volume, services, submitted charges, allowed amounts, Medicare payments and patient-population indicators. The Actor converts the official CMS provider-summary release into clean records for healthcare sales, market sizing, provider intelligence and payer analysis.

No CMS API key is required. The Actor uses the dataset's stable CMS identifier, which resolves to the current official release rather than depending on a fragile download-page URL.

### What can you do with this Actor?

- Build national or state-level lists of physicians, groups and healthcare organizations.
- Rank providers by Medicare beneficiaries, service volume or reimbursement.
- Segment territories by specialty, geography and Medicare participation.
- Support pharma, medical-device, payer, healthcare staffing and market-research workflows.
- Enrich NPI-based databases with aggregate utilization and payment signals.
- Export optional beneficiary condition profiles for population-health analysis.

### Input

All filters are optional. Empty input exports provider records from the current release.

| Field | Type | Description |
| --- | --- | --- |
| `states` | string\[] | Exact two-letter provider state abbreviations. |
| `specialties` | string\[] | Exact CMS specialty names such as `Cardiology`. |
| `countries` | string\[] | Provider country codes; US records generally use `US`. |
| `nameKeyword` | string | Provider organization, last-name or first-name search. |
| `medicareParticipatingOnly` | boolean | Keep only providers with participating indicator `Y`. |
| `minBeneficiaries` | integer | Minimum distinct Medicare beneficiaries. |
| `minServices` | number | Minimum total Medicare services. |
| `minMedicarePayment` | number | Minimum aggregate Medicare payment in USD. |
| `includeConditionProfile` | boolean | Include aggregate condition percentages when present. |
| `maxResults` | integer | Maximum unique NPIs to save, up to 500,000. |

Example for high-volume California cardiology providers:

```json
{
  "states": ["CA"],
  "specialties": ["Cardiology"],
  "medicareParticipatingOnly": true,
  "minMedicarePayment": 50000,
  "includeConditionProfile": true,
  "maxResults": 10000
}
```

### Output

Each dataset item is one provider-level profile keyed by NPI.

| Field group | Included data |
| --- | --- |
| Identity | `npi`, provider name components, organization name, credentials, entity type, gender. |
| Classification | `specialty`, Medicare participation indicator. |
| Location | Address lines, city, state, ZIP, country and rural/urban code. |
| Volume | Total beneficiaries, services, unique HCPCS codes and beneficiary-day services. |
| Financial | Submitted charges, Medicare allowed amount, Medicare payment and standardized payment. |
| Population | Average age, risk score, female/male percentages, race indicators and dual/Medicare-only shares. |
| Conditions | Optional aggregate percentages for major chronic conditions available in the CMS release. |
| Lineage | Data year, official source URL and scrape timestamp. |

```json
{
  "npi": "1234567890",
  "providerName": "EXAMPLE CARDIOLOGY GROUP",
  "entityType": "O",
  "specialty": "Cardiology",
  "city": "LOS ANGELES",
  "state": "CA",
  "medicareParticipating": true,
  "totalBeneficiaries": 742,
  "totalServices": 5180,
  "totalSubmittedCharges": 2145000.75,
  "totalMedicarePayment": 387420.18,
  "dataYear": 2024
}
```

CMS suppresses some values to protect beneficiary privacy. Those values remain `null`; the Actor does not estimate or reconstruct them. Payment and utilization metrics are aggregate historical measures, not a statement about current provider availability or quality.

### High-volume workflow tips

Use exact state and specialty filters to build focused territories quickly. For national market sizing, increase `maxResults` and let the Actor paginate the CMS API automatically. Multiple states and specialties are handled as independent source segments and NPIs are deduplicated across them. Join output to other NPI datasets using the normalized `npi` string.

`minBeneficiaries`, `minServices` and `minMedicarePayment` are applied to the normalized numeric values. Use them to prioritize commercially meaningful accounts without downloading irrelevant rows into your final dataset.

### Integrations and API

Results are available through Apify datasets as JSON, JSONL, CSV, Excel, XML or RSS. Runs can be scheduled and connected to webhooks, Google Sheets, Make, Zapier, databases or your own ETL. JavaScript and Python Apify clients are supported.

```bash
curl -X POST "https://api.apify.com/v2/acts/logiover~cms-medicare-provider-payments-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"states":["TX"],"specialties":["Internal Medicine"],"maxResults":5000}'
```

Through Apify MCP, AI agents can also call the Actor as a structured provider-research tool.

### FAQ

**Which CMS dataset is used?** The official Medicare Physician & Other Practitioners provider-level summary dataset.

**How many records are available?** The current release contains roughly 1.29 million provider records; availability varies as CMS updates releases.

**Does it include individual claims?** No. It provides privacy-protected provider-level aggregates.

**Does it need an API key?** No external CMS key is required.

**Are all values populated?** No. CMS suppression and source completeness can produce nulls.

**Can I filter by multiple specialties?** Yes. Use exact CMS specialty labels.

**Is NPI preserved safely?** Yes. It is returned as a string to avoid numeric formatting loss.

**Can the Actor prove provider quality?** No. Utilization and payment aggregates should not be interpreted as quality ratings.

**Can I schedule annual refreshes?** Yes. The stable source identifier follows the current CMS release; schedule runs to refresh your downstream index.

### Responsible use

This Actor is not affiliated with or endorsed by CMS. Use the records for lawful research and business intelligence. Verify material healthcare decisions against authoritative sources and do not infer sensitive individual-patient information from aggregate data.

### Changelog

#### 2026-08-04

- Initial provider-level CMS Medicare payments and utilization release.
- Added state, specialty, country, name, participation, volume and payment filters.
- Added stable NPI deduplication and optional beneficiary condition fields.
- Validated numeric payment, volume, identity and location output against the live CMS API.

# Actor input Schema

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

Two-letter provider state abbreviations. Leave empty for nationwide data.

## `specialties` (type: `array`):

Exact CMS provider specialty names, for example Cardiology or Internal Medicine.

## `countries` (type: `array`):

Provider country codes. Most records use US.

## `nameKeyword` (type: `string`):

Search provider organization, last name or first name using the CMS keyword index.

## `medicareParticipatingOnly` (type: `boolean`):

Only include providers with a Medicare participating indicator of Y.

## `minBeneficiaries` (type: `integer`):

Only save providers serving at least this many Medicare beneficiaries.

## `minServices` (type: `number`):

Only save providers with at least this many total Medicare services.

## `minMedicarePayment` (type: `number`):

Only save providers with at least this total Medicare payment amount.

## `includeConditionProfile` (type: `boolean`):

Include CMS-suppressed aggregate percentages for common chronic conditions.

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

Maximum number of unique provider records saved.

## Actor input object example

```json
{
  "states": [],
  "specialties": [],
  "countries": [],
  "nameKeyword": "",
  "medicareParticipatingOnly": false,
  "includeConditionProfile": false,
  "maxResults": 200
}
```

# 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 = {
    "maxResults": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/cms-medicare-provider-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 = { "maxResults": 200 }

# Run the Actor and wait for it to finish
run = client.actor("logiover/cms-medicare-provider-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 '{
  "maxResults": 200
}' |
apify call logiover/cms-medicare-provider-payments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/GhTVXgq7lS6PXeH1J/builds/2HZh6JTt2sTSkdh7m/openapi.json