# Booksy Scraper — Salon, Barber & Beauty Business Data (`haketa/booksy-scraper`) Actor

Scrape Booksy local business listings by service and city. Extract salon, barber, spa, nail and beauty business name, full address, GPS coordinates, rating, review count, category, photos and booking badges. Export to JSON/CSV/Excel for local lead generation and market research.

- **URL**: https://apify.com/haketa/booksy-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Lead generation, Business
- **Stats:** 8 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 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.
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

## Booksy Scraper — Salon, Barber & Beauty Business Data

Extract structured local-business data from **Booksy**, one of the largest booking platforms for salons, barbers, spas, nail studios and beauty & wellness professionals. Paste a Booksy search URL and get clean, ready-to-use records for every business: **name, category, full address, GPS coordinates, rating, review count, cover photo, staff size and booking badges**.

No code, no login, no API key. Run it from the Apify Console, on a schedule, or from your own app via the API. Results download as **JSON, CSV, Excel, HTML or XML**, or sync straight into Google Sheets, Airtable, HubSpot, Make, Zapier and n8n.

> **💈 Built for local lead generation & market research.** Every record includes a **rating, review count and precise location** — perfect for building targeted lists of salons, barbers and beauty businesses in any US city.

---

### 📋 What this scraper does

Booksy lists hundreds of thousands of appointment-based local businesses across the US. This actor turns a Booksy search into a clean, structured dataset you can analyse, enrich or feed into a CRM.

Give it a Booksy search URL (service + city), and it will:

- ✅ Collect every matching business, page after page
- ✅ Return the **rating (0–5), star score and review count**
- ✅ Break out the **full location** — street address, city and **GPS latitude/longitude**
- ✅ Capture the **category, cover photo and staff size**
- ✅ Flag **online booking, Booksy Pay, "Best of Booksy" and mobile/traveling** service
- ✅ Build a direct **link to the business page**
- ✅ De-duplicate every business by its Booksy ID

Data comes straight from Booksy's structured business feed, so runs are fast, cheap and reliable — hundreds of businesses in seconds.

---

### ⭐ Why choose this scraper

- **Ready-to-use local leads.** Name, address, coordinates and rating for every salon/barber/spa — build outreach or supplier lists in minutes.
- **Precise geo data.** GPS coordinates on every record for mapping, radius analysis and territory planning.
- **Reputation signals.** Rating, star score and review count let you rank and qualify businesses instantly.
- **Rich local coverage.** Salons, barbers, nail studios, spas, massage, lashes, brows and more, across every US city.
- **Fast and economical.** Pure API extraction — a few hundred businesses finish in seconds at very low cost.

---

### 💡 Popular use cases

| Use case | How this scraper helps |
| --- | --- |
| **Local B2B lead generation** | Build targeted lists of salons/barbers/spas by service and city for outreach. |
| **Market research** | Measure supply, average rating and review volume for any beauty niche and market. |
| **Franchise & expansion** | Map competitor density and ratings before opening or expanding. |
| **Supplier & distributor sales** | Find beauty businesses by category and location to sell products/services to. |
| **Reputation benchmarking** | Compare ratings and review counts across a city or category. |
| **Data products & dashboards** | Feed a clean local-business feed into BI tools or a database. |

---

### 🚀 Quick start

1. On **booksy.com**, search a service (e.g. `hair salon`) in a city (e.g. `Chicago`).
2. Copy the resulting URL — it looks like `https://booksy.com/en-us/s/hair-salon/18229_chicago`.
3. Paste it into **Booksy search URLs** in the actor, set **Max items**, and click **Start**.
4. Download your data from the **Storage → Dataset** tab.

You can paste several search URLs at once — each is scraped and paginated automatically.

---

### ⚙️ Input

| Field | Type | Description |
| --- | --- | --- |
| **Booksy search URLs** | array | Booksy search-result URLs (service + city), e.g. `https://booksy.com/en-us/s/barber/17501_new-york`. Search on booksy.com and copy the URL. |
| **Max items per search** | integer | Max businesses per URL. Default 100 (Booksy caps a search at ~10,000). |
| **Proxy** | object | Apify Proxy (US) recommended and on by default. |

#### Example 1 — Hair salons in Chicago

