# Dentist Lead Scraper (`automation-lab/dentist-lead-scraper`) Actor

🦷 Find dentist, orthodontist, and dental clinic leads from Google Maps with phones, websites, ratings, and optional email enrichment.

- **URL**: https://apify.com/automation-lab/dentist-lead-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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

## Dentist Lead Scraper

Find dental practice leads from Google Maps and enrich them with public website contact data.

Dentist Lead Scraper helps marketing teams, local SEO agencies, SaaS sales teams, recruiters, and researchers build structured prospect lists of dentists, orthodontists, pediatric dentists, emergency dentists, oral surgeons, and dental clinics.

The actor searches Google Maps by dental query and location, extracts business details, and can optionally visit practice websites to discover public email addresses and social links.

---

### What does Dentist Lead Scraper do?

Dentist Lead Scraper turns Google Maps dental searches into a clean dataset.

It can collect:

- 🦷 Dental practice names
- 📍 Addresses and cities
- ☎️ Phone numbers
- 🌐 Websites
- ✉️ Emails found on public practice websites
- ⭐ Ratings and review counts
- 🗺️ Google Maps URLs and place identifiers
- 📌 Coordinates when available
- 🧭 Search query and location used
- 🕒 Opening status and hours when available
- 📈 Lead score fields for prioritization

Use it when you need more than a manual copy-paste export from Google Maps.

---

### Who is it for?

#### Dental marketing agencies

Build prospect lists for practices that may need SEO, ads, review management, or website redesign services.

#### Local SEO consultants

Find dentists in a target city, compare ratings and review counts, and prioritize practices with weak online presence.

#### SaaS sales teams

Create account lists for dental practice management software, patient messaging tools, billing tools, and review platforms.

#### Recruiters and staffing firms

Map dental clinics in a region before outreach for hygienist, assistant, or specialist roles.

#### Market researchers

Analyze density, ratings, categories, and web presence of dental businesses across locations.

---

### Why use this actor?

- 🦷 Dental-focused input defaults
- 📍 Query plus location search workflow
- ✉️ Optional website email extraction
- 📊 Structured output ready for CRM import
- ⚙️ Filters for rating, website, and email presence
- 🧹 Built-in deduplication across multiple searches
- 🔎 Optional email verification signals
- 🧾 Pay-per-result pricing model

---

### Data you can extract

| Field | Description |
| --- | --- |
| `name` | Dental practice or clinic name |
| `category` | Google Maps business category |
| `address` | Street address or formatted address |
| `city` | Parsed city when available |
| `phone` | Phone number listed on Google Maps |
| `website` | Practice website URL |
| `email` | Best email found on the public website |
| `rating` | Google rating |
| `reviewsCount` | Number of Google reviews |
| `googleMapsUrl` | Source Google Maps URL |
| `location` | Latitude and longitude when available |
| `leadScore` | Simple prioritization score |
| `enrichment` | Emails, social links, contact page hint |
| `scrapedAt` | Timestamp of extraction |

---

### How much does it cost to scrape dentist leads?

Dentist Lead Scraper uses pay-per-event pricing.

You are charged for:

- Run start
- Each dental lead saved
- Optional email verification attempts

Small tests with 5-10 leads are recommended before running large prospecting jobs.

Final prices are visible on the Apify Store actor page before you start a run.

---

### How to scrape dentist leads

1. Open Dentist Lead Scraper on Apify.
2. Add dental queries such as `dentist`, `orthodontist`, or `pediatric dentist`.
3. Add one or more locations such as `Austin, TX` or `Berlin, Germany`.
4. Set `maxLeads`.
5. Choose whether to extract emails from practice websites.
6. Run the actor.
7. Export results as JSON, CSV, Excel, or connect them to your workflow.

---

### Input options

#### Dental search queries

Use broad or niche dental terms.

Examples:

- `dentist`
- `dental clinic`
- `orthodontist`
- `pediatric dentist`
- `emergency dentist`
- `cosmetic dentist`
- `oral surgeon`

#### Locations

Use cities, regions, or countries.

Examples:

- `Austin, TX`
- `Miami, FL`
- `London, UK`
- `Berlin, Germany`
- `Toronto, Canada`

#### Filters

Use filters to narrow the list:

- Minimum rating
- Require website
- Require email

---

