# ZocDoc Scraper (`silentflow/zocdoc-scraper`) Actor

Scrape ZocDoc doctors, patient reviews, and appointment availability without login. Search by specialty, location, and insurance. Extract ratings, reviews, availability slots, and full provider profiles.

- **URL**: https://apify.com/silentflow/zocdoc-scraper.md
- **Developed by:** [SilentFlow](https://apify.com/silentflow) (community)
- **Categories:** Lead generation, Other
- **Stats:** 5 total users, 2 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: No ratings yet

## Pricing

$29.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

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

by [SilentFlow](https://apify.com/silentflow)

Unlimited ZocDoc web scraper to crawl doctors, patient reviews, and appointment availability without login. Search by specialty, location, insurance, and more.

### Why use this scraper?

- **No login required**: Scrape all public ZocDoc data without authentication
- **Comprehensive data**: Doctors, reviews, ratings, availability, and full provider profiles
- **Flexible input**: Scrape by URL or search by specialty and location
- **Advanced filtering**: Sort by rating, filter by telehealth, gender, day, and insurance
- **High reliability**: Built-in retry logic and residential proxy support

### Use cases

| Industry | Application |
|----------|-------------|
| **Healthcare analytics** | Analyze doctor ratings, wait times, and patient satisfaction |
| **Market research** | Map healthcare provider distribution across regions |
| **Insurance analysis** | Track which providers accept specific insurance plans |
| **Patient experience** | Monitor review sentiment and bedside manner ratings |
| **Competitor intelligence** | Benchmark practice performance against competitors |
| **Appointment tracking** | Monitor availability trends for popular specialties |

### Input parameters

#### URL scraping

| Parameter | Type | Description |
|-----------|------|-------------|
| `startUrls` | array | ZocDoc URL(s) to scrape (search pages, doctor profiles, practice pages) |

**Supported URL types:**
- Search pages: `https://www.zocdoc.com/search?address=New+York&dr_specialty=dentist`
- Doctor profiles: `https://www.zocdoc.com/doctor/john-smith-do-123456`
- Practice pages: `https://www.zocdoc.com/practice/downtown-dental-12345`

#### Specialty search

| Parameter | Type | Description |
|-----------|------|-------------|
| `searches` | array | Specialty names to search (e.g., "Dentist", "Dermatologist") |
| `location` | string | City, state, or zip code (default: "New York, NY") |
| `insurance` | string | Insurance carrier name (optional) |

#### Sorting & filtering

| Parameter | Type | Default | Options |
|-----------|------|---------|---------|
| `sort` | string | Default | Default, BestMatch, HighestRated, SoonestAvailable |
| `dayFilter` | string | AnyDay | AnyDay, Today, Tomorrow, NextThreeDays, NextTwoWeeks |
| `gender` | string | -1 | -1 (Any), 1 (Male), 2 (Female) |
| `offersTelehealth` | boolean | false | Only telehealth providers |
| `seesChildren` | boolean | false | Only pediatric providers |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxItems` | integer | 50 | Maximum total items to save |
| `maxDoctors` | integer | 20 | Maximum doctors per search |
| `maxReviews` | integer | 10 | Maximum reviews per doctor |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `scrapeProfiles` | boolean | true | Visit doctor profiles for detailed data |
| `skipReviews` | boolean | false | Skip review extraction |
| `skipAvailability` | boolean | false | Skip availability extraction |

#### Advanced

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `scrollTimeout` | integer | 30 | Request timeout in seconds |
| `debugMode` | boolean | false | Enable detailed logging |
| `proxy` | object | residential | Proxy configuration |

### Output data

#### Doctor example

```json
{
  "id": "123456",
  "url": "https://www.zocdoc.com/doctor/john-smith-do-123456",
  "name": "John Smith, DO",
  "firstName": "John",
  "lastName": "Smith, DO",
  "title": "DO",
  "specialty": "Dentist",
  "specialties": ["Dentist", "Cosmetic Dentistry"],
  "address": "123 Main St, Suite 200",
  "city": "New York",
  "state": "NY",
  "zipCode": "10001",
  "phone": "(212) 555-0100",
  "latitude": 40.7128,
  "longitude": -74.006,
  "overallRating": 4.8,
  "bedsideMannerRating": 4.9,
  "waitTimeRating": 4.6,
  "reviewCount": 142,
  "profilePhotoUrl": "https://d1k13df5m14swc.cloudfront.net/photos/...",
  "education": ["NYU College of Dentistry - DDS"],
  "boardCertifications": ["American Board of Dentistry"],
  "languages": ["English", "Spanish"],
  "insurancesAccepted": ["Aetna", "Blue Cross", "Cigna", "United Healthcare"],
  "gender": "Male",
  "yearsOfExperience": 15,
  "practiceName": "Downtown Dental Care",
  "bio": "Dr. Smith specializes in...",
  "isAcceptingNewPatients": true,
  "offersTelehealth": false,
  "nextAvailableDate": "2024-06-15",
  "scrapedAt": "2024-06-14T10:30:00Z",
  "dataType": "doctor"
}
````

#### Review example

```json
{
  "id": "review-1",
  "doctorName": "John Smith, DO",
  "doctorUrl": "https://www.zocdoc.com/doctor/john-smith-do-123456",
  "reviewRating": 5.0,
  "reviewBedsideManner": 5.0,
  "reviewWaitTime": 4.0,
  "reviewText": "Dr. Smith was excellent. Very thorough and took the time to explain everything.",
  "reviewDate": "2024-05-20",
  "isVerified": true,
  "scrapedAt": "2024-06-14T10:30:00Z",
  "dataType": "review"
}
```

#### Availability example

```json
{
  "doctorName": "John Smith, DO",
  "doctorUrl": "https://www.zocdoc.com/doctor/john-smith-do-123456",
  "date": "2024-06-15",
  "timeSlots": ["9:00 AM", "10:30 AM", "2:00 PM", "3:30 PM"],
  "appointmentType": "in-person",
  "locationName": "Downtown Dental Care",
  "address": "123 Main St, Suite 200",
  "scrapedAt": "2024-06-14T10:30:00Z",
  "dataType": "availability"
}
```

### Data fields

| Category | Fields |
|----------|--------|
| **Identity** | id, url, name, firstName, lastName, title |
| **Specialty** | specialty, specialties, boardCertifications |
| **Location** | address, city, state, zipCode, phone, latitude, longitude |
| **Ratings** | overallRating, bedsideMannerRating, waitTimeRating, reviewCount |
| **Profile** | profilePhotoUrl, education, languages, bio, gender, yearsOfExperience |
| **Practice** | practiceName, insurancesAccepted, isAcceptingNewPatients, offersTelehealth |
| **Availability** | nextAvailableDate, date, timeSlots, appointmentType, locationName |
| **Reviews** | reviewRating, reviewBedsideManner, reviewWaitTime, reviewText, reviewDate, isVerified |
| **Meta** | scrapedAt, dataType |

### Examples

#### Search for dentists in New York

```json
{
  "searches": ["Dentist"],
  "location": "New York, NY",
  "maxItems": 50,
  "maxDoctors": 20,
  "maxReviews": 10,
  "sort": "HighestRated"
}
```

#### Search for therapists with telehealth

```json
{
  "searches": ["Therapist"],
  "location": "Los Angeles, CA",
  "offersTelehealth": true,
  "maxItems": 100,
  "maxDoctors": 50
}
```

#### Scrape a specific doctor profile

```json
{
  "startUrls": [{"url": "https://www.zocdoc.com/doctor/john-smith-do-123456"}],
  "maxReviews": 50
}
```

#### Search multiple specialties

```json
{
  "searches": ["Dermatologist", "Primary Care Doctor", "Pediatrician"],
  "location": "Chicago, IL",
  "sort": "SoonestAvailable",
  "dayFilter": "NextThreeDays",
  "maxItems": 200,
  "maxDoctors": 30
}
```

### Integrations

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("silentflow/zocdoc-scraper").call(run_input={
    "searches": ["Dentist"],
    "location": "New York, NY",
    "maxItems": 50,
    "maxDoctors": 20,
    "maxReviews": 10,
    "sort": "HighestRated"
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["dataType"] == "doctor":
        print(f"[{item['overallRating']}] {item['name']} - {item['specialty']}")
    elif item["dataType"] == "review":
        print(f"  ⭐ {item['reviewRating']}: {item['reviewText'][:80]}")
    elif item["dataType"] == "availability":
        print(f"  📅 {item['date']}: {', '.join(item['timeSlots'])}")
```

#### JavaScript

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('silentflow/zocdoc-scraper').call({
    searches: ['Dermatologist'],
    location: 'San Francisco, CA',
    maxItems: 100,
    sort: 'HighestRated'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => {
    if (item.dataType === 'doctor') {
        console.log(`[${item.overallRating}] ${item.name} - ${item.specialty}`);
    }
});
```

### Performance & limits

| Metric | Value |
|--------|-------|
| Results per page | up to 10 |
| Pages per search | up to 10 (ZocDoc limit) |
| Max doctors per search | ~100 |
| Supported content | Doctors, Reviews, Availability |

### Tips for best results

1. **Use specific specialties**: Target specific specialties for focused results
2. **Set realistic limits**: Start with `maxItems: 50` to test before large scrapes
3. **Use residential proxy**: Enabled by default for best reliability with ZocDoc
4. **Skip what you don't need**: Use `skipReviews` and `skipAvailability` for faster scraping
5. **Disable profile scraping**: Set `scrapeProfiles: false` for quick search-only results
6. **Filter by day**: Use `dayFilter` to find doctors with immediate availability

### FAQ

**Q: Can I scrape all doctors in a city?**
A: ZocDoc limits search results to ~10 pages per specialty. Search multiple specialties for broader coverage.

**Q: Why are some fields empty?**
A: Not all doctors have complete profiles. Enable `scrapeProfiles` for maximum data.

**Q: How often can I run the scraper?**
A: No limits on frequency. Use residential proxies for best results.

**Q: What happens if ZocDoc blocks the scraper?**
A: The scraper automatically rotates proxies and retries. If all attempts fail, try again later.

**Q: Can I filter by insurance?**
A: Yes, use the `insurance` parameter with the carrier name.

### Support

Need help? We're here for you:

- **Feature requests**: Let us know what you need
- **Custom solutions**: Contact us for enterprise integrations or high-volume needs

Check out our other scrapers: [SilentFlow on Apify](https://apify.com/silentflow)

# Actor input Schema

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

ZocDoc URL(s) to scrape directly. Supports doctor profile URLs, search result pages, and practice pages.

## `skipReviews` (type: `boolean`):

Skip scraping patient reviews when visiting doctor profiles.

## `skipAvailability` (type: `boolean`):

Skip scraping appointment availability slots.

## `searches` (type: `array`):

Specialty search terms (e.g., 'Dentist', 'Dermatologist', 'Primary Care Doctor', 'Therapist').

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

City, state, or zip code for doctor search (e.g., 'New York, NY', '10001', 'Los Angeles, CA').

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

Insurance carrier name to filter doctors (leave empty for all).

## `sort` (type: `string`):

Sort search results by criteria.

## `dayFilter` (type: `string`):

Filter by appointment availability day.

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

Filter by provider gender preference.

## `offersTelehealth` (type: `boolean`):

Only show providers offering telehealth/video visits.

## `seesChildren` (type: `boolean`):

Only show providers who see children/pediatric patients.

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

The maximum total number of items (doctors + reviews + availability) to save.

## `maxDoctors` (type: `integer`):

Maximum number of doctor profiles to scrape per search or URL.

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

Maximum number of reviews to scrape per doctor profile. Set to 0 to skip reviews.

## `scrapeProfiles` (type: `boolean`):

Visit each doctor's profile page for detailed information (education, bio, insurance list). Disable for faster search-only scraping.

## `scrollTimeout` (type: `integer`):

HTTP request timeout in seconds.

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

Either use Apify proxy, or provide your own proxy servers.

## `debugMode` (type: `boolean`):

Activate to see detailed logs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.zocdoc.com/search?address=New+York%2C+NY&dr_specialty=dentist&sort_type=Default&offset=0"
    }
  ],
  "skipReviews": false,
  "skipAvailability": false,
  "searches": [
    "dentist"
  ],
  "location": "New York, NY",
  "sort": "Default",
  "dayFilter": "AnyDay",
  "gender": "-1",
  "offersTelehealth": false,
  "seesChildren": false,
  "maxItems": 50,
  "maxDoctors": 20,
  "maxReviews": 10,
  "scrapeProfiles": true,
  "scrollTimeout": 30,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "debugMode": false
}
```

# Actor output Schema

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

Complete ZocDoc data including: doctor profiles (name, specialty, rating, address, insurance), patient reviews (rating, text, date), and availability slots. Each item has a dataType field (doctor/review/availability).

## `resultsCSV` (type: `string`):

CSV format export for spreadsheet analysis

## `resultsExcel` (type: `string`):

Excel format export

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.zocdoc.com/search?address=New+York%2C+NY&dr_specialty=dentist&sort_type=Default&offset=0"
        }
    ],
    "searches": [
        "dentist"
    ],
    "location": "New York, NY",
    "sort": "Default",
    "maxItems": 50,
    "maxDoctors": 20,
    "maxReviews": 10,
    "scrollTimeout": 30,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("silentflow/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 = {
    "startUrls": [{ "url": "https://www.zocdoc.com/search?address=New+York%2C+NY&dr_specialty=dentist&sort_type=Default&offset=0" }],
    "searches": ["dentist"],
    "location": "New York, NY",
    "sort": "Default",
    "maxItems": 50,
    "maxDoctors": 20,
    "maxReviews": 10,
    "scrollTimeout": 30,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("silentflow/zocdoc-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 '{
  "startUrls": [
    {
      "url": "https://www.zocdoc.com/search?address=New+York%2C+NY&dr_specialty=dentist&sort_type=Default&offset=0"
    }
  ],
  "searches": [
    "dentist"
  ],
  "location": "New York, NY",
  "sort": "Default",
  "maxItems": 50,
  "maxDoctors": 20,
  "maxReviews": 10,
  "scrollTimeout": 30,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call silentflow/zocdoc-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ZocDoc Scraper",
        "description": "Scrape ZocDoc doctors, patient reviews, and appointment availability without login. Search by specialty, location, and insurance. Extract ratings, reviews, availability slots, and full provider profiles.",
        "version": "1.0",
        "x-build-id": "mdYdaeN1s6uKsQAun"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/silentflow~zocdoc-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-silentflow-zocdoc-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/silentflow~zocdoc-scraper/runs": {
            "post": {
                "operationId": "runs-sync-silentflow-zocdoc-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/silentflow~zocdoc-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-silentflow-zocdoc-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",
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "ZocDoc URL(s) to scrape directly. Supports doctor profile URLs, search result pages, and practice pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "skipReviews": {
                        "title": "Skip reviews",
                        "type": "boolean",
                        "description": "Skip scraping patient reviews when visiting doctor profiles.",
                        "default": false
                    },
                    "skipAvailability": {
                        "title": "Skip availability",
                        "type": "boolean",
                        "description": "Skip scraping appointment availability slots.",
                        "default": false
                    },
                    "searches": {
                        "title": "Search specialties",
                        "type": "array",
                        "description": "Specialty search terms (e.g., 'Dentist', 'Dermatologist', 'Primary Care Doctor', 'Therapist').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, state, or zip code for doctor search (e.g., 'New York, NY', '10001', 'Los Angeles, CA').",
                        "default": "New York, NY"
                    },
                    "insurance": {
                        "title": "Insurance (optional)",
                        "type": "string",
                        "description": "Insurance carrier name to filter doctors (leave empty for all)."
                    },
                    "sort": {
                        "title": "Sort results",
                        "enum": [
                            "Default",
                            "BestMatch",
                            "HighestRated",
                            "SoonestAvailable"
                        ],
                        "type": "string",
                        "description": "Sort search results by criteria.",
                        "default": "Default"
                    },
                    "dayFilter": {
                        "title": "Day filter",
                        "enum": [
                            "AnyDay",
                            "Today",
                            "Tomorrow",
                            "NextThreeDays",
                            "NextTwoWeeks"
                        ],
                        "type": "string",
                        "description": "Filter by appointment availability day.",
                        "default": "AnyDay"
                    },
                    "gender": {
                        "title": "Provider gender",
                        "enum": [
                            "-1",
                            "1",
                            "2"
                        ],
                        "type": "string",
                        "description": "Filter by provider gender preference.",
                        "default": "-1"
                    },
                    "offersTelehealth": {
                        "title": "Telehealth only",
                        "type": "boolean",
                        "description": "Only show providers offering telehealth/video visits.",
                        "default": false
                    },
                    "seesChildren": {
                        "title": "Sees children",
                        "type": "boolean",
                        "description": "Only show providers who see children/pediatric patients.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum number of items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "The maximum total number of items (doctors + reviews + availability) to save.",
                        "default": 50
                    },
                    "maxDoctors": {
                        "title": "Maximum doctors per search",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of doctor profiles to scrape per search or URL.",
                        "default": 20
                    },
                    "maxReviews": {
                        "title": "Maximum reviews per doctor",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per doctor profile. Set to 0 to skip reviews.",
                        "default": 10
                    },
                    "scrapeProfiles": {
                        "title": "Scrape full profiles",
                        "type": "boolean",
                        "description": "Visit each doctor's profile page for detailed information (education, bio, insurance list). Disable for faster search-only scraping.",
                        "default": true
                    },
                    "scrollTimeout": {
                        "title": "Request timeout (seconds)",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "HTTP request timeout in seconds.",
                        "default": 30
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Either use Apify proxy, or provide your own proxy servers.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "debugMode": {
                        "title": "Debug Mode",
                        "type": "boolean",
                        "description": "Activate to see detailed logs.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
