# Open Payments Scraper: CMS Pharma Payments to Doctors (`transparent_meteorite/medicare-open-payments-doctors`) Actor

Search the public CMS Open Payments data for payments and gifts from drug and device makers to doctors. Filter by year, state, doctor, NPI, manufacturer, payment type and amount. No login, no proxy.

- **URL**: https://apify.com/transparent_meteorite/medicare-open-payments-doctors.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 payment records

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

## Open Payments Scraper: CMS Pharma Payments to Doctors

Search the public CMS Open Payments data and get clean rows: which drug or device maker paid which doctor, how much, when, for what, and for which product. You pick the year and any filters. The actor reads the official CMS open-data portal, so there is no login, no proxy and no API key.

### What does this Actor do?

Under the US Sunshine Act, drug and medical device companies must report payments and gifts to doctors (meals, travel, consulting fees, speaker fees, research and more). CMS publishes them each year as the Open Payments program. The raw files hold millions of rows with 90+ columns. This actor queries the General Payment Data file for the year you choose, applies your filters, and returns a small, tidy row per payment.

Who it is for: journalists, compliance teams, researchers, healthcare sales and market-intelligence teams, and anyone who wants to check a doctor or a manufacturer without downloading a multi-gigabyte file.

**Run in 30 seconds**

1. Open the Actor and press **Try for free** (a free Apify account is enough).
2. Keep the prefilled input (2024, Michigan, payments of at least 100 USD) and press **Start**.
3. Open the **Output** tab. Use the table view or download CSV, Excel or JSON.

### Input

| Field | What it does |
|---|---|
| `programYear` | Reporting year of the CMS file, 2019 and later. Default 2024. |
| `state` | Two-letter state of the doctor's primary address, for example `MI`. |
| `recipientLastName`, `recipientFirstName` | Exact doctor name, any case. |
| `npi` | 10-digit National Provider Identifier. The most reliable way to find one doctor. |
| `manufacturerContains` | Part of the paying company's name, for example `Pfizer`. |
| `natureOfPayment` | Keep payments whose type contains one of these words, for example `Consulting`, `Food`, `Travel`. |
| `minAmountUsd` | Keep payments of at least this many US dollars. |
| `maxItems` | Stop after this many payments. |

Sample input:

```json
{
  "programYear": 2024,
  "state": "MI",
  "manufacturerContains": "Medtronic",
  "natureOfPayment": ["Consulting", "Speaker"],
  "minAmountUsd": 500,
  "maxItems": 100
}
```

Only physicians are returned. Teaching hospitals and the research and ownership files are not included in this version.

### Output

One row per payment record:

| Field | Meaning |
|---|---|
| `recordId`, `programYear` | The CMS record number and the reporting year. |
| `paymentDate` | Date of payment, ISO format. |
| `recipientName`, `recipientNpi`, `recipientSpecialty` | The doctor, as reported. |
| `recipientCity`, `recipientState` | Primary business address city and state. |
| `manufacturerName`, `manufacturerState` | The company that made the payment. |
| `totalAmountUsd`, `paymentCount` | Total in US dollars and how many payments it covers. |
| `natureOfPayment`, `formOfPayment` | For example Food and Beverage, paid as cash or in kind. |
| `productName`, `productCategory` | The related drug or device, when reported. |
| `contextualInfo`, `disputed` | Free text from the company, and whether the record is under dispute. |
| `profileUrl`, `sourceUrl`, `scrapedAt` | Link to the doctor's CMS profile, the CMS dataset, and run time. |

### Sample output

```json
{
  "recordId": "1076213626",
  "programYear": 2024,
  "paymentDate": "2024-10-23",
  "recipientName": "TIMOTHY DAVID LOGAN",
  "recipientNpi": "1477763779",
  "recipientSpecialty": "Cardiovascular Disease",
  "recipientCity": "SAINT CLAIR SHORES",
  "recipientState": "MI",
  "manufacturerName": "Penumbra, Inc.",
  "totalAmountUsd": 128.65,
  "natureOfPayment": "Food and Beverage",
  "productName": "Indigo System",
  "disputed": false
}
```

### Use cases

- Check which manufacturers paid a specific doctor, by NPI, before a story, a hire or a referral decision.
- Track one company's payments by state or specialty each year, for compliance review or market research.
- Build a weekly sheet or n8n workflow that flags new large payments above a dollar threshold.
- Compare payment types (food, travel, consulting) across states to see where industry money goes.
- Enrich a physician list with payment totals for healthcare sales and account planning.

