# NPI Registry Scraper — 17 Fields, US Providers, No Key (`themineworks/npi-registry-healthcare`) Actor

Scrape US healthcare providers from the official CMS NPI Registry by specialty, name, org, city or state. Get NPI, credentials, specialty, license, address, phone as clean JSON. No API key. Works in Claude, ChatGPT and any MCP agent.

- **URL**: https://apify.com/themineworks/npi-registry-healthcare.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Other, Business, MCP servers
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 providers

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: US Healthcare Provider Data (No API Key)

### Overview

NPI Registry Scraper pulls verified US healthcare provider records straight from the official CMS National Provider Identifier registry. Search by specialty, name, organisation, city, state, or ZIP code and get back structured JSON with NPIs, credentials, taxonomy, license numbers, practice addresses, and phone numbers. No API key, no signup, no per-seat pricing.

It's the fastest way to build a targeted list of doctors, dentists, therapists, pharmacies, or hospitals for outreach, referral mapping, market sizing, or credentialing. The registry is the single source of truth for US healthcare identifiers, so every record you get is billable-grade data.

Reliability posture: blocked, empty, or failed runs are never charged. You only pay for a provider record that was actually delivered.

✅ No login required | ✅ No API key | ✅ Pay only for providers returned | ✅ MCP-ready for AI agents

### Features

Specialty search. Pull every dentist in California or every cardiologist in Manhattan in one run.
Organisation search. Wildcard match hospitals, clinics, and pharmacies by name.
Individual lookup. Query by first name, last name, or a specific 10-digit NPI.
Geo filters. Restrict by state code, city, or ZIP (wildcards supported for ZIP prefixes).
Clean output. NPI, credentials, taxonomy code, license, address, phone, fax as flat JSON fields.

### How it works

The actor calls the official CMS NPI Registry API (npiregistry.cms.hhs.gov), which is the authoritative source for every provider that bills Medicare or Medicaid in the United States. It doesn't scrape a third-party mirror, so every field matches what CMS itself publishes.

Each search request is scoped by your input filters (specialty, geo, name), paginated up to the CMS single-query cap of 1,200 records, and normalised into flat fields ready for a CRM or database. Records without a required field are still returned so you can decide how to handle partial data downstream.

### 🧾 Input configuration

```json
{
  "taxonomyDescription": "Dentist",
  "state": "CA",
  "city": "Los Angeles",
  "maxResults": 200
}
```

### 📤 Output format

```json
{
  "npi": "1932088416",
  "type": "Individual",
  "name": "AZITA HAJ HOSSEIN TALASAZ",
  "credential": "PharmD, PhD",
  "status": "Active",
  "primary_specialty": "Pharmacist, Cardiology",
  "taxonomy_code": "1835C0206X",
  "license": "071090",
  "license_state": "NY",
  "address": "622 W 168TH ST APT 5C",
  "city": "NEW YORK",
  "state": "NY",
  "postal_code": "100323720",
  "phone": "212-305-2500",
  "enumeration_date": "2025-08-29",
  "last_updated": "2025-08-29",
  "scraped_at": "2026-07-15T04:15:43.911Z"
}
```

Every provider record contains these fields:

| Field | Description |
| --- | --- |
| 🆔 `npi` | 10-digit National Provider Identifier |
| 👤 `type` | Individual or Organization |
| 🙋 `name` | Full name for individuals, organisation name for entities |
| 🎓 `credential` | Professional credentials (MD, DO, DDS, RN, PharmD, etc.) |
| ✅ `status` | Active or inactive |
| 🩺 `primary_specialty` | Primary specialty description from CMS taxonomy |
| 🔖 `taxonomy_code` | 10-character NUCC taxonomy code |
| 📜 `license` | State license number if published |
| 🏛️ `license_state` | State that issued the license |
| 🏢 `address` | Street address of practice location |
| 🏙️ `city` | Practice city |
| 🗺️ `state` | Practice state (2-letter) |
| 📮 `postal_code` | Practice ZIP |
| 📞 `phone` | Practice phone number |
| 📆 `enumeration_date` | Date the NPI was first issued |
| 🕒 `last_updated` | Date CMS last updated this record |

