Healthgrades Scraper API

A Healthgrades scraper API that searches a specialty in a US city, state or ZIP and returns one row per doctor: name with credentials, specialty, the 1–5 patient rating with its ratings and written-review counts, practice, full address with coordinates, office phone, whether they accept new patients, telehealth, distance, NPI and the profile URL. Sponsored placements are delivered too, but labelled.

By Aldo Morese, founder of QuanticData · Published Aug 21, 2026 · Updated Sep 3, 2026

Get my free API key See the request

$0.001 per delivered doctor · $2 free every month · Failed runs never billed

POST /v1/scraper/collectors/healthgrades_doctors/run

$ curl $QD/healthgrades_doctors/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"specialty": "cardiology", "location": "Austin,  TX", "max_results": 40}'
{ "status": "done", "count": 40,
  "results": [
    {
      "provider_id": "…",
      "npi": "…",
      "name": "…",
      "specialty": "…" } ],
  "cost": 0.04 }
# 40 doctors × $0.001 · nothing delivered, nothing charged

Healthgrades Scraper API: specialty and location in, a residential exit in the middle, delivered rows with rank, provider_id and npi on the right, $0.001 per doctor. — You send specialty and location; the run goes out through a residential exit and comes back as doctors with rank, provider_id and npi — 26 fields on every row — and you are billed $0.001 for each doctor actually delivered, nothing for a run that delivers none.

$0.001 / doctor2,000 doctors on the free $2 every month

Semantic inputspecialty, location, country — no URL lists

Up to 200doctors per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

Try it

Healthgrades doctors, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

What a Healthgrades scraper API does

Healthgrades ships its search results as a React Server Components stream rather than as a JSON block, and this collector joins that stream and reads the search response verbatim: twenty providers per page plus the three sponsored cards above the list. Every value is a typed field — accepting new patients is a boolean, not the absence of a badge; the rating is 4.9, not the string “Rated 4.9 out of 5”; the phone is a value, not a link. The markup was used only to confirm the payload agrees with what a visitor sees, and it did on every field checked.

Two details decide whether the numbers are right. The stream must be joined before parsing: a page splits it across some thirty pushes and the cuts land mid-object, so reading one script at a time yields truncated JSON that looks like a site change and is not. And the payload carries two rating fields, one of them wrong for this purpose — a 0–10 half-star integer next to the 1–5 average the page prints. Reading the first would ship a plausible number that is off by two on every row; the collector reads the second.

Limits, in plain numbers

Everything that bounds one run of this collector. No hidden throttles.

Max per run

200 doctors

Price

$0.001 / doctor

Per 1,000

$1.00

Failed runs

Free zero rows, zero charge

Free every month

$2 no card

Rate limit

60 req/min on the free tier

What one doctor looks like

