# Healthline Medical Provider Directory Scraper (`muhammadafzal/healthline-medical-providers-directory-scraper`) Actor

Export Healthline doctors by specialty and city: NPI, phone, address, insurance accepted, telehealth and ratings. A doctor database at USD 10 per 1,000.

- **URL**: https://apify.com/muhammadafzal/healthline-medical-providers-directory-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 medical providers

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Healthline Medical Provider Directory Scraper

Healthline Medical Provider Directory Scraper exports US doctors from Healthline FindCare by specialty and city: name, NPI, specialties, practice phone and address, rating, insurance accepted, languages, telehealth and new-patient status. It is built for healthcare marketers, provider-data and network teams, and researchers who need a doctor list without copying profiles by hand, and costs USD 10 per 1,000 providers on the FREE tier (USD 8 per 1,000 on GOLD).

It reads public listing and profile pages only. It collects no patient reviews, patient data or clinical records.

### What data does the Healthline Medical Provider Directory Scraper return?

Each dataset row is one unique provider, deduplicated by NPI (or profile URL when no NPI is shown).

| Field | What it contains |
|---|---|
| `name`, `profileUrl` | Provider name with credentials and the Healthline profile link |
| `npi` | Ten-digit National Provider Identifier from the profile, or `null` |
| `specialty`, `specialties` | Primary specialty and every listed specialty |
| `phone` | Practice phone shown by Healthline (can be a referral number) |
| `streetAddress`, `city`, `state`, `postalCode` | Primary practice address |
| `practiceName` | Practice or office name (profile pages) |
| `rating`, `reviewCount` | Aggregate rating on a 1–5 scale (`null` when unrated) and review count |
| `acceptingNewPatients`, `offersTelehealth` | `true` or `false` when stated, otherwise `null` |
| `yearsOfExperience` | Years in practice when stated |
| `insuranceAccepted`, `languages`, `hospitalAffiliations` | Lists from the profile; empty arrays when absent |
| `imageUrl` | Profile photo URL |
| `sourceUrl`, `detailsFetched`, `scrapedAt` | Listing the provider came from, whether the profile was parsed, timestamp |

The `OUTPUT` record shows the outcome (`DATA`, `PARTIAL`, `EMPTY`, `NOT_FOUND`, `REJECTED`, `BLOCKED` or `FAILED`), stop reason, listing pages read, requests, warnings and charged events.

### How do I build a list of doctors by specialty and city?

Give a Healthline specialty slug, a two-letter state and a city. The Actor opens that FindCare listing, follows its pagination, and (by default) visits each provider profile for phone, insurance and availability details.

```json
{
  "specialty": "cardiology",
  "state": "ny",
  "city": "New York",
  "maxResults": 5,
  "includeDetails": true
}
```

The slug is the part after `/find-care/specialty/` in a Healthline URL, for example `cardiology`, `dermatology`, `dentistry` or `primary-care-doctors`. You can instead pass up to 20 listing or provider URLs in `startUrls`; they override the specialty and location fields.

Listing-only export, faster and without profile requests:

```json
{
  "startUrls": [{ "url": "https://care.healthline.com/find-care/specialty/dermatology/ca/los-angeles" }],
  "includeDetails": false,
  "maxResults": 70,
  "maxPages": 2
}
```

One provider profile:

```json
{
  "startUrls": [{ "url": "https://care.healthline.com/find-care/provider/dr-carol-chen-1750452140" }],
  "maxResults": 1
}
```

### Does it include NPI numbers, insurance and telehealth?

Yes, when Healthline shows them. The NPI comes from the profile URL or page; insurance plans, languages, telehealth and new-patient status come from the profile, so they need `includeDetails: true`. In listing-only mode those fields stay `null` or empty and `detailsFetched` is `false`. Treat every value as Healthline's claim, not a credential check.

### When should I use it, and when not?

**Use it when** you need a US doctor database for one specialty and metro: outreach lists for medical-device or pharma field teams, provider-network gap analysis, directory enrichment by NPI, or insurance-acceptance research.

**Use another Actor when:**

