# VetLocator - US Veterinarian & Pet Pro Directory Scraper (`crawlerbros/vetlocator-scraper`) Actor

Scrape VetLocator.com's US veterinary directory. Search by zip code + radius or by city/state across general practice, emergency, holistic/alternative, house-call, equine vets and other pet professionals. Get names, addresses, phone numbers, and more.

- **URL**: https://apify.com/crawlerbros/vetlocator-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## VetLocator Scraper

Scrape **VetLocator.com** — a nationwide US directory of veterinary clinics, animal hospitals, and other pet professionals. Search by zip code + radius (with fine-grained category and specialty filters) or by city and state to get clinic names, full addresses, phone numbers, and more. HTTP-only, no login, no API key required.

### What this actor does

- **Two search modes:** by zip code + radius, or by city + state
- **Six curated categories:** general practice, emergency/24-hour, holistic & alternative, house-call/mobile, equine/horse, and other pet professionals (groomers, sitters, trainers, etc.)
- **Advanced filters:** narrow by animal type treated (dogs, cats, exotics, horses, birds, reptiles...), veterinary specialty/procedure (dental, cardiology, surgery, vaccinations...), or holistic modality (acupuncture, chiropractic, homeopathy...) — combinable
- **Full contact enrichment:** fetches each clinic's own page for phone number, email, website, description and more
- **Premium-listing enrichment:** for VetLocator's featured Silver/Gold clinics, also pulls weekly hours, veterinarian/staff names, animal types treated, specialties, payment methods, insurance accepted, and current promotional specials — whatever the clinic itself has published
- **Distance-aware:** miles from your search zip code, when the source provides it
- **Empty fields are omitted** — you never get a field with `null`, `""`, or a placeholder value

### Output per clinic

- `clinicId` — VetLocator's internal listing ID
- `name` — business name
- `isVeterinarian` — `true` for licensed veterinary practices, `false` for non-medical pet professionals (groomers, sitters, trainers, etc.)
- `listingTier` — `standard`, `bronze`, `silver`, or `gold`, reflecting how VetLocator itself features the listing. Silver/Gold clinics carry the richest data (see below).
- `streetAddress`, `city`, `state`, `zip`, `fullAddress`
- `distanceMiles` — distance from the searched zip code (when available)
- `locationNote` — a proximity note such as "within 10001 zipcode" when an exact distance isn't given
- `phone`, `email`, `website` — when the listing provides them
- `description` — the clinic's own "About" text, when provided
- `specialOffers` — current promotions/coupons the clinic has published (Silver/Gold listings only, when present)
- `hours` — weekly opening hours as `{"monday": "9:00 am - 5:00 pm", ...}`, only for the days the clinic publishes (Silver/Gold listings)
- `staffNames` — named veterinarians/staff (Silver/Gold listings, when published)
- `animalTypesTreated` — species the clinic treats, e.g. `["Cats", "Dogs", "Horses"]` (Silver/Gold listings)
- `veterinarySpecialties` — medical services/procedures offered, e.g. `["Dental", "Vaccinations"]` (Silver/Gold listings)
- `holisticModalities` — alternative/holistic services offered, e.g. `["Acupuncture"]` (Silver/Gold listings)
- `clinicServicesOffered` — non-medical amenities, e.g. `["Boarding", "Grooming"]` (Silver/Gold listings)
- `paymentMethods` — accepted payment types, e.g. `["VISA", "Mastercard"]` (Silver/Gold listings)
- `insuranceAccepted` — pet insurance providers accepted, e.g. `["CareCredit"]` (Silver/Gold listings)
- `sourceUrl` — the clinic's page on VetLocator.com
- `googleMapsUrl` — a ready-to-open Google Maps search link for the clinic's address
- `recordType: "clinic"`, `scrapedAt`