```json
{ "startUrls": ["https://booksy.com/en-us/s/hair-salon/18229_chicago"], "maxItems": 300 }
````

#### Example 2 — Multiple services / cities

```json
{
  "startUrls": [
    "https://booksy.com/en-us/s/barber/17501_new-york",
    "https://booksy.com/en-us/s/nail-salon/18229_chicago"
  ],
  "maxItems": 200
}
```

> **Tip:** The URL encodes the service and city (`/s/{service}/{locationId}_{city}`). Build any search you like on booksy.com and paste it here.

***

### 📦 Output

Each business becomes one dataset record:

```json
{
  "businessId": "1439833",
  "name": "Spoil Me Hair Salon",
  "category": "Hair Salon",
  "rating": 4.86,
  "reviewsCount": 159,
  "reviewsStars": 5,
  "address": "921 Chalkstone Ave, Chicago, 60601",
  "city": "Chicago",
  "latitude": 41.8326,
  "longitude": -87.6298,
  "imageUrl": "https://d2zdpiztbgorvt.cloudfront.net/.../biz-photo.jpeg",
  "staffCount": 3,
  "bestOfBooksy": false,
  "acceptsBooksyPay": false,
  "hasOnlineBooking": true,
  "isPromoted": false,
  "travelingService": false,
  "url": "https://booksy.com/en-us/1439833_spoil-me-hair-salon",
  "searchUrl": "https://booksy.com/en-us/s/hair-salon/18229_chicago",
  "scrapedAt": "2026-07-02T00:00:00.000Z"
}
```

#### Output fields

| Field | Description |
| --- | --- |
| `businessId` | Booksy business ID. |
| `name` | Business name. |
| `category` | Business category / searched service. |
| `rating` / `reviewsStars` / `reviewsCount` | Average rating, star score and review count. |
| `address` / `city` | Location. |
| `latitude` / `longitude` | GPS coordinates. |
| `imageUrl` | Cover photo URL. |
| `staffCount` | Number of staff. |
| `bestOfBooksy` | "Best of Booksy" award. |
| `acceptsBooksyPay` / `hasOnlineBooking` | Payment / online-booking flags. |
| `isPromoted` / `travelingService` | Promoted listing / mobile service. |
| `url` | Business page URL. |
| `searchUrl` | The search URL this record came from. |
| `scrapedAt` | Extraction timestamp. |

***

### 💈 Services you can search

Search any service on Booksy and paste the URL — e.g. `hair salon`, `barber`, `nail salon`, `spa`, `massage`, `lashes`, `brows`, `waxing`, `skin care`, `makeup`, `tattoo`, `piercing`, `hair removal`, `braids`, `locs`, `wellness`, `day spa`.

***

### 🧭 Tips for best results

- **Search the exact city** on booksy.com so the URL carries the right location.
- **Paste multiple URLs** to cover several services or cities in one run.
- **Rank by `rating` + `reviewsCount`** to surface the strongest businesses.
- **Use the GPS fields** for mapping, radius targeting and territory analysis.

***

### 🔌 Integrations & export

- **Download formats:** JSON, CSV, Excel, HTML, XML, RSS.
- **CRM / Sheets / Airtable / Make / Zapier / n8n:** push results automatically.
- **API:** run and fetch data with the Apify API or the JS / Python clients.
- **Scheduling:** run weekly to track new businesses and rating changes.

***

### ❓ FAQ

**Do I need a Booksy account or API key?**
No. You only need an Apify account.

**Which countries are covered?**
US business data (booksy.com/en-us search URLs).

**How do I get a search URL?**
Search a service and city on booksy.com, then copy the address bar URL — that's your input.

**Does it return duplicates?**
No. Businesses are de-duplicated by their Booksy ID within each search.

***

### ⚖️ Legal & responsible use

This actor collects **publicly available** business information from Booksy search results — the same data any visitor can see. It does not bypass logins or access private data. Respect Booksy's Terms of Use and applicable law, and use the data for lawful purposes such as market research, analytics and B2B outreach.

***

### 🛟 Support

Need a field added or hit an issue? Open a ticket from the actor's **Issues** tab with your input configuration.

Happy sourcing! 💈

# Actor input Schema

## `startUrls` (type: `array`):

Paste Booksy search-result URLs. Search a service + city on booksy.com, then copy the URL here — e.g. https://booksy.com/en-us/s/hair-salon/18229\_chicago or https://booksy.com/en-us/s/barber/17501\_new-york. Each URL is scraped and paginated automatically.

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

Maximum businesses to collect per URL. Default 100 (Booksy caps a search at ~10,000).

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

Booksy serves US business data — a US proxy is recommended. Apify Proxy (US) is on by default.

## Actor input object example

```json
{
  "startUrls": [
    "https://booksy.com/en-us/s/barber/17501_new-york"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `businessId` (type: `string`):

Booksy business ID

## `name` (type: `string`):

Business name

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

Searched service/category

## `rating` (type: `string`):

Average review rating (0-5)

## `reviewsCount` (type: `string`):

Number of reviews

## `reviewsStars` (type: `string`):

Rounded star rating

## `address` (type: `string`):

Street address

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

City

## `latitude` (type: `string`):

GPS latitude

## `longitude` (type: `string`):

GPS longitude

## `imageUrl` (type: `string`):

Cover photo URL

## `staffCount` (type: `string`):

Number of staff

## `bestOfBooksy` (type: `string`):

Best of Booksy award

## `acceptsBooksyPay` (type: `string`):

Accepts Booksy Pay

## `hasOnlineBooking` (type: `string`):

Offers online booking

## `isPromoted` (type: `string`):

Promoted listing

## `travelingService` (type: `string`):

Traveling/mobile service

## `url` (type: `string`):

Business page URL

## `searchUrl` (type: `string`):

Booksy search URL used

## `scrapedAt` (type: `string`):

Extraction timestamp

# 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 = {
    "startUrls": [
        "https://booksy.com/en-us/s/hair-salon/18229_chicago"
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/booksy-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 = {
    "startUrls": ["https://booksy.com/en-us/s/hair-salon/18229_chicago"],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/booksy-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 '{
  "startUrls": [
    "https://booksy.com/en-us/s/hair-salon/18229_chicago"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}' |
apify call haketa/booksy-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Booksy Scraper — Salon, Barber & Beauty Business Data",
        "description": "Scrape Booksy local business listings by service and city. Extract salon, barber, spa, nail and beauty business name, full address, GPS coordinates, rating, review count, category, photos and booking badges. Export to JSON/CSV/Excel for local lead generation and market research.",
        "version": "0.1",
        "x-build-id": "246f8t5QGidcUYZxY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~booksy-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-booksy-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/haketa~booksy-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-booksy-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/haketa~booksy-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-booksy-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Booksy search URLs",
                        "type": "array",
                        "description": "Paste Booksy search-result URLs. Search a service + city on booksy.com, then copy the URL here — e.g. https://booksy.com/en-us/s/hair-salon/18229_chicago or https://booksy.com/en-us/s/barber/17501_new-york. Each URL is scraped and paginated automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items per search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum businesses to collect per URL. Default 100 (Booksy caps a search at ~10,000).",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Booksy serves US business data — a US proxy is recommended. Apify Proxy (US) is on by default.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```