### Output example

```json
{
  "name": "Example Dental Care",
  "category": "Dentist",
  "address": "123 Main St, Austin, TX",
  "phone": "+1 555-0100",
  "website": "https://exampledental.com",
  "email": "info@exampledental.com",
  "rating": 4.8,
  "reviewsCount": 126,
  "googleMapsUrl": "https://www.google.com/maps/place/...",
  "searchQuery": "dentist",
  "searchLocation": "Austin, TX",
  "leadScore": 82,
  "scrapedAt": "2026-05-31T00:00:00.000Z"
}
````

***

### Tips for better dental prospecting

- Start with one city and one query.
- Keep `maxLeads` low for the first run.
- Use `includeWebsiteEnrichment` only when you need emails.
- Use `requireWebsite` for outreach campaigns that depend on web presence.
- Use `requireEmail` only when you want email-first lists.
- Run separate jobs for different specialties to keep segments clean.

***

### Email enrichment

When website enrichment is enabled, the actor visits public dental practice websites and looks for contact emails and social links.

It may inspect:

- Home pages
- Contact pages
- About pages
- Footer links
- Public email patterns

Email availability depends on each website. Some practices only publish forms or phone numbers.

***

### Email verification

Optional email verification can add signals such as:

- Valid format
- MX records
- Disposable provider detection
- Free provider detection
- Role account detection
- Confidence score

Verification is useful before sending outreach, but it can add runtime.

***

### Integrations

Use the output with:

- HubSpot CRM imports
- Salesforce lead uploads
- Google Sheets automations
- Airtable databases
- Clay enrichment workflows
- Email outreach tools
- Local SEO audit pipelines
- Agency prospecting dashboards

***

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/dentist-lead-scraper').call({
  searchQueries: ['dentist'],
  locations: ['Austin, TX'],
  maxLeads: 10,
  includeWebsiteEnrichment: false
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/dentist-lead-scraper').call(run_input={
    'searchQueries': ['orthodontist'],
    'locations': ['Chicago, IL'],
    'maxLeads': 10,
    'includeWebsiteEnrichment': False,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~dentist-lead-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["dentist"],"locations":["Austin, TX"],"maxLeads":10,"includeWebsiteEnrichment":false}'
```

***

### MCP usage