If a search input is invalid (e.g. an unresolvable zip code), the actor pushes a single typed record with `recordType: "error"`, `errorType`, and `message` instead of crashing.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byZip` | `byZip` or `byCity` |
| `zip` | string | `10001` | 5-digit US zip code (mode=byZip) |
| `radius` | string | `25` | Search radius in miles: `5`/`10`/`15`/`25`/`50`/`100` (mode=byZip) |
| `city` | string | `Los Angeles` | US city name (mode=byCity) |
| `state` | string | – | 2-letter US state code (mode=byCity) |
| `category` | string | `general` | `general` / `emergency` / `holistic` / `housecall` / `equine` / `otherPetProfessional` (mode=byZip; ignored if any Advanced filter is set) |
| `otherPetProfessionalService` | string | – | Required when category=otherPetProfessional |
| `animalType` | string | – | Advanced filter: species treated (mode=byZip) |
| `vetSpecialty` | string | – | Advanced filter: veterinary specialty/procedure (mode=byZip) |
| `holisticModality` | string | – | Advanced filter: holistic/alternative modality (mode=byZip) |
| `clinicService` | string | – | Advanced filter: amenity/service offered (mode=byZip) |
| `fetchDetails` | boolean | `true` | Fetch phone/email/description per clinic (slower, richer) |
| `maxItems` | integer | `20` | Hard cap on emitted records (1–2000) |
| `proxyConfiguration` | object | AUTO | Automatic fallback proxy; not required for normal use |

Advanced filters (`animalType`, `vetSpecialty`, `holisticModality`, `clinicService`) only apply in `byZip` mode and can be combined with each other. When any is set, they take priority over `category`. City search (`byCity`) returns VetLocator's base listing for that city only — category and advanced filters are not supported by the source for city search.

#### Example: emergency vets near a zip code

```json
{
  "mode": "byZip",
  "zip": "60601",
  "radius": "25",
  "category": "emergency",
  "maxItems": 50
}
````

#### Example: holistic/acupuncture vets

```json
{
  "mode": "byZip",
  "zip": "94103",
  "radius": "50",
  "holisticModality": "54",
  "maxItems": 50
}
```

#### Example: groomers and pet-sitters near a zip code

```json
{
  "mode": "byZip",
  "zip": "33101",
  "radius": "25",
  "category": "otherPetProfessional",
  "otherPetProfessionalService": "43",
  "maxItems": 50
}
```

#### Example: all vets in a city

```json
{
  "mode": "byCity",
  "city": "Austin",
  "state": "TX",
  "maxItems": 100
}
```

### Use cases

- **Pet-care marketplaces** — build a local veterinarian directory for your app or site
- **Local SEO / lead generation** — find veterinary businesses to reach out to in a territory
- **Insurance & fintech** — verify a policyholder's local pet-care providers
- **Relocation services** — hand new residents a list of nearby vets, emergency clinics, and pet pros
- **Market research** — measure veterinary/pet-services density across zip codes or cities
- **Pet-owner apps** — power a "find a vet near me" feature with real contact data

### FAQ

**What is VetLocator.com?** A US-focused online directory of veterinary clinics, animal hospitals, and pet-service professionals, searchable by location and specialty.

**Is this affiliated with VetLocator.com?** No — this is an independent, third-party actor that reads VetLocator's publicly accessible directory pages.

**What's the difference between `category` and the Advanced filters?** `category` picks one of VetLocator's five main directory tabs (general/emergency/holistic/housecall/equine) plus "other pet professional." The Advanced filters (`animalType`, `vetSpecialty`, `holisticModality`, `clinicService`) are a separate, more granular facet search that can combine multiple criteria at once (e.g., "dogs" + "dental"). Setting any Advanced filter overrides `category` for that run.

**Why do some records have `distanceMiles` and others have `locationNote` instead?** VetLocator reports either an exact mileage from your search zip code, or — for listings very close to it — a proximity note like "within 10001 zipcode" instead of a computed distance. The actor passes through whichever the source provides; it never fabricates a distance.

**Why do some clinics have no `phone` or `email`?** Not every listing on VetLocator includes complete contact details — some are minimal/free directory entries. The actor only ever emits fields the source actually provides.

**What does `isVeterinarian: false` mean?** VetLocator's directory also includes non-medical pet professionals (groomers, trainers, pet-sitters, rescues, etc.). These are flagged `isVeterinarian: false` so you can filter them out if you only want licensed veterinary practices.

**Does city search support the same filters as zip search?** No — VetLocator's city+state search only returns its base "all veterinarians and pet pros in this city" listing. Category and Advanced filters require a zip code + radius search.

**Why might a large city return fewer records than the result count shown on VetLocator's own city page?** VetLocator's city-search pagination is not perfectly stable — re-requesting the next page can reshuffle ordering and reissue clinics already seen a page or two earlier. The actor fetches every page up to the source's own final (short) page and dedupes by clinic ID, but this server-side overlap means the number of *unique* clinics actually reachable through pagination can run somewhat below the headline result count for high-volume cities. This is a source-side limitation, not a bug in the actor.

**Why do only some clinics have `email`, `description`, `hours`, `staffNames`, `website`, or service/payment lists?** These come from VetLocator's paid Bronze/Silver/Gold listing tiers (`listingTier`), which is where clinics publish that level of detail. The free/unbadged "standard" tier — the large majority of listings — only ever provides name, address, and (when `fetchDetails` is on) phone; VetLocator's own clinic pages never include an email address or an "About" section for those. The actor never fabricates the richer fields for a listing that doesn't have them.

