# Chiropractor Lead Scraper (`automation-lab/chiropractor-lead-scraper`) Actor

Find chiropractor practices by location and extract public lead details, websites, emails, and source links for outreach and local SEO.

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

## Pricing

Pay per event

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Chiropractor Lead Scraper

Find chiropractor practices by city or region and export public lead data for outreach, SEO research, and market mapping.

### What does Chiropractor Lead Scraper do?

Chiropractor Lead Scraper searches public web results for chiropractic clinics in the locations you provide.
It returns practice names, websites, snippets, location labels, contact fields, source URLs, and optional emails found on practice websites.

### Who is it for?

- Local SEO agencies building chiropractor prospect lists.
- Healthcare marketing teams researching clinics by city.
- B2B SaaS teams selling appointment, billing, or patient engagement tools.
- Data teams enriching CRM records with public chiropractor websites.
- Researchers mapping local healthcare provider markets.

### Why use this actor?

- Purpose-built for chiropractor and chiropractic clinic discovery.
- Simple location input: enter one or more cities/regions.
- Optional website email enrichment.
- Produces clean rows that are easy to export to CSV, Excel, JSON, or API workflows.
- Includes a Google Maps search URL for quick manual verification.

### Data you can extract

| Field | Description |
| --- | --- |
| `name` | Practice or page title cleaned into a lead name. |
| `category` | Chiropractor category label. |
| `address` | Public search snippet, often including service area or address context. |
| `city` | City parsed from your location input. |
| `region` | State/region parsed from your location input. |
| `phone` | Phone number when visible in the public snippet. |
| `website` | Practice website or source page. |
| `email` | First email found during optional website enrichment. |
| `emails` | All emails found during optional enrichment. |
| `socialLinks` | Public social profile links found on the website. |
| `googleMapsSearchUrl` | Verification search link for the practice. |
| `sourceUrl` | Original public result URL. |
| `scrapedAt` | Timestamp of extraction. |

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

This actor uses pay-per-event pricing.
You pay a small start fee and a per-lead fee for each saved dataset item.
Keep first runs small by using the prefilled input or setting `maxItems` to 10-50.

### Input options

- `locations`: cities, states, regions, or service areas to search.
- `maxItems`: maximum leads to save across all locations.
- `includeWebsiteEmails`: visit each website and extract emails/social links.
- `searchQuery`: optional advanced override for the search phrase.

### Example input

```json
{
  "locations": ["Austin, Texas", "Denver, Colorado"],
  "maxItems": 50,
  "includeWebsiteEmails": false
}
````

### Example output

```json
{
  "name": "Austin Chiropractic",
  "category": "chiropractor",
  "city": "Austin",
  "region": "Texas",
  "website": "https://www.austintxchiro.com/",
  "email": null,
  "googleMapsSearchUrl": "https://www.google.com/maps/search/?api=1&query=Austin%20Chiropractic%20Austin%2C%20Texas",
  "source": "OpenStreetMap/Nominatim public data"
}
```

### How to run it

1. Open the actor on Apify.
2. Enter one or more locations.
3. Choose the maximum number of leads.
4. Enable website email enrichment only when you need emails.
5. Start the run.
6. Download results from the Dataset tab.

### Tips for better results

- Use city + state/country, for example `Austin, Texas`.
- Use several nearby cities for metro-wide prospecting.
- Keep email enrichment off for faster discovery runs.
- Turn enrichment on for smaller lists that need contact emails.
- Review `googleMapsSearchUrl` for high-value prospects.

### Integrations

- Send dataset rows to Google Sheets with an Apify integration.
- Use webhooks to trigger CRM imports after a run succeeds.
- Pull results from the Dataset API into Clay, Make, Zapier, or n8n.
- Combine with email verification tools before outreach.
- Join with existing CRM records by website domain.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/chiropractor-lead-scraper').call({
  locations: ['Austin, Texas'],
  maxItems: 25
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/chiropractor-lead-scraper').call(run_input={
    'locations': ['Austin, Texas'],
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~chiropractor-lead-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"locations":["Austin, Texas"],"maxItems":25}'
```

### MCP usage

Use Apify MCP with Claude Code or Claude Desktop:

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

