# US Healthcare Provider (NPI) Scraper (`foo121/npi-provider-scraper`) Actor

Export US healthcare providers from the official NPI registry by specialty, state and city: name, NPI, taxonomy, address, phone, fax. B2B healthcare lead-gen, pay per result.

- **URL**: https://apify.com/foo121/npi-provider-scraper.md
- **Developed by:** [ziv shay](https://apify.com/foo121) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## US Healthcare Provider (NPI) Scraper

**NPI provider scraper** that pulls a clean, structured **US healthcare provider list** straight from the **NPI registry data** — filter by specialty, state, city, or ZIP and export verified providers in seconds.

Built for **healthcare B2B lead-gen, med-device and pharma sales teams, and medical recruiters** who need accurate, deduplicated provider contact records without paying for a bloated data subscription. Every record comes from the **official NPPES NPI Registry API** — the same public source CMS maintains — so the data is authoritative, free at the source, and updated as providers re-attest.

No API key required. Point this **NPI provider scraper** at a specialty plus a geography and it returns NPI numbers, names, credentials, taxonomy, address, and listed phone/fax for every matching provider.

> Note: the NPPES API caps any single query at **1,200 results**. For larger pulls (e.g. all dentists in California), split the run by city or ZIP (the `postalCode` field supports wildcards like `902*`) and the scraper paginates within each slice.

### What you get

| Field | Description |
|---|---|
| `npi` | 10-digit National Provider Identifier |
| `name` | Full provider name, built from NPPES basic name fields (first, last, org) |
| `credential` | Listed credential (MD, DDS, NP, etc.) |
| `taxonomy` | Primary taxonomy / specialty description |
| `taxonomyCode` | NUCC taxonomy code for the primary specialty |
| `sex` | Provider sex (individual providers) |
| `status` | Enumeration status (active / deactivated) |
| `city` | Practice location city |
| `state` | Practice location state |
| `postalCode` | Practice location ZIP code |
| `phone` | Listed practice phone number |
| `fax` | Listed practice fax number |
| `enumerationDate` | Date the NPI was first issued |
| `lastUpdated` | Date the NPPES record was last updated |
| `registryUrl` | Direct link to the provider's NPPES registry record |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `taxonomy` | string | `"Dentist"` | Specialty / taxonomy to search (e.g. "Cardiology", "Nurse Practitioner") |
| `state` | string | `"CA"` | Two-letter US state code |
| `city` | string | — | Optional city filter |
| `postalCode` | string | — | Optional ZIP filter; supports wildcards (e.g. `"902*"`) |
| `organizationName` | string | — | Optional organization name filter; supports wildcards |
| `maxItems` | integer | `500` | Max provider records to return (NPPES caps each query at 1200) |

#### Example input

```json
{
  "taxonomy": "Dentist",
  "state": "CA",
  "city": "Los Angeles",
  "postalCode": "900*",
  "maxItems": 500
}
````

### Example run output

```json
{
  "npi": "1487654321",
  "name": "Maria L. Hernandez",
  "credential": "DDS",
  "taxonomy": "Dentist",
  "taxonomyCode": "122300000X",
  "sex": "F",
  "status": "A",
  "city": "Los Angeles",
  "state": "CA",
  "postalCode": "90017",
  "phone": "213-555-0182",
  "fax": "213-555-0183",
  "enumerationDate": "2008-06-14",
  "lastUpdated": "2024-11-02",
  "registryUrl": "https://npiregistry.cms.hhs.gov/provider-view/1487654321"
}
```

### Use cases

- **Healthcare B2B lead-gen agencies** building targeted provider lists by specialty and metro for outreach campaigns.
- **Med-device and pharma sales teams** mapping prescribers and practices in a territory before a launch.
- **Medical and dental recruiters** sourcing licensed providers by credential and geography.
- **Healthcare market intelligence teams** sizing provider density by taxonomy across states.

### Pricing

Pay per result — you're billed only for the provider records this **NPI provider scraper** returns, with no subscription or platform fee.

### Keywords

NPI provider scraper, NPI registry data, US healthcare provider list, NPPES scraper, healthcare provider data, NPI lookup API, medical provider list by specialty, dentist list by state, prescriber list, provider contact data

# Actor input Schema

## `taxonomy` (type: `string`):

Provider specialty / taxonomy description, e.g. "Dentist", "Internal Medicine", "Pharmacy", "Chiropractor". Matches the NPPES taxonomy\_description field.

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

Two-letter US state code, e.g. CA, NY, TX.

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

City name, e.g. "Los Angeles". Optional.

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

5-digit ZIP code. Use "902\*" style wildcards for a ZIP prefix. Optional.

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

Filter to a specific organization / clinic name (NPI-2 records). Wildcards with \* allowed. Optional.

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

Maximum number of providers to output. Note: the NPPES API caps pagination at 1200 results per query (skip 1000 + limit 200). For larger pulls, split by city / postal code.

## Actor input object example

```json
{
  "taxonomy": "Dentist",
  "state": "CA",
  "maxItems": 500
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("foo121/npi-provider-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 = {
    "taxonomy": "Dentist",
    "state": "CA",
}

# Run the Actor and wait for it to finish
run = client.actor("foo121/npi-provider-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 '{
  "taxonomy": "Dentist",
  "state": "CA"
}' |
apify call foo121/npi-provider-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Healthcare Provider (NPI) Scraper",
        "description": "Export US healthcare providers from the official NPI registry by specialty, state and city: name, NPI, taxonomy, address, phone, fax. B2B healthcare lead-gen, pay per result.",
        "version": "1.0",
        "x-build-id": "RAbOh3Szgplw3fErI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/foo121~npi-provider-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-foo121-npi-provider-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/foo121~npi-provider-scraper/runs": {
            "post": {
                "operationId": "runs-sync-foo121-npi-provider-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/foo121~npi-provider-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-foo121-npi-provider-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": {
                    "taxonomy": {
                        "title": "Specialty / taxonomy",
                        "type": "string",
                        "description": "Provider specialty / taxonomy description, e.g. \"Dentist\", \"Internal Medicine\", \"Pharmacy\", \"Chiropractor\". Matches the NPPES taxonomy_description field."
                    },
                    "state": {
                        "title": "State",
                        "type": "string",
                        "description": "Two-letter US state code, e.g. CA, NY, TX."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name, e.g. \"Los Angeles\". Optional."
                    },
                    "postalCode": {
                        "title": "Postal code",
                        "type": "string",
                        "description": "5-digit ZIP code. Use \"902*\" style wildcards for a ZIP prefix. Optional."
                    },
                    "organizationName": {
                        "title": "Organization name",
                        "type": "string",
                        "description": "Filter to a specific organization / clinic name (NPI-2 records). Wildcards with * allowed. Optional."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of providers to output. Note: the NPPES API caps pagination at 1200 results per query (skip 1000 + limit 200). For larger pulls, split by city / postal code.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
