# ZocDoc + Healthgrades Doctors & Reviews Scraper (`crawlerbros/zocdoc-healthgrades-scraper`) Actor

Scrape physicians, specialists, ratings, reviews, accepted insurance, locations, and bio data from ZocDoc.com and Healthgrades.com. Single actor with platform switch (zocdoc | healthgrades). No login required.

- **URL**: https://apify.com/crawlerbros/zocdoc-healthgrades-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 11 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## ZocDoc + Healthgrades Doctors & Reviews Scraper

Scrape physicians, dentists, mental-health providers, surgeons, and 80+ other
healthcare specialists from **ZocDoc.com** and **Healthgrades.com** in a
single Apify actor. Pick a platform with the `platform` switch and a mode
with `mode` — the rest of the input adapts to the platform.

### What you get per provider

- Provider name, credentials, gender (canonical `Male` / `Female` / `Non-binary` when listed)
- Medical specialty / sub-specialties
- Office address (street, city, state, ZIP) + phone
- Star rating (1-5) and aggregate review count
- Free-text reviews (author, rating, body, date) — capped per provider
- Languages spoken
- Profile image URL and canonical profile URL
- Bio / description (when published on the profile)

Empty / unknown fields are omitted entirely from the dataset row — you never
get `null`, `""`, `[]` keys.

### Modes

| Mode | What it does | Inputs |
|---|---|---|
| `search` | Search providers by city + specialty (+ optional insurance, gender, language, rating filters) | `specialty`, `city`, `state` |
| `byProvider` | Scrape one or more provider profiles directly | `providerUrlsOrSlugs` |
| `bySpecialty` | Browse a specialty hub page | `specialty` |
| `byCity` | List top providers in a city | `city`, `state` |
| `byInsurance` | Filter by accepted insurance plan (**ZocDoc only**) | `insurance` |
| `byUrl` | Scrape arbitrary listing or profile URLs | `urls` |

### Filters

- `specialty` — 80+ medical / dental / mental-health specialty dropdown.
- `state` — US state code dropdown (50 states + DC).
- `gender` — any / female / male.
- `language` — provider-spoken language dropdown (50 languages, ISO 639-1).
- `acceptsNewPatients` — boolean.
- `minRating` — minimum 1-5 star rating.
- `minReviewCount` — minimum review count.
- `insurance` — accepted insurance plan (top 50 US insurers, ZocDoc only).

### Anti-bot

- **Healthgrades** works from Apify datacenter IPs without any proxy, since
  Apify already runs in the US. From other regions the actor pins the proxy
  to `country=US` to bypass the geo-block (`This page is not available in
  your area`).
- **ZocDoc is fronted by DataDome and is currently blocked even from Apify
  Residential US.** All datacenter and residential tiers return the
  `Please enable JS and disable any ad blocker` 403 challenge page. The
  actor still ships ZocDoc URL builders, JSON-LD parsers, and the full mode
  surface — if you bring your own clean US-residential proxy pool that
  DataDome hasn't fingerprinted, the actor will use it transparently. For
  most users, **Healthgrades is the recommended platform.**

If proxy escalation fails the actor emits a typed `error` record with the
HTTP status and reason, and a status-message summary.

### Daily test prefill