Every delivered doctor carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`rank`	integer	1-based position across the merged pages, sponsored cards first as the page renders them.
`provider_id`	string · nullable	Healthgrades provider id (pwid) — the key in the profile URL and the de-duplication key.
`npi`	string · nullable	National Provider Identifier.
`name`	string	Doctor's name with credentials, e.g. "Dr. Norman Risinger, MD".
`specialty`	string · nullable	Primary specialty, e.g. "Cardiology".
`specialties`	string[] · nullable	All specialist descriptions Healthgrades lists, e.g. ["Internist", "Cardiology Specialist"].
`rating`	number · nullable	Patient satisfaction rating out of 5. Null when Healthgrades suppresses surveys for the row.
`reviews`	integer · nullable	Number of patient ratings behind the score.
`written_reviews`	integer · nullable	How many of those ratings include a written review.
`accepting_new_patients`	boolean · nullable	Whether the doctor accepts new patients, as Healthgrades states it.
`telehealth`	boolean · nullable	Whether virtual visits are offered.
`phone`	string · nullable	The practice's phone number as published. Never a sponsor call-tracking number, and null when Healthgrades hides the phone for that placement.
`practice`	string · nullable	Office or practice name, e.g. "Austin Heart - South".
`address`	string · nullable	Full address on one line.
`street`	string · nullable	Street line only.
`city`	string · nullable	City.
`state`	string · nullable	US state code.
`zipcode`	string · nullable	ZIP code.
`latitude`	number · nullable	Office GPS latitude.
`longitude`	number · nullable	Office GPS longitude.
`distance_miles`	number · nullable	Distance in miles from the searched location, as Healthgrades computes it.
`gender`	string · nullable	Gender as Healthgrades publishes it ("M" / "F").
`years_experience`	integer · nullable	Years in practice, rounded. Healthgrades states it on a minority of rows; null elsewhere.
`sponsored`	boolean	True for the featured cards Healthgrades places above the results — real doctors, but paid placements that repeat on every page of the search.
`url`	string · nullable	Healthgrades profile URL.
`image`	string · nullable	Profile photo URL.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`specialty`	string	yes	Specialty, condition or procedure to search for, e.g. "cardiology", "dentistry", "family medicine" or "knee replacement".
`location`	string	yes	US city and state or ZIP code, e.g. "Austin, TX" or "33139".
`country`	string	no	ISO 3166-1 alpha-2 code — proxy exit geo and Google locale (gl). Omit for the default pool.
`max_results`	integer	no	How many doctors to deliver at most (1–200). You pay only for delivered doctors.

Pricing

Healthgrades Scraper API pricing

$0.001 per delivered doctor. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 2,000 doctors before you spend anything.

$0.001per delivered doctor$1 per 1,000 delivered doctors

2,000 doctorson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/healthgrades_doctors/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/healthgrades_doctors/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"specialty":"cardiology","location":"Austin, TX","max_results":40}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/healthgrades_doctors/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "specialty": "cardiology",
        "location": "Austin, TX",
        "max_results": 40
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/healthgrades_doctors/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"specialty":"cardiology","location":"Austin, TX","max_results":40}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the healthgrades_doctors collector with specialty="cardiology" and location="Austin, TX"

What people build with the Healthgrades scraper API

Three shapes of work this endpoint was designed around.

Provider lead lists

Cardiologists in a metro with practice, address, phone and NPI — the row a medical-device or services sales team starts from.

Access studies

Who is accepting new patients and who offers telehealth, by specialty and area, as booleans rather than badges.

Reputation monitoring

Rating, rating count and written-review count per doctor, keyed by NPI, re-run monthly.

Healthgrades Scraper API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Payload	One script at a time — truncated JSON	The stream joined before parsing
Rating	A 0–10 field that is off by two	The 1–5 average the page prints
Sponsored doctors	Blended into the ranking	Delivered and labelled `sponsored`
Class names	Hashed build artefacts	Not read at all

Healthgrades Scraper API: the POST to the healthgrades_doctors collector with specialty and location, and the JSON envelope back with 40 doctors and usage.cost_usd $0.04. — The same call you would paste into a terminal: a Bearer key, specialty, location and country in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many doctors arrived and usage.cost_usd is $0.04, which is 40 × $0.001. A run that delivers nothing costs nothing. The key is good for 60 req/min on the free tier.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the Healthgrades scraper API.

Something else? Ask us →

Are sponsored results included?

Yes, and they are labelled: the three sponsored cards above the list are real, named doctors and useful leads, but they are never mixed into the organic ranking unlabelled. Filter on sponsored if you want the organic list only.

What can I search by?

A specialty, a condition or a procedure in specialty, and a US city, state or ZIP in location. Distance from that location is delivered per row.

Is the NPI on every row?

It is delivered where Healthgrades states it in the payload, which is the norm for practising physicians; the field is nullable rather than guessed.

Does this include reviews text?

No — counts of ratings and of written reviews, plus the average. Review text lives on the profile page, which is a different surface.

Is there a free Healthgrades scraper API?

Every account gets $2 of credit every month with no card, which is about 2,000 delivered doctors on this endpoint at $0.001 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.001. A run capped at 200 doctors — the maximum for this collector — costs $0.2 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Run the Healthgrades scraper API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Get my free API key