### 💼 Common use cases

**Healthcare sales & marketing**
Build targeted lists of specialists to reach with pharma, medical device, or SaaS outreach.
Filter by state and specialty to plan a rep territory or a regional launch.

**Provider directory & referral mapping**
Populate an in-house directory or referral tool with authoritative CMS data.
Cross check the specialty and license of a doctor before adding them to a network.

**Credentialing & compliance**
Verify NPI, taxonomy, and license against the CMS source of truth.
Pull a monthly refresh of active providers in a given state for compliance audits.

**Market research**
Size a market by counting active providers per specialty per state.
Track new registrations and status changes over time.

### 🚀 Getting started

1. Open the actor and add a specialty (e.g. `Dentist`, `Cardiology`, `Pharmacy`).
2. Add a state code (`CA`, `NY`, `TX`) and optionally a city or ZIP to narrow the search.
3. Set max providers (default 200, hard cap 1,200 per query).
4. Click Start. Results stream to the dataset as they're fetched.
5. Download as JSON, CSV, or Excel, or pull the dataset via API or MCP into your CRM.

### FAQ

**Where does the data come from?**
Directly from the official CMS NPI Registry at npiregistry.cms.hhs.gov. This is the same registry that Medicare and Medicaid use to verify providers, so the data is authoritative and updated continuously.

**Is there a rate limit?**
CMS caps a single query at 1,200 results. To pull more than 1,200 providers in one specialty, split your search by state or city and run several queries.

**How much does it cost?**
Pay per provider returned. Cheap enough to build a national provider database, priced to be used often. No subscription, no seat license, no monthly minimum.

**Can I use it in an AI agent?**
Yes. It's exposed as an MCP tool. See below.

### Use in Claude, ChatGPT & any MCP agent

```
https://mcp.apify.com/?tools=themineworks/npi-registry-healthcare
```

Or call it programmatically with the Apify client:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('themineworks/npi-registry-healthcare').call({
  taxonomyDescription: 'Dentist',
  state: 'CA',
  maxResults: 200,
});

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

### 🛠️ Complete your healthcare data pipeline

Pulled the providers. Now enrich and act on them with the rest of the suite:

- **[Website Contact Scraper](https://apify.com/themineworks/website-contact-finder)**: take practice websites and extract emails, phones, and social profiles.
- **[Email Verifier & Validator](https://apify.com/themineworks/email-verifier-validator)**: MX and SMTP verify every email before you send.
- **[B2B Leads Finder](https://apify.com/themineworks/b2b-leads-finder)**: turn a practice or hospital domain into named decision-maker contacts.

Typical flow: NPI Registry finds the providers, website-contact-finder adds practice-level contact info, email-verifier-validator confirms deliverability.

Questions or need a custom field set? Reach out through the Apify profile.

# Actor input Schema

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

Provider specialty (e.g. Dentist, Cardiology, Physical Therapist, Pharmacy). Partial matches allowed.

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

US state code (e.g. CA, NY, TX).

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

City name.

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

ZIP code (supports wildcard, e.g. 902\*).

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

Organization/practice name (supports wildcard \*).

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

Individual provider first name.

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

Individual provider last name.

## `npiNumber` (type: `string`):

Look up a specific 10-digit NPI directly.

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

Maximum providers to return (NPI Registry caps a single query at 1,200).

## Actor input object example

```json
{
  "taxonomyDescription": "Dentist",
  "state": "CA",
  "maxResults": 25
}
```

# 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 = {
    "taxonomyDescription": "Dentist",
    "state": "CA",
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/npi-registry-healthcare").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 = {
    "taxonomyDescription": "Dentist",
    "state": "CA",
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("themineworks/npi-registry-healthcare").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 '{
  "taxonomyDescription": "Dentist",
  "state": "CA",
  "maxResults": 25
}' |
apify call themineworks/npi-registry-healthcare --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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