# Chiropractor Scraper (FindAChiropractor) (`compute-edge/findachiropractor-scraper`) Actor

FindAChiropractor.com Chiropractor Directory Scraper

Extract chiropractor listings from FindAChiropractor.com - the comprehensive chiropractor directory covering all 50 US states with over 35,000 chiropractor listings.

- **URL**: https://apify.com/compute-edge/findachiropractor-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

## FindAChiropractor.com Chiropractor Directory Scraper

**Extract chiropractor listings from FindAChiropractor.com** -- the comprehensive **chiropractor directory** covering all 50 US states with over **35,000 chiropractor listings**. This Apify Actor scrapes practice names, street addresses, cities, states, ZIP codes, phone numbers, and profile photos from every listed chiropractor in the directory.

### What data can you scrape from FindAChiropractor.com?

This **FindAChiropractor scraper** extracts structured data from the directory's city-level listing pages. All chiropractor contact information is available directly on the listing pages, so no detail page visits are needed -- making this scraper fast and efficient.

| Field | Description |
|-------|-------------|
| **name** | Chiropractor or practice name |
| **address** | Street address |
| **city** | City name |
| **state** | Two-letter state code |
| **zip** | ZIP code (5-digit or ZIP+4) |
| **phone** | Phone number formatted as (XXX) XXX-XXXX |
| **imageUrl** | Profile photo URL (when available) |
| **cityStateZip** | Full city, state, and ZIP string |
| **searchState** | The state used for the search |

### Why use this FindAChiropractor scraper?

- **35,000+ listings** -- access the full national chiropractor directory across all 50 US states
- **No login required** -- all data is publicly accessible on the directory website
- **City-level scraping** -- scrape a single city, or discover and scrape all cities in a state automatically
- **Fast and efficient** -- uses CheerioCrawler (no browser needed) for minimal compute costs
- **Automatic pagination** -- handles multi-page city listings (12 chiropractors per page) with automatic page discovery
- **Structured output** -- clean JSON data with parsed address components ready for your CRM or spreadsheet
- **Safety limits** -- configurable request limits to control costs and prevent runaway scrapes

### How to scrape FindAChiropractor.com

Follow these steps to **extract chiropractor data** from the directory:

1. Go to the [FindAChiropractor Scraper](https://apify.com/seatsignal/findachiropractor-scraper) page on Apify Store
2. Click **Try for free** to open the Actor in Apify Console
3. Enter the **State** name with hyphens for spaces (e.g., `New-York`, `California`, `North-Carolina`)
4. Enter the **State Code** matching your state (e.g., `NY`, `CA`, `NC`)
5. Optionally enter a **City** name to scrape only that city (e.g., `Albany`, `Buffalo`). Leave empty to scrape all cities in the state.
6. Set **Max Pages per City** to control how many pages per city to scrape (each page has up to 12 listings)
7. Set **Max Requests** as a safety limit on total HTTP requests
8. Click **Start** and wait for results
9. Download your data as JSON, CSV, or Excel from the **Dataset** tab

### Input example

```json
{
    "state": "New-York",
    "stateCode": "NY",
    "city": "Albany",
    "maxPages": 5,
    "maxRequestsPerCrawl": 500
}
````

To scrape all cities in a state, omit the `city` field:

```json
{
    "state": "California",
    "stateCode": "CA",
    "maxPages": 5,
    "maxRequestsPerCrawl": 1000
}
```

### Output example

Each chiropractor listing returns a JSON object like this:

```json
{
    "name": "Albany Back & Neck Pain Relief",
    "address": "845 CENTRAL AVE STE L112",
    "cityStateZip": "Albany, NY 12206",
    "city": "Albany",
    "state": "NY",
    "zip": "12206",
    "phone": "(518) 437-1757",
    "imageUrl": "https://findachiropractor.com/thumbnail/5184371757.jpg",
    "searchState": "New-York"
}
```

### How much does it cost to scrape FindAChiropractor.com?

This Actor uses **CheerioCrawler** (no browser), so compute costs are very low. The scraper only needs to visit listing pages -- no detail page visits required.

| Scenario | Pages | Results | Est. Compute | Est. Actor Fee |
|----------|-------|---------|-------------|----------------|
| One city (small) | 2 | ~20 | ~$0.005 | ~$0.04 |
| One city (large) | 10 | ~120 | ~$0.02 | ~$0.24 |
| Entire state (small) | 50 | ~500 | ~$0.10 | ~$1.00 |
| Entire state (large) | 500 | ~5,000 | ~$0.50 | ~$10.00 |

Actor pricing: **$0.002 per result** + minimal compute costs. A typical run scraping one city costs under $0.25 total.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `state` | string | Yes | `New-York` | State name with hyphens (e.g., `New-York`, `California`) |
| `stateCode` | string | Yes | `NY` | Two-letter state code (e.g., `NY`, `CA`) |
| `city` | string | No | -- | Specific city to scrape. Leave empty for all cities. |
| `maxPages` | integer | No | `5` | Max listing pages per city (1-100) |
| `maxRequestsPerCrawl` | integer | No | `500` | Safety limit on total HTTP requests |

### Supported states

All 50 US states are supported. Use the state name with hyphens for multi-word states:

| State | State Code | State | State Code |
|-------|-----------|-------|-----------|
| `Alabama` | `AL` | `Montana` | `MT` |
| `Alaska` | `AK` | `Nebraska` | `NE` |
| `Arizona` | `AZ` | `Nevada` | `NV` |
| `Arkansas` | `AR` | `New-Hampshire` | `NH` |
| `California` | `CA` | `New-Jersey` | `NJ` |
| `Colorado` | `CO` | `New-Mexico` | `NM` |
| `Connecticut` | `CT` | `New-York` | `NY` |
| `Delaware` | `DE` | `North-Carolina` | `NC` |
| `Florida` | `FL` | `North-Dakota` | `ND` |
| `Georgia` | `GA` | `Ohio` | `OH` |
| `Hawaii` | `HI` | `Oklahoma` | `OK` |
| `Idaho` | `ID` | `Oregon` | `OR` |
| `Illinois` | `IL` | `Pennsylvania` | `PA` |
| `Indiana` | `IN` | `Rhode-Island` | `RI` |
| `Iowa` | `IA` | `South-Carolina` | `SC` |
| `Kansas` | `KS` | `South-Dakota` | `SD` |
| `Kentucky` | `KY` | `Tennessee` | `TN` |
| `Louisiana` | `LA` | `Texas` | `TX` |
| `Maine` | `ME` | `Utah` | `UT` |
| `Maryland` | `MD` | `Vermont` | `VT` |
| `Massachusetts` | `MA` | `Virginia` | `VA` |
| `Michigan` | `MI` | `Washington` | `WA` |
| `Minnesota` | `MN` | `West-Virginia` | `WV` |
| `Mississippi` | `MS` | `Wisconsin` | `WI` |
| `Missouri` | `MO` | `Wyoming` | `WY` |

### Tips for best results

- **Finding city names**: Visit [findachiropractor.com](https://findachiropractor.com) and navigate to your state. City names use hyphens for spaces (e.g., `New-York`, `Bay-Shore`, `East-Meadow`).
- **Large states**: States like California, New York, and Texas have hundreds of cities. Use the `maxRequestsPerCrawl` limit to control costs.
- **Single city mode**: Set the `city` parameter to skip the state page and go directly to city listings. This is fastest when you know which city you need.
- **Pagination**: The directory shows 12 listings per page. The scraper automatically detects total listing counts and paginates through all pages up to the `maxPages` limit.

### Integrations

Connect FindAChiropractor data with your workflow:

- **API** -- Access results programmatically via the [Apify API](https://docs.apify.com/api/v2)
- **Webhooks** -- Get notified when a scrape completes
- **Zapier / Make** -- Pipe results into Google Sheets, CRMs, or databases
- **Python / Node.js** -- Use the [Apify SDK](https://docs.apify.com/sdk/js) to run and retrieve data

### Legal disclaimer

This Actor extracts publicly available business information from FindAChiropractor.com. It does not extract private user data, bypass authentication, or access protected content. The scraped data consists of chiropractor business listings that practices have voluntarily published on the public directory.

Users are responsible for ensuring their use of scraped data complies with applicable laws, including GDPR and CCPA. For questions about data usage, consult a legal professional.

### Support

- **Issues?** Open an issue on the Actor's Apify page
- **Custom data needs?** Contact us for enterprise solutions

# Actor input Schema

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

US state name with hyphens for spaces (e.g., 'New-York', 'California', 'North-Carolina'). See full list at findachiropractor.com.

## `stateCode` (type: `string`):

Two-letter state code matching the state above (e.g., 'NY', 'CA', 'NC'). Used for city page URLs.

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

Specific city to scrape (e.g., 'Albany', 'New-York'). Leave empty to scrape all cities in the state.

## `maxPages` (type: `integer`):

Maximum number of listing pages to scrape per city. Each page has up to 12 listings.

## `maxRequestsPerCrawl` (type: `integer`):

Maximum total HTTP requests. Safety limit to prevent runaway costs.

## Actor input object example

```json
{
  "state": "New-York",
  "stateCode": "NY",
  "maxPages": 5,
  "maxRequestsPerCrawl": 500
}
```

# 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 = {
    "state": "New-York",
    "stateCode": "NY"
};

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/findachiropractor-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 = {
    "state": "New-York",
    "stateCode": "NY",
}

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/findachiropractor-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 '{
  "state": "New-York",
  "stateCode": "NY"
}' |
apify call compute-edge/findachiropractor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Chiropractor Scraper (FindAChiropractor)",
        "description": "FindAChiropractor.com Chiropractor Directory Scraper\n\nExtract chiropractor listings from FindAChiropractor.com - the comprehensive chiropractor directory covering all 50 US states with over 35,000 chiropractor listings.",
        "version": "0.1",
        "x-build-id": "TdEFRIzsPH8gJci6Z"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~findachiropractor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-findachiropractor-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/compute-edge~findachiropractor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-findachiropractor-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/compute-edge~findachiropractor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-findachiropractor-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": [
                    "state",
                    "stateCode"
                ],
                "properties": {
                    "state": {
                        "title": "State",
                        "type": "string",
                        "description": "US state name with hyphens for spaces (e.g., 'New-York', 'California', 'North-Carolina'). See full list at findachiropractor.com."
                    },
                    "stateCode": {
                        "title": "State Code",
                        "type": "string",
                        "description": "Two-letter state code matching the state above (e.g., 'NY', 'CA', 'NC'). Used for city page URLs."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Specific city to scrape (e.g., 'Albany', 'New-York'). Leave empty to scrape all cities in the state."
                    },
                    "maxPages": {
                        "title": "Max Pages per City",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of listing pages to scrape per city. Each page has up to 12 listings.",
                        "default": 5
                    },
                    "maxRequestsPerCrawl": {
                        "title": "Max Requests",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum total HTTP requests. Safety limit to prevent runaway costs.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```