### Why use it

- **Official public source.** Rows come straight from the CMS Open Payments portal, with the record ID so you can verify each one.
- **Filters done for you.** State, name, NPI, company, payment type and amount, without writing queries.
- **Clean fields.** Dates in ISO format, amounts as numbers, specialty trimmed to its last level.
- **Public registry data only.** No login, no proxy, nothing behind a paywall.

### Pricing

Pay per event. You pay a small fixed amount per payment record delivered, listed on the Pricing tab, plus a tiny start fee per run. Records removed by your filters are never charged. Set a maximum cost per run in the run options to cap spend.

### FAQ

**Is this Medicare billing data?**
No. These are payments that drug and device manufacturers reported to CMS under the Sunshine Act. The program is run by the Medicare agency, but the rows are not claims or reimbursements.

**Does a payment mean wrongdoing?**
No. Most records are meals, travel or lawful consulting and speaking fees. Read the payment type and context, and do not infer motive.

**How current is the data?**
It follows the CMS publication schedule. A year is published after the reporting period, and CMS refreshes it when companies correct records.

**Why did my name search return the wrong person?**
Names are not unique. Add the NPI, the state or the first name to narrow it down.

**Can I get several years?**
Run the actor once per year. Each run reads one reporting year.

### Limits

- Data is as reported by manufacturers. Doctors can dispute records, shown in the `disputed` field.
- A run scans up to 20,000 matching records. Narrow the filters to reach further.
- The amount filter is applied after CMS returns the records, so a high minimum on a broad query can scan many records before enough match.
- General payments to physicians only in this version.

### Related Actors

- [Federal Grants and Contracts](https://apify.com/transparent_meteorite/federal-grants-contracts) searches US federal award data from public sources.
- [Sanctions Screening](https://apify.com/transparent_meteorite/sanctions-screening) checks names against public sanctions lists.
- [SAM.gov Opportunities](https://apify.com/transparent_meteorite/sam-gov-opportunities) lists public federal contract opportunities.

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

### More from DWA Open Data

Browse all 69 data Actors, with live prices and sample output, at [open-data-actors.pages.dev](https://open-data-actors.pages.dev).

***

**Feedback:** if this Actor was useful, or if it fell short, an honest review on the [Reviews tab](https://apify.com/transparent_meteorite/medicare-open-payments-doctors/reviews) helps other users decide. Problems or feature requests: please open an [Issue](https://apify.com/transparent_meteorite/medicare-open-payments-doctors/issues) and we usually reply within one business day.

# Actor input Schema

## `programYear` (type: `integer`):

Reporting year of the CMS General Payment Data file, for example 2024. Years 2019 and later are published.

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

Two-letter US state of the doctor's primary address, for example MI. Leave empty for all states.

## `recipientLastName` (type: `string`):

Exact last name of the doctor, any case. Names are ambiguous, so add an NPI or state when you can.

## `recipientFirstName` (type: `string`):

Exact first name of the doctor, any case.

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

10-digit National Provider Identifier. The most reliable way to match one doctor.

## `manufacturerContains` (type: `string`):

Part of the paying company's name, for example Pfizer or Medtronic.

## `natureOfPayment` (type: `array`):

Keep payments whose type contains one of these words, for example Consulting, Food, Travel, Gift, Speaker. Leave empty for all types.

## `minAmountUsd` (type: `integer`):

Keep payments of at least this many US dollars. 0 = no minimum.

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

Stop after this many payments. You pay only for payments delivered.

## Actor input object example

```json
{
  "programYear": 2024,
  "state": "MI",
  "minAmountUsd": 100,
  "maxItems": 50
}
```

# 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 = {
    "programYear": 2024,
    "state": "MI",
    "minAmountUsd": 100,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/medicare-open-payments-doctors").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 = {
    "programYear": 2024,
    "state": "MI",
    "minAmountUsd": 100,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/medicare-open-payments-doctors").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 '{
  "programYear": 2024,
  "state": "MI",
  "minAmountUsd": 100,
  "maxItems": 50
}' |
apify call transparent_meteorite/medicare-open-payments-doctors --silent --output-dataset

```

## MCP server setup

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

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/zDeKDpKuAumD4I0JY/builds/A1mUmg3CSm6n1veGA/openapi.json