```json
{
  "platform": "healthgrades",
  "mode": "search",
  "specialty": "primary-care-doctor",
  "city": "New York, NY",
  "maxItems": 10,
  "fetchProviderDetails": true,
  "autoEscalateOnBlock": true
}
````

### Output sample

Both platforms emit the same flat record shape — keys are uniform across
`zocdoc` and `healthgrades`. A platform-agnostic `entityId` (URL slug) is
exposed alongside the platform-specific `slug` for cross-platform joins.

#### ZocDoc

```json
{
  "platform": "zocdoc",
  "entityId": "jane-doe-12345",
  "providerName": "Dr. Jane Doe, MD",
  "specialty": "Primary Care Doctor",
  "city": "New York",
  "state": "NY",
  "address": {
    "addressStreet": "123 Main St",
    "addressLocality": "New York",
    "addressRegion": "NY",
    "postalCode": "10001"
  },
  "phone": "+1-212-555-0100",
  "rating": 4.8,
  "reviewCount": 124,
  "languages": ["English", "Spanish"],
  "url": "https://www.zocdoc.com/doctor/jane-doe-12345",
  "slug": "jane-doe-12345",
  "imageUrl": "https://...",
  "reviews": [
    {
      "author": "Patient ID 5532",
      "rating": 5,
      "body": "Excellent bedside manner.",
      "datePublished": "2025-09-12"
    }
  ],
  "recordType": "provider",
  "scrapedAt": "2026-05-08T..."
}
```

#### Healthgrades

```json
{
  "platform": "healthgrades",
  "entityId": "dr-john-smith-xyz",
  "providerName": "Dr. John Smith, MD",
  "specialty": "Cardiologist",
  "city": "Boston",
  "state": "MA",
  "rating": 4.6,
  "reviewCount": 88,
  "url": "https://www.healthgrades.com/physician/dr-john-smith-xyz",
  "slug": "dr-john-smith-xyz",
  "recordType": "provider",
  "scrapedAt": "2026-05-08T..."
}
```

### FAQ

**Do I need a ZocDoc / Healthgrades login?**
No. Both platforms expose all listing/profile data on public pages — no auth,
no API key.

**How many providers per run?**
Up to 1000 (`maxItems`). Practical limit per search is constrained by the
platform's own page count (~100-200 results for a city + specialty).

**Will Healthgrades work outside the US?**
Yes — the actor auto-pins the Apify proxy to `country=US` regardless of where
the actor itself is running.

**Is this legal?**
This actor only fetches public, unauthenticated, non-PHI directory data
(provider names, specialties, addresses, public reviews) — the same data any
visitor sees on the website. No patient or PHI data is collected. You are
responsible for complying with each platform's Terms of Service in your
jurisdiction.

**Why are some fields missing on certain provider profiles?**
The actor never emits empty fields — if Healthgrades didn't list a phone for
a provider, that key is simply absent in the record (instead of `null` or
`""`). Use the present-keys list to filter dataset rows.

### High-churn output fields

Some fields evolve rapidly between runs and should be treated as snapshot-in-time:

- **`rating` / `reviewCount`** — Provider aggregate scores update as new
  reviews are posted; expect minor drift on every re-scrape. Match providers by
  `entityId` / `slug`, not by `(name, rating)` tuple.
- **`reviews[]`** — Both ZocDoc and Healthgrades expose only a recent window of
  reviews; an older review present on one run may roll off on the next. Use
  `reviewCount` as the canonical aggregate, not `len(reviews)`.
- **`acceptsNewPatients`** — Heuristic from Healthgrades bio text; can flip
  between runs as providers update their availability blurb.
- **`affiliation` / `awards`** — Self-reported on Healthgrades profile bio;
  occasionally rotates as the provider edits their bio.
- **`imageUrl`** — CDN URLs may rotate; use the URL as a reference, not a key.

Stable fields safe for diff/dedup: `entityId`, `slug`, `providerName`, `url`,
`address`, `specialty`, `gender`, `languages`, `phone`.

### Limitations

- **ZocDoc is currently blocked from Apify datacenter and residential
  pools (DataDome).** Cloud-verification rounds returned 0 ZocDoc records
  across 4 attempts — the platform is shipped as a code path but not
  daily-test viable. Use Healthgrades unless you supply your own clean
  residential proxy.
- Healthgrades exposes review *counts* + first-page reviews on profile
  pages; deeper review pages are not paginated by this actor.
- Healthgrades fuzzy-matches the `what=<specialty>` query — searching for
  "Dentist" can occasionally surface providers named "Dennis". This is the
  upstream platform's behavior, not the actor's.
- Healthgrades plan-level filtering is not exposed by the site, so
  `byInsurance` is ZocDoc-only.

### Pricing

Charge model (pay-per-result) is configured at the Apify UI level. This actor
emits one row per provider profile (plus optional review children inline).

# Actor input Schema

## `platform` (type: `string`):

Which provider directory to scrape. Healthgrades is recommended (works from Apify datacenter IPs without proxy). ZocDoc is fronted by aggressive DataDome anti-bot that blocks even residential proxies most of the time — use only when you have a clean residential IP pool.

## `mode` (type: `string`):

What to scrape. `search` accepts city + specialty; `byProvider` takes a provider URL or slug; `bySpecialty` browses a single specialty hub; `byCity` lists every specialty in a city; `byInsurance` filters by an accepted plan (ZocDoc-only); `byUrl` accepts arbitrary listing URLs.

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

Medical specialty slug. Used by `search` and `bySpecialty`.

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

City for `search`, `byCity`. ZocDoc format: `new-york-ny`, `los-angeles-ca`. Healthgrades format: `New York, NY` or `Boston, MA`. The actor accepts either form and normalizes per platform.

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

Two-letter US state code (used for disambiguation when city alone is ambiguous).

## `gender` (type: `string`):

Filter providers by gender (best-effort — not all providers expose this).

## `language` (type: `string`):

Filter providers who speak this language (ISO 639-1 code).

## `acceptsNewPatients` (type: `boolean`):

Drop providers not currently accepting new patients.

## `minRating` (type: `integer`):

Drop providers with star rating below this threshold (1-5).

## `minReviewCount` (type: `integer`):

Drop providers with fewer reviews than this.

## `insurance` (type: `string`):

Filter providers who accept this insurance plan. ZocDoc-only — Healthgrades doesn't expose plan-level filtering.

## `providerUrlsOrSlugs` (type: `array`):

Provider profile URLs (e.g. `https://www.zocdoc.com/doctor/john-smith-md-12345`, `https://www.healthgrades.com/physician/dr-john-smith-xyz`) or just the slug.

