# NPI Provider Registry Scraper (`crawlerbros/npi-provider-registry`) Actor

Search the CMS National Provider Identifier (NPI) registry for US healthcare providers - doctors, hospitals, nurses, and other licensed professionals. Free, no authentication required.

- **URL**: https://apify.com/crawlerbros/npi-provider-registry.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## CMS Open Payments Scraper (Sunshine Act)

Extract pharma and medical device company payments to US physicians and teaching hospitals from the official CMS Open Payments database (Sunshine Act). Retrieve general payments, research funding, and ownership interests — no login required.

### What data you get

Each record includes:

| Field | Description |
|---|---|
| `paymentType` | `general`, `research`, or `ownership` |
| `programYear` | Calendar year of the payment (2018–2024) |
| `recipientName` | Full name of the physician or teaching hospital |
| `recipientType` | Covered Recipient Physician / Non-Physician Practitioner / Teaching Hospital |
| `recipientNpi` | National Provider Identifier (physicians) |
| `recipientCity` | City of the recipient |
| `recipientState` | US state code (2-letter) |
| `recipientZip` | ZIP code |
| `recipientCountry` | Country |
| `recipientSpecialties` | List of medical specialties |
| `manufacturerName` | Company making the payment |
| `manufacturerState` | Manufacturer's state |
| `manufacturerCountry` | Manufacturer's country |
| `totalAmountUsd` | Total payment amount in USD |
| `numberOfPayments` | Number of payments included in the total |
| `formOfPayment` | Cash, in-kind, etc. |
| `natureOfPayment` | Consulting fee, honoraria, travel, food, education, etc. |
| `associatedProducts` | Drug/device names associated with the payment |
| `travelDestination` | City, state, country for travel payments |
| `nameOfStudy` | Research study name (research payments) |
| `clinicalTrialGovUrl` | ClinicalTrials.gov identifier (research payments) |
| `natureOfInterest` | Type of ownership interest (ownership payments) |
| `disputeStatus` | Whether the record is disputed |
| `scrapedAt` | ISO-8601 timestamp of scrape |

### Use cases

- **Healthcare transparency research** — track which companies pay which doctors and how much
- **Compliance monitoring** — audit payments to physicians in your organization or specialty
- **Investigative journalism** — follow the money between pharma companies and healthcare providers
- **Academic research** — analyze industry influence on prescribing patterns
- **Business intelligence** — identify key opinion leaders and consulting relationships

### Input parameters

| Parameter | Required | Default | Description |
|---|---|---|---|
| `paymentType` | Yes | `general` | Category: `general`, `research`, or `ownership` |
| `programYear` | Yes | `2024` | Year of data: 2018–2024 |
| `recipientState` | No | all | Filter by 2-letter US state code |
| `recipientType` | No | all | Filter by physician, non-physician, or entity |
| `natureOfPayment` | No | all | Filter by payment category (consulting fee, honoraria, etc.) |
| `manufacturerName` | No | — | Partial match on manufacturer name (e.g., `Pfizer`) |
| `minAmountUsd` | No | — | Minimum payment amount in USD |
| `maxItems` | No | `100` | Maximum records to return (up to 10,000) |

### Example input

