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

Scrape US healthcare providers from the official NPPES NPI Registry — no login, no API key, no blocking. 8M+ doctors, dentists, pharmacies and clinics with name, specialty, license, address and phone. Tens of thousands per run. Schedule for an always-fresh provider database.

- **URL**: https://apify.com/logiover/npi-registry-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 7 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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

## 🏥 NPI Registry Scraper — Scrape US Healthcare Provider Data (NPPES)

![NPI Registry Scraper](https://apify-image-uploads-prod.s3.us-east-1.amazonaws.com/GjS6nQ8qauOdq9KGy-actor-EqVWC0bZriGLElOpR-snTawccEBZ-logo.png)

Scrape **US healthcare providers** from the **official NPPES NPI Registry** maintained by the Centers for Medicare & Medicaid Services (CMS). This NPI Registry scraper extracts provider name, NPI number, specialty/taxonomy, license number, full address, phone and fax — covering 8M+ doctors, dentists, pharmacies, clinics, hospitals and every other healthcare provider in the United States. It uses the official government API, so there is **no login, no API key and no blocking** — one run can return tens of thousands of provider records exported to JSON, CSV or Excel.

### ✨ What this Actor does / Key features

- 🏛️ **Official government API** — sources the NPPES NPI Registry directly; reliable, never blocked, and updated daily by CMS.
- 🔑 **No API key needed** — just configure your filters and run.
- 🇺🇸 **Nationwide coverage** — scrape any combination of US states, or all 50 states + DC by default.
- 🩺 **Specialty filtering** — filter by taxonomy/specialty (dentist, pharmacy, physical therapist, nurse practitioner, etc.).
- 👤 **Provider type filter** — individuals (NPI-1), organizations (NPI-2), or both.
- 🏙️ **City filter** — optionally narrow results to a single city.
- 📇 **Rich provider data** — name, organization, NPI number, taxonomy, license, full address, phone, fax, status and authorized official details.
- 📈 **High volume** — de-duplicated results; tens of thousands of providers per run.
- ⏱️ **Schedule-ready** — run on a schedule for an always-current US healthcare provider database.

### 🔍 Input

| Field | Type | Description |
|-------|------|-------------|
| `states` | array | US state codes to scrape (e.g. "NY", "CA", "TX"). Defaults to all 50 states + DC. |
| `taxonomyDescription` | string | Filter by provider specialty (e.g. "dentist", "pharmacy", "nurse practitioner"). Leave empty for all specialties. |
| `enumerationType` | string | Provider type: `NPI-1` = individuals, `NPI-2` = organizations, empty = both. |
| `city` | string | Optional city filter to narrow results (e.g. "Brooklyn"). Leave empty for the whole state. |
| `maxRecords` | integer | Maximum providers to save. 0 = all matching records. |

### 🚀 Example input

```json
{
  "states": ["NY", "CA", "TX"],
  "taxonomyDescription": "dentist",
  "enumerationType": "NPI-1",
  "city": "",
  "maxRecords": 10000
}
````

### 📦 Output

Each provider is saved as a structured item in the dataset. Export to JSON, CSV, Excel or XML, or pull via the Apify API.

| Field | Description |
|-------|-------------|
| `npi` | 10-digit National Provider Identifier |
| `enumerationType` | NPI-1 (individual) or NPI-2 (organization) |
| `organizationName` | Organization name (for NPI-2 providers) |
| `firstName` | Provider first name (for NPI-1 providers) |
| `lastName` | Provider last name (for NPI-1 providers) |
| `credential` | Credential (e.g. MD, DDS, RN) |
| `gender` | Provider gender |
| `soleProprietor` | Sole proprietor status |
| `status` | NPI record status (active / deactivated) |
| `authorizedOfficialName` | Name of the organization's authorized official |
| `authorizedOfficialTitle` | Title of the authorized official |
| `authorizedOfficialPhone` | Phone of the authorized official |
| `primaryTaxonomy` | Primary taxonomy / specialty description |
| `taxonomyCode` | Taxonomy code |
| `taxonomyGroup` | Taxonomy group |
| `licenseNumber` | State license number |
| `addressLine` | Practice street address |
| `city` | City |
| `state` | State code |
| `postalCode` | ZIP / postal code |
| `phone` | Practice phone number |
| `fax` | Practice fax number |
| `enumerationDate` | Date the NPI was issued |
| `lastUpdated` | Date the record was last updated |
| `scrapedAt` | Scrape timestamp (ISO 8601) |

### 💡 Use cases

- **Medical & pharma sales** — build targeted prospect lists of providers by specialty, state and city.
- **Healthcare marketing** — reach dentists, physicians, clinics and pharmacies at scale with verified contact data.
- **Recruitment & staffing** — source healthcare professionals nationwide by specialty and location.
- **Research & analytics** — map provider density, specialty distribution and licensing across the US.
- **CRM enrichment** — verify and enrich existing provider records against the official NPI Registry.
- **Compliance & verification** — check provider NPI numbers, license numbers and active status.

### ❓ Frequently Asked Questions

**Is it legal to scrape the NPI Registry?**
Yes. The NPPES NPI Registry is a public dataset published by CMS specifically for public use. The Actor reads from the official government API. You are still responsible for using contact data in compliance with applicable laws such as CAN-SPAM and TCPA.

**Do I need an API key or a login?**
No. There is no NPPES account, login or API key required. You only need an Apify account to run the Actor.

**How much data can I get?**
The registry contains 8M+ providers. A single run can return tens of thousands of records — set `maxRecords` to 0 to capture all matching providers across your selected states.

**How fresh is the data?**
The NPPES NPI Registry is updated daily by CMS, and the Actor pulls live data at run time. Schedule it to keep your provider database always current.

**Can I filter by specialty, state or provider type?**
Yes. You can filter by US state(s), taxonomy/specialty description, city, and provider type (individuals, organizations, or both).

**Does it get blocked or rate-limited?**
No. It uses the official government API, which is stable and not subject to anti-bot blocking.

**What output formats are supported?**
Results are stored in a structured Apify dataset and can be exported as JSON, CSV, Excel or XML, or accessed via the Apify API.

### ⏰ Scheduling & integration

Schedule this Actor on Apify to keep an always-fresh US healthcare provider database. Export results to JSON, CSV or Excel, sync to Google Sheets, or push to your CRM, database and webhooks through the Apify API.

# Actor input Schema

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

US state codes to scrape, e.g. 'NY', 'CA', 'TX'. Default = all 50 states + DC. More states = more providers.

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

Filter by provider specialty, e.g. 'dentist', 'pharmacy', 'physical therapist', 'nurse practitioner'. Leave empty for all specialties.

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

'NPI-1' = individual providers, 'NPI-2' = organizations. Leave empty for both.

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

Optional city filter to narrow results, e.g. 'Brooklyn'. Leave empty for whole state.

## `maxRecords` (type: `integer`):

Maximum providers to save. 0 = all matching (tens of thousands across all states).

## Actor input object example

```json
{
  "states": [
    "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"
  ],
  "taxonomyDescription": "",
  "enumerationType": "",
  "city": ""
}
```

# Actor output Schema

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

npi

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

organizationName

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

firstName

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

lastName

## `primaryTaxonomy` (type: `string`):

primaryTaxonomy

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

city

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

state

## `phone` (type: `string`):

phone

# 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": [
        "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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/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 = { "states": [
        "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",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("logiover/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 '{
  "states": [
    "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"
  ]
}' |
apify call logiover/npi-registry-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NPI Registry Scraper",
        "description": "Scrape US healthcare providers from the official NPPES NPI Registry — no login, no API key, no blocking. 8M+ doctors, dentists, pharmacies and clinics with name, specialty, license, address and phone. Tens of thousands per run. Schedule for an always-fresh provider database.",
        "version": "1.0",
        "x-build-id": "S6l8SwNsp6CReRO2p"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~npi-registry-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-npi-registry-scraper",
                "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/logiover~npi-registry-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-npi-registry-scraper",
                "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/logiover~npi-registry-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-npi-registry-scraper",
                "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": {
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "US state codes to scrape, e.g. 'NY', 'CA', 'TX'. Default = all 50 states + DC. More states = more providers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "taxonomyDescription": {
                        "title": "Taxonomy / Specialty",
                        "type": "string",
                        "description": "Filter by provider specialty, e.g. 'dentist', 'pharmacy', 'physical therapist', 'nurse practitioner'. Leave empty for all specialties.",
                        "default": ""
                    },
                    "enumerationType": {
                        "title": "Provider Type",
                        "enum": [
                            "",
                            "NPI-1",
                            "NPI-2"
                        ],
                        "type": "string",
                        "description": "'NPI-1' = individual providers, 'NPI-2' = organizations. Leave empty for both.",
                        "default": ""
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Optional city filter to narrow results, e.g. 'Brooklyn'. Leave empty for whole state.",
                        "default": ""
                    },
                    "maxRecords": {
                        "title": "Max Records",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum providers to save. 0 = all matching (tens of thousands across all states)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
