# NPI Provider Lead Extractor 🩺 (US doctors, clinics, phones) (`tagadanar/nppes-npi-provider-leads`) Actor

Pull targeted lists of US healthcare providers from the official CMS NPPES registry: name, NPI, specialty, practice address and phone. Filter by state, specialty, city, ZIP, name or organization. Clean flat JSON for outreach, credentialing and territory mapping. $1.50 per 1,000 providers.

- **URL**: https://apify.com/tagadanar/nppes-npi-provider-leads.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** Lead generation, Automation, AI
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 1,000 provider founds

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 Provider Lead Extractor: US Doctors, Clinics, Specialties & Phones

Build targeted lists of US healthcare providers from the official CMS NPPES registry (the national NPI database). Tell it a state and a specialty, or a name, city, ZIP or organization, and you get back a clean list of providers: NPI number, name or organization, credential, specialty taxonomy, practice address, phone and fax. It is the same public registry your credentialing and sales teams already trust, delivered as ready-to-use JSON or a spreadsheet.

It reads the NPPES API directly, so it is fast and returns complete records. There is no browser to time out, no login, no API key to manage, and no residential proxy requirement, so you are not paying a proxy surcharge on top of every lead. Give it a list of states and it runs one query per state and merges the results for you.

### What you get per provider

| Field | Description |
| --- | --- |
| `npi` | The 10-digit National Provider Identifier |
| `enumerationType` | `individual` (a person, NPI-1) or `organization` (a practice or facility, NPI-2) |
| `firstName`, `lastName`, `credential` | Name and credential for individual providers, e.g. MD, DO, NP (null for organizations) |
| `organizationName` | Practice or facility name for organizations (null for individuals) |
| `primaryTaxonomy`, `taxonomyCode` | The provider's primary specialty description and its taxonomy code |
| `allTaxonomies` | Every specialty listed on the record |
| `status` | NPI status, `A` for active |
| `addressLine1`, `addressLine2`, `city`, `state`, `postalCode` | Practice location address |
| `phone`, `fax` | Practice phone and fax from the registry, when present |
| `enumerationDate`, `lastUpdated` | When the NPI was issued and last updated |
| `npiUrl` | Direct link to the provider's public NPPES profile |
| `retrievedAt` | When this actor pulled the record |

Fields are null where the registry genuinely has no value. Nothing is guessed.

### Who uses it

- Medical-device, pharma and healthtech SDR teams building call lists by specialty and territory.
- Healthcare recruiters and staffing agencies sourcing physicians, nurses and therapists in a region.
- Credentialing and provider-data vendors validating NPIs, names and practice addresses.
- Market and territory analysts mapping provider density by specialty across states.

### Input examples

Every example below validates against the input schema as written.

All dermatologists in California and Texas (individuals and organizations):

