# Oladoc Doctors Scraper 🩺 (`shahidirfan/oladoc-scraper`) Actor

Efficiently extract doctor profiles, specialties, and consultation fees from Oladoc. This lightweight scraper is built for speed and ease of use. For optimal performance and to ensure uninterrupted data collection, the use of residential proxies is strongly recommended.

- **URL**: https://apify.com/shahidirfan/oladoc-scraper.md
- **Developed by:** [Shahid Irfan](https://apify.com/shahidirfan) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Features:** Limited permissions
- **Stats:** 24 total users, 4 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

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

### What does Oladoc Doctors Scraper do?

Oladoc Doctors Scraper collects structured doctor directory data from Oladoc, Pakistan's healthcare platform. Search by specialty and city, or provide a public Oladoc listing URL, then export doctor profiles with qualifications, experience, ratings, consultation fees, availability, locations, services, and hospital information.

The Actor is useful for healthcare market research, doctor and clinic directory projects, provider discovery, appointment marketplace analysis, competitive research, and data enrichment. Each run saves unique doctor records to an Apify Dataset and removes empty values from the final output.

### Why use Oladoc Doctors Scraper?

- **Build doctor datasets** - Collect consistent provider records for dashboards, directories, research, and internal databases.
- **Search Pakistani healthcare markets** - Focus on a specialty and city such as dermatology in Lahore or cardiology in Karachi.
- **Compare provider information** - Analyze qualifications, experience, ratings, review counts, fees, services, and availability.
- **Understand appointment coverage** - Identify hospitals, clinics, video consultation locations, booking availability, opening hours, and available days.
- **Create cleaner downstream data** - Duplicate doctor profiles are skipped by doctor ID, and empty strings, null values, and empty nested objects are omitted.
- **Run repeatable workflows** - Use Apify datasets, schedules, webhooks, API access, and exports for recurring research or monitoring.

### What data can you extract from Oladoc?

The Actor returns one JSON object for each unique doctor profile. Fields are included when Oladoc publishes them for that record.

| Field | Type | Description |
|-------|------|-------------|
| `doctor_id` | String | Unique doctor identifier from Oladoc. |
| `name` | String | Doctor display name. |
| `url` | String | Public Oladoc doctor profile URL. |
| `gender` | String | Gender value when published. |
| `specialty` | String | Specialties associated with the doctor. |
| `primary_specialty` | String | Primary specialty name. |
| `specialty_slug` | String | Primary specialty slug used by the listing. |
| `specialty_slugs` | Array | Normalized list of specialty slugs. |
| `qualifications` | String | Degrees and other educational credentials. |
| `profile_image` | String | Doctor profile image URL when available. |
| `experience` | String | Human-readable experience, such as `8 Years`. |
| `experience_years` | Integer | Numeric years of experience when available. |
| `rating` | Number | Average rating score. |
| `reviews_count` | Integer | Total review count. |
| `consultation_fee` | String | Fee range or formatted consultation fee. |
| `maximum_fee` | Integer | Maximum fee value when available. |
| `wait_time` | String | Average wait time or wait-time range. |
| `availability` | String | Current availability text when published. |
| `city` | String | Doctor city. |
| `locality` | String | Practice locality when available. |
| `locations` | Array or Object | Additional location information when available. |
| `opening_hours` | String or Array | Published opening hours. |
| `phone` | String | Appointment contact number when published. |
| `description` | String | Public profile summary or about text. |
| `pmdc_verified` | Boolean | Whether the profile is marked as PMDC verified. |
| `pmdc_id` | String | PMDC identifier when published. |
| `governing_body` | String | Governing medical body when published. |
| `is_bookable` | Boolean | Whether booking is indicated for the profile. |
| `is_partner` | Boolean | Whether the doctor is marked as a platform partner. |
| `has_active_subscription` | Boolean | Whether an active subscription is indicated. |
| `video_consultation_available` | Boolean | Whether video consultation is available. |
| `recommendation_percentage` | Integer | Recommendation percentage when available. |
| `feedback_percentage` | Integer | Feedback percentage when available. |
| `total_users` | Integer | User count associated with the profile when available. |
| `featured_review` | String or Object | Featured review information when published. |
| `available_days` | Array | Days on which availability is listed. |
| `services` | Object | Service count, service names, and related service metadata. |
| `hospitals` | Array | Hospital and clinic locations from the doctor profile. |
| `bookable_hospitals` | Array | Locations where appointment booking is indicated. |
| `vc_hospitals` | Array | Video consultation locations. |
| `subscribed_hospitals` | Array | Subscribed practice locations when available. |
| `all_hospitals` | Array | Combined, deduplicated hospital and consultation locations. |

Hospital entries can include names, addresses, cities, localities, fees, phone numbers, coordinates, availability, booking URLs, consultation mode, and insurance or discount indicators when published.

### How to use Oladoc Doctors Scraper

1. Open Oladoc Doctors Scraper in Apify Console.
2. Enter both `specialty` and `city`, or provide a public `startUrl` for an Oladoc listing.
3. Set `results_wanted` and `max_pages` for the size of the collection.
4. Keep `collectDetails` enabled when hospital and service information is needed.
5. Add optional proxy settings for longer or recurring runs.
6. Start the run and review the Dataset preview.
7. Download the results or connect the Dataset to your application or automation workflow.

When `startUrl` is provided, it takes precedence over `specialty`, `city`, and `country` for building the listing source. Without `startUrl`, both `specialty` and `city` are needed. The default country is `pakistan`.

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `startUrl` | String | Conditional | - | Public Oladoc listing URL. When provided, it takes precedence over `specialty`, `city`, and `country`. |
| `specialty` | String | Conditional | - | Specialty slug, such as `dermatologist` or `cardiologist`. Required with `city` when `startUrl` is not provided. |
| `city` | String | Conditional | - | City slug, such as `lahore`, `karachi`, or `islamabad`. Required with `specialty` when `startUrl` is not provided. |
| `country` | String | No | `pakistan` | Country slug used with `city` and `specialty` to build the listing URL. |
| `collectDetails` | Boolean | No | `true` | Include hospital, bookable hospital, video consultation, subscribed hospital, and combined hospital arrays. |
| `results_wanted` | Integer | No | `20` | Maximum number of unique doctor records to save. |
| `max_pages` | Integer | No | `10` | Maximum number of listing pages to process. |
| `proxyConfiguration` | Object | No | `{ "useApifyProxy": false }` | Optional Apify Proxy settings for longer or recurring runs. |

### Output Data

The Dataset contains one item per unique doctor ID. Base profile fields remain available when `collectDetails` is `false`, while the hospital arrays are omitted. Optional source values are omitted instead of being returned as empty fields.

Hospital and service objects are also cleaned of empty values and duplicate entries. The exact number of fields can vary between doctors because Oladoc does not publish the same information for every profile.

### Usage Examples

#### Basic specialty and city search

Collect up to 20 dermatologists listed in Lahore.

```json
{
  "specialty": "dermatologist",
  "city": "lahore",
  "results_wanted": 20
}
```

#### Direct Oladoc listing URL

Use a public listing URL when you already know the specialty and location page to collect.

```json
{
  "startUrl": "https://oladoc.com/pakistan/lahore/dermatologist",
  "results_wanted": 30,
  "max_pages": 5
}
```

#### Detailed collection with proxy settings

Collect cardiologists in Karachi and include detailed hospital data for a larger run.

```json
{
  "specialty": "cardiologist",
  "city": "karachi",
  "collectDetails": true,
  "results_wanted": 50,
  "max_pages": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Sample Output

This example shows a single dataset item with profile, service, booking, and hospital information. Actual fields vary according to the source profile.

```json
{
  "doctor_id": "1601408",
  "name": "Dr. Alina Abbas",
  "url": "https://oladoc.com/pakistan/lahore/dr/dermatologist/alina-abbas/1601408",
  "specialty": "Dermatologist, Cosmetologist",
  "qualifications": "M.B.B.S., F.C.P.S.",
  "experience": "8 Years",
  "experience_years": 8,
  "rating": 4.9,
  "reviews_count": 1238,
  "consultation_fee": "1500 - 2500",
  "wait_time": "15 - 30 Min",
  "availability": "today",
  "city": "Lahore",
  "locality": "Johar Town",
  "phone": "04238900939",
  "description": "Dr. Alina Abbas is one of the best Dermatologist in Lahore.",
  "pmdc_verified": true,
  "services": {
    "count": 39,
    "items": [
      "Acne Treatment",
      "Alopecia",
      "Antihistamine Treatment",
      "Boil",
      "Carbon Facial"
    ],
    "user_id": "1601408"
  },
  "all_hospitals": [
    {
      "doctor_id": "1601408",
      "hospital_id": "4681",
      "name": "Online Video Consultation",
      "locality": "Online",
      "city": "Video Consultation",
      "fee": 1500,
      "when_available": "Tue, Apr 14",
      "video_consultation": true,
      "book": true
    },
    {
      "doctor_id": "1601408",
      "hospital_id": "117",
      "name": "Ihsan Mumtaz Hospital",
      "locality": "Johar Town",
      "city": "Lahore",
      "fee": 2500,
      "when_available": "today",
      "video_consultation": false,
      "book": true
    }
  ]
}
```

### Tips for Best Results

- Use Oladoc specialty and city slugs that match the public listing URL format.
- Start with `results_wanted` set to `20` to confirm the fields and geographic scope.
- Increase `max_pages` when the selected specialty and city contain more results.
- Use `startUrl` when you already have a specific public listing page.
- Keep `collectDetails` enabled for hospital, booking, service, and video consultation data.
- Set `collectDetails` to `false` when you only need lighter base doctor records. Hospital arrays are then omitted, but profile fields such as name, specialty, rating, fee, and URL remain available.
- Use proxy settings for longer collections or recurring schedules when additional connection reliability is needed.
- Treat missing phone numbers, fees, ratings, and hospital details as normal source-data variation. These values are included only when published.
- Review a small Dataset preview before scheduling larger runs.

### Integrations

- **JSON** - Use structured records in applications, scripts, and data pipelines.
- **CSV** - Analyze doctor coverage, specialties, fees, and locations in spreadsheet tools.
- **Excel** - Prepare reports and share provider research with business teams.
- **XML** - Support workflows that require XML-based data exchange.
- **Google Sheets and Airtable** - Build searchable doctor and clinic directories.
- **Make and Zapier** - Send completed datasets into CRM, notification, or enrichment workflows.
- **Webhooks** - Notify downstream systems when a run finishes.
- **Apify API** - Retrieve Dataset records programmatically.
- **Scheduling** - Refresh public Oladoc directory data on an hourly, daily, weekly, or custom schedule.

### Frequently Asked Questions

#### Can I search Oladoc by specialty and city?

Yes. Provide both `specialty` and `city` to create a location-focused Oladoc listing search. `country` defaults to `pakistan`.

#### Can I provide my own Oladoc URL?

Yes. Set `startUrl` to a public Oladoc listing URL. It takes precedence over `specialty`, `city`, and `country` when the collection source is built.

#### Does `collectDetails: false` remove doctor profile fields?

No. It only omits the hospital arrays. Base profile fields such as name, specialty, qualifications, rating, fees, availability, city, and URL remain available when published.

#### How are duplicate doctors handled?

Duplicate records are skipped using the doctor ID before they are saved to the Dataset. Empty strings, null values, empty objects, and repeated nested values are also removed.

#### Can I export Oladoc data to CSV or Excel?

Yes. Apify Dataset results can be downloaded as CSV, Excel, JSON, XML, and other supported formats.

#### Can I schedule recurring Oladoc collections?

Yes. Create an Apify schedule to refresh provider profiles, fees, ratings, availability, and hospital information at a chosen interval.

#### Why is a phone number or hospital missing?

Oladoc does not publish every field for every doctor. The Actor keeps available public values and omits unavailable or empty values, so records can have different field coverage.

#### Is Oladoc Doctors Scraper suitable for medical decisions?

No. The output is directory information for research and data workflows, not medical advice, diagnosis, provider quality certification, or a substitute for professional healthcare guidance.

#### Is it legal to collect Oladoc data?

Public data collection may be subject to Oladoc's terms, privacy requirements, healthcare data rules, and other applicable laws. You are responsible for confirming that your collection, storage, analysis, and use of the data are lawful.

### Related Actors

- [Practo Doctors Scraper](https://apify.com/shahidirfan/practo-doctors-scraper) - Collect doctor and clinic data from Practo, including specialties, fees, ratings, availability, and practice details.
- [Marham.pk Scraper](https://apify.com/shahidirfan/Marham-pk-Scraper) - Collect Pakistani doctor profiles, consultation fees, reviews, hospitals, services, and availability indicators from Marham.pk.
- [HealthGrades Scraper](https://apify.com/shahidirfan/healthgrades-scraper) - Collect healthcare provider profiles, specialties, ratings, review counts, locations, and contact details from Healthgrades.

### Support

For issues, feature requests, or reports that Oladoc fields have changed, use the Issues tab on the Actor page. Include the input used, run ID, and a short description of the affected fields when possible.

### Legal Notice

This Actor is intended for legitimate collection and analysis of publicly available Oladoc directory information. Users are responsible for complying with Oladoc's terms, applicable privacy and healthcare data requirements, and all other laws relevant to their use case. Do not use the output for unlawful outreach, discriminatory decisions, or clinical decisions without appropriate independent verification.

# Actor input Schema

## `startUrl` (type: `string`):

Optional: Start from a specific Oladoc URL (e.g., https://oladoc.com/pakistan/lahore/dermatologist). If provided, specialty/city/country are ignored.

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

Doctor specialty to search for (e.g., 'dermatologist', 'cardiologist', 'pediatrician').

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

City to search in (e.g., 'lahore', 'karachi', 'islamabad').

## `country` (type: `string`):

Country code (default: 'pakistan').

## `collectDetails` (type: `boolean`):

Visit each doctor's profile page to extract full details including qualifications, experience, and services.

## `results_wanted` (type: `integer`):

Maximum number of doctor profiles to collect.

## `max_pages` (type: `integer`):

Maximum number of listing pages to scrape.

## `proxyConfiguration` (type: `object`):

Proxy settings. Residential proxies recommended for Oladoc.

## Actor input object example

```json
{
  "specialty": "dermatologist",
  "city": "lahore",
  "country": "pakistan",
  "collectDetails": true,
  "results_wanted": 20,
  "max_pages": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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": "dermatologist",
    "city": "lahore",
    "country": "pakistan",
    "results_wanted": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("shahidirfan/oladoc-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": "dermatologist",
    "city": "lahore",
    "country": "pakistan",
    "results_wanted": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("shahidirfan/oladoc-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": "dermatologist",
  "city": "lahore",
  "country": "pakistan",
  "results_wanted": 20
}' |
apify call shahidirfan/oladoc-scraper --silent --output-dataset

```

## MCP server setup

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