# Booksy Scraper | 1.5$/1k Cheap (`trev0n/booksy-scraper`) Actor

Scrape beauty & wellness businesses from Booksy by keyword and location, or from direct Booksy URLs. Pulls names, ratings, reviews, full services with prices, opening hours, staff, contacts and social links.

- **URL**: https://apify.com/trev0n/booksy-scraper.md
- **Developed by:** [Paweł](https://apify.com/trev0n) (community)
- **Categories:** Automation, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 83.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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

## 💈 Booksy Scraper

🎯 **Pull every beauty & wellness business on Booksy into a clean, structured dataset — by keyword, by city, or straight from a Booksy link.**

This scraper turns Booksy listings into ready-to-use data: business names, ratings and reviews, the full services menu with prices and durations, opening hours, staff, contact details and social links. Perfect for lead generation, market research, and competitive analysis across barbershops, hair & nail salons, spas, beauticians and more.

### 🚀 What Does It Do?

This scraper automatically finds businesses on Booksy and collects **structured, ready-to-use data** for each one. No manual browsing, no copy-pasting — just set your search and hit Start.

💡 **Two modes of operation:**

1. **🔍 Search Mode** — Type a service or business type (e.g. _barber_, _nails_, _spa_) and a location (e.g. _Chicago_, _Warszawa_). The scraper finds every matching business in that area and pulls full profiles.
2. **📋 Direct URL Mode** — Paste specific Booksy search pages or individual business profile links and scrape exactly those.

### 👥 Who Is This For?

| 🏢 Use Case                     | 💬 How It Helps                                                                     |
| ------------------------------- | ----------------------------------------------------------------------------------- |
| 📣 **Marketing agencies**       | Build targeted lead lists of salons and barbershops with contact and social details |
| 📊 **Market researchers**       | Analyze pricing, service offerings, and ratings across cities and categories        |
| 💼 **Sales teams**              | Find and qualify beauty businesses by location, rating, and service mix             |
| 🧴 **Suppliers & B2B brands**   | Discover salons and spas to pitch products and partnerships                         |
| 🏷️ **Salon owners**             | Benchmark competitors' prices, hours, services, and customer ratings                |
| 🤝 **Booking & SaaS platforms** | Source verified business directories for onboarding and outreach                    |

### ✨ Features

- 🌍 **10 Booksy markets** — United States, United Kingdom, Ireland, Australia, Canada, South Africa, Poland, Spain, France and Brazil
- 🔍 **Keyword + location search** — Find any service type in any city, with automatic location matching
- 💈 **Full business profiles** — Names, categories, descriptions, ratings and review counts
- 💰 **Services & prices** — The complete menu with prices and durations for every business
- 🕒 **Opening hours** — Full weekly schedule per business
- 👤 **Staff & reviews** — Team members and a sample of recent customer reviews
- 📞 **Contacts & socials** — Website, Instagram and Facebook links
- 🖼️ **Photos** — Cover image and a gallery of business photos
- 🎛️ **Smart Filters** — Limit results, cap pages, toggle services/reviews, and trim empty fields
- ⚡ **Fast & Scalable** — Pull thousands of businesses per run
- 🧹 **Deduplication** — Every business appears once, even across paginated results
- 📤 **Export Anywhere** — Download results as JSON, CSV, Excel, or push to Google Sheets, Zapier, Make, or your CRM

### 🎛️ Filters & Options

| Option                      | What It Does                                                                    |
| --------------------------- | ------------------------------------------------------------------------------- |
| 🔍 **Search Query**         | The service or business type to find (barber, hair salon, nails, spa, fryzjer…) |
| 📍 **Location**             | City or area to search in — matched to a Booksy region automatically            |
| 🌍 **Country**              | Which Booksy country site to search                                             |
| 💈 **Include Services**     | Collect the full services catalog with prices and durations                     |
| ⭐ **Include Reviews**      | Collect a sample of recent customer reviews                                     |
| 🔢 **Max Results**          | Control how many businesses to extract per run                                  |
| 📄 **Max Listing Pages**    | Optionally cap how many result pages to read                                    |
| 🧹 **Exclude Empty Fields** | Drop null/empty fields for a leaner dataset                                     |
| 🔗 **Direct URLs**          | Optionally provide specific Booksy URLs to scrape                               |

### 📦 What You Get (Output Fields)

Every business includes:

#### Business Info

| Field           | Example                                                    |
| --------------- | ---------------------------------------------------------- |
| businessId      | `424015`                                                   |
| name            | `Virile Barber & Shop`                                     |
| slug            | `virile-barber-shop`                                       |
| primaryCategory | `Barbershop`                                               |
| categories      | `["Barbershop"]`                                           |
| description     | `Virile's inception took place in 2011 in Waldwick, NJ...` |

#### Ratings & Reviews

| Field       | Example                                                                                                          |
| ----------- | ---------------------------------------------------------------------------------------------------------------- |
| rating      | `5`                                                                                                              |
| reviewCount | `416`                                                                                                            |
| rankScore   | `4.945`                                                                                                          |
| reviews     | `[{ "author": "Erik D", "rating": 5, "text": "Perfect haircut. I'll be back!", "date": "2026-05-30T14:21:00" }]` |

#### Location

| Field     | Example                           |
| --------- | --------------------------------- |
| address   | `2 Frederick St, Waldwick, 07463` |
| city      | `Waldwick`                        |
| state     | `New Jersey`                      |
| zipCode   | `07463`                           |
| latitude  | `41.0123191`                      |
| longitude | `-74.1205505`                     |

#### Services & Hours

| Field     | Example                                                                                                                                     |
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| services  | `[{ "category": "Haircuts", "name": "Haircut & Beard Trim", "price": 90, "priceText": "$90.00", "durationMin": 60, "description": "..." }]` |
| openHours | `[{ "day": "Monday", "from": "14:30", "till": "19:00", "closed": false }]`                                                                  |
| staff     | `[{ "name": "Anthony", "position": "Master Barber", "description": null, "photoUrl": "https://..." }]`                                      |

#### Contacts & Media

| Field        | Example                                                                         |
| ------------ | ------------------------------------------------------------------------------- |
| website      | `https://www.virile.com`                                                        |
| instagram    | `https://www.instagram.com/virile/`                                             |
| facebook     | `https://www.facebook.com/virilewaldwick/`                                      |
| phone        | `(201) 444-4565`                                                                |
| imageUrl     | `https://d2zdpiztbgorvt.cloudfront.net/region1/us/424015/logo/...booksy.jpeg`   |
| photoGallery | `["https://.../biz_photo/...booksy.jpeg", "..."]`                               |
| bookingUrl   | `https://booksy.com/en-us/424015_virile-barber-shop_barber-shop_28400_waldwick` |

### 📊 Example Output

```json
{
    "businessId": 424015,
    "name": "Virile Barber & Shop",
    "slug": "virile-barber-shop",
    "primaryCategory": "Barbershop",
    "categories": ["Barbershop"],
    "description": "Virile's inception took place in 2011 in Waldwick, NJ. The concept was a haven where men can comfortably walk in for professional grooming.",
    "rating": 5,
    "reviewCount": 416,
    "rankScore": 4.945,
    "address": "2 Frederick St, Waldwick, 07463",
    "city": "Waldwick",
    "state": "New Jersey",
    "zipCode": "07463",
    "latitude": 41.0123191,
    "longitude": -74.1205505,
    "phone": "(201) 444-4565",
    "website": "https://www.virile.com",
    "instagram": "https://www.instagram.com/virile/",
    "facebook": "https://www.facebook.com/virilewaldwick/",
    "openHours": [
        { "day": "Monday", "from": "14:30", "till": "19:00", "closed": false },
        { "day": "Tuesday", "from": "10:00", "till": "18:30", "closed": false }
    ],
    "services": [
        {
            "category": "Haircuts",
            "name": "Haircut & Beard Trim",
            "price": 90,
            "priceText": "$90.00",
            "durationMin": 60,
            "description": "Haircut and a beard trim with the first available Master or Senior Barber."
        }
    ],
    "staff": [{ "name": "Anthony", "position": "Master Barber", "description": null, "photoUrl": "https://..." }],
    "reviews": [
        { "author": "Erik D", "rating": 5, "text": "Perfect haircut. I'll be back!", "date": "2026-05-30T14:21:00" }
    ],
    "imageUrl": "https://d2zdpiztbgorvt.cloudfront.net/region1/us/424015/logo/...booksy.jpeg",
    "photoGallery": ["https://d2zdpiztbgorvt.cloudfront.net/region1/us/424015/biz_photo/...booksy.jpeg"],
    "priceLevel": 2,
    "acceptsBooksyPay": true,
    "acceptsGiftCards": true,
    "bookingUrl": "https://booksy.com/en-us/424015_virile-barber-shop_barber-shop_28400_waldwick",
    "searchQuery": "barber",
    "searchLocation": "Waldwick, NJ",
    "scrapedAt": "2026-06-26T12:00:00.000Z"
}
````

### 📋 Dataset Views

The Apify Console gives you **3 ready-made table views** to quickly browse your results:

| View                     | What It Shows                                                                    |
| ------------------------ | -------------------------------------------------------------------------------- |
| 📊 **Overview**          | Name, category, rating, reviews, city, state, address and booking link           |
| 📞 **Contacts & Social** | Name, city, website, Instagram, Facebook and booking link — ideal for lead lists |
| 📋 **Full Details**      | Every single field — the complete dataset                                        |

### ❓ FAQ

**🤔 How do I search a specific city?**
Just type the city in the **Location** field (e.g. *Chicago*, *Miami*, *Warszawa*) and pick the matching **Country**. The scraper matches it to the right Booksy region automatically.

**🤔 Which countries are supported?**
United States, United Kingdom, Ireland, Australia, Canada, South Africa, Poland, Spain, France and Brazil — all the markets where Booksy operates.

**🤔 Can I scrape a single business or a specific search page?**
Yes — paste its Booksy URL into the **Direct URLs** field and the scraper will pull exactly that.

**🤔 Does it include prices and opening hours?**
Yes — every business comes with its full services menu (with prices and durations) and its weekly opening hours.

**🤔 Do results include phone numbers?**
Yes — business phone numbers are included whenever Booksy has one on file, alongside website, Instagram and Facebook links.

**🤔 Can I export the data?**
Yes — JSON, CSV, Excel, XML, HTML, RSS. You can also push data directly to Google Sheets, Zapier, Make, or any webhook/API endpoint.

**🤔 How often should I run this?**
For fresh data, run daily or weekly. You can schedule automatic runs on Apify with just a few clicks.

**🤔 Does it work with proxies?**
Yes — residential proxies are recommended for the best results on large or recurring runs. The scraper works with Apify's built-in proxy service.

### 🛠️ Need Custom Filters or Features?

**I'm happy to customize this scraper for your specific needs!** 🤝

Whether you need:

- 🎯 Additional filters (by rating, by minimum review count, by service category, by accepting Booksy Pay…)
- 📊 Extra data fields or custom output formats
- 🔄 Integration with your CRM, Google Sheets, or database
- ⏰ Scheduled scraping with automatic deduplication
- 🌐 Scraping from other booking and directory platforms alongside Booksy

👉 **Don't hesitate to reach out via private message** — I respond quickly and I'm always open to building exactly what you need. No request is too small or too specific!

### ⚖️ Legal & Ethical Use

This scraper collects business information from Booksy and does not interact with the booking system. Please use the data responsibly and in compliance with applicable laws and platform terms of service.

# Actor input Schema

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

What to look for — a business type or service (e.g. "barber", "hair salon", "nails", "spa", "fryzjer"). Leave empty to pull every business in the location.

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

City or area to search in (e.g. "Chicago", "New York", "Warszawa"). Required for search mode — it is geocoded to a Booksy region automatically.

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

Which Booksy country site to search. Must match the location's country.

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

Optionally scrape specific Booksy URLs directly — paste search-result pages and/or individual business profile URLs. Overrides nothing; runs alongside search mode.

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

Maximum number of businesses to scrape. Set to 0 for no limit.

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

Optional cap on how many result pages to read per search (20 businesses per page). 0 = no page cap.

## `includeServices` (type: `boolean`):

Collect the full services catalog with prices and durations for each business.

## `includeReviews` (type: `boolean`):

Collect a sample of recent customer reviews for each business.

## `servicesLimit` (type: `integer`):

Cap the number of services collected per business. 0 = all services.

## `reviewsLimit` (type: `integer`):

How many sample reviews to keep per business.

## `detailConcurrency` (type: `integer`):

How many business detail requests to run in parallel (1–20).

## `excludeEmptyFields` (type: `boolean`):

Drop null / empty fields from each output record for a leaner dataset.

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

Proxy settings. Booksy's public API works without a proxy, but residential proxies are recommended for large or recurring runs.

## Actor input object example

```json
{
  "searchQuery": "barber",
  "location": "Chicago",
  "country": "us",
  "startUrls": [],
  "maxItems": 50,
  "maxPages": 0,
  "includeServices": true,
  "includeReviews": true,
  "servicesLimit": 0,
  "reviewsLimit": 10,
  "detailConcurrency": 8,
  "excludeEmptyFields": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQuery": "barber",
    "location": "Chicago",
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("trev0n/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 = {
    "searchQuery": "barber",
    "location": "Chicago",
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("trev0n/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 '{
  "searchQuery": "barber",
  "location": "Chicago",
  "startUrls": []
}' |
apify call trev0n/booksy-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Booksy Scraper | 1.5$/1k Cheap",
        "description": "Scrape beauty & wellness businesses from Booksy by keyword and location, or from direct Booksy URLs. Pulls names, ratings, reviews, full services with prices, opening hours, staff, contacts and social links.",
        "version": "1.0",
        "x-build-id": "c7J9LPygvn94Nqedv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trev0n~booksy-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trev0n-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/trev0n~booksy-scraper/runs": {
            "post": {
                "operationId": "runs-sync-trev0n-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/trev0n~booksy-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-trev0n-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",
                "properties": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "What to look for — a business type or service (e.g. \"barber\", \"hair salon\", \"nails\", \"spa\", \"fryzjer\"). Leave empty to pull every business in the location."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or area to search in (e.g. \"Chicago\", \"New York\", \"Warszawa\"). Required for search mode — it is geocoded to a Booksy region automatically."
                    },
                    "country": {
                        "title": "Country / Booksy site",
                        "enum": [
                            "us",
                            "gb",
                            "ie",
                            "au",
                            "ca",
                            "za",
                            "pl",
                            "es",
                            "fr",
                            "br"
                        ],
                        "type": "string",
                        "description": "Which Booksy country site to search. Must match the location's country.",
                        "default": "us"
                    },
                    "startUrls": {
                        "title": "Direct Booksy URLs",
                        "type": "array",
                        "description": "Optionally scrape specific Booksy URLs directly — paste search-result pages and/or individual business profile URLs. Overrides nothing; runs alongside search mode.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of businesses to scrape. Set to 0 for no limit.",
                        "default": 50
                    },
                    "maxPages": {
                        "title": "Max listing pages",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional cap on how many result pages to read per search (20 businesses per page). 0 = no page cap.",
                        "default": 0
                    },
                    "includeServices": {
                        "title": "Include services & prices",
                        "type": "boolean",
                        "description": "Collect the full services catalog with prices and durations for each business.",
                        "default": true
                    },
                    "includeReviews": {
                        "title": "Include sample reviews",
                        "type": "boolean",
                        "description": "Collect a sample of recent customer reviews for each business.",
                        "default": true
                    },
                    "servicesLimit": {
                        "title": "Services per business",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap the number of services collected per business. 0 = all services.",
                        "default": 0
                    },
                    "reviewsLimit": {
                        "title": "Reviews per business",
                        "minimum": 0,
                        "type": "integer",
                        "description": "How many sample reviews to keep per business.",
                        "default": 10
                    },
                    "detailConcurrency": {
                        "title": "Detail concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many business detail requests to run in parallel (1–20).",
                        "default": 8
                    },
                    "excludeEmptyFields": {
                        "title": "Exclude empty fields",
                        "type": "boolean",
                        "description": "Drop null / empty fields from each output record for a leaner dataset.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Booksy's public API works without a proxy, but residential proxies are recommended for large or recurring runs.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
