# Fresha Leads Scraper (`solidcode/fresha-scraper`) Actor

\[💰 $10 / 1K] Extract salon, barber, spa, nail, and beauty business leads from Fresha — names, contact details, ratings, services, pricing, and location. Search by keyword and location or paste Fresha URLs.

- **URL**: https://apify.com/solidcode/fresha-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Fresha Leads Scraper

Pull beauty and wellness business leads from Fresha at scale — names, unmasked phone numbers, full addresses, ratings and review counts, exact GPS coordinates, starting prices, and a services preview for every salon, barber, spa, and nail bar. Search by keyword and location across 13 countries, or paste Fresha venue and search URLs directly. Built for salon-supply sales reps, beauty-brand business-development teams, and local marketing agencies who need verified, ready-to-call beauty-business leads without trawling directories one listing at a time.

### Why This Scraper?

- **Unmasked phone numbers** — every enriched lead returns the venue's full, dialable phone number, not the partial or hidden numbers competing Fresha extractors deliver. This is the difference between a usable call list and a dead end.
- **20 beauty & wellness categories** — scope to Hair & styling, Nails, Barbering, Massage, Facials & skincare, Aesthetics, Tattoo & piercing, Spa & wellness, and 12 more from a dropdown — no guessing slugs or typing category strings exactly.
- **Exact GPS coordinates on every lead** — latitude and longitude for each venue, so you can map territories, assign routes by distance, or cluster leads by neighborhood.
- **Ratings plus review counts** — both the star rating (e.g. 4.9) and the underlying review volume, so you can rank prospects by reputation and prioritize established, high-traffic venues.
- **Starting price and currency** — each enriched lead carries a "from" price (e.g. "from £60") and currency code, letting you segment premium salons from budget operators before you reach out.
- **Services preview plus a service count** — see a sample of the named services each venue offers alongside the total count, so you instantly know whether a prospect is a fit for your product line.
- **13-country locale coverage** — UK, US, Australia, Canada, Ireland, New Zealand, UAE, Spain, Italy, Netherlands, Germany, France, and Portugal, each returning region-correct businesses for keyword searches.
- **Keyword search or direct URL input** — batch many search terms in one run, or paste specific Fresha venue and search-results URLs for pinpoint targeting. Results across overlapping searches are de-duplicated by venue.
- **Toggle contact enrichment for speed** — keep it on for phone, full address, description, and pricing; switch it off to pull names, ratings, categories, and approximate locations in a single fast pass.

### Use Cases

**Lead Generation**
- Build call-ready prospect lists of salons and barbershops with unmasked phone numbers
- Compile beauty-business databases for outbound sales and cold outreach
- Target high-rating venues with established review volume as priority accounts
- Segment leads by starting price to match premium versus value product lines

**Market Research**
- Map salon and spa density across a city or region using GPS coordinates
- Benchmark average ratings and review counts by category and location
- Track the mix of beauty categories present in a target market
- Compare starting prices across neighborhoods to size the addressable market

**Competitive Analysis**
- Monitor which services competitors and prospects advertise on Fresha
- Identify the busiest, best-reviewed venues in a category to study their offering
- Compare service counts to gauge the breadth of competing businesses
- Spot new entrants in a local beauty market over repeated runs

**Local Marketing & Outreach**
- Find independent salons in a defined area for franchise or partnership pitches
- Geo-target advertising campaigns using per-venue coordinates and addresses
- Assign field-sales territories by clustering venues on a map
- Localize outreach by pulling region-correct businesses for each country you sell into

### Getting Started

#### Search a Category in a City

The simplest run — what to find and where:

```json
{
    "searchTerms": ["nail salon"],
    "location": "London, UK",
    "maxResults": 50
}
````

#### Scope to a Beauty Category

Narrow to one Fresha category and pull richer detail:

```json
{
    "searchTerms": ["spa"],
    "location": "New York, NY",
    "category": "category:massage",
    "country": "us",
    "maxResults": 100
}
```

#### Paste Fresha URLs Directly

Target specific venues or search pages for pinpoint control:

```json
{
    "startUrls": [
        "https://www.fresha.com/a/example-salon-london",
        "https://www.fresha.com/s/barbershop/leeds"
    ],
    "maxResults": 100
}
```

#### Full-Featured Example

```json
{
    "searchTerms": ["barber", "hair salon", "massage"],
    "location": "Manchester, UK",
    "category": "",
    "country": "gb",
    "maxResults": 500,
    "includeContactDetails": true
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | array | `["nail salon"]` | What kind of business to find on Fresha (e.g. "barber", "nail salon", "massage", "spa"). Each term is combined with the Location below. Leave empty if you paste full Fresha URLs instead. |
| `location` | string | `"London, UK"` | City or area to search in (e.g. "London, UK", "New York, NY", "Sydney"). Combined with each Search Term. Leave empty if you paste full Fresha URLs. |
| `category` | select | `Any category` | Optionally narrow results to one Fresha category. Leave as "Any category" to search across all beauty & wellness types. |
| `startUrls` | array | `[]` | Paste Fresha venue or search URLs directly, e.g. https://www.fresha.com/a/venue-name. When provided, these are scraped in addition to any Search Terms above. A pasted venue link always returns that venue's full profile (phone, address, pricing), even when Include Contact Details is off. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of business leads to return across all searches and URLs. Set to 0 for unlimited (up to a 100,000-result safety ceiling per run). Each Search Term + Location pair sweeps a grid of nearby points and tops out at roughly 16,000 venues per single city before de-duplication; to pull more for one city, split it into several nearby locations. Tip: start with 20-50 to test, then increase. |
| `includeContactDetails` | boolean | `true` | Fetch each business's phone number, full street address, description, and starting price by opening its profile page. It makes one extra lookup per business, so a run takes a little longer. Turn it off for a faster, lighter run when you only need names, ratings, categories, and approximate locations. (Applies to keyword + location searches; a pasted venue link always returns full contact details.) |
| `country` | select | `United Kingdom` | Which Fresha region to search. Affects the businesses returned for keyword + location searches. Choose from United Kingdom, United States, Australia, Canada, Ireland, New Zealand, United Arab Emirates, Spain, Italy, Netherlands, Germany, France, or Portugal. |

The **Category** dropdown covers: Any category, Hair & styling, Nails, Hair removal, Eyebrows & eyelashes, Facials & skincare, Massage, Makeup, Aesthetics, Barbering, Spa & wellness, Body & skin, Tattoo & piercing, Holistic health, Dental, Medical, Pets, Fitness, Physical therapy, Counseling & therapy, and Other.

### Output

Each business is one flat row. Here is a representative result with contact details enabled:

```json
{
    "name": "The Grooming Room",
    "category": "Barbershop",
    "description": "Award-winning barbershop in central London offering classic cuts, hot-towel shaves, and beard styling.",
    "rating": 4.9,
    "reviewCount": 1284,
    "address": "42 Carnaby Street, London W1F 7DR",
    "city": "London",
    "country": "United Kingdom",
    "latitude": 51.5138,
    "longitude": -0.1387,
    "phone": "+44 20 7123 4567",
    "priceFrom": "from £25",
    "currency": "GBP",
    "serviceCount": 18,
    "services": [
        { "name": "Skin Fade", "price": "£28" },
        { "name": "Hot Towel Shave", "price": "£35" },
        { "name": "Beard Trim", "price": "£18" }
    ],
    "url": "https://www.fresha.com/a/the-grooming-room-london",
    "venueId": "1234567"
}
```

#### Output Fields

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Business / venue name |
| `category` | string | Primary business category (e.g. "Hair Salon", "Barbershop", "Nails") |
| `description` | string | Short business description (when contact details are enabled) |
| `rating` | number | Average star rating (e.g. 4.9) |
| `reviewCount` | number | Number of reviews behind the rating |
| `address` | string | Formatted street address |
| `city` | string | City name |
| `country` | string | Country name |
| `latitude` | number | Venue latitude |
| `longitude` | number | Venue longitude |
| `phone` | string | Full, unmasked phone number when publicly listed (when contact details are enabled) |
| `priceFrom` | string | Starting "from" price summary (e.g. "from £60") |
| `currency` | string | Currency code for prices (e.g. "GBP", "USD") |
| `serviceCount` | number | Total number of services the venue offers |
| `services` | array | Preview list of named services with prices |
| `url` | string | Direct link to the Fresha venue profile |
| `venueId` | string | Stable Fresha venue identifier (used for de-duplication) |

### Tips for Best Results

- **Start small** — set `maxResults` to 20-50 on your first run to confirm the data matches your needs, then scale up.
- **Keep contact details on for a call list** — the unmasked `phone`, full `address`, `description`, and `priceFrom` only populate when contact enrichment is enabled. Turn it off only when you need names, ratings, and approximate locations fast.
- **Batch many terms in one run** — list several Search Terms together (e.g. "barber", "hair salon", "massage") against one Location to cover a whole market in a single pass; overlapping results are de-duplicated by `venueId`.
- **Maximize coverage in a dense city** — large cities hold far more venues than a single search returns, so the scraper sweeps a grid of nearby points to reach deeper inventory. Set a higher `maxResults` (e.g. 500+) for metros like London or New York to pull beyond the first wave of listings.
- **Match the country to your location** — set `country` to the region your Location sits in (e.g. `us` for "New York, NY") so keyword searches return region-correct businesses.
- **Rank prospects by reputation** — sort your export by `reviewCount` to surface established, high-traffic venues, then by `rating` to prioritize the best-reviewed accounts.
- **Use `priceFrom` to segment** — filter by the starting price to separate premium salons from budget operators before you reach out.

### Pricing

**From $10.00 per 1,000 results** — undercuts comparable Fresha leads extractors while returning unmasked phone numbers. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $1.20 | $1.13 | $1.06 | $1.00 |
| 1,000 | $12.00 | $11.30 | $10.60 | $10.00 |
| 10,000 | $120.00 | $113.00 | $106.00 | $100.00 |
| 100,000 | $1,200.00 | $1,130.00 | $1,060.00 | $1,000.00 |

A "result" is any business lead row in the output dataset. The per-run start fee and any platform storage costs are additional and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate lead generation, market research, and competitive analysis of publicly listed beauty and wellness businesses. Users are responsible for complying with applicable laws and Fresha's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal data in line with applicable privacy regulations such as GDPR.

# Actor input Schema

## `searchTerms` (type: `array`):

What kind of business to find on Fresha (e.g. 'barber', 'nail salon', 'massage', 'spa'). Each term is combined with the Location below. Leave empty if you paste full Fresha URLs instead.

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

City or area to search in (e.g. 'London, UK', 'New York, NY', 'Sydney'). Combined with each Search Term. Leave empty if you paste full Fresha URLs.

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

Optionally narrow results to one Fresha category. Leave as 'Any category' to search across all beauty & wellness types.

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

Paste Fresha venue or search URLs directly, e.g. https://www.fresha.com/a/venue-name. When provided, these are scraped in addition to any Search Terms above. A pasted venue link always returns that venue's full profile (phone, address, pricing) — even when Include Contact Details is off — because you asked for that specific business.

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

Maximum number of business leads to return across all searches and URLs. Set to 0 for unlimited (up to a 100,000-result safety ceiling per run). Each Search Term + Location pair sweeps a grid of nearby points to go deep on dense cities; that grid tops out at roughly 16,000 venues per single city before de-duplication, so to pull more than that for one city, split it into several nearby locations. Tip: start with 20-50 to test, then increase.

## `includeContactDetails` (type: `boolean`):

Fetch each business's phone number, full street address, description, and starting price by opening its profile page. This is the core value of a leads list, so it is on by default. It makes one extra lookup per business, so a run takes a little longer. Turn it off for a faster, lighter run when you only need names, ratings, categories, and approximate locations. (This toggle applies to keyword + location searches; a venue link pasted into Fresha URLs always returns full contact details.)

## `country` (type: `string`):

Which Fresha region to search. Affects the businesses returned for keyword + location searches.

## Actor input object example

```json
{
  "searchTerms": [
    "nail salon"
  ],
  "location": "London, UK",
  "category": "",
  "startUrls": [],
  "maxResults": 100,
  "includeContactDetails": true,
  "country": "gb"
}
```

# Actor output Schema

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

Table of business leads with name, category, rating, location, and profile link.

## `contact` (type: `string`):

Table of contact information: phone, address, city, and starting price.

# 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 = {
    "searchTerms": [
        "nail salon"
    ],
    "location": "London, UK",
    "category": "",
    "startUrls": [],
    "maxResults": 100,
    "includeContactDetails": false,
    "country": "gb"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/fresha-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 = {
    "searchTerms": ["nail salon"],
    "location": "London, UK",
    "category": "",
    "startUrls": [],
    "maxResults": 100,
    "includeContactDetails": False,
    "country": "gb",
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/fresha-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 '{
  "searchTerms": [
    "nail salon"
  ],
  "location": "London, UK",
  "category": "",
  "startUrls": [],
  "maxResults": 100,
  "includeContactDetails": false,
  "country": "gb"
}' |
apify call solidcode/fresha-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fresha Leads Scraper",
        "description": "[💰 $10 / 1K] Extract salon, barber, spa, nail, and beauty business leads from Fresha — names, contact details, ratings, services, pricing, and location. Search by keyword and location or paste Fresha URLs.",
        "version": "1.0",
        "x-build-id": "qkdBOo9Wh6Cpc42ky"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~fresha-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-fresha-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/solidcode~fresha-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-fresha-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/solidcode~fresha-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-fresha-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",
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "What kind of business to find on Fresha (e.g. 'barber', 'nail salon', 'massage', 'spa'). Each term is combined with the Location below. Leave empty if you paste full Fresha URLs instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or area to search in (e.g. 'London, UK', 'New York, NY', 'Sydney'). Combined with each Search Term. Leave empty if you paste full Fresha URLs."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "category:hair-and-styling",
                            "category:nails",
                            "category:hair-removal",
                            "category:eyebrows-and-eyelashes",
                            "category:facials-and-skincare",
                            "category:massage",
                            "category:makeup",
                            "category:aesthetics",
                            "category:barbering",
                            "category:spa-and-wellness",
                            "category:body-and-skin",
                            "category:tattoo-and-piercing",
                            "category:holistic-health",
                            "category:dental",
                            "category:medical",
                            "category:pet-services",
                            "category:health-and-fitness",
                            "category:physical-therapy",
                            "category:counselling-and-therapy",
                            "category:other"
                        ],
                        "type": "string",
                        "description": "Optionally narrow results to one Fresha category. Leave as 'Any category' to search across all beauty & wellness types.",
                        "default": ""
                    },
                    "startUrls": {
                        "title": "Fresha URLs",
                        "type": "array",
                        "description": "Paste Fresha venue or search URLs directly, e.g. https://www.fresha.com/a/venue-name. When provided, these are scraped in addition to any Search Terms above. A pasted venue link always returns that venue's full profile (phone, address, pricing) — even when Include Contact Details is off — because you asked for that specific business.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of business leads to return across all searches and URLs. Set to 0 for unlimited (up to a 100,000-result safety ceiling per run). Each Search Term + Location pair sweeps a grid of nearby points to go deep on dense cities; that grid tops out at roughly 16,000 venues per single city before de-duplication, so to pull more than that for one city, split it into several nearby locations. Tip: start with 20-50 to test, then increase.",
                        "default": 100
                    },
                    "includeContactDetails": {
                        "title": "Include Contact Details (phone, full address & description)",
                        "type": "boolean",
                        "description": "Fetch each business's phone number, full street address, description, and starting price by opening its profile page. This is the core value of a leads list, so it is on by default. It makes one extra lookup per business, so a run takes a little longer. Turn it off for a faster, lighter run when you only need names, ratings, categories, and approximate locations. (This toggle applies to keyword + location searches; a venue link pasted into Fresha URLs always returns full contact details.)",
                        "default": true
                    },
                    "country": {
                        "title": "Country / Region",
                        "enum": [
                            "gb",
                            "us",
                            "au",
                            "ca",
                            "ie",
                            "nz",
                            "ae",
                            "es",
                            "it",
                            "nl",
                            "de",
                            "fr",
                            "pt"
                        ],
                        "type": "string",
                        "description": "Which Fresha region to search. Affects the businesses returned for keyword + location searches.",
                        "default": "gb"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