Claude Code setup:

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

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-chiropractor-leads": {
      "url": "https://mcp.apify.com/?tools=automation-lab/chiropractor-lead-scraper"
    }
  }
}
```

Example prompts:

- "Find 25 chiropractor practices in Austin and summarize their websites."
- "Run the chiropractor lead scraper for Denver and return a CSV-ready table."
- "Extract chiropractor leads, then flag rows that include emails."

### Data quality notes

The actor uses public OpenStreetMap/Nominatim listings, with public web-search fallback pages and optional website fetches.
Some fields may be null when the public source does not expose them.
Use the source URL and Google Maps search URL to verify important prospects.

### Website email enrichment

When enabled, the actor opens each discovered website and scans the HTML for email addresses and social links.
This can improve contact coverage, but it may be slower because every website is a separate request.
For large discovery runs, scrape leads first and enrich a smaller shortlist later.

### Limitations

- Search engines may return directory pages as well as direct practice websites.
- Phone numbers appear only when visible in public snippets.
- Address fields are best-effort because many organic results expose location text, not structured addresses.
- Email extraction only finds emails visible in website HTML.

### Legality

This actor extracts publicly available information from public web pages.
You are responsible for using the data lawfully, honoring applicable privacy rules, and complying with outreach regulations such as CAN-SPAM, GDPR, and local marketing laws.

### FAQ

#### Why are some emails empty?

Many practices hide emails behind contact forms or images. Enable website enrichment and verify high-value websites manually.

#### Why do I see directory pages?

Public search results can include directories. Use the website and source URL fields to filter direct clinic domains.

#### How can I get more leads?

Add more locations or increase `maxItems`. For metro areas, include suburbs as separate locations.

#### Can I scrape other healthcare specialties?

You can use `searchQuery` to test related terms, but this actor is optimized and described for chiropractor leads.

### Related scrapers

- https://apify.com/automation-lab/google-maps-scraper
- https://apify.com/automation-lab/business-leads-scraper
- https://apify.com/automation-lab/email-scraper

### Changelog

- 0.1.0 Initial version for chiropractor lead discovery.

### Support

If a location returns too few results, try a broader city name, include the state or country, and reduce advanced filters.

### Production prospecting workflow

A practical workflow is to start with a small discovery run, review the result quality, and then expand the location list. For example, a sales team targeting a metro area can enter the main city plus surrounding suburbs, keep email enrichment disabled, and export a first CSV of practice websites. After filtering out directories or low-fit rows, the same team can rerun smaller batches with `includeWebsiteEmails` enabled to collect public contact emails and social profile links.

For repeatable lead generation, store successful inputs in your CRM playbook. Use consistent location names such as `Phoenix, Arizona` or `Orange County, California`, then schedule runs monthly or quarterly to refresh new practices and changed websites. The `sourceUrl`, `googleMapsSearchUrl`, and `scrapedAt` fields help your team audit where each row came from and when it was collected.

### Quality control checklist

- Review a sample of source URLs before outreach.
- Filter obvious directory pages when you need only direct clinic websites.
- De-duplicate by website domain across multiple locations.
- Validate emails before campaigns.
- Keep `maxItems` small while testing new markets.
- Add suburbs as separate locations for better metro coverage.
- Prefer city and state/country over broad country-wide searches.
- Monitor null contact fields and enrich only shortlisted rows.
- Combine dataset exports with CRM suppression lists.
- Keep outreach compliant with privacy and marketing rules.

# Actor input Schema

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

Cities, regions, or areas to search for chiropractor practices.

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

Maximum number of chiropractor leads to save across all locations.

## `includeWebsiteEmails` (type: `boolean`):

When enabled, the actor visits each public website to find email addresses and social links. This is slower but produces richer leads.

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

Optional advanced override for the default chiropractor/chiropractic clinic query.

## Actor input object example

```json
{
  "locations": [
    "Austin, Texas",
    "Denver, Colorado"
  ],
  "maxItems": 20,
  "includeWebsiteEmails": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "locations": [
        "Austin, Texas",
        "Denver, Colorado"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/chiropractor-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 = { "locations": [
        "Austin, Texas",
        "Denver, Colorado",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/chiropractor-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 '{
  "locations": [
    "Austin, Texas",
    "Denver, Colorado"
  ]
}' |
apify call automation-lab/chiropractor-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Chiropractor Lead Scraper",
        "description": "Find chiropractor practices by location and extract public lead details, websites, emails, and source links for outreach and local SEO.",
        "version": "0.1",
        "x-build-id": "YkNinpfy7MEZxfja5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~chiropractor-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-chiropractor-lead-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~chiropractor-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-chiropractor-lead-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~chiropractor-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-chiropractor-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": [
                    "locations"
                ],
                "properties": {
                    "locations": {
                        "title": "Locations",
                        "minItems": 1,
                        "type": "array",
                        "description": "Cities, regions, or areas to search for chiropractor practices.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum leads",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of chiropractor leads to save across all locations.",
                        "default": 20
                    },
                    "includeWebsiteEmails": {
                        "title": "Extract emails from practice websites",
                        "type": "boolean",
                        "description": "When enabled, the actor visits each public website to find email addresses and social links. This is slower but produces richer leads.",
                        "default": false
                    },
                    "searchQuery": {
                        "title": "Custom search query",
                        "type": "string",
                        "description": "Optional advanced override for the default chiropractor/chiropractic clinic query."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