- You need ACA Marketplace health plans, premiums and benefits: [Healthcare.gov Plans Scraper](https://apify.com/muhammadafzal/healthcare-gov-plan-scraper).
- You need hospital profiles and CMS ratings: [Medicare Hospital Compare Scraper](https://apify.com/muhammadafzal/medicare-hospital-compare-scraper).
- You need doctors in India: [Practo Doctors Scraper](https://apify.com/muhammadafzal/practo-doctors-scraper).
- You need therapists with public emails: [Mental Health Professionals Email Scraper](https://apify.com/muhammadafzal/mental-health-professionals-email-scraper).

### Use it from an AI assistant

Healthline Medical Provider Directory Scraper works from Claude, ChatGPT, Cursor or any MCP client through Apify's MCP server. Add it with `https://mcp.apify.com/?tools=muhammadafzal/healthline-medical-providers-directory-scraper`, then ask, for example: "Find 20 dermatologists in Los Angeles who accept new patients and list their NPI, phone and accepted insurance."

### Run it with the API

JavaScript:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('muhammadafzal/healthline-medical-providers-directory-scraper').call({
    specialty: 'cardiology',
    state: 'ny',
    city: 'new-york',
    maxResults: 5,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((p) => `${p.name} ${p.npi} ${p.phone}`));
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("muhammadafzal/healthline-medical-providers-directory-scraper").call(
    run_input={"specialty": "dermatology", "state": "ca", "city": "Los Angeles", "maxResults": 20}
)
for doctor in client.dataset(run.default_dataset_id).iterate_items():
    print(doctor["name"], doctor["npi"], doctor["acceptingNewPatients"])
```

### What does the output look like?

Two cardiologists from the default New York run on 2026-10-26 (insurance lists shortened):

```json
[
  {
    "name": "Dr. Carol Chen, MD",
    "profileUrl": "https://care.healthline.com/find-care/provider/dr-carol-chen-1750452140",
    "npi": "1750452140",
    "specialty": "Cardiology",
    "specialties": ["Cardiology"],
    "phone": "(929) 298-9478",
    "streetAddress": "160 E 53rd St",
    "city": "New York",
    "state": "NY",
    "postalCode": "10022",
    "rating": null,
    "reviewCount": 0,
    "acceptingNewPatients": true,
    "offersTelehealth": true,
    "yearsOfExperience": 27,
    "practiceName": "Rockefeller Outpatient Pavilion",
    "insuranceAccepted": ["Aetna", "Cigna", "EmblemHealth", "UnitedHealthCare"],
    "languages": ["English", "Spanish"],
    "detailsFetched": true,
    "sourceUrl": "https://care.healthline.com/find-care/specialty/cardiology/ny/new-york",
    "scrapedAt": "2026-10-26T07:22:41.010Z"
  },
  {
    "name": "Dr. Ioanna Kosmidou, MD",
    "npi": "1801067376",
    "specialty": "Clinical Cardiac Electrophysiology",
    "phone": "(929) 343-3533",
    "city": "New York",
    "state": "NY",
    "acceptingNewPatients": true,
    "offersTelehealth": true,
    "yearsOfExperience": null,
    "insuranceAccepted": ["Aetna", "Cigna", "Healthfirst", "UnitedHealthCare"],
    "hospitalAffiliations": ["New York-Presbyterian Hospital"],
    "detailsFetched": true
  }
]
```

### Pricing: how much does a doctor list cost?

The Actor uses pay-per-event pricing. Platform usage is included, and profile enrichment adds no second charge.

| Event | FREE | BRONZE | SILVER | GOLD / PLATINUM / DIAMOND |
|---|---:|---:|---:|---:|
| Medical provider (one dataset row) | USD 0.01 | USD 0.00975 | USD 0.0095 | USD 0.008 |
| Actor start (per started GB of allocated memory) | USD 0.00625 | USD 0.006094 | USD 0.005938 | USD 0.005 |

Worked totals on the FREE tier at the default 256 MB memory (one start event):

- Default run, 5 providers: 5 × USD 0.01 + USD 0.00625 = **USD 0.05625**
- 30 providers with details: 30 × USD 0.01 + USD 0.00625 = **USD 0.30625**

The start fee is charged even when a run returns no providers. The smallest accepted total-charge limit is USD 0.02.

### How long does a run take, and what are the limits?

- **Five-second spacing.** The Actor waits at least 5 seconds between requests, following Healthline's crawl delay. The default 5-provider run took 44 seconds on 2026-10-26.
- **Detail runs** need one profile request per provider, so the default 180-second runtime budget delivers about 30 providers. Raise `maxRuntimeSecs` (up to 900) or use listing-only mode for larger lists.
- **Transfer ceiling** of 64 MiB per run. Pages averaged about 0.6 MB in that run, so detail runs stop near 100 providers; split bigger jobs.
- **Bounds:** `maxResults` 1–500, `maxPages` 1–20, `startUrls` up to 20. Search-query URLs are not accepted.
- **Access:** if Healthline denies a request, the Actor retries through alternative US access routes it manages. If all are denied, the run ends `BLOCKED` and keeps any providers already delivered.

### FAQ

#### Does it collect patient reviews?

No. It returns only the aggregate rating and review count, never review text or reviewer identities.

#### Is the NPI verified?

No. It is the ten-digit number Healthline attaches to the profile. Check the official NPPES NPI Registry before relying on it for credentialing.

#### Why is a provider's city different from the city I searched?

Healthline geographic listings include nearby practices, so a New York search can return Brooklyn or Queens offices.

#### Can I scrape a single doctor's profile?

Yes. Put the provider URL in `startUrls` and set `maxResults` to 1.

#### Does it return email addresses?

No. Healthline profiles do not publish provider emails, and the Actor does not guess them.

#### What happens if a profile page fails?

The provider is still delivered from the listing data with `detailsFetched: false`, and the warning appears in `OUTPUT`.

### Related Actors

Healthcare data from the same developer:

- [Healthcare.gov Plans Scraper](https://apify.com/muhammadafzal/healthcare-gov-plan-scraper) for ACA plans, premiums and benefits by ZIP
- [Medicare Hospital Compare Scraper](https://apify.com/muhammadafzal/medicare-hospital-compare-scraper) for hospital profiles and ratings
- [WhatClinic Clinic Scraper](https://apify.com/muhammadafzal/whatclinic-clinic-scraper) for clinic listings and treatments
- [Practo Doctors Scraper](https://apify.com/muhammadafzal/practo-doctors-scraper) for doctor profiles in India

### Legal and compliance

Healthline Medical Provider Directory Scraper reads public professional directory pages, follows the site's robots rules and crawl delay, and is not affiliated with Healthline. Use the data only for lawful business purposes, respect Healthline's terms and applicable privacy and marketing rules, and confirm insurance and appointment details with the practice. It is not medical advice or a credential check.

Last verified: 2026-10-26

# Actor input Schema

## `startUrls` (type: `array`):

Use specialty/city listings or individual provider profiles on care.healthline.com/find-care/. Up to 20 starting URLs.

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

Use this to cap how many unique providers are delivered and charged. Example: 25. Range 1-500; default 5. With profile details on, the default 180-second runtime budget fits about 30 providers.

## `maxPages` (type: `integer`):

Use this to bound how many Healthline listing pages are read across all starting URLs. Example: 3. Range 1-20; default 2.

## `includeDetails` (type: `boolean`):

Use this when you need phone, practice name, insurance accepted, languages, telehealth and new-patient status. Fetches one profile per provider at a 5-second interval. Turn off for faster listing-only exports.

## `requestTimeoutSecs` (type: `integer`):

Maximum time per HTTP request, in seconds.

## `specialty` (type: `string`):

Healthline specialty URL slug, for example cardiology, dermatology, dentistry or primary-care-doctors. Used when startUrls is empty.

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

US two-letter state code. Used when startUrls is empty. Example: ny.

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

City name or URL slug. Example: New York or new-york. Used when startUrls is empty.

## `maxRuntimeSecs` (type: `integer`):

Graceful runtime budget in seconds. Preserves delivered providers when reached. Detail requests obey a five-second crawl delay; large jobs can finish partially.

## Actor input object example

```json
{
  "startUrls": [],
  "maxResults": 5,
  "maxPages": 2,
  "includeDetails": true,
  "requestTimeoutSecs": 25,
  "specialty": "cardiology",
  "state": "ny",
  "city": "new-york",
  "maxRuntimeSecs": 180
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [],
    "maxResults": 5,
    "specialty": "cardiology",
    "state": "ny",
    "city": "new-york"
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/healthline-medical-providers-directory-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 = {
    "startUrls": [],
    "maxResults": 5,
    "specialty": "cardiology",
    "state": "ny",
    "city": "new-york",
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/healthline-medical-providers-directory-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [],
  "maxResults": 5,
  "specialty": "cardiology",
  "state": "ny",
  "city": "new-york"
}' |
apify call muhammadafzal/healthline-medical-providers-directory-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,muhammadafzal/healthline-medical-providers-directory-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/RwNDvubYebcNQ9QI5/builds/8ywKNSI4pEWcS7PfA/openapi.json