# Veterinarian & Pet Services Lead Scraper — Verified Emails (`samstorm/veterinarian-lead-scraper`) Actor

Find veterinarians, pet groomers, dog trainers, and pet service businesses on Google Maps. Get verified emails, phone numbers, addresses, and social links. CRM-ready for HubSpot.

- **URL**: https://apify.com/samstorm/veterinarian-lead-scraper.md
- **Developed by:** [Sam Kleespies](https://apify.com/samstorm) (community)
- **Categories:** Lead generation
- **Stats:** 7 total users, 5 monthly users, 94.7% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 enriched veterinary leads

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Veterinarian & Pet Services Lead Scraper — Verified Emails

Build a verified **veterinarian email list** from Google Maps in minutes. This actor scrapes vet clinics, animal hospitals, emergency vets, pet groomers, dog trainers, pet boarding facilities, and pet stores — returning verified emails, phone numbers, addresses, and ratings for every listing. Export a complete **vet clinic contact database** without purchasing outdated data broker files.

Built for pet pharmaceutical reps, veterinary software companies, pet food suppliers, pet insurance companies, veterinary equipment suppliers, and anyone who needs **animal hospital leads** or a targeted **pet services scraper** at scale — without expensive data subscriptions.

### Key Features

- **Google Maps search** — Find businesses by type and location, powered by Playwright
- **Email extraction** — Automatically visits business websites to find contact emails
- **DNS + SMTP verification** — Confirms email deliverability to reduce bounce rates
- **Social media links** — Extracts Facebook, Instagram, LinkedIn, and Twitter/X profiles
- **CRM-ready export** — Output in Full, HubSpot Import, or Salesforce Import format
- **Real-time data** — Fresh results scraped on demand, not a stale database

### What Data Do You Get?

Each record is pulled directly from Google Maps and enriched with email addresses crawled from the business website.

```json
{
  "name": "Westside Animal Hospital",
  "category": "Veterinarian",
  "address": "1420 Westside Blvd, Austin, TX 78701",
  "phone": "(555) 842-1100",
  "website": "https://westsideanimalhospital.com",
  "mapsUrl": "https://www.google.com/maps/place/...",
  "rating": 4.8,
  "reviewCount": 312,
  "email": "info@westsideanimalhospital.com",
  "emailVerified": true,
  "emailVerificationStatus": "smtp_verified",
  "emailVerificationNote": "Verified via SMTP",
  "allEmails": [{"address": "info@westsideanimalhospital.com", "verified": true, "status": "smtp_verified", "verificationNote": "Verified via SMTP"}],
  "socialLinks": {"facebook": "https://facebook.com/westsideanimalhospital"}
}
````

### Use Cases

- **Veterinary product and pharmaceutical sales**: Build a targeted veterinarian email list by city or sales territory to pitch pet pharmaceuticals, vaccines, flea/tick treatments, or medical equipment directly to clinic owners and practice managers.
- **Pet food and nutrition companies**: Reach vet clinics that recommend prescription diets and therapeutic foods. A verified vet clinic email list lets pet food brands pitch directly to the practitioners who influence purchasing decisions.
- **Veterinary software and SaaS**: Find veterinarian emails to promote scheduling tools, practice management software, telemedicine platforms, or payment processing tailored to the animal care sector.
- **Pet insurance companies**: Source animal hospital leads to build referral partnerships. Vet clinics are primary referral channels for pet insurance — connect with practice managers and clinic owners at scale.
- **Local partnership development**: Source vet clinic leads in specific ZIP codes to establish referral networks between complementary businesses — groomers, trainers, boarding facilities, and clinics.
- **Pet services marketing campaigns**: Compile a pet services contact list across an entire metro area or state to run email or direct mail campaigns promoting insurance, supplies, or co-marketing partnerships.
- **Market research and competitive analysis**: Map the density of veterinary practices and pet businesses across regions, analyze ratings, and identify underserved markets before expanding or launching.

### How It Works

**Phase 1 — Search Google Maps**: The actor sends queries to Google Maps for each specified business type and location, paginating through all available results to capture every listing — not just the top 20 shown in a standard browser search.

**Phase 2 — Profile Extraction**: For each listing, it extracts the structured data panel: business name, category, phone, website URL, full address, star rating, review count, and Google Maps URL.

**Phase 3 — Email Discovery**: The actor visits each business website and crawls the homepage, contact page, and footer to locate verified email addresses. Candidates are deduplicated and checked via DNS/MX lookup and SMTP handshake without sending any mail.

**Phase 4 — Output and Delivery**: Results are written to the Apify dataset in real time. Export to JSON, CSV, or Excel, or push to HubSpot and Salesforce directly using the built-in output format options.

### Input Options

| Parameter | Type | Description |
|-|-|-|
| `businessType` | select | Pet business type (Veterinarian, Emergency Vet, Pet Groomer, Dog Trainer, Pet Boarding, Pet Store, Custom) |
| `location` | string | City, state, or ZIP code (e.g., "Austin, TX" or "78701") |
| `searchQuery` | string | Custom query, used only when businessType is "Custom" |
| `maxResults` | integer | Maximum records to return (default: 50, max: 500) |
| `enrichEmails` | boolean | Enable website crawl for email discovery (default: true) |
| `verifyEmails` | boolean | Run DNS/SMTP email verification (default: true) |
| `enrichSocials` | boolean | Extract Facebook, Instagram, LinkedIn, Twitter/X links (default: true) |
| `outputFormat` | string | full, hubspot, or salesforce |

### Output Formats

**Full Output** — All scraped and enriched fields: business name, category, verified email, phone, website, full address, rating, review count, social media links, and Google Maps URL. Best for custom pipelines or segmented CRM imports.

**HubSpot-Ready** — Columns pre-mapped to HubSpot Contact and Company properties. Import directly via HubSpot's CSV import without any column remapping. Includes `Company Name`, `Email`, `Phone Number`, `Street Address`, `Website URL`, `Google Maps URL`, `Rating`, `Number of Reviews`, `Industry`, `Facebook Company Page`, `LinkedIn Company Page`, `Twitter Handle`.

**Salesforce-Ready** — Fields aligned to the Salesforce Lead object: `Account Name`, `Phone`, `Website`, `Billing Street`, `Email__c`, `Rating__c`, `Review_Count__c`, `Google_Maps_URL__c`, `Facebook__c`, `LinkedIn__c`, `Industry`.

### Why Choose This Over Apollo or ZoomInfo?

| Feature | This Actor | Apollo / ZoomInfo |
|-|-|-|
| Veterinarian and pet business coverage | Comprehensive via Google Maps | Sparse — focused on tech and enterprise |
| Local vet clinic leads | Extracted fresh on each run | Static database, often incomplete |
| Verified emails from actual websites | Yes — crawled in real time | Aged records, variable accuracy |
| Cost per lead | Cents at scale | $0.50–$3.00+ per contact |
| Geographic precision | Any city, ZIP, or radius | Limited local granularity |
| Subscription required | No — pay per run on Apify | Monthly or annual contract |

Apollo and ZoomInfo are optimized for enterprise SaaS prospecting. For building a veterinarian email list, finding pet groomer contacts, or compiling veterinary marketing leads for local or regional campaigns, this actor delivers far better coverage at a fraction of the cost.

### Use via Apify API

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

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

const run = await client.actor('samstorm/veterinarian-lead-scraper').call({
    businessType: 'Veterinarian',
    location: 'Dallas, TX',
    maxResults: 50,
    enrichEmails: true,
    verifyEmails: true,
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('samstorm/veterinarian-lead-scraper').call(run_input={
    'businessType': 'Veterinarian',
    'location': 'Denver, CO',
    'maxResults': 100,
    'enrichEmails': True,
    'verifyEmails': True,
    'outputFormat': 'hubspot',
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(f'Got {len(items)} veterinary leads')
```

### Multi-Location Workflows

Google Maps returns up to ~120 results per search query, so large-scale prospecting requires running the actor once per city or metro area and merging the datasets.

**Option 1: Apify API loop** — Call the actor programmatically for each location:

```javascript
const locations = ['Denver, CO', 'Boulder, CO', 'Fort Collins, CO', 'Colorado Springs, CO'];

for (const location of locations) {
    const run = await client.actor('samstorm/veterinarian-lead-scraper').call({
        businessType: 'Veterinarian',
        location,
        maxResults: 200,
        enrichEmails: true,
        verifyEmails: true,
    });
    console.log(`Completed ${location}: run ${run.id}`);
}
```

**Option 2: Apify Schedules** — Set up a schedule in the Apify Console that triggers runs for different locations on a recurring basis. Use a separate Saved Task for each city.

**Deduplication across runs:** Each run deduplicates internally by business name + address. When merging datasets from multiple runs, deduplicate on the same key to remove businesses that appear in overlapping metro areas.

### Integrations

This actor works with the full Apify ecosystem and popular automation platforms:

- **Apify API & Webhooks** — Trigger runs programmatically and receive results via webhook when complete
- **Zapier** — Connect to 5,000+ apps using the [Apify Zapier integration](https://zapier.com/apps/apify)
- **Make (Integromat)** — Build multi-step automations with the [Apify Make module](https://www.make.com/en/integrations/apify)
- **Google Sheets** — Export results directly to a spreadsheet using Apify's built-in Google Sheets integration
- **Slack** — Get notified in Slack when a run completes using Apify's webhook notifications

### Frequently Asked Questions

**How do I get a veterinarian email list for my sales territory?**
Set `location` to a city or ZIP code in your territory and `businessType` to `Veterinarian`. Run multiple location queries to cover your full territory and merge the results. The actor queries Google Maps for every matching clinic, visits each website, and returns a verified email list — typically covering a metro area in under 30 minutes.

**How much does a vet clinic contact database cost?**
Veterinary-specific lists from data vendors like AVMA or specialty brokers typically cost $1,000–$5,000 for a one-time file that ages immediately. This actor charges per verified lead at a fraction of that cost, with no subscription, no contract, and you can re-run it monthly to capture new practices and updated contact info — so your animal hospital leads never go stale.

**What types of pet businesses can I find?**
Veterinarians, emergency veterinary clinics, animal hospitals, pet groomers, dog trainers, pet boarding facilities, and pet stores are all supported as native search categories. Run multiple types in one job and the actor returns a single deduplicated dataset with a `category` field for easy segmentation.

**Can I export vet leads to HubSpot or Salesforce?**
Yes. Set `outputFormat` to `hubspot` or `salesforce` before running. HubSpot output maps to standard Contact and Company properties for direct CSV import; Salesforce output aligns to the Lead object and is compatible with Data Loader and standard import flows.

**How accurate are the emails in the veterinarian lead list?**
Each email is checked with a DNS MX lookup confirming the domain accepts mail, followed by an SMTP handshake verifying the specific mailbox exists — without sending a message. The `emailVerified` flag on each record lets you filter to high-confidence addresses before importing to your CRM. Verified addresses typically deliver at 85–95% inbox rate.

**How is this different from buying a vet list from a data broker?**
Broker lists are static files that can be 12–24 months out of date. New clinics open, practices merge, and contact emails change constantly — none of which is reflected in an aged database purchase. This pet services scraper queries Google Maps and crawls each practice website live on every run, capturing recently opened clinics and current contact info. You get fresh veterinarian leads every time, not recycled data.

**Can pet food suppliers and pet insurance companies use this?**
Yes — these are two of the strongest use cases. Pet food companies use this actor to build a vet clinic email list for pitching prescription diets, therapeutic foods, and sample programs to practice managers. Pet insurance companies use it to identify and contact animal hospitals for referral partnership programs. Both benefit from the geographic targeting: run the actor for specific states, metro areas, or ZIP codes where you want to grow distribution or referral volume.

**Can I use this to find emergency vet clinics separately from general practice vets?**
Yes. Set `businessType` to `Emergency Vet` to target emergency animal hospitals specifically. Emergency animal hospitals have distinct operational needs — 24-hour staffing software, specialized equipment suppliers, and different pharmaceutical purchasing patterns — making them a valuable segment to target independently.

### Getting Started

1. [Create a free Apify account](https://apify.com) if you do not already have one.
2. Open the Veterinarian Lead Scraper actor page and click **Try for free**.
3. Enter your target `businessType` and `location` in the input form.
4. Click **Start** and watch verified leads appear in your dataset in real time.
5. Export your veterinary marketing leads as CSV or JSON, or connect directly to HubSpot or Salesforce using the built-in output formats.

For bulk runs, custom territory builds, or dedicated support, reach out through the Apify actor page.

### Recent Updates

- **March 2026** — Version 1.0 release: production-ready with verified email pipeline
- **March 2026** — Optimized proxy usage with aggressive resource blocking — ~50% cost reduction per run
- **March 2026** — Added fail-fast error recovery: blocked requests abort immediately instead of retrying
- **March 2026** — Added social media link extraction (Facebook, Instagram, LinkedIn, Twitter/X)

### Related Lead Scrapers by samstorm

Build a complete prospecting database across industries with verified email enrichment:

| Actor | What It Does | Best For | Try It |
|---|---|---|---|
| [Dentist Lead Scraper](https://apify.com/samstorm/dentist-lead-scraper) | Verified emails from dental & medical practices | Dental supply sales, healthcare SaaS, medical recruiters | [Try free](https://apify.com/samstorm/dentist-lead-scraper) |
| [Contractor Lead Scraper](https://apify.com/samstorm/contractor-lead-scraper) | HVAC, plumber, roofer, electrician contacts | Construction suppliers, trade insurance, home service SaaS | [Try free](https://apify.com/samstorm/contractor-lead-scraper) |
| [Lawyer Lead Scraper](https://apify.com/samstorm/lawyer-lead-scraper) | Attorney & law firm contact extraction | Legal tech sales, court reporting services, legal marketing | [Try free](https://apify.com/samstorm/lawyer-lead-scraper) |
| [Restaurant Lead Scraper](https://apify.com/samstorm/restaurant-lead-scraper) | Restaurant, bar, and cafe owner contacts | Food suppliers, POS system sales, restaurant tech | [Try free](https://apify.com/samstorm/restaurant-lead-scraper) |
| [Real Estate Lead Scraper](https://apify.com/samstorm/real-estate-lead-scraper) | Agent, broker, and property manager emails | Mortgage lenders, PropTech, real estate marketing | [Try free](https://apify.com/samstorm/real-estate-lead-scraper) |
| [Auto Dealer Lead Scraper](https://apify.com/samstorm/auto-dealer-lead-scraper) | Car dealership and auto shop contacts | Auto parts suppliers, dealer management software, F\&I products | [Try free](https://apify.com/samstorm/auto-dealer-lead-scraper) |
| [Wedding Vendor Lead Scraper](https://apify.com/samstorm/wedding-vendor-lead-scraper) | Venue, photographer, planner contacts | Wedding SaaS platforms, bridal advertising | [Try free](https://apify.com/samstorm/wedding-vendor-lead-scraper) |
| [Financial Advisor Lead Scraper](https://apify.com/samstorm/financial-advisor-lead-scraper) | Financial advisor and insurance agent emails | FinTech sales, compliance software, wealth management | [Try free](https://apify.com/samstorm/financial-advisor-lead-scraper) |
| [B2B Lead Enrichment](https://apify.com/samstorm/lead-enrichment-actor) | Google Maps to CRM for any business type | General B2B prospecting, custom niche research | [Try free](https://apify.com/samstorm/lead-enrichment-actor) |

[See all actors by samstorm](https://apify.com/samstorm)

### Why Use This Instead of a General Google Maps Scraper?

The general-purpose Google Maps Scraper on Apify costs $4-10 per 1,000 results but requires you to chain multiple actors, configure filters manually, and pay extra for email enrichment. Here is what you get with this dedicated Veterinarian scraper that you will not get from a general tool:

| Feature | General Google Maps Scraper | This Actor |
|-|-|-|
| Pre-filtered veterinarian results | No — returns mixed in | Yes — every result is a veterinarian |
| Verified email addresses | Extra add-on ($0.002/place) | Built-in, included in price |
| Email deliverability check (DNS+SMTP) | Not available | Built-in |
| Social media profiles | Extra add-on | Built-in |
| CRM-ready export (HubSpot, Salesforce) | Not available | Built-in |
| Single-actor simplicity | Need 2-3 actors chained | One actor, one click |

#### What you get in a single run

1. Search Google Maps for veterinarian businesses in any location
2. Automatically crawl each business website for email addresses
3. Verify every email with DNS and SMTP checks
4. Extract social media profiles (Facebook, Instagram, LinkedIn, Twitter)
5. Export in your choice of format: Full JSON, HubSpot Import, or Salesforce Import

No coding required. No API keys needed. No multi-actor pipelines to configure.

### Limitations

- Google Maps typically returns up to ~120 results per search query. Use multiple locations for larger datasets.
- Email extraction depends on the business having a website with visible contact info. Businesses using only contact forms won't have emails extracted.
- SMTP verification may be blocked by some mail servers, resulting in "unknown" status rather than confirmed valid/invalid.
- This actor finds business/professional emails only, not personal consumer emails.

### Help Us Improve

If this actor saves you time, please consider leaving a review on the Apify Store. Your feedback helps other users discover this tool and helps us improve it. You can also report issues or request features through the Issues tab on the actor page.

# Actor input Schema

## `businessType` (type: `string`):

Select the type of veterinary or pet service business to find on Google Maps. The actor automatically constructs the search using this type plus your location — for example, 'Veterinarian' finds general vet clinics and animal hospitals, while 'Emergency Vet' targets 24-hour emergency animal hospitals specifically. Choose 'Custom' to write your own query (e.g., 'exotic animal vets in Denver, CO' or 'mobile veterinarians in Austin, TX').

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

The city, state, or region to search for veterinarian leads and pet service businesses. Use 'City, ST' format for US locations (e.g., 'Denver, CO' or 'Phoenix, AZ'). You can also use ZIP codes, neighborhoods, or broader regions like 'Cherry Creek, CO' or 'Southern California'. Run multiple locations to cover a full sales territory.

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

A raw Google Maps search query, used only when Business Type is set to 'Custom'. For all other types, the search is built automatically from Business Type + Location. Write queries the same way you would type them into Google Maps — for example: 'exotic animal vets in Denver, CO', 'mobile veterinarians in Austin, TX', 'equine veterinarians in Kentucky', or 'animal hospitals near Phoenix, AZ'.

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

The maximum number of veterinarian leads to collect and return. The prefill is set to 3 for a quick test run — increase to 50–200 for production use. Google Maps typically returns up to 120 results per search query; run multiple city queries and merge to build a larger vet clinic email list.

## `enrichEmails` (type: `boolean`):

When enabled, the actor visits each vet clinic or pet business website and scans contact pages, footers, and about pages to extract email addresses. Disable if you only need phone numbers and addresses, or want faster results without website crawling.

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

When enabled, each extracted email address is checked using DNS (MX record lookup) and an SMTP handshake to confirm the mailbox exists and can receive mail. This adds roughly 1 extra minute to the run but significantly reduces bounce rates. Only applies when 'Find Email Addresses' is also enabled.

## `enrichSocials` (type: `boolean`):

When enabled, the actor scans each business website for links to social media profiles including Facebook, Instagram, LinkedIn, and Twitter/X. These links are included in the output and are useful for multi-channel outreach and account-based marketing.

## `outputFormat` (type: `string`):

Controls the structure of the output dataset. 'Full' returns all available fields. 'HubSpot Import' reformats the data to match HubSpot's CSV import column names for direct upload. 'Salesforce Import' reformats for Salesforce data import. All formats are available in Apify's dataset export (CSV, JSON, Excel).

## `proxyUrl` (type: `string`):

Optional HTTP proxy URL for using third-party residential proxies instead of Apify's built-in proxies. Format: http://username:password@host:port. Compatible with IPRoyal, Smartproxy, Bright Data, and other rotating proxy services. Leave empty to use Apify's default residential proxies.

## Actor input object example

```json
{
  "businessType": "Pet Groomer",
  "location": "Denver, CO",
  "searchQuery": "exotic animal vets in Denver, CO",
  "maxResults": 50,
  "enrichEmails": true,
  "verifyEmails": true,
  "enrichSocials": true,
  "outputFormat": "hubspot",
  "proxyUrl": "http://user:pass@proxy.example.com:8080"
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "location": "Denver, CO",
    "searchQuery": "veterinarians in Denver, CO",
    "maxResults": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("samstorm/veterinarian-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 = {
    "location": "Denver, CO",
    "searchQuery": "veterinarians in Denver, CO",
    "maxResults": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("samstorm/veterinarian-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 '{
  "location": "Denver, CO",
  "searchQuery": "veterinarians in Denver, CO",
  "maxResults": 3
}' |
apify call samstorm/veterinarian-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Veterinarian & Pet Services Lead Scraper — Verified Emails",
        "description": "Find veterinarians, pet groomers, dog trainers, and pet service businesses on Google Maps. Get verified emails, phone numbers, addresses, and social links. CRM-ready for HubSpot.",
        "version": "1.0",
        "x-build-id": "0IEe98J9BiJCp2zH8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/samstorm~veterinarian-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-samstorm-veterinarian-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/samstorm~veterinarian-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-samstorm-veterinarian-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/samstorm~veterinarian-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-samstorm-veterinarian-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": [
                    "businessType",
                    "location"
                ],
                "properties": {
                    "businessType": {
                        "title": "Business Type",
                        "enum": [
                            "Veterinarian",
                            "Emergency Vet",
                            "Pet Groomer",
                            "Dog Trainer",
                            "Pet Boarding",
                            "Pet Store",
                            "Custom"
                        ],
                        "type": "string",
                        "description": "Select the type of veterinary or pet service business to find on Google Maps. The actor automatically constructs the search using this type plus your location — for example, 'Veterinarian' finds general vet clinics and animal hospitals, while 'Emergency Vet' targets 24-hour emergency animal hospitals specifically. Choose 'Custom' to write your own query (e.g., 'exotic animal vets in Denver, CO' or 'mobile veterinarians in Austin, TX').",
                        "default": "Veterinarian"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "The city, state, or region to search for veterinarian leads and pet service businesses. Use 'City, ST' format for US locations (e.g., 'Denver, CO' or 'Phoenix, AZ'). You can also use ZIP codes, neighborhoods, or broader regions like 'Cherry Creek, CO' or 'Southern California'. Run multiple locations to cover a full sales territory."
                    },
                    "searchQuery": {
                        "title": "Custom Search Query",
                        "type": "string",
                        "description": "A raw Google Maps search query, used only when Business Type is set to 'Custom'. For all other types, the search is built automatically from Business Type + Location. Write queries the same way you would type them into Google Maps — for example: 'exotic animal vets in Denver, CO', 'mobile veterinarians in Austin, TX', 'equine veterinarians in Kentucky', or 'animal hospitals near Phoenix, AZ'."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "The maximum number of veterinarian leads to collect and return. The prefill is set to 3 for a quick test run — increase to 50–200 for production use. Google Maps typically returns up to 120 results per search query; run multiple city queries and merge to build a larger vet clinic email list.",
                        "default": 50
                    },
                    "enrichEmails": {
                        "title": "Find Email Addresses",
                        "type": "boolean",
                        "description": "When enabled, the actor visits each vet clinic or pet business website and scans contact pages, footers, and about pages to extract email addresses. Disable if you only need phone numbers and addresses, or want faster results without website crawling.",
                        "default": true
                    },
                    "verifyEmails": {
                        "title": "Verify Email Deliverability",
                        "type": "boolean",
                        "description": "When enabled, each extracted email address is checked using DNS (MX record lookup) and an SMTP handshake to confirm the mailbox exists and can receive mail. This adds roughly 1 extra minute to the run but significantly reduces bounce rates. Only applies when 'Find Email Addresses' is also enabled.",
                        "default": true
                    },
                    "enrichSocials": {
                        "title": "Find Social Media Links",
                        "type": "boolean",
                        "description": "When enabled, the actor scans each business website for links to social media profiles including Facebook, Instagram, LinkedIn, and Twitter/X. These links are included in the output and are useful for multi-channel outreach and account-based marketing.",
                        "default": true
                    },
                    "outputFormat": {
                        "title": "Output Format",
                        "enum": [
                            "full",
                            "hubspot",
                            "salesforce"
                        ],
                        "type": "string",
                        "description": "Controls the structure of the output dataset. 'Full' returns all available fields. 'HubSpot Import' reformats the data to match HubSpot's CSV import column names for direct upload. 'Salesforce Import' reformats for Salesforce data import. All formats are available in Apify's dataset export (CSV, JSON, Excel).",
                        "default": "full"
                    },
                    "proxyUrl": {
                        "title": "Custom Proxy URL (optional)",
                        "type": "string",
                        "description": "Optional HTTP proxy URL for using third-party residential proxies instead of Apify's built-in proxies. Format: http://username:password@host:port. Compatible with IPRoyal, Smartproxy, Bright Data, and other rotating proxy services. Leave empty to use Apify's default residential proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```