# NPI Registry Scraper (`fetch_cat/npi-registry-scraper`) Actor

Search and export public CMS NPI Registry healthcare provider records by NPI, specialty, name, organization, and location.

- **URL**: https://apify.com/fetch\_cat/npi-registry-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 provider records

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

## NPI Registry Scraper

Extract public healthcare provider records from the CMS NPI Registry. Search by NPI number, specialty, provider name, organization, city, state, ZIP, and entity type, then export normalized provider data to CSV, JSON, Excel, or the Apify API.

### What does NPI Registry Scraper do?

- Build healthcare lead lists by specialty and geography.
- Enrich internal provider records with official NPI details.
- Find clinics, hospitals, pharmacies, and individual practitioners.
- Support compliance, KYC, provider network, and market research workflows.

### Who is it for

- Healthcare sales and marketing teams building specialty-specific outreach lists.
- Provider network and credentialing teams checking official NPI details.
- Compliance, KYC, and due-diligence teams validating provider identities.
- Data enrichment teams matching internal provider records to official registry data.

### Example input

```json
{
  "taxonomyDescription": "Cardiology",
  "city": "Seattle",
  "state": "WA",
  "maxResults": 20,
  "includeRaw": true
}
```

Exact NPI lookup:

```json
{
  "npiNumbers": ["1679576722"],
  "maxResults": 1
}
```

### Example output

```json
{
  "npi": "1679576722",
  "entityType": "individual",
  "enumerationType": "NPI-1",
  "firstName": "JANE",
  "lastName": "DOE",
  "organizationName": null,
  "credential": "MD",
  "primarySpecialty": "Internal Medicine, Cardiovascular Disease",
  "practiceCity": "SEATTLE",
  "practiceState": "WA",
  "practicePhone": "2065550100",
  "enumerationDate": "2005-07-01",
  "status": "A",
  "url": "https://npiregistry.cms.hhs.gov/provider-view/1679576722",
  "scrapedAt": "2026-07-08T08:00:00.000Z"
}
```

### Input settings

| Field | Type | Description |
| --- | --- | --- |
| `npiNumbers` | string\[] | Exact 10-digit NPI numbers to look up. |
| `taxonomyDescription` | string | Specialty or taxonomy text, such as `Cardiology` or `Family Medicine`. |
| `firstName` / `lastName` | string | Individual provider name filters. |
| `organizationName` | string | Hospital, clinic, pharmacy, group practice, or other organization name. |
| `city` | string | Provider practice city. |
| `state` | string | Two-letter US state code. |
| `postalCode` | string | ZIP/postal code filter. |
| `countryCode` | string | Two-letter country code. Defaults to `US` when omitted. |
| `enumerationType` | string | `NPI-1` for individuals, `NPI-2` for organizations, or blank for both. |
| `maxResults` | integer | Maximum provider records to save. Default: `20`. |
| `includeRaw` | boolean | Include the complete CMS source record in `raw`. |
| `proxyConfiguration` | object | Optional proxy settings. Off by default because the registry is public. |

Provide at least one NPI number or one search filter.

### Output fields

The dataset includes flat fields for easy spreadsheet use and structured fields for enrichment pipelines:

- Provider identity: `npi`, `entityType`, `enumerationType`, `firstName`, `middleName`, `lastName`, `organizationName`, `credential`, `gender`, `status`.
- Specialties: `primarySpecialty`, `specialties`, `taxonomyCodes`, `taxonomies`.
- Practice and mailing contact data: address, city, state, ZIP, country, phone, and fax fields.
- Registry dates: `enumerationDate`, `certificationDate`, `lastUpdated`, `createdEpoch`, `lastUpdatedEpoch`.
- Source details: `url`, `scrapedAt`, `endpoints`, `identifiers`, `otherNames`, `practiceLocations`, and optional `raw`.

### Input recipes

#### Providers by specialty and state

```json
{
  "taxonomyDescription": "Pediatrics",
  "state": "CA",
  "maxResults": 100
}
```

#### Organizations in a city

```json
{
  "organizationName": "clinic",
  "city": "Austin",
  "state": "TX",
  "enumerationType": "NPI-2",
  "maxResults": 50
}
```

#### Known NPI enrichment

```json
{
  "npiNumbers": ["1679576722", "1234567893"],
  "includeRaw": true
}
```

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee per run | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `result` | Per NPI Registry provider record saved to the dataset | $0.575 / 1,000 | $0.5 / 1,000 | $0.39 / 1,000 | $0.3 / 1,000 | $0.2 / 1,000 | $0.14 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### API usage

Run the actor from code with the Apify API.

Node.js:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/npi-registry-scraper').call({
  taxonomyDescription: 'Cardiology',
  state: 'WA',
  maxResults: 20
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Python:

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/npi-registry-scraper').call(run_input={
    'taxonomyDescription': 'Cardiology',
    'state': 'WA',
    'maxResults': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