```json
{
  "paymentType": "general",
  "programYear": "2024",
  "recipientState": "TX",
  "natureOfPayment": "Consulting Fee",
  "maxItems": 200
}
````

### Example output record

```json
{
  "paymentType": "general",
  "recordId": "12345678",
  "programYear": "2024",
  "paymentDate": "2024-03-15",
  "recipientName": "DONALD A GRIFFITH MD",
  "recipientType": "Covered Recipient Physician",
  "recipientNpi": "1821102930",
  "recipientCity": "HOUSTON",
  "recipientState": "TX",
  "recipientZip": "77030",
  "recipientCountry": "United States",
  "recipientSpecialties": ["Allopathic & Osteopathic Physicians|Urology"],
  "manufacturerName": "Pfizer Inc.",
  "manufacturerState": "NY",
  "manufacturerCountry": "United States",
  "totalAmountUsd": 1500.00,
  "numberOfPayments": "1",
  "formOfPayment": "Cash or cash equivalent",
  "natureOfPayment": "Consulting Fee",
  "associatedProducts": ["VIAGRA"],
  "scrapedAt": "2026-06-04T00:00:00+00:00"
}
```

### Data source

Data is sourced directly from the **CMS Open Payments** database at [openpaymentsdata.cms.gov](https://openpaymentsdata.cms.gov), published by the Centers for Medicare & Medicaid Services (CMS) under the Physician Payments Sunshine Act (Section 6002 of the Affordable Care Act). The data is public, free, and requires no API key.

Coverage: 2018–2024 (updated annually). The 2024 program year data was published in 2025.

### FAQ

**Does this require an API key or registration?**
No. CMS Open Payments data is fully public and requires no authentication.

**How current is the data?**
Data is published annually. The most recent available is the 2024 program year (published mid-2025). Use `programYear` to select the desired year.

**What is the difference between payment types?**

- *General* — includes meals, consulting fees, honoraria, speaking fees, travel, gifts, and education
- *Research* — funding for clinical trials and research studies paid to organizations or investigators
- *Ownership* — stock, investment interests, or compensation for ownership stakes

**Can I filter by specific company?**
Yes. Use the `manufacturerName` field with a partial company name (e.g., `Pfizer`, `Medtronic`, `Johnson`).

**How many records are available?**
The 2024 general payments dataset alone contains millions of records. Use state, specialty, or manufacturer filters to narrow results.

**Is this data reliable?**
Yes. Companies are legally required to report these payments under the Sunshine Act. Penalties apply for non-disclosure or inaccurate reporting.

# Actor input Schema

## `providerType` (type: `string`):

Filter by provider type: individual (NPI-1) or organization (NPI-2).

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

Filter by 2-letter US state or territory code. Leave blank to search all states.

## `taxonomyDescription` (type: `string`):

Filter by provider specialty description, e.g. "Internal Medicine", "Family Practice", "Cardiology". Partial matches supported.

## `firstName` (type: `string`):

Filter individual providers by first name. Partial matches supported.

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

Filter individual providers by last name. Partial matches supported.

## `organizationName` (type: `string`):

Filter organizations by name. Partial matches supported.

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

Maximum number of provider records to return.

## Actor input object example

```json
{
  "providerType": "individual",
  "state": "CA",
  "taxonomyDescription": "Internal Medicine",
  "maxItems": 50
}
```

# Actor output Schema

## `payments` (type: `string`):

Dataset containing all scraped Open Payments 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 = {
    "providerType": "individual",
    "state": "CA",
    "taxonomyDescription": "Internal Medicine",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/npi-provider-registry").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 = {
    "providerType": "individual",
    "state": "CA",
    "taxonomyDescription": "Internal Medicine",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/npi-provider-registry").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 '{
  "providerType": "individual",
  "state": "CA",
  "taxonomyDescription": "Internal Medicine",
  "maxItems": 50
}' |
apify call crawlerbros/npi-provider-registry --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NPI Provider Registry Scraper",
        "description": "Search the CMS National Provider Identifier (NPI) registry for US healthcare providers - doctors, hospitals, nurses, and other licensed professionals. Free, no authentication required.",
        "version": "0.1",
        "x-build-id": "ObxFM1H8wWdpQ3i6X"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~npi-provider-registry/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-npi-provider-registry",
                "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/crawlerbros~npi-provider-registry/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-npi-provider-registry",
                "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/crawlerbros~npi-provider-registry/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-npi-provider-registry",
                "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": {
                    "providerType": {
                        "title": "Provider Type",
                        "enum": [
                            "all",
                            "individual",
                            "organization"
                        ],
                        "type": "string",
                        "description": "Filter by provider type: individual (NPI-1) or organization (NPI-2).",
                        "default": "all"
                    },
                    "state": {
                        "title": "State (optional)",
                        "enum": [
                            "",
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "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",
                            "DC",
                            "PR",
                            "VI",
                            "GU",
                            "MP",
                            "AS"
                        ],
                        "type": "string",
                        "description": "Filter by 2-letter US state or territory code. Leave blank to search all states.",
                        "default": ""
                    },
                    "taxonomyDescription": {
                        "title": "Specialty / Taxonomy (optional)",
                        "type": "string",
                        "description": "Filter by provider specialty description, e.g. \"Internal Medicine\", \"Family Practice\", \"Cardiology\". Partial matches supported."
                    },
                    "firstName": {
                        "title": "First Name (optional, individuals only)",
                        "type": "string",
                        "description": "Filter individual providers by first name. Partial matches supported."
                    },
                    "lastName": {
                        "title": "Last Name (optional, individuals only)",
                        "type": "string",
                        "description": "Filter individual providers by last name. Partial matches supported."
                    },
                    "organizationName": {
                        "title": "Organization Name (optional, organizations only)",
                        "type": "string",
                        "description": "Filter organizations by name. Partial matches supported."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of provider records to return.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