**How fresh is the data?** VetLocator listings are maintained by the businesses themselves and by the site's editorial team; the actor always reads the live page, so data is as current as the source.

# Actor input Schema

## `mode` (type: `string`):

How to locate clinics: by zip code + radius (supports category & advanced filters), or by city/state (base listing only, no filters).

## `zip` (type: `string`):

US 5-digit zip code to search around.

## `radius` (type: `string`):

Distance in miles around the zip code to search.

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

US city name to search.

## `state` (type: `string`):

US state for the city search.

## `category` (type: `string`):

Curated VetLocator category tab. Ignored if any Advanced filter below is set. Not supported in mode=byCity.

## `otherPetProfessionalService` (type: `string`):

Required when category=otherPetProfessional. The non-medical pet service to search for.

## `animalType` (type: `string`):

Only clinics that treat this animal type. Combinable with other Advanced filters; overrides Category when set.

## `vetSpecialty` (type: `string`):

Only clinics offering this specific procedure/specialty. Combinable with other Advanced filters; overrides Category when set.

## `holisticModality` (type: `string`):

Only clinics offering this holistic/alternative modality. Combinable with other Advanced filters; overrides Category when set.

## `clinicService` (type: `string`):

Only clinics offering this amenity/service (broader than the Other Pet Professional category - includes vets too). Combinable with other Advanced filters; overrides Category when set.

## `fetchDetails` (type: `boolean`):

Fetch each clinic's detail page for phone number, plus email/description/hours/website when the listing's paid tier includes them. Slower but much richer data. Turn off for a fast name+address-only scrape.

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

Hard cap on emitted records.

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

VetLocator works without a proxy in normal conditions. This is only used as an automatic fallback if the site starts blocking datacenter IPs (403/429). Leave on the free AUTO group.

## Actor input object example

