# Healthgrades Scraper \[$1.5/1k💰] | Doctor Leads | NPI & Reviews (`ahmed_jasarevic/healthgrades-scraper`) Actor

Scrape US doctor and healthcare provider profiles from Healthgrades: NPI, specialty, ratings, reviews, insurance, education and hospital affiliations for medical lead generation and healthcare market research.

- **URL**: https://apify.com/ahmed\_jasarevic/healthgrades-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.35 / 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/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

## Healthgrades Doctor Scraper

Scrape **US healthcare provider profiles from Healthgrades.com** — doctors, dentists, specialists with NPI, ratings, reviews, insurance, education, hospital affiliations and locations — for **medical lead generation and healthcare market research**. Search by specialty + city, or paste provider profile URLs.

### Main Use Cases

- **Healthcare lead generation** — build provider lists (name, NPI, practice, specialty, phone, address, insurance) for medical sales, recruiting and pharma rep targeting.
- **Doctor & physician database** — enrich a CRM or directory with ratings, reviews, education, board certifications and hospital affiliations.
- **Medical reputation monitoring** — track provider review counts and ratings over time for healthcare marketing.
- **Market & network analysis** — map provider distribution by specialty/city, or research insurance acceptance for patient-access strategy.

### How It Works

Healthgrades serves pages from Akamai behind a geo-fence (US residential IPs only, TLS fingerprinting, database backend). The actor drives a real Chromium browser through header-level anti-bot with **US residential proxies** built in, reading the **database-driven JSON payloads** that render each profile page. It accepts either a list of search queries (`searchQueries`) or direct provider URLs (`startUrls`). Search results are de-duplicated, skipped if the profile is unavailable, and each profile page is scraped through detail + reviews to full depth. A free preview returns the first 10 results for testing.

### Build Doctor & Healthcare Provider Databases Without an Official Healthgrades API

Healthgrades has no public API and its data is scattered across HTML, JSON payloads and CDN assets. This actor assembles every public provider field into one clean JSON object per profile: name, NPI, specialty, practice details, phone, address, education, board certifications, insurance accepted, hospital affiliations, ratings and patient reviews — ready for a healthcare CRM, provider directory or lead-gen pipeline.

### Track Patient Ratings & Reviews for Reputation Monitoring

Each profile carries the full provider rating (1–5 stars), review count, and — when `includeReviews` is on — the patient review timeline with text, rating, and date. Schedule weekly or monthly runs to monitor how ratings and new reviews evolve for the doctors you track.

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `searchQueries` | array | No | — | Free-text searches like `"cardiologist New York, NY"` or `"dentist 90210"`. Each query runs as its own search; results de-duplicated. |
| `startUrls` | array | No | — | Direct provider profile URLs, e.g. `https://www.healthgrades.com/physician/nick-berg-3z7w6` (must be internal profile links from alerts/other sources — search results are ignored). |
| `sortBy` | enum | No | `bestmatch` | `bestmatch`, `ratings` (highest rated first), `distance`, `experience` (most years of experience first). |
| `maxItems` | integer | No | `50` | Hard cap on provider rows for the whole run. |
| `includeProfileDetails` | boolean | No | `true` | Fetch the full profile: summary, education, certifications, hospitals, insurance, reviews preview. |
| `includeReviews` | boolean | No | `true` | Also fetch reviews on the provider's profile (implies details; adds paying time). |
| `maxReviewsPerProfile` | integer | No | `10` | Cap on review entries kept per provider (max 100). |
| `maxReviews` | integer | No | `500` | Hard cap on review rows for the whole run. |
| `maxRequestsPerCrawl` | integer | No | `500` | Cap on page requests (details/reviews pages count too). |
| `maxConcurrency` | integer | No | `0` | Number of parallel pages; `0` = auto. Use profiler to tune. |
| `debug` | boolean | No | `false` | Output full logs to the dataset/console as `#debug` rows. |

#### Note on `proxy` input

