# Zocdoc Scraper \[Only $3.5/1K💰] | Doctor Ratings & Availability (`ahmed_jasarevic/zocdoc-scraper`) Actor

Scrape Zocdoc doctors by specialty and location for healthcare lead generation: doctor names, specialties, ratings, reviews, insurance flags, next-available appointment slots, addresses, phone numbers and coordinates. Fast API-based scraping — no browser, no login.

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

## Pricing

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

## Zocdoc Scraper — Doctor Profiles, Ratings & Appointment Availability Data

Scrape **[Zocdoc.com](https://www.zocdoc.com) doctors by specialty and location** for **physician lead generation, healthcare market research and provider directory building**: name, specialty, rating, review count + review snippet, insurance acceptance flags, next-available appointment slot, address/phone, geo-coordinates and profile URL — at **$3.5 per 1,000 results**. No login, no browser.

### Main Use Cases

- **Healthcare lead generation** — build doctor and dentist lead lists by specialty and metro for medical marketing agencies, healthtech and staffing teams.
- **Insurance network & panel building** — collect in-network provider lists by specialty and location using the `acceptsInNetwork` / `acceptsOutOfNetwork` / `acceptsSelfPay` flags.
- **Provider directory & app data** — power doctor-finder apps and directories with live profile data, geo-coordinates, distance and profile URLs.
- **Appointment availability monitoring** — track next-available appointment slots per provider over a configurable window (default 14 days, up to 90).
- **Competitor & ranking research** — compare provider ratings, review counts and bedside-manner/wait-time scores across practices and metros.
- **Medical recruiting & market analysis** — map specialist supply (dermatologists, dentists, therapists, primary care) by city and state.

### How It Works

The actor calls Zocdoc's own internal directory GraphQL API (`POST api.zocdoc.com/directory/v3/gql`) — the same endpoint its React frontend uses. It resolves the specialty name to Zocdoc's internal ID at runtime, pages through provider search results, and optionally enriches each doctor with next-available timeslots. Pure HTTP (roughly 2 requests per 20 doctors) at 256 MB, so runs are fast and cheap compared to browser-based scraping. The public `www.zocdoc.com` site is protected by DataDome (it blocks datacenter IPs and challenges browsers), but the directory API itself is open and needs no auth cookies or tokens.

### Build a Doctor Database Without the Zocdoc Partner API

Zocdoc does publish a partner API for appointment booking and calendar integration, but it requires partner onboarding and is designed around scheduling flows — not bulk directory exports. This actor instead reads Zocdoc's **publicly listed directory data** and returns it as structured JSON/CSV/Excel for any specialty and location, or programmatically via the **Apify API**. Schedule **weekly runs** to keep ratings, reviews and availability current, and route new providers to your pipeline through **webhooks, Zapier or Make**.

### Input

| Field | Type | Required | Default | Notes |
|-------|------|----------|---------|-------|
| `specialty` | string | No | `Dentist` | Doctor specialty name (e.g. `Dentist`, `Dermatologist`, `Primary Care Doctor`, `Therapist`). Resolved to Zocdoc's internal specialty ID automatically. |
| `specialtyId` | string | No | — | Zocdoc internal specialty ID (e.g. `98` = Dentist). If set, skips the name lookup. |
| `location` | string | No | `New York, NY` | City + state or ZIP code (e.g. `New York, NY`, `10001`). |
| `maxResults` | integer | No | `50` | Maximum doctor profiles to return (max 1000; free users capped at 10). |
| `includeAvailability` | boolean | No | `true` | Fetch next-available appointment slots per doctor (one extra API call per page of 20). |
| `availabilityDays` | integer | No | `14` | How many days ahead to scan for appointment slots (max 90). |
| `proxy` | object | No | off | Standard Apify proxy picker. The API endpoint needs no proxy — enable only if you hit rate limits. |

### Output

Each dataset item is one doctor profile. Example:

```json
{
  "name": "Dr. Jenny Armstrong, DDS, FAGD",
  "firstName": "Jenny",
  "lastName": "Armstrong",
  "specialty": "Dentist",
  "allSpecialties": ["Dentist", "Cosmetic Dentist"],
  "rating": 4.92,
  "reviewCount": 528,
  "reviewSnippet": "Amazing experience, highly recommend…",
  "bedsideMannerRating": 5,
  "waitTimeRating": 4.9,
  "highlyRecommendPct": 98,
  "acceptsInNetwork": true,
  "acceptsOutOfNetwork": false,
  "acceptsSelfPay": true,
  "nextAvailableDate": "2026-09-18T09:00:00",
  "nextAvailableSlot": "2026-09-18T09:00:00",
  "slotsFoundNextDays": 12,
  "address": "241 W 37th St",
  "city": "New York",
  "state": "NY",
  "zip": "10018",
  "phone": "(212) 730-4440",
  "latitude": 40.7523,
  "longitude": -73.9903,
  "distanceMiles": 1.4,
  "isVirtual": false,
  "profileUrl": "https://www.zocdoc.com/dentist/jenny-armstrong-dds-fagd-441155",
  "photoUrl": "https://cdn.zocdoc.com/...",
  "zocdocProviderId": "441155",
  "zocdocLocationId": "1299442",
  "scrapedAt": "2026-09-16T12:00:00.000Z"
}
```

#### Field reference

| Field | Description |
|-------|-------------|
| `name` / `firstName` / `lastName` | Provider display and split names. |
| `specialty` / `allSpecialties` | Primary and all listed specialties. |
| `rating` / `bedsideMannerRating` / `waitTimeRating` / `highlyRecommendPct` | 0–5 score metrics. |
| `reviewCount` / `reviewSnippet` | Total review count and one representative review text. |
| `acceptsInNetwork` / `acceptsOutOfNetwork` / `acceptsSelfPay` | Insurance acceptance flags. |
| `nextAvailableDate` / `nextAvailableSlot` / `slotsFoundNextDays` | Availability enrichment. |
| `address` / `city` / `state` / `zip` / `phone` | Practice location and phone. |
| `latitude` / `longitude` / `distanceMiles` / `isVirtual` | Geo and visit type. |
| `profileUrl` / `photoUrl` | Links. |
| `zocdocProviderId` / `zocdocLocationId` | Stable Zocdoc IDs (use to join availability or deduplicate). |
| `npi` / `education` / `languages` / `insurancesAccepted` | `null`/`[]` — not exposed by Zocdoc's public directory API (see FAQ). |

### Example Input

```json
{
  "specialty": "Dentist",
  "location": "New York, NY",
  "maxResults": 50,
  "includeAvailability": true,
  "availabilityDays": 14
}
```

To skip the availability enrichment (fewer requests, cheaper):

```json
{
  "specialty": "Dermatologist",
  "location": "Los Angeles, CA",
  "maxResults": 100,
  "includeAvailability": false
}
```

### Integrations & Automation

- **Apify API** — run the actor and fetch datasets programmatically from your app or data pipeline.
- **Webhooks / Zapier / Make** — push new provider records to your CRM or directory as a run completes.
- **Scheduling** — schedule weekly runs to refresh ratings, review counts and availability (recurring runs also improve Apify Store recommendations for this actor).

### Related Actors

- [ZocDoc + Healthgrades Doctors & Reviews Scraper (crawlerbros)](https://apify.com/crawlerbros/zocdoc-healthgrades-scraper) — the largest Zocdoc-focused actor on the Store (37 users).
- [Zocdoc Search Parser Spider (getdataforme)](https://apify.com/getdataforme/zocdoc-search-parser-spider) — Zocdoc search-result provider data (36 users).
- [ZocDoc Scraper — Pay Per Result (silentflow)](https://apify.com/silentflow/zocdoc-scraper-ppr) — doctors, reviews and availability (33 users).
- [Zocdoc Scraper — Doctor Leads, NPI & Insurance (scrapersdelight)](https://apify.com/scrapersdelight/zocdoc-scraper) — profile-URL mode with NPI and insurance.
- [Care.com Scraper](https://apify.com/ahmed_jasarevic/care-scraper) — caregiver and senior-care provider data for the broader care/health space.

### FAQ

#### Why use this actor instead of the official Zocdoc API?

Zocdoc's official API is a **partner API for scheduling and calendar integration** — it requires partner onboarding/credentials and is built around booking flows, not bulk provider-directory exports. This actor reads Zocdoc's **publicly listed directory data** (the same public data the website shows) with no auth and returns it as a downloadable dataset or a per-result API feed.

#### What are alternatives to this actor?

- Other Zocdoc actors on Apify (see Related Actors — typical rates range from $0.00433 to $0.009 per result vs **$0.0035 here**).
- Healthgrades / WebMD / NPPES (NPI registry) for other provider datasets.
- Official partner API if you only need booking/availability integration.

#### How can I build a list of dentists accepting new patients?

Run the actor with `specialty: "Dentist"` and your `location`. Every provider Zocdoc shows is open to new patients, and each record includes `nextAvailableDate` (the soonest bookable slot) plus address, phone and profile URL — filter on `nextAvailableDate != null` to keep only actively bookable providers.

#### How do I monitor doctor appointment availability over time?

Enable `includeAvailability: true` and set `availabilityDays` (up to 90). Schedule a recurring task (e.g. daily) and compare `nextAvailableDate` / `slotsFoundNextDays` per `zocdocProviderId` to track availability shifts.

#### Why are NPI, education, languages and full insurance lists null?

Zocdoc's public directory API does not expose those fields — they live on DataDome-protected profile pages. The actor returns `null`/`[]` for them and always includes `profileUrl` so you can enrich profiles separately (e.g. with a residential-proxy browser run).

#### Does the actor get the full review text?

No. The API exposes **one representative review snippet per doctor plus the total review count** — not the full review feed.

#### How much does it cost to scrape Zocdoc?

A 50-doctor run makes roughly 8 lightweight JSON requests at 256 MB and finishes in under a minute. Pricing is **$3.5 per 1,000 results** on the free tier (less on higher tiers) plus a small start event; free-plan users get 10 profiles per run as a preview. Turning off `includeAvailability` reduces requests further.

### Competitive Positioning

| Capability | Other Zocdoc actors | This actor |
|---|---|---|
| Price per 1,000 results | $4.33–$9.00 (crawlerbros $4.33, scrapersdelight $4.50, silentflow $5.00, getdataforme $9.00) | **$3.50** (free tier) |
| Specialty by name | Required on several actors as `searches`/`specialty` + `city`/`state` | `specialty` name resolved live to Zocdoc's ID automatically |
| Availability window | Not always configurable | `includeAvailability` + `availabilityDays` (1–90) |
| No browser / no login | Varies (some use Playwright + residential proxies) | Pure HTTP GraphQL API, no browser |

### SEO Keywords

zocdoc scraper, zocdoc api alternative, doctor database, physician directory data, healthcare provider data, doctor lead generation, dentist lead list, doctors accepting new patients, dermatologist list by city, primary care doctor list, therapist directory data, pediatrician list, doctor ratings data, zocdoc doctor profiles, next available appointment data, insurance accepted doctor data, in-network dentist data, telehealth providers list, healthcare market research data, medical marketing leads

### For AI Agents & LLM Apps

**Purpose:** Returns one JSON record per provider from Zocdoc for a given specialty + location, including rating, review count, insurance flags, next-available appointment and location/contact data.

**Minimal input:**

```json
{ "specialty": "Dentist", "location": "New York, NY", "maxResults": 20 }
```

**Cheaper variant (no availability enrichment):**

```json
{ "specialty": "Dermatologist", "location": "10001", "maxResults": 50, "includeAvailability": false }
```

**Output fields:** `name`, `firstName`, `lastName`, `specialty`, `allSpecialties`, `rating`, `bedsideMannerRating`, `waitTimeRating`, `highlyRecommendPct`, `reviewCount`, `reviewSnippet`, `acceptsInNetwork`, `acceptsOutOfNetwork`, `acceptsSelfPay`, `nextAvailableDate`, `nextAvailableSlot`, `slotsFoundNextDays`, `address`, `city`, `state`, `zip`, `phone`, `latitude`, `longitude`, `distanceMiles`, `isVirtual`, `profileUrl`, `photoUrl`, `zocdocProviderId`, `zocdocLocationId`, `npi`, `education`, `insurancesAccepted`, `languages`, `scrapedAt`.

**Behaviors an agent should know:**

- If `specialtyId` is set it takes priority and skips the specialty-name lookup; otherwise `specialty` is resolved live.
- `includeAvailability: true` (default) adds **one extra API request per page of 20 doctors** — set it `false` when availability isn't needed to reduce time and cost.
- `availabilityDays` caps at 90; default is 14.
- `maxResults` max is 1000; free-plan runs are capped at 10 profiles.
- `npi`, `education`, `languages`, `insurancesAccepted` come back `null`/`[]` by design (not exposed by the public directory API).
- Billing is pay-per-result: **$3.5 per 1,000 results** (free tier).

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Zocdoc, Inc.** It accesses only publicly listed provider directory data through Zocdoc's own public directory endpoint — it does not access patient records, is not a covered-entity integration, and does not book appointments. Users are responsible for complying with Zocdoc's Terms of Use and applicable law, including data-protection rules and healthcare-marketing regulations (e.g., HIPAA does not cover business contact/listing data, but any downstream use of provider or patient data is the user's responsibility). Data returned is provider directory information; NPI, education and full insurance details are not exposed. This summary is not legal advice.

# Actor input Schema

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

Doctor specialty to search (e.g. Dentist, Dermatologist, Primary Care Doctor). Resolved to Zocdoc's internal specialty ID automatically.

## `specialtyId` (type: `string`):

Zocdoc internal specialty ID (e.g. 98 = Dentist). If set, skips the specialty name lookup.

## `location` (type: `string`):

City + state or ZIP code (e.g. New York, NY or 10001).

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

Maximum doctor profiles to return (free users capped at 10).

## `includeAvailability` (type: `boolean`):

Fetch next-available appointment slots per doctor (one extra API call per page of 20).

## `availabilityDays` (type: `integer`):

How many days ahead to scan for appointment slots (max 90).

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "specialty": "Dentist",
  "location": "New York, NY",
  "maxResults": 50,
  "includeAvailability": true,
  "availabilityDays": 14,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "specialty": "Dentist",
    "location": "New York, NY",
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/zocdoc-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 = {
    "specialty": "Dentist",
    "location": "New York, NY",
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/zocdoc-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 '{
  "specialty": "Dentist",
  "location": "New York, NY",
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/zocdoc-scraper --silent --output-dataset

```

## MCP server setup

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