# 🦷 Extract Dentist Leads with Emails — Worldwide (`muhammadafzal/worldwide-dentist-scraper`) Actor

Extract dentist listings worldwide from Google Maps with emails, phones, ratings, specialties, and full contact details. Search by country, state, city, or zip code. Export scraped data, run the scraper via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/muhammadafzal/worldwide-dentist-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.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.

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

## 🦷 Worldwide Dentist Scraper — Extract Dentist Leads with Emails

Extract dentist listings worldwide from Google Maps with emails, phones, ratings, specialties, and full contact details. Search by country, state, city, or zip code. Export scraped data, run the scraper via API, schedule and monitor runs, or integrate with other tools.

### 🎯 Features

- **Worldwide coverage** — Search dentists in any country, state, city, or zip code worldwide
- **Email extraction** — Automatically visits dentist websites to extract email addresses
- **Multi-input mode** — Search by keyword + location OR provide direct Google Maps URLs
- **18 data fields** — Business name, category, specialties, full address, city, state, postal code, country, phone, email, website, Google Maps URL, rating, reviews count, GPS coordinates, opening hours, new patient status, and metadata
- **B2B lead generation** — CRM-ready structured JSON output perfect for sales prospecting
- **Anti-bot stealth** — Session rotation, random delays, viewport randomization, resource blocking
- **14 languages** — Results in English, Spanish, French, German, Portuguese, Italian, Japanese, and more

### 📥 Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | `dentist` | What to search for (e.g., "orthodontist", "dental clinic") |
| `location` | string | `United States` | Where to search — country, state, city, or zip code |
| `startUrls` | array | `[]` | Direct Google Maps URLs (alternative to search) |
| `maxResults` | integer | `50` | Maximum dentist listings to extract (1–5000) |
| `language` | select | `en` | Language for Google Maps results |
| `includeEmails` | boolean | `true` | Visit websites to extract email addresses |
| `proxyConfiguration` | object | Apify Proxy | Proxy settings (datacenter recommended) |

### 📤 Output

Each result contains:

| Field | Type | Description |
|-------|------|-------------|
| `business_name` | string | Name of the dental practice |
| `category` | string | Business category on Google Maps |
| `specialties` | string | Dental specialties offered (comma-separated) |
| `address` | string | Street address |
| `city` | string | City |
| `state` | string | State or province |
| `postal_code` | string | ZIP or postal code |
| `country` | string | Country |
| `phone` | string | Phone number with country code |
| `email` | string | Email address (null if not found) |
| `website` | string | Practice website URL |
| `google_maps_url` | string | Direct Google Maps listing link |
| `rating` | number | Star rating (1.0–5.0) |
| `reviews_count` | integer | Number of Google reviews |
| `latitude` | number | GPS latitude |
| `longitude` | number | GPS longitude |
| `opening_hours` | string | Operating hours |
| `accepts_new_patients` | boolean | Whether accepting new patients |
| `scraped_at` | string | ISO 8601 extraction timestamp |
| `source_url` | string | Source Google Maps URL |

#### Example Output

```json
{
  "business_name": "Smile Dental Clinic",
  "category": "Dentist",
  "specialties": "Orthodontics, Cosmetic Dentistry, Dental Implants",
  "address": "123 Main St, Suite 200",
  "city": "Miami",
  "state": "FL",
  "postal_code": "33101",
  "country": "United States",
  "phone": "+1-305-555-0123",
  "email": "contact@smiledental.com",
  "website": "https://smiledental.com",
  "google_maps_url": "https://www.google.com/maps/place/Smile+Dental/",
  "rating": 4.7,
  "reviews_count": 342,
  "latitude": 25.7617,
  "longitude": -80.1918,
  "opening_hours": "Mon-Fri: 8AM-6PM, Sat: 9AM-2PM",
  "accepts_new_patients": true,
  "scraped_at": "2026-04-08T12:00:00.000Z",
  "source_url": "https://www.google.com/maps/search/dentist+in+Miami"
}
````

### 💰 Pricing

This actor uses **pay-per-event pricing** at **$0.05 per dentist listing** extracted.

#### Cost Examples

- Extract 50 dentists → $2.50
- Extract 200 dentists → $10.00
- Extract 1,000 dentists → $50.00

### 🔧 Usage Examples

#### Search dentists in a specific city

```json
{
  "searchQuery": "dentist",
  "location": "Miami, FL",
  "maxResults": 100
}
```

#### Search orthodontists in a country

```json
{
  "searchQuery": "orthodontist",
  "location": "United Kingdom",
  "maxResults": 200,
  "language": "en"
}
```

#### Search by zip code with email extraction

```json
{
  "searchQuery": "pediatric dentist",
  "location": "90210",
  "maxResults": 50,
  "includeEmails": true
}
```

#### API call

```javascript
const Apify = require('apify-client');
const client = new Apify.ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('muhammadafzal/worldwide-dentist-scraper').call({
    searchQuery: 'dental implant',
    location: 'Tokyo, Japan',
    maxResults: 100,
    language: 'ja'
});