Use this actor from MCP-compatible tools through Apify MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/dentist-lead-scraper
```

#### Claude Code setup

Add the Apify MCP server with the actor allowlisted:

```bash
claude mcp add apify-dentist-leads https://mcp.apify.com/?tools=automation-lab/dentist-lead-scraper
```

#### Claude Desktop JSON config

Add this server to your Claude Desktop MCP configuration and replace `YOUR_APIFY_TOKEN` with your Apify API token:

```json
{
  "mcpServers": {
    "apify-dentist-leads": {
      "url": "https://mcp.apify.com/?tools=automation-lab/dentist-lead-scraper",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Example prompts:

- "Find 20 orthodontist leads in Austin and return names, websites, and phones."
- "Scrape dentists in Berlin and include emails when available."
- "Create a CSV of pediatric dental clinics in Toronto with ratings and review counts."

***

### Legality and responsible use

This actor extracts publicly available business information from Google Maps and public dental practice websites.

You are responsible for:

- Following applicable privacy laws
- Respecting anti-spam rules
- Using extracted emails responsibly
- Honoring opt-out requests
- Reviewing Google and website terms for your use case

Do not use scraped data for abusive, deceptive, or unlawful outreach.

***

### FAQ

#### Why did I get fewer leads than requested?

The selected location may have fewer visible dental practices, filters may be strict, or Google Maps may return fewer unique results for that query.

#### Why are some emails missing?

Many dental websites publish contact forms or phone numbers instead of emails. Enable website enrichment, but expect partial email coverage.

#### Should I use residential proxies?

Start with the default direct setup. Enable Apify proxy or switch to residential only if your specific searches are blocked or incomplete.

#### Can I search multiple cities?

Yes. Add multiple locations. The actor combines every query with every location and deduplicates the results.

***

### Related scrapers

- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder)
- [Google Maps Scraper](https://apify.com/automation-lab/google-maps-scraper)
- [Google Maps Reviews Scraper](https://apify.com/automation-lab/google-maps-reviews-scraper)
- [Apple Maps Places Scraper](https://apify.com/automation-lab/apple-maps-places-scraper)

***

### Changelog

#### 0.1

- Initial Dentist Lead Scraper build
- Google Maps dental lead extraction
- Optional website email enrichment
- Optional email verification
- Lead scoring and deduplication

***

### Support

If a run fails or returns unexpected data, open the run log and share the run URL with support.

Helpful details include:

- Search queries
- Locations
- Max leads
- Whether website enrichment was enabled
- Whether proxy settings were changed

***

### Best practices

- Segment by specialty.
- Keep exports small while testing.
- Review sample rows before bulk outreach.
- Validate email quality before campaigns.
- Combine ratings and review counts with website/email presence.

***

### Data freshness

Google Maps and dental websites change over time. Run the actor again when you need fresh outreach lists or updated contact data.

***

### Limitations

- Google Maps may vary results by country, language, and proxy route.
- Some websites block automated requests.
- Some practices do not publish email addresses.
- Opening hours and coordinates may not be available for every lead.
- Email verification is best-effort and can be inconclusive for catch-all domains.

***

### Ready-to-run example

```json
{
  "searchQueries": ["dentist", "orthodontist"],
  "locations": ["Austin, TX"],
  "maxLeads": 5,
  "countryCode": "US",
  "language": "en",
  "includeWebsiteEnrichment": false
}
```

# Actor input Schema

## `searchQueries` (type: `array`):

Dental business types or exact searches to run on Google Maps. Examples: dentist, dental clinic, orthodontist, pediatric dentist, emergency dentist.

## `locations` (type: `array`):

Cities, regions, or countries to search. Examples: Austin, TX; Berlin, Germany; Toronto, Canada.

## `maxLeads` (type: `integer`):

Maximum number of unique dental practices to return. Lower values reduce cost and runtime.

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

Language for Google Maps results. Controls returned categories and addresses.

## `countryCode` (type: `string`):

Country targeting for Google search (gl parameter). Helps return dental practices relevant to the selected country.

## `minRating` (type: `number`):

Only include practices with at least this Google rating (1.0–5.0). Leave empty to include all.

## `requireWebsite` (type: `boolean`):

Only include dental practices that have a website URL listed on Google Maps.

## `requireEmail` (type: `boolean`):

Only include dental practices where an email address was found on the practice website. Requires website enrichment.

## `includeWebsiteEnrichment` (type: `boolean`):

Visit each dental practice website to extract emails and social media links. Disable for faster basic Google Maps exports.

## `enrichmentTimeoutSecs` (type: `integer`):

Timeout in seconds when fetching dental practice websites. Increase for slow sites, decrease for faster runs.

## `verifyEmails` (type: `boolean`):

When enabled, verify extracted emails and add format, MX, provider, and confidence signals.

## `verificationLevel` (type: `string`):

How deeply to verify each email. Format is fastest; MX is recommended; SMTP is slow and can be inconclusive.

## `dedupeStrategy` (type: `string`):

How to identify duplicate dental practices across query/location combinations.

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

Optional Apify proxy configuration. By default the actor uses direct requests because current Google Maps validation is faster and cheaper without proxy; enable proxy only if your searches are blocked.

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

Enable verbose logging for troubleshooting parser or enrichment issues.

## Actor input object example

```json
{
  "searchQueries": [
    "dentist",
    "orthodontist"
  ],
  "locations": [
    "Austin, TX"
  ],
  "maxLeads": 5,
  "language": "en",
  "countryCode": "US",
  "requireWebsite": false,
  "requireEmail": false,
  "includeWebsiteEnrichment": true,
  "enrichmentTimeoutSecs": 12,
  "verifyEmails": false,
  "verificationLevel": "mx",
  "dedupeStrategy": "placeIdAndAddress",
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "debugMode": 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 = {
    "searchQueries": [
        "dentist",
        "orthodontist"
    ],
    "locations": [
        "Austin, TX"
    ],
    "maxLeads": 5,
    "language": "en",
    "countryCode": "US",
    "includeWebsiteEnrichment": false,
    "enrichmentTimeoutSecs": 12,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/dentist-lead-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 = {
    "searchQueries": [
        "dentist",
        "orthodontist",
    ],
    "locations": ["Austin, TX"],
    "maxLeads": 5,
    "language": "en",
    "countryCode": "US",
    "includeWebsiteEnrichment": False,
    "enrichmentTimeoutSecs": 12,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/dentist-lead-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 '{
  "searchQueries": [
    "dentist",
    "orthodontist"
  ],
  "locations": [
    "Austin, TX"
  ],
  "maxLeads": 5,
  "language": "en",
  "countryCode": "US",
  "includeWebsiteEnrichment": false,
  "enrichmentTimeoutSecs": 12,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/dentist-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dentist Lead Scraper",
        "description": "🦷 Find dentist, orthodontist, and dental clinic leads from Google Maps with phones, websites, ratings, and optional email enrichment.",
        "version": "0.1",
        "x-build-id": "srBCElpRX6BxzcfKX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~dentist-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-dentist-lead-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/automation-lab~dentist-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-dentist-lead-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/automation-lab~dentist-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-dentist-lead-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Dental search queries",
                        "type": "array",
                        "description": "Dental business types or exact searches to run on Google Maps. Examples: dentist, dental clinic, orthodontist, pediatric dentist, emergency dentist.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities, regions, or countries to search. Examples: Austin, TX; Berlin, Germany; Toronto, Canada.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxLeads": {
                        "title": "Max dental leads",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique dental practices to return. Lower values reduce cost and runtime.",
                        "default": 100
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "de",
                            "es",
                            "fr",
                            "it",
                            "pt",
                            "nl",
                            "pl",
                            "ru",
                            "ja",
                            "ko",
                            "zh",
                            "ar",
                            "tr"
                        ],
                        "type": "string",
                        "description": "Language for Google Maps results. Controls returned categories and addresses.",
                        "default": "en"
                    },
                    "countryCode": {
                        "title": "Country code",
                        "enum": [
                            "US",
                            "GB",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "PT",
                            "NL",
                            "PL",
                            "AU",
                            "CA",
                            "BR",
                            "MX",
                            "JP",
                            "KR",
                            "IN",
                            "RU",
                            "TR",
                            "AE"
                        ],
                        "type": "string",
                        "description": "Country targeting for Google search (gl parameter). Helps return dental practices relevant to the selected country.",
                        "default": "US"
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only include practices with at least this Google rating (1.0–5.0). Leave empty to include all."
                    },
                    "requireWebsite": {
                        "title": "Require website",
                        "type": "boolean",
                        "description": "Only include dental practices that have a website URL listed on Google Maps.",
                        "default": false
                    },
                    "requireEmail": {
                        "title": "Require email",
                        "type": "boolean",
                        "description": "Only include dental practices where an email address was found on the practice website. Requires website enrichment.",
                        "default": false
                    },
                    "includeWebsiteEnrichment": {
                        "title": "Extract emails from practice websites",
                        "type": "boolean",
                        "description": "Visit each dental practice website to extract emails and social media links. Disable for faster basic Google Maps exports.",
                        "default": true
                    },
                    "enrichmentTimeoutSecs": {
                        "title": "Website timeout (secs)",
                        "minimum": 5,
                        "maximum": 45,
                        "type": "integer",
                        "description": "Timeout in seconds when fetching dental practice websites. Increase for slow sites, decrease for faster runs.",
                        "default": 15
                    },
                    "verifyEmails": {
                        "title": "Verify emails",
                        "type": "boolean",
                        "description": "When enabled, verify extracted emails and add format, MX, provider, and confidence signals.",
                        "default": false
                    },
                    "verificationLevel": {
                        "title": "Verification level",
                        "enum": [
                            "format",
                            "mx",
                            "smtp"
                        ],
                        "type": "string",
                        "description": "How deeply to verify each email. Format is fastest; MX is recommended; SMTP is slow and can be inconclusive.",
                        "default": "mx"
                    },
                    "dedupeStrategy": {
                        "title": "Dedupe strategy",
                        "enum": [
                            "placeId",
                            "placeIdAndAddress"
                        ],
                        "type": "string",
                        "description": "How to identify duplicate dental practices across query/location combinations.",
                        "default": "placeIdAndAddress"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy configuration. By default the actor uses direct requests because current Google Maps validation is faster and cheaper without proxy; enable proxy only if your searches are blocked."
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Enable verbose logging for troubleshooting parser or enrichment issues.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