You must select a proxy configuration — use **Residential** proxies; the author recommends the pre-configured value `{{ RESIDENTIAL_PROXY_PASS }}`. Without a US residential proxy, Healthgrades' geo-fence blocks the run.

### Example Input

```json
{
  "searchQueries": ["cardiologist New York, NY"],
  "sortBy": "ratings",
  "maxItems": 50,
  "includeProfileDetails": true,
  "includeReviews": true,
  "maxReviewsPerProfile": 10,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

### Output

Two datasets: **providers** (default) and **reviews** (separate, when `includeReviews` is on).

#### Provider row

```json
{
  "url": "https://www.healthgrades.com/physician/nick-berg-3z7w6",
  "name": "Nick Berg",
  "npi": "1255003242",
  "specialty": "Internal Medicine",
  "subspecialties": ["Cardiac Disease"],
  "rating": 4.4,
  "reviewCount": 312,
  "location": "New York, NY",
  "phone": "(212) 555-0134",
  "insurancesAccepted": ["Aetna", "Empire Blue Cross Blue Shield", "UnitedHealthcare"],
  "education": ["University of Wisconsin School of Medicine"],
  "certifications": [],
  "hospitals": ["Mount Sinai Hospital"],
  "yearsExperience": 19,
  "isMale": true,
  "telehealthAvailability": false
}
```

Review rows (reviews dataset) include `providerName`, `providerUrl`, `reviewDate`, `rating`, `text`, `reviewerUsername`, `category` (e.g. a specialty tag) and `issueFlag`.

#### Dataset schema (default dataset — `overview` view)

`providerName`, `specialty`, `rating`, `reviewCount`, `npi` (when available), `location` / `address`, `phone`, `url` / `sourceUrl`, `scrapedAt` (schema-backed fields; the actor's dataset schema is being completed by the developer).

### Scrape Insurance Acceptance & Hospital Affiliations for Network Planning

Profile rows include which insurance plans each provider accepts and which hospitals they are affiliated with — a ready-made dataset for healthcare network analysis, insurer directory enrichment and care-access research.

### Integrations & Automation

- **Apify API** — feed provider rows into a healthcare CRM, sales tool or ERP.
- **Webhooks** — notify your pipeline when a scrape finishes.
- **Scheduling** — weekly reputation monitoring, monthly market sweeps.
- **Export** — JSON, CSV, HTML, Excel.

*Recommended schedule:* weekly for reputation monitoring; monthly for market research.

### Related Actors

- [Healthgrades Scraper - Doctors, Reviews & Details](https://apify.com/jaybird/healthgrades-scraper) — most-used Healthgrades actor (75 users).
- [Zocdoc & Healthgrades Scraper - Doctor Details & Reviews](https://apify.com/crawlerbros/zocdoc-healthgrades-scraper) — Healthgrades + Zocdoc in one actor.
- [Healthgrades Doctor Scrapper - Profiles & Reviews](https://apify.com/memo23/healthgrades-doctor-scraper) — paste-a-URL Healthgrades doctor scraper.
- [Healthgrades Scraper](https://apify.com/shahidirfan/Healthgrades-Scraper) — lowest-priced Healthgrades competitor.
- [Vivian Health Scraper - Travel Nurse Job Listings](https://apify.com/user/vivian-scraper) — healthcare workforce data for staffing research beyond providers.

### FAQ

#### Why use this actor instead of the official CMS NPI registry?

The free NPI registry carries only the basics: name, specialty, practice address. It has **no ratings, no patient reviews, no insurance acceptance, no education/certifications, no hospital affiliations, and no review history**. Healthgrades' profiles layer all of the above on top — this actor captures the full public profile, not just the directory stub.

#### What are alternatives to this actor / US provider data?

- [jaybird/healthgrades-scraper](https://apify.com/jaybird/healthgrades-scraper) and [crawlerbros/zocdoc-healthgrades-scraper](https://apify.com/crawlerbros/zocdoc-healthgrades-scraper) (also Zocdoc) — comparable coverage; pricing varies by volume.
- [memo23/healthgrades-doctor-scraper](https://apify.com/memo23/healthgrades-doctor-scraper) — paste-a-URL alternative.
- [shahidirfan/Healthgrades-Scraper](https://apify.com/shahidirfan/Healthgrades-Scraper) — cheapest Store competitor (~$0.001/provider).
- Non-Apify: RxNORM/CMS datasets cover billing data but not reputation or insurance-acceptance detail.

#### How can I get all cardiologists in a city?

Use `searchQueries` like `"cardiologist New York, NY"`, set `sortBy` (`ratings`, `experience`, `distance`) and raise `maxItems`. The actor de-duplicates and paginates the search results automatically.

#### What is the best way to track a provider's rating over time?

Save the provider's profile URL in `startUrls` and run weekly with `includeReviews: true`. The reviews dataset keeps date stamps so you can diff new reviews and rating changes.

#### Why do I need a US residential proxy?

Healthgrades geo-fences its content to US IP addresses (Akamai + TLS fingerprinting). The actor works reliably through **residential** proxies — the `proxy` input is mandatory, not optional.

### For AI Agents & LLM Apps

- **Purpose:** given search queries or provider URLs, returns one structured healthcare-provider record per Healthgrades profile (name, NPI, specialty, address, phone, rating, review count, insurance, education, hospitalization, reviews).
- **Minimal input:**

```json
{
  "searchQueries": ["dentist 90210"],
  "maxItems": 10,
  "includeProfileDetails": true,
  "includeReviews": false,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

- **Variant — reviews mode:**

```json
{
  "searchQueries": ["cardiologist New York, NY"],
  "sortBy": "ratings",
  "maxItems": 20,
  "includeProfileDetails": true,
  "includeReviews": true,
  "maxReviewsPerProfile": 20,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

- **Output field list (providers dataset):** `url`, `name`, `npi`, `specialty`, `subspecialties`, `rating`, `reviewCount`, `location`, `address`, `phone`, `insurancesAccepted`, `education`, `certifications`, `hospitals`, `yearsExperience`, `isMale`, `telehealthAvailability`, `scrapedAt`, plus `reviews` ({providerName, providerUrl, reviewDate, rating, text, reviewerUsername, category}).

Behaviors an agent should know:

- **`proxy` is required** — use Residential; without it Healthgrades' geo-fence (Akamai, TLS pinning) blocks the run.
- `startUrls` accept internal profile links only (e.g. from alerts); **search-result URLs in `startUrls` are ignored** — use `searchQueries` for discovery.
- `includeReviews` implies details and adds paying time; respect `maxReviewsPerProfile`/`maxReviews` caps to bound cost.
- `maxRequestsPerCrawl` counts **page requests** (search, detail, reviews), so a few hundred profiles can consume it — raise it for large runs.
- Some fields (`npi` occasionally absent; certifications sometimes empty) can legitimately be `[]`/absent — don't treat as errors.
- **Billing:** pay-per-event — `result` $0.0015/provider row, `Review` $0.001/review row.

### Legal & Compliance Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Healthgrades Marketplace LLC. It reads only publicly available provider profile and review pages — no login bypass. It scrapes personal contact data (names, provider phones, addresses); users are responsible for complying with Healthgrades' Terms of Service and applicable data-protection laws (e.g. HIPAA applies to protected health information — Healthgrades public profiles are provider-self-provided, but handle carefully; GDPR/CCPA for any personal data). Provider contact data should not be used for unsolicited commercial outreach in violation of applicable laws (CAN-SPAM, TCPA).

### SEO Keywords

healthgrades scraper, doctor database, physician data, healthcare provider data, healthgrades reviews, doctor ratings data, npi data enrichment, medical lead generation, healthcare sales leads, physician directory data, patient reviews data, doctor reputation monitoring, healthcare market research, provider insurance acceptance data, specialist data by city, telehealth provider data, healthcare crm enrichment, us provider database

# Actor input Schema

## `searchQueries` (type: `array`):

Searches in "Specialty | Location" form, e.g. "Cardiology | New York, NY" or "Dentist | 90210". Location is optional (nationwide search).

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

Paste /usearch result URLs and/or /physician, /providers, /dentist profile URLs. Auto-classified.

## `sortBy` (type: `string`):

How to sort search results. 'ratings' suppresses most sponsored placements.

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

Maximum provider rows in the dataset. Free users are capped at a 10-item preview.

## `includeProfileDetails` (type: `boolean`):

Visit each provider's profile page to add NPI, education, board certifications, languages, insurance, hospital affiliations, all office locations and reviews. Off = search-card data only (faster).

## `includeReviews` (type: `boolean`):

Save individual patient reviews as separate rows in the reviews dataset (requires profile details).

## `maxReviewsPerProfile` (type: `integer`):

Cap on patient reviews stored per provider (each saved review is a separate row in the reviews dataset).

## `maxReviews` (type: `integer`):

Global cap on review rows saved to the separate reviews dataset (protects the run from ballooning with many providers).

## `maxRequestsPerCrawl` (type: `integer`):

Safety cap on total HTTP requests (search pages + profile pages).

## `maxConcurrency` (type: `integer`):

Parallel HTTP requests. 0 = auto (16 with proxy enabled, 6 without). Raise to 20-50 with US residential proxies for max speed.

## `debug` (type: `boolean`):

Advanced: store embedded-JSON key shapes of the first profile pages in the key-value store (debug-profile-shapes) to diagnose parsing. Off by default.

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "searchQueries": [
    "Cardiology | New York, NY"
  ],
  "startUrls": [
    {
      "url": "https://www.healthgrades.com/usearch?what=Cardiology&where=New%20York%2C%20NY&pageNum=1"
    }
  ],
  "sortBy": "bestmatch",
  "maxItems": 20,
  "includeProfileDetails": true,
  "includeReviews": true,
  "maxReviewsPerProfile": 10,
  "maxReviews": 500,
  "maxRequestsPerCrawl": 500,
  "maxConcurrency": 2,
  "debug": false,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

One row per provider (name, NPI, specialty, ratings, education, insurance, hospitals, locations). No embedded reviews.

## `reviews` (type: `string`):

One row per patient review, keyed to its provider via providerId/npi/profileUrl.

# 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 = {
    "searchQueries": [
        "Cardiology | New York, NY"
    ],
    "startUrls": [
        {
            "url": "https://www.healthgrades.com/usearch?what=Cardiology&where=New%20York%2C%20NY&pageNum=1"
        }
    ],
    "sortBy": "bestmatch",
    "maxItems": 20,
    "includeProfileDetails": true,
    "includeReviews": true,
    "maxReviewsPerProfile": 10,
    "maxReviews": 500,
    "maxRequestsPerCrawl": 500,
    "maxConcurrency": 2,
    "debug": false,
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/healthgrades-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 = {
    "searchQueries": ["Cardiology | New York, NY"],
    "startUrls": [{ "url": "https://www.healthgrades.com/usearch?what=Cardiology&where=New%20York%2C%20NY&pageNum=1" }],
    "sortBy": "bestmatch",
    "maxItems": 20,
    "includeProfileDetails": True,
    "includeReviews": True,
    "maxReviewsPerProfile": 10,
    "maxReviews": 500,
    "maxRequestsPerCrawl": 500,
    "maxConcurrency": 2,
    "debug": False,
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/healthgrades-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 '{
  "searchQueries": [
    "Cardiology | New York, NY"
  ],
  "startUrls": [
    {
      "url": "https://www.healthgrades.com/usearch?what=Cardiology&where=New%20York%2C%20NY&pageNum=1"
    }
  ],
  "sortBy": "bestmatch",
  "maxItems": 20,
  "includeProfileDetails": true,
  "includeReviews": true,
  "maxReviewsPerProfile": 10,
  "maxReviews": 500,
  "maxRequestsPerCrawl": 500,
  "maxConcurrency": 2,
  "debug": false,
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/healthgrades-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/healthgrades-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/adkRWKamUbpsCXI0V/builds/jJ4EoBljF6ZdjraGI/openapi.json