const dataset = await client.dataset(run.defaultDatasetId).listItems();
console.log(dataset.items);
```

### ❓ FAQ

**Does this work worldwide?**\
Yes! Enter any country, state, city, or zip code in the `location` field.

**How does email extraction work?**\
When `includeEmails` is enabled, the actor visits each dentist's website and extracts email addresses from the page content and mailto links. This takes longer but provides valuable contact data.

**What if I get blocked?**\
The actor uses Apify Proxy with session rotation, random delays, and stealth settings. Use datacenter proxies first — residential proxies are available if needed.

**Can I search for specific dental specialties?**\
Yes! Set `searchQuery` to "orthodontist", "pediatric dentist", "cosmetic dentist", etc.

### 📊 Tips for Best Results

1. **Start small** — Test with 20-50 results first, then scale up
2. **Use datacenter proxies** — Faster and cheaper; switch to residential only if blocked
3. **Be specific with location** — "Miami, FL" works better than just "Florida"
4. **Combine search terms** — Try "cosmetic dentist", "dental clinic", or "oral surgeon"
5. **Disable emails for speed** — Set `includeEmails: false` for faster runs when emails aren't needed

# Actor input Schema

## `searchQuery` (type: `string`):

What to search for. Use this field when the user wants to find dentists by type or specialty, e.g., 'dentist', 'orthodontist', 'cosmetic dentist', 'dental implant', 'pediatric dentist'. Do NOT use this when the user provides a direct Google Maps URL — use startUrls instead.

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

Where to search. Enter a country, state, city, or zip code. Examples: 'United States', 'Florida', 'Miami, FL', '33101', 'London, UK', 'Tokyo, Japan'. Combine with searchQuery to find specific dentist types in specific areas.

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

Direct Google Maps search URLs to scrape. Use this field when the user provides a specific Google Maps URL. Do NOT use this when the user describes a location or search term — use searchQuery and location instead.

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

Maximum number of dentist listings to extract. Each listing counts as one result for billing. Lower values complete faster.

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

Language code for Google Maps results (e.g., 'en' for English, 'es' for Spanish, 'fr' for French, 'de' for German, 'pt' for Portuguese, 'ja' for Japanese).

## `includeEmails` (type: `boolean`):

Visit each dentist's website to extract email addresses. Increases accuracy but takes longer and uses more resources.

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

Select proxy to use for scraping. Datacenter proxies are recommended for Google Maps.

## Actor input object example

```json
{
  "searchQuery": "dentist",
  "location": "United States",
  "startUrls": [],
  "maxResults": 500,
  "language": "en",
  "includeEmails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Array of dentist listing objects with full contact details, ratings, and location data.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/worldwide-dentist-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/worldwide-dentist-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 '{}' |
apify call muhammadafzal/worldwide-dentist-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🦷 Extract Dentist Leads with Emails — Worldwide",
        "description": "Extract dentist listings worldwide from Google Maps with emails, phones, ratings, specialties, and full contact details. Search by country, state, city, or zip code. Export scraped data, run the scraper via API, schedule and monitor runs, or integrate with other tools.",
        "version": "1.0",
        "x-build-id": "7Evm1VWWn19cnuEGR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/muhammadafzal~worldwide-dentist-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-muhammadafzal-worldwide-dentist-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/muhammadafzal~worldwide-dentist-scraper/runs": {
            "post": {
                "operationId": "runs-sync-muhammadafzal-worldwide-dentist-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/muhammadafzal~worldwide-dentist-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-muhammadafzal-worldwide-dentist-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "What to search for. Use this field when the user wants to find dentists by type or specialty, e.g., 'dentist', 'orthodontist', 'cosmetic dentist', 'dental implant', 'pediatric dentist'. Do NOT use this when the user provides a direct Google Maps URL — use startUrls instead.",
                        "default": "dentist"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Where to search. Enter a country, state, city, or zip code. Examples: 'United States', 'Florida', 'Miami, FL', '33101', 'London, UK', 'Tokyo, Japan'. Combine with searchQuery to find specific dentist types in specific areas.",
                        "default": "United States"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Direct Google Maps search URLs to scrape. Use this field when the user provides a specific Google Maps URL. Do NOT use this when the user describes a location or search term — use searchQuery and location instead.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of dentist listings to extract. Each listing counts as one result for billing. Lower values complete faster.",
                        "default": 500
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "pt",
                            "it",
                            "ja",
                            "ko",
                            "zh-CN",
                            "ar",
                            "hi",
                            "ru",
                            "nl",
                            "pl",
                            "tr"
                        ],
                        "type": "string",
                        "description": "Language code for Google Maps results (e.g., 'en' for English, 'es' for Spanish, 'fr' for French, 'de' for German, 'pt' for Portuguese, 'ja' for Japanese).",
                        "default": "en"
                    },
                    "includeEmails": {
                        "title": "Include Email Extraction",
                        "type": "boolean",
                        "description": "Visit each dentist's website to extract email addresses. Increases accuracy but takes longer and uses more resources.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Select proxy to use for scraping. Datacenter proxies are recommended for Google Maps.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