```json
{
  "states": ["CA", "TX"],
  "taxonomyDescription": "Dermatology",
  "maxResults": 500
}
````

Only individual physical therapists in one city:

```json
{
  "states": ["FL"],
  "taxonomyDescription": "Physical Therapist",
  "city": "Miami",
  "enumerationType": "Individual",
  "maxResults": 300
}
```

Find organizations by name across a ZIP area:

```json
{
  "organizationName": "Kaiser*",
  "postalCode": "94*",
  "enumerationType": "Organization",
  "maxResults": 200
}
```

Look up providers by last name nationwide:

```json
{
  "lastName": "Nguyen",
  "taxonomyDescription": "Internal Medicine",
  "maxResults": 100
}
```

### Output sample

```json
{
  "npi": "1881198588",
  "enumerationType": "individual",
  "firstName": "JORDAN",
  "lastName": "ABBOTT",
  "credential": "MD",
  "organizationName": null,
  "primaryTaxonomy": "Dermatology",
  "taxonomyCode": "207N00000X",
  "allTaxonomies": ["Dermatology", "Dermatology, MOHS-Micrographic Surgery"],
  "status": "A",
  "addressLine1": "2600 E PFLUGERVILLE PKWY BLDG 2",
  "addressLine2": null,
  "city": "PFLUGERVILLE",
  "state": "TX",
  "postalCode": "786605998",
  "phone": "512-564-6500",
  "fax": null,
  "enumerationDate": "2018-03-19",
  "lastUpdated": "2026-04-16",
  "npiUrl": "https://npiregistry.cms.hhs.gov/provider-view/1881198588",
  "retrievedAt": "2026-07-09T11:30:00.000Z"
}
```

### Pricing

You pay per provider returned, platform usage included. Providers that do not match are free, and there is no subscription and no minimum.

| Event | Price |
| --- | --- |
| Provider found | $0.0015 per provider ($1.50 per 1,000) |

### FAQ

**How do I get a list of all dermatologists in Texas?** Set `states` to `["TX"]`, `taxonomyDescription` to `Dermatology`, and raise `maxResults`. The actor pages through the registry and returns each matching provider as one row.

**Does it include provider phone numbers?** Yes, when the registry has one. Each record carries the practice `phone` and `fax` from the provider's NPPES location address. Some records have no phone on file, in which case the field is null.

**Is NPPES data free and legal to use?** NPPES is the official CMS registry of National Provider Identifiers. CMS publishes it as public data and even offers a full monthly bulk download. This actor reads the same public records, so there is no consumer PII and no login involved.

**What is a taxonomy?** It is the standardized code and description for a provider's specialty, e.g. `Dermatology` (207N00000X) or `Physical Therapist` (225100000X). Type the specialty wording into `taxonomyDescription`; matching is on the start of the description.

**Can I pull individuals only, or organizations only?** Yes. Set `enumerationType` to `Individual` for people (doctors, nurses, therapists) or `Organization` for practices, groups and facilities. Leave it on `Any` for both.

**How many providers can I get per run?** Raise `maxResults`. The registry returns up to about 1,200 matches per state for a given query, so to go wider add more states or narrow with a city, ZIP or specialty. The actor merges results across every state you list.

**Do I need a proxy or an API key?** No. The NPPES API is public and answers plain requests, so runs need no key, no login and no residential proxy.

**Can I filter by ZIP code?** Yes. Use `postalCode` with a 5-digit ZIP, or a prefix and a trailing `*` (e.g. `902*`) for a wider area.

### For AI agents and MCP

Every field comes back as clean, typed JSON, so this actor drops straight into an agent tool or an MCP server. Point your agent at a state and a specialty and it gets a structured provider feed with no HTML parsing.

***

### Something missing?

If you need an extra field, another filter, or a different output shape, open an issue on this Actor and describe it. I read every request and small additions usually ship within days. More data and lead Actors are on [my profile](https://apify.com/tagadanar).

*NPI lookup, NPPES API, NPI registry scraper, US healthcare provider leads, doctor list by specialty, physician contact data, medical practice phone numbers, provider taxonomy, credentialing data, healthcare SDR list, territory mapping, CMS NPI database export.*

# Actor input Schema

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

Optional. Two-letter US state codes to pull leads from, one per entry, e.g. <code>CA</code>, <code>TX</code>. The actor runs one query per state and merges the results. Leave empty to search nationwide (a name, organization or postal code filter is then recommended).

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

Provider specialty, using the NPPES taxonomy wording, e.g. <code>Dermatology</code>, <code>Internal Medicine</code>, <code>Physical Therapist</code>, <code>Pharmacy</code>. Matches on the start of the description.

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

Optional. Restrict to one practice city, e.g. <code>San Diego</code>.

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

Optional. A 5-digit ZIP, or a prefix with a trailing <code>*</code> for a wider area, e.g. <code>90210</code> or <code>902*</code>.

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

Optional. Individual provider first name. Accepts a trailing <code>\*</code> wildcard.

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

Optional. Individual provider last name. Accepts a trailing <code>\*</code> wildcard.

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

Optional. Organization / practice name. Accepts a trailing <code>*</code> wildcard, e.g. <code>Kaiser*</code>.

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

Return individual providers (NPI-1), organizations (NPI-2), or both.

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

Total providers to return across all states. The NPPES registry returns up to 1,200 matches per state per query, so raise the state list to go wider.

## Actor input object example

```json
{
  "states": [
    "CA"
  ],
  "taxonomyDescription": "Dermatology",
  "enumerationType": "Any",
  "maxResults": 10
}
```

# Actor output Schema

## `providers` (type: `string`):

One item per provider in the default dataset.

# 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": [
        "CA"
    ],
    "taxonomyDescription": "Dermatology",
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/nppes-npi-provider-leads").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": ["CA"],
    "taxonomyDescription": "Dermatology",
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/nppes-npi-provider-leads").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": [
    "CA"
  ],
  "taxonomyDescription": "Dermatology",
  "maxResults": 10
}' |
apify call tagadanar/nppes-npi-provider-leads --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NPI Provider Lead Extractor 🩺 (US doctors, clinics, phones)",
        "description": "Pull targeted lists of US healthcare providers from the official CMS NPPES registry: name, NPI, specialty, practice address and phone. Filter by state, specialty, city, ZIP, name or organization. Clean flat JSON for outreach, credentialing and territory mapping. $1.50 per 1,000 providers.",
        "version": "0.1",
        "x-build-id": "e8eyHznWZD9aehWq4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tagadanar~nppes-npi-provider-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tagadanar-nppes-npi-provider-leads",
                "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/tagadanar~nppes-npi-provider-leads/runs": {
            "post": {
                "operationId": "runs-sync-tagadanar-nppes-npi-provider-leads",
                "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/tagadanar~nppes-npi-provider-leads/run-sync": {
            "post": {
                "operationId": "run-sync-tagadanar-nppes-npi-provider-leads",
                "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",
                        "minItems": 1,
                        "type": "array",
                        "description": "Optional. Two-letter US state codes to pull leads from, one per entry, e.g. <code>CA</code>, <code>TX</code>. The actor runs one query per state and merges the results. Leave empty to search nationwide (a name, organization or postal code filter is then recommended).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "taxonomyDescription": {
                        "title": "Specialty (taxonomy)",
                        "type": "string",
                        "description": "Provider specialty, using the NPPES taxonomy wording, e.g. <code>Dermatology</code>, <code>Internal Medicine</code>, <code>Physical Therapist</code>, <code>Pharmacy</code>. Matches on the start of the description."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Optional. Restrict to one practice city, e.g. <code>San Diego</code>."
                    },
                    "postalCode": {
                        "title": "ZIP / postal code",
                        "type": "string",
                        "description": "Optional. A 5-digit ZIP, or a prefix with a trailing <code>*</code> for a wider area, e.g. <code>90210</code> or <code>902*</code>."
                    },
                    "firstName": {
                        "title": "First name",
                        "type": "string",
                        "description": "Optional. Individual provider first name. Accepts a trailing <code>*</code> wildcard."
                    },
                    "lastName": {
                        "title": "Last name",
                        "type": "string",
                        "description": "Optional. Individual provider last name. Accepts a trailing <code>*</code> wildcard."
                    },
                    "organizationName": {
                        "title": "Organization name",
                        "type": "string",
                        "description": "Optional. Organization / practice name. Accepts a trailing <code>*</code> wildcard, e.g. <code>Kaiser*</code>."
                    },
                    "enumerationType": {
                        "title": "Provider type",
                        "enum": [
                            "Any",
                            "Individual",
                            "Organization"
                        ],
                        "type": "string",
                        "description": "Return individual providers (NPI-1), organizations (NPI-2), or both.",
                        "default": "Any"
                    },
                    "maxResults": {
                        "title": "Max providers",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Total providers to return across all states. The NPPES registry returns up to 1,200 matches per state per query, so raise the state list to go wider.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```