## `urls` (type: `array`):

Raw ZocDoc or Healthgrades listing/search URLs to scrape.

## `fetchProviderDetails` (type: `boolean`):

Whether to follow each search-result URL to fetch the full provider profile (bio, ratings, languages, insurance, locations, reviews). Disable for faster but lighter listing-only output.

## `maxReviewsPerProvider` (type: `integer`):

Cap on reviews emitted per provider (0 = no reviews).

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

Hard cap on emitted provider records.

## `maxPagesPerListing` (type: `integer`):

How many search-result pages to walk per seed.

## `autoEscalateOnBlock` (type: `boolean`):

When a fetch returns 403/anti-bot block, automatically engage Apify Proxy (datacenter US → residential US fallback). Both ZocDoc (DataDome) and Healthgrades (geo-block) require US-egress proxy from cloud datacenters.

## `proxyGroups` (type: `array`):

Proxy groups to try on the first block. Empty = datacenter (default), then residential fallback automatically.

## Actor input object example

```json
{
  "platform": "healthgrades",
  "mode": "search",
  "city": "New York, NY",
  "gender": "any",
  "language": "any",
  "acceptsNewPatients": false,
  "insurance": "any",
  "providerUrlsOrSlugs": [],
  "urls": [],
  "fetchProviderDetails": true,
  "maxReviewsPerProvider": 20,
  "maxItems": 10,
  "maxPagesPerListing": 3,
  "autoEscalateOnBlock": true,
  "proxyGroups": []
}
```

# Actor output Schema

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

Dataset of provider records.

