# Medicare Providers Scraper: CMS Utilization & Payments (`transparent_meteorite/medicare-providers-scraper`) Actor

Search Medicare providers by state, specialty, city, ZIP or NPI with beneficiaries, services and Medicare payments from the public CMS provider dataset. No login.

- **URL**: https://apify.com/transparent_meteorite/medicare-providers-scraper.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Lead generation, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 provider rows

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Medicare Providers Scraper: CMS Utilization & Payments

Search Medicare providers by state, specialty, city, ZIP or NPI and get one row per provider with services, beneficiaries, submitted charges, Medicare payments and patient mix. It reads the public CMS Medicare Physician and Other Practitioners by Provider dataset, so there is no login, no proxy and no API key.

### What is Medicare Providers Scraper: CMS Utilization & Payments?

This Actor turns the CMS Medicare provider utilization and payment file (more than 1.2 million providers a year) into a filtered, sorted list you can use as doctor leads, territory data or research input. Medical device and pharma sales teams use it to size accounts by Medicare volume, analysts use it to compare specialties and states, and healthcare marketers use it to build target lists by specialty and city. The data is for Medicare Part B fee-for-service, calendar years 2022 to 2024.

It is a different dataset from our Open Payments actor: that one lists money drug and device makers paid to doctors, while this one lists what Medicare paid the providers. Use both together to see a doctor's Medicare volume next to the industry money they receive.

### Why use it

- **Source-sorted.** Rows are sorted by CMS before download, so "top 100 cardiologists in Michigan by Medicare payments" is exact and fast.
- **Filters that match how buyers search.** State, specialty, city, ZIP, NPI list, individual or organization, minimum beneficiaries and minimum payments.
- **Ready metrics.** Payment per beneficiary, payment per service, average patient age and risk score, dual-eligible share and common chronic condition rates.
- **Public data only.** It reads data.cms.gov open data with no login and no personal patient data.

### Output

Every field in the dataset, one row per provider.

| Field | Meaning |
|---|---|
| `npi`, `providerName`, `entityType`, `credentials` | Who the provider is. NPI is the ten-digit National Provider Identifier. |
| `specialty` | The Medicare provider type, for example Cardiology or Nurse Practitioner. |
| `street`, `city`, `state`, `zip`, `ruralUrban` | Practice address and rural-urban class. |
| `participatesInMedicare`, `year` | Participation flag and the data year. |
| `distinctServiceCodes`, `beneficiaries`, `services` | How many service codes, patients and services. CMS hides counts of 10 or fewer. |
| `submittedChargesUsd`, `medicareAllowedUsd`, `medicarePaymentsUsd`, `drugPaymentsUsd` | What was charged, allowed and paid by Medicare, and the Part B drug share. |
| `paymentPerBeneficiaryUsd`, `paymentPerServiceUsd` | Payments divided by patients and by services. |
| `avgBeneficiaryAge`, `avgRiskScore`, `dualEligiblePct` | Patient age, CMS risk score and share also on Medicaid. |
| `diabetesPct`, `hypertensionPct`, `heartDiseasePct` | Share of the provider's patients with each condition. |
| `npiRegistryUrl`, `scrapedAt` | Link to the public NPI Registry record and the collection time. |

### Sample output

```json
{
  "npi": "1003030685",
  "providerName": "Example Provider",
  "entityType": "Individual",
  "specialty": "Cardiology",
  "city": "Dearborn",
  "state": "MI",
  "year": 2024,
  "beneficiaries": 1231,
  "services": 6808,
  "medicarePaymentsUsd": 546846.63,
  "paymentPerBeneficiaryUsd": 444.2
}
```

The values above illustrate the format and are not a real provider.

### Input

| Field | What it does |
|---|---|
| `states` | Two-letter state codes. Default MI. Empty means the whole country. |
| `specialties` | Provider types such as Cardiology, Family Practice. Partial names match. |
| `cities`, `zipCodes` | Optional city names and five-digit ZIP codes. |
| `npis` | Ten-digit NPI numbers for direct lookup; other filters are ignored. |
| `entityType` | all, individual or organization. |
| `year` | 2024 (default), 2023 or 2022. |
| `minBeneficiaries`, `minMedicarePaymentsUsd` | Keep only larger providers. |
| `sortBy` | payments (default), beneficiaries, services or charges. |
| `maxItems` | Stop after this many rows. Default 30, cap 20,000. |

Sample input:

```json
{"states": ["MI"], "specialties": ["Cardiology"], "year": "2024", "sortBy": "payments", "maxItems": 30}
```

### How it works

1. Open the Actor and press **Try for free**.
2. Keep the prefilled input and press **Start**.
3. Open the **Output** tab and download JSON, CSV or Excel.

**Run in 30 seconds**: the default run finishes in under a minute and costs a few cents.

### Use cases and workflows

- Build a doctor lead list by specialty, state and city for medical device or pharma sales.
- Size sales territories by Medicare beneficiaries and payments.
- Compare payment per patient across specialties, states or years.
- Look up a list of NPI numbers and enrich them with Medicare volume.
- Send new rows to a CRM, spreadsheet or n8n workflow on a schedule.

### Limits

- Only Medicare Part B fee-for-service providers appear. Providers who bill only Medicare Advantage or private plans are not in the file.
- CMS publishes one year at a time, with a lag. 2024 is the latest release.
- Counts of 10 or fewer beneficiaries are suppressed by CMS and return empty.
- The file has no phone or email. Use the NPI Registry link or our other actors for contact data.
- This is aggregate billing data, not patient records and not a quality rating.

### Related Actors