cURL:

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~npi-registry-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"taxonomyDescription":"Cardiology","state":"WA","maxResults":20}'
```

### MCP and agent usage

Connect AI agents through Apify MCP with:

```text
https://mcp.apify.com/?tools=fetch_cat/npi-registry-scraper
```

Claude CLI setup:

```bash
claude mcp add apify-npi-registry https://mcp.apify.com/?tools=fetch_cat/npi-registry-scraper
```

MCP JSON config:

```json
{
  "mcpServers": {
    "apify-npi-registry": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/npi-registry-scraper"
    }
  }
}
```

Example prompts showing MCP usage:

- "Use MCP to run `fetch_cat/npi-registry-scraper` and find 50 active cardiology providers in Seattle. Return NPI, name, specialty, phone, and address."
- "Use the Apify MCP server and `fetch_cat/npi-registry-scraper` to enrich these NPI numbers with official organization names and taxonomy codes."

### Limits and tips

- Keep `maxResults` low for the first run, then scale once the filters return the right provider type.
- The CMS registry can return zero results for overly specific combinations; broaden city, specialty, or name filters if needed.
- Exact NPI lookup is best for enrichment. Specialty and location search is best for lead generation.
- When looking up several NPIs, check the run summary for any unavailable identifiers. Provider records saved before a later unavailable lookup remain in the dataset.

### Legality and responsible use

The actor exports public CMS NPI Registry data. Provider data is public registry data, but you are responsible for using it lawfully and respecting applicable healthcare, marketing, and privacy rules.

### FAQ

**Does this require a CMS account?** No. It uses public NPI Registry records.

**Can I look up exact NPIs?** Yes. Add one or more 10-digit values in `npiNumbers`.

**Why did my search return zero records?** The filters may be too narrow or the specialty text may not match registry taxonomy wording. Try fewer filters or a broader specialty.

**Can I export phone numbers and addresses?** Yes. Practice and mailing address fields, phones, and fax numbers are included when CMS provides them.

### Related actors

- [Google Maps Lead Finder](https://apify.com/fetch_cat/google-maps-lead-finder) for local business lead lists.
- [Google Maps Reviews Scraper](https://apify.com/fetch_cat/google-maps-reviews-scraper) for business review intelligence.

### Support

If a run does not return the expected records, open an issue and include the run ID or run URL, input JSON, expected output, actual output, and a reproducible public URL from the [NPI Registry](https://npiregistry.cms.hhs.gov/) when available.

### Privacy and data handling

This Actor only requests the permissions needed to run the input you provide. It uses your input (such as URLs, search terms, identifiers, filters, and limits) only to fetch the requested public data from the relevant source site or API for this Actor, then writes results to your Apify dataset/key-value store.

Data may pass through Apify platform services and Apify Proxy during the run, and requests are sent only to the target site or public data provider required for this Actor's results. FetchCat does not send your inputs or outputs to advertising networks, data brokers, or model-training services, and does not retain run data outside Apify storage after the run except when you explicitly share run details for transient support debugging.

You are responsible for using this Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs. Review the output before storing, sharing, or combining it with other data.

# Actor input Schema

## `npiNumbers` (type: `array`):

Optional exact 10-digit NPI numbers to look up. Use this when you already know provider NPIs.

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

Provider specialty text, such as Cardiology, Family Medicine, Acupuncturist, Pharmacy, or Hospital.

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

First name for individual provider searches.

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

Last name for individual provider searches.

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

Organization, clinic, pharmacy, hospital, or group practice name.

## `city` (type: `string`):

Provider practice city.

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

Two-letter US state code, such as WA, CA, NY, or TX.

## `postalCode` (type: `string`):

US ZIP/postal code filter accepted by the NPI Registry API.

## `countryCode` (type: `string`):

Two-letter country code for provider address filtering. Defaults to US when omitted by the API.

## `enumerationType` (type: `string`):

Filter individuals (NPI-1) or organizations (NPI-2). Leave blank to include both.

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

Maximum number of provider records to save. Keep this low for a first test run.

## `includeRaw` (type: `boolean`):

Include the complete source record in the `raw` field for advanced enrichment workflows.

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

Optional proxy settings. The CMS API is public, so proxies are off by default.

## Actor input object example

```json
{
  "npiNumbers": [
    "1679576722"
  ],
  "taxonomyDescription": "Cardiology",
  "city": "Seattle",
  "state": "WA",
  "countryCode": "US",
  "enumerationType": "",
  "maxResults": 20,
  "includeRaw": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "npiNumbers": [
        "1679576722"
    ],
    "taxonomyDescription": "Cardiology",
    "city": "Seattle",
    "state": "WA"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/npi-registry-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 = {
    "npiNumbers": ["1679576722"],
    "taxonomyDescription": "Cardiology",
    "city": "Seattle",
    "state": "WA",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/npi-registry-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 '{
  "npiNumbers": [
    "1679576722"
  ],
  "taxonomyDescription": "Cardiology",
  "city": "Seattle",
  "state": "WA"
}' |
apify call fetch_cat/npi-registry-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/ZLHry7bARluOPbIhC/builds/u3ZOOnSmgeAElNN3h/openapi.json