# 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 = {
    "platform": "healthgrades",
    "mode": "search",
    "city": "New York, NY",
    "gender": "any",
    "language": "any",
    "acceptsNewPatients": false,
    "insurance": "any",
    "fetchProviderDetails": true,
    "maxReviewsPerProvider": 20,
    "maxItems": 10,
    "maxPagesPerListing": 3,
    "autoEscalateOnBlock": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/zocdoc-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 = {
    "platform": "healthgrades",
    "mode": "search",
    "city": "New York, NY",
    "gender": "any",
    "language": "any",
    "acceptsNewPatients": False,
    "insurance": "any",
    "fetchProviderDetails": True,
    "maxReviewsPerProvider": 20,
    "maxItems": 10,
    "maxPagesPerListing": 3,
    "autoEscalateOnBlock": True,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/zocdoc-healthgrades-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 '{
  "platform": "healthgrades",
  "mode": "search",
  "city": "New York, NY",
  "gender": "any",
  "language": "any",
  "acceptsNewPatients": false,
  "insurance": "any",
  "fetchProviderDetails": true,
  "maxReviewsPerProvider": 20,
  "maxItems": 10,
  "maxPagesPerListing": 3,
  "autoEscalateOnBlock": true
}' |
apify call crawlerbros/zocdoc-healthgrades-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ZocDoc + Healthgrades Doctors & Reviews Scraper",
        "description": "Scrape physicians, specialists, ratings, reviews, accepted insurance, locations, and bio data from ZocDoc.com and Healthgrades.com. Single actor with platform switch (zocdoc | healthgrades). No login required.",
        "version": "1.0",
        "x-build-id": "c7AKPSJymfjR2irwa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~zocdoc-healthgrades-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-zocdoc-healthgrades-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/crawlerbros~zocdoc-healthgrades-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-zocdoc-healthgrades-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/crawlerbros~zocdoc-healthgrades-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-zocdoc-healthgrades-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",
                "required": [
                    "platform",
                    "mode"
                ],
                "properties": {
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "healthgrades",
                            "zocdoc"
                        ],
                        "type": "string",
                        "description": "Which provider directory to scrape. Healthgrades is recommended (works from Apify datacenter IPs without proxy). ZocDoc is fronted by aggressive DataDome anti-bot that blocks even residential proxies most of the time — use only when you have a clean residential IP pool.",
                        "default": "healthgrades"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byProvider",
                            "bySpecialty",
                            "byCity",
                            "byInsurance",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to scrape. `search` accepts city + specialty; `byProvider` takes a provider URL or slug; `bySpecialty` browses a single specialty hub; `byCity` lists every specialty in a city; `byInsurance` filters by an accepted plan (ZocDoc-only); `byUrl` accepts arbitrary listing URLs.",
                        "default": "search"
                    },
                    "specialty": {
                        "title": "Specialty",
                        "enum": [
                            "primary-care-doctor",
                            "family-physician",
                            "internist",
                            "pediatrician",
                            "obstetrician-gynecologist",
                            "dermatologist",
                            "ophthalmologist",
                            "optometrist",
                            "ent-doctor",
                            "dentist",
                            "orthodontist",
                            "endodontist",
                            "periodontist",
                            "oral-surgeon",
                            "pediatric-dentist",
                            "prosthodontist",
                            "psychiatrist",
                            "psychologist",
                            "therapist-counselor",
                            "marriage-counselor",
                            "psychotherapist",
                            "child-psychiatrist",
                            "addiction-medicine",
                            "cardiologist",
                            "gastroenterologist",
                            "endocrinologist",
                            "rheumatologist",
                            "pulmonologist",
                            "neurologist",
                            "nephrologist",
                            "hematologist",
                            "infectious-disease",
                            "allergist",
                            "immunologist",
                            "geriatrician",
                            "oncologist",
                            "radiation-oncologist",
                            "surgical-oncologist",
                            "general-surgeon",
                            "vascular-surgeon",
                            "plastic-surgeon",
                            "neurosurgeon",
                            "cardiothoracic-surgeon",
                            "colon-rectal-surgeon",
                            "hand-surgeon",
                            "orthopedic-surgeon",
                            "podiatrist",
                            "urologist",
                            "sports-medicine",
                            "physical-therapist",
                            "occupational-therapist",
                            "speech-therapist",
                            "chiropractor",
                            "acupuncturist",
                            "massage-therapist",
                            "naturopath",
                            "midwife",
                            "nurse-practitioner",
                            "physician-assistant",
                            "audiologist",
                            "dietitian-nutritionist",
                            "anesthesiologist",
                            "pain-management-specialist",
                            "sleep-medicine",
                            "emergency-medicine",
                            "hospice-palliative-care",
                            "preventive-medicine",
                            "physiatrist",
                            "radiologist",
                            "pathologist",
                            "neonatologist",
                            "perinatologist",
                            "reproductive-endocrinologist",
                            "fertility-specialist",
                            "urogynecologist",
                            "maternal-fetal-medicine",
                            "gynecologic-oncologist",
                            "pediatric-cardiologist",
                            "pediatric-neurologist",
                            "pediatric-orthopedic-surgeon",
                            "pediatric-endocrinologist",
                            "pediatric-allergist"
                        ],
                        "type": "string",
                        "description": "Medical specialty slug. Used by `search` and `bySpecialty`."
                    },
                    "city": {
                        "title": "City slug or 'city, ST'",
                        "type": "string",
                        "description": "City for `search`, `byCity`. ZocDoc format: `new-york-ny`, `los-angeles-ca`. Healthgrades format: `New York, NY` or `Boston, MA`. The actor accepts either form and normalizes per platform."
                    },
                    "state": {
                        "title": "US state code",
                        "enum": [
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "DC",
                            "FL",
                            "GA",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NC",
                            "ND",
                            "OH",
                            "OK",
                            "OR",
                            "PA",
                            "RI",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY"
                        ],
                        "type": "string",
                        "description": "Two-letter US state code (used for disambiguation when city alone is ambiguous)."
                    },
                    "gender": {
                        "title": "Provider gender",
                        "enum": [
                            "any",
                            "female",
                            "male"
                        ],
                        "type": "string",
                        "description": "Filter providers by gender (best-effort — not all providers expose this).",
                        "default": "any"
                    },
                    "language": {
                        "title": "Language spoken",
                        "enum": [
                            "any",
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "ru",
                            "zh",
                            "ja",
                            "ko",
                            "vi",
                            "ar",
                            "hi",
                            "bn",
                            "pa",
                            "ur",
                            "fa",
                            "tr",
                            "pl",
                            "uk",
                            "nl",
                            "sv",
                            "da",
                            "no",
                            "fi",
                            "el",
                            "he",
                            "th",
                            "tl",
                            "id",
                            "ms",
                            "sw",
                            "ro",
                            "hu",
                            "cs",
                            "sk",
                            "bg",
                            "hr",
                            "sr",
                            "ta",
                            "te",
                            "ml",
                            "mr",
                            "gu",
                            "kn",
                            "yo",
                            "ig",
                            "ha",
                            "am",
                            "so",
                            "ps"
                        ],
                        "type": "string",
                        "description": "Filter providers who speak this language (ISO 639-1 code).",
                        "default": "any"
                    },
                    "acceptsNewPatients": {
                        "title": "Accepting new patients only",
                        "type": "boolean",
                        "description": "Drop providers not currently accepting new patients.",
                        "default": false
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Drop providers with star rating below this threshold (1-5)."
                    },
                    "minReviewCount": {
                        "title": "Minimum review count",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop providers with fewer reviews than this."
                    },
                    "insurance": {
                        "title": "Insurance plan (ZocDoc only)",
                        "enum": [
                            "any",
                            "aetna",
                            "anthem-blue-cross",
                            "blue-cross-blue-shield",
                            "cigna",
                            "humana",
                            "united-healthcare",
                            "kaiser-permanente",
                            "medicare",
                            "medicaid",
                            "tricare",
                            "ambetter",
                            "amerigroup",
                            "centene",
                            "molina",
                            "wellcare",
                            "fidelis",
                            "emblemhealth",
                            "healthfirst",
                            "metroplus",
                            "carefirst",
                            "horizon-bcbs",
                            "highmark",
                            "premera",
                            "regence",
                            "florida-blue",
                            "blue-shield-california",
                            "empire-bcbs",
                            "independence-blue-cross",
                            "anthem-bcbs",
                            "hcsc",
                            "molina-healthcare",
                            "oscar",
                            "magellan",
                            "beacon-health-options",
                            "optum",
                            "evernorth",
                            "meritain",
                            "healthnet",
                            "bright-health",
                            "guardian",
                            "delta-dental",
                            "metlife-dental",
                            "principal",
                            "vsp",
                            "eyemed",
                            "mvp-healthcare",
                            "tufts",
                            "harvard-pilgrim",
                            "blueshield-northeastern-ny",
                            "geha",
                            "fep-blue",
                            "uhc-community-plan"
                        ],
                        "type": "string",
                        "description": "Filter providers who accept this insurance plan. ZocDoc-only — Healthgrades doesn't expose plan-level filtering.",
                        "default": "any"
                    },
                    "providerUrlsOrSlugs": {
                        "title": "Provider URLs or slugs (mode=byProvider)",
                        "type": "array",
                        "description": "Provider profile URLs (e.g. `https://www.zocdoc.com/doctor/john-smith-md-12345`, `https://www.healthgrades.com/physician/dr-john-smith-xyz`) or just the slug.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "urls": {
                        "title": "Listing URLs (mode=byUrl)",
                        "type": "array",
                        "description": "Raw ZocDoc or Healthgrades listing/search URLs to scrape.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchProviderDetails": {
                        "title": "Fetch full provider details",
                        "type": "boolean",
                        "description": "Whether to follow each search-result URL to fetch the full provider profile (bio, ratings, languages, insurance, locations, reviews). Disable for faster but lighter listing-only output.",
                        "default": true
                    },
                    "maxReviewsPerProvider": {
                        "title": "Max reviews per provider",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap on reviews emitted per provider (0 = no reviews).",
                        "default": 20
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted provider records.",
                        "default": 25
                    },
                    "maxPagesPerListing": {
                        "title": "Max listing pages to crawl",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many search-result pages to walk per seed.",
                        "default": 3
                    },
                    "autoEscalateOnBlock": {
                        "title": "Auto-escalate to Apify proxy on block",
                        "type": "boolean",
                        "description": "When a fetch returns 403/anti-bot block, automatically engage Apify Proxy (datacenter US → residential US fallback). Both ZocDoc (DataDome) and Healthgrades (geo-block) require US-egress proxy from cloud datacenters.",
                        "default": true
                    },
                    "proxyGroups": {
                        "title": "Apify proxy groups (used on auto-escalation)",
                        "type": "array",
                        "description": "Proxy groups to try on the first block. Empty = datacenter (default), then residential fallback automatically.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