- [Open Payments Scraper: CMS Pharma Payments to Doctors](https://apify.com/transparent_meteorite/medicare-open-payments-doctors) lists the money and gifts drug and device makers paid to doctors, the other half of the picture.
- [NPI New Provider Enrollment Monitor](https://apify.com/transparent_meteorite/npi-new-provider-enrollment-monitor) lists newly enrolled providers in the NPI Registry.
- [CMS Nursing Home Ratings & Penalties](https://apify.com/transparent_meteorite/cms-nursing-home-ratings-penalties) lists nursing home star ratings and penalties from CMS.

Found a bug or need a field? Open an issue on the Issues tab with the run URL.

### Use with the API, n8n, Make, Zapier or AI agents

**API** (one call, returns the rows as JSON):

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~medicare-providers-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"states": ["MI"], "specialties": ["Cardiology"], "year": "2024", "sortBy": "payments", "maxItems": 20}'
```

The call waits up to 5 minutes. For bigger inputs, start the run with `/runs` instead and read the dataset when it finishes.

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/medicare-providers-scraper").call(run_input={"states": ["MI"], "specialties": ["Cardiology"], "year": "2024", "sortBy": "payments", "maxItems": 20})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row)
```

- **n8n, Make, Zapier:** use the Apify app's "Run Actor" step with actor `transparent_meteorite/medicare-providers-scraper`, paste the input JSON, then map the dataset items to your sheet or CRM. In n8n, add a Schedule Trigger, the Apify node, then a Google Sheets or Slack node.
- **Clay:** add an HTTP API column that calls the run-sync endpoint above.
- **Schedules:** in Apify Console, Schedules, run it daily or weekly with the same input for a steady feed.
- **AI agents (MCP):** connect the Apify MCP server at `https://mcp.apify.com?tools=transparent_meteorite/medicare-providers-scraper` to Claude, Cursor or any MCP client, and your agent can run Medicare Providers Scraper: CMS Utilization & Payments on request and read the rows.

### Personal data and fair use

This Actor reads only public CMS Medicare Physician and Other Practitioners by Provider dataset on data.cms.gov. Some rows are individual clinicians, identified by their public NPI name and practice address. Public data is still personal data under GDPR, UK GDPR and CCPA, so you are responsible for how you use it: have a lawful basis, honor opt-out and deletion requests, do not use it for decisions about credit, employment, insurance or housing, and follow the source's terms of use. The Actor does not log in, bypass access controls or collect private data. This is not legal advice.

#### What a run costs

| Event | When it is charged | Free plan | Paid plans from |
|---|---|---|---|
| Actor Start | Charged when the Actor starts running | $0.00005 | same |
| Provider row | Charged once per row delivered to the dataset | $0.0018 | same |

- 1,000 x "Provider row" = $1.80 on the Free plan.
- 100 x "Provider row" = $0.18. Each run also has a start fee of $0.00005.
- You pay only for the events in this table. Platform compute is included and there is no monthly fee.

### FAQ

**Where does the data come from?**
The CMS Medicare Physician and Other Practitioners by Provider dataset on data.cms.gov, the same file CMS publishes each year, read through the public CMS data API.

**How is this different from the Open Payments actor?**
Open Payments is money from manufacturers to doctors. This actor is Medicare utilization and payments to providers. They use different CMS datasets.

**Why is a provider missing?**
Only providers with Medicare Part B fee-for-service claims in the year appear, and rows with 10 or fewer beneficiaries have suppressed counts.

**Can I get a doctor's email or phone?**
No. The file has no contact fields. The NPI Registry link shows the public practice location.

Long-tail searches this Actor answers: Medicare providers by state and specialty, doctor leads from Medicare data, CMS Medicare provider utilization and payments, top Medicare billing physicians by state, NPI lookup with Medicare payments, Medicare Part B provider data download, Medicare physician payment data API.

# Actor input Schema

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

Two-letter US state codes of the provider practice address, for example MI, TX. Leave empty for the whole country.

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

Medicare provider types to match, for example Cardiology, Family Practice, Nurse Practitioner, Dermatology. Partial names match.

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

Optional city names of the practice address. Partial names match.

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

Optional five-digit ZIP codes of the practice address.

## `npis` (type: `array`):

Optional list of ten-digit NPI numbers to look up directly. Other filters are ignored when set.

## `entityType` (type: `string`):

Keep individual clinicians, organizations such as labs and ambulance companies, or both.

## `year` (type: `string`):

Medicare calendar year of the utilization data. Default 2024, the latest CMS release.

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

Keep providers who treated at least this many distinct Medicare beneficiaries.

## `minMedicarePaymentsUsd` (type: `integer`):

Keep providers whose total Medicare payments were at least this amount.

## `sortBy` (type: `string`):

Largest first. Rows are sorted at the source, so the top of the list is exact.

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

Stop after this many rows. You pay only for rows delivered. Hard cap 20,000.

## Actor input object example

```json
{
  "states": [
    "MI"
  ],
  "entityType": "all",
  "year": "2024",
  "minBeneficiaries": 0,
  "minMedicarePaymentsUsd": 0,
  "sortBy": "payments",
  "maxItems": 30
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "states": [
        "MI"
    ],
    "entityType": "all",
    "year": "2024",
    "sortBy": "payments",
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/medicare-providers-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "states": ["MI"],
    "entityType": "all",
    "year": "2024",
    "sortBy": "payments",
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/medicare-providers-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "states": [
    "MI"
  ],
  "entityType": "all",
  "year": "2024",
  "sortBy": "payments",
  "maxItems": 30
}' |
apify call transparent_meteorite/medicare-providers-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/medicare-providers-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/79nMh6kKBV76xENwP/builds/JG9OEkw8WLyZw3tu8/openapi.json