```json
{
  "mode": "byZip",
  "zip": "10001",
  "radius": "25",
  "city": "Los Angeles",
  "state": "CA",
  "category": "general",
  "otherPetProfessionalService": "",
  "animalType": "",
  "vetSpecialty": "",
  "holisticModality": "",
  "clinicService": "",
  "fetchDetails": true,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `clinics` (type: `string`):

Dataset containing all scraped clinic / pet-pro listings.

# 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 = {
    "mode": "byZip",
    "zip": "10001",
    "radius": "25",
    "city": "Los Angeles",
    "state": "CA",
    "category": "general",
    "otherPetProfessionalService": "",
    "animalType": "",
    "vetSpecialty": "",
    "holisticModality": "",
    "clinicService": "",
    "fetchDetails": true,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/vetlocator-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 = {
    "mode": "byZip",
    "zip": "10001",
    "radius": "25",
    "city": "Los Angeles",
    "state": "CA",
    "category": "general",
    "otherPetProfessionalService": "",
    "animalType": "",
    "vetSpecialty": "",
    "holisticModality": "",
    "clinicService": "",
    "fetchDetails": True,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/vetlocator-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 '{
  "mode": "byZip",
  "zip": "10001",
  "radius": "25",
  "city": "Los Angeles",
  "state": "CA",
  "category": "general",
  "otherPetProfessionalService": "",
  "animalType": "",
  "vetSpecialty": "",
  "holisticModality": "",
  "clinicService": "",
  "fetchDetails": true,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/vetlocator-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "VetLocator - US Veterinarian & Pet Pro Directory Scraper",
        "description": "Scrape VetLocator.com's US veterinary directory. Search by zip code + radius or by city/state across general practice, emergency, holistic/alternative, house-call, equine vets and other pet professionals. Get names, addresses, phone numbers, and more.",
        "version": "1.0",
        "x-build-id": "lO1oDfoZzfR8Sty0c"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~vetlocator-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-vetlocator-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/crawlerbros~vetlocator-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-vetlocator-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/crawlerbros~vetlocator-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-vetlocator-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "byZip",
                            "byCity"
                        ],
                        "type": "string",
                        "description": "How to locate clinics: by zip code + radius (supports category & advanced filters), or by city/state (base listing only, no filters).",
                        "default": "byZip"
                    },
                    "zip": {
                        "title": "Zip code (mode=byZip)",
                        "type": "string",
                        "description": "US 5-digit zip code to search around.",
                        "default": "10001"
                    },
                    "radius": {
                        "title": "Search radius (mode=byZip)",
                        "enum": [
                            "5",
                            "10",
                            "15",
                            "25",
                            "50",
                            "100"
                        ],
                        "type": "string",
                        "description": "Distance in miles around the zip code to search.",
                        "default": "25"
                    },
                    "city": {
                        "title": "City (mode=byCity)",
                        "type": "string",
                        "description": "US city name to search."
                    },
                    "state": {
                        "title": "State (mode=byCity)",
                        "enum": [
                            "",
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "DC",
                            "FL",
                            "GA",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NC",
                            "ND",
                            "OH",
                            "OK",
                            "OR",
                            "PA",
                            "RI",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY"
                        ],
                        "type": "string",
                        "description": "US state for the city search.",
                        "default": ""
                    },
                    "category": {
                        "title": "Category (mode=byZip)",
                        "enum": [
                            "general",
                            "emergency",
                            "holistic",
                            "housecall",
                            "equine",
                            "otherPetProfessional"
                        ],
                        "type": "string",
                        "description": "Curated VetLocator category tab. Ignored if any Advanced filter below is set. Not supported in mode=byCity.",
                        "default": "general"
                    },
                    "otherPetProfessionalService": {
                        "title": "Other pet professional service (category=otherPetProfessional)",
                        "enum": [
                            "",
                            "51",
                            "42",
                            "44",
                            "121",
                            "49",
                            "43",
                            "139",
                            "75",
                            "47",
                            "46",
                            "138",
                            "66",
                            "120",
                            "118",
                            "73",
                            "74",
                            "48",
                            "50",
                            "52",
                            "45"
                        ],
                        "type": "string",
                        "description": "Required when category=otherPetProfessional. The non-medical pet service to search for.",
                        "default": ""
                    },
                    "animalType": {
                        "title": "Advanced filter: animal type (mode=byZip)",
                        "enum": [
                            "",
                            "36",
                            "35",
                            "34",
                            "65",
                            "76",
                            "94",
                            "37",
                            "39",
                            "40",
                            "93",
                            "38",
                            "96"
                        ],
                        "type": "string",
                        "description": "Only clinics that treat this animal type. Combinable with other Advanced filters; overrides Category when set.",
                        "default": ""
                    },
                    "vetSpecialty": {
                        "title": "Advanced filter: veterinary specialty (mode=byZip)",
                        "enum": [
                            "",
                            "33",
                            "2",
                            "4",
                            "6",
                            "53",
                            "8",
                            "10",
                            "11",
                            "78",
                            "12",
                            "13",
                            "14",
                            "119",
                            "99",
                            "17",
                            "18",
                            "95",
                            "77",
                            "19",
                            "22",
                            "25",
                            "98",
                            "26",
                            "28",
                            "29",
                            "30",
                            "127"
                        ],
                        "type": "string",
                        "description": "Only clinics offering this specific procedure/specialty. Combinable with other Advanced filters; overrides Category when set.",
                        "default": ""
                    },
                    "holisticModality": {
                        "title": "Advanced filter: holistic modality (mode=byZip)",
                        "enum": [
                            "",
                            "54",
                            "55",
                            "56",
                            "68",
                            "135",
                            "57",
                            "72",
                            "58",
                            "64",
                            "124",
                            "59",
                            "71",
                            "136",
                            "61",
                            "134",
                            "62",
                            "126",
                            "116",
                            "63",
                            "69",
                            "125",
                            "67"
                        ],
                        "type": "string",
                        "description": "Only clinics offering this holistic/alternative modality. Combinable with other Advanced filters; overrides Category when set.",
                        "default": ""
                    },
                    "clinicService": {
                        "title": "Advanced filter: clinic service/amenity (mode=byZip)",
                        "enum": [
                            "",
                            "51",
                            "42",
                            "44",
                            "121",
                            "49",
                            "43",
                            "139",
                            "75",
                            "47",
                            "46",
                            "138",
                            "66",
                            "120",
                            "118",
                            "73",
                            "74",
                            "48",
                            "50",
                            "52",
                            "45"
                        ],
                        "type": "string",
                        "description": "Only clinics offering this amenity/service (broader than the Other Pet Professional category - includes vets too). Combinable with other Advanced filters; overrides Category when set.",
                        "default": ""
                    },
                    "fetchDetails": {
                        "title": "Fetch phone / email / description",
                        "type": "boolean",
                        "description": "Fetch each clinic's detail page for phone number, plus email/description/hours/website when the listing's paid tier includes them. Slower but much richer data. Turn off for a fast name+address-only scrape.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "VetLocator works without a proxy in normal conditions. This is only used as an automatic fallback if the site starts blocking datacenter IPs (403/429). Leave on the free AUTO group.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
