# Booksy Salons, Services & Prices Scraper (`automation-lab/booksy-salons-services-prices-scraper`) Actor

💇 Extract public Booksy salons, locations, ratings, service menus, prices, discounts, and durations for territory research, lead generation, and recurring market benchmarks.

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

## Pricing

from $0.04 / 1,000 item extracteds

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Salons, Services & Prices Scraper

Turn public Booksy salon listings and service menus into a clean market-research dataset.

The Actor extracts one row per provider-service-price combination, including provider identity, location, ratings, current and previous prices, discounts, duration, and source URLs.

Use it for territory mapping, beauty-industry lead research, competitive menu tracking, and recurring local price benchmarks—without manually copying Booksy pages.

### What does Booksy Salons, Services & Prices Scraper do?

This Booksy scraper accepts public category/city search URLs and public provider URLs.

It reads Booksy's server-rendered pages and saves structured records to an Apify dataset.

It can:

- 🔎 Extract providers from a Booksy city/category search
- 💇 Capture public service and variant names
- 💵 Compare current prices with previous prices
- 🏷️ Identify discounts and `from` prices
- ⏱️ Normalize service durations to minutes
- ⭐ Capture provider ratings and review counts
- 📍 Export flat address and geographic fields
- 📄 Follow bounded public search pagination

The Actor does not book appointments or access private calendars.

### Who is it for?

#### Beauty chains and operators

Build a recurring view of competing salons, menu coverage, and visible prices in a territory.

#### Beauty suppliers and distributors

Find provider prospects by location, category, rating, and service mix before outreach.

#### Market researchers

Measure how service names, prices, discounting, and appointment duration vary by neighborhood.

#### Local lead-generation teams

Create structured salon rosters with direct public provider URLs and business context.

#### Data and revenue operations teams

Schedule repeat runs, compare snapshots downstream, and route results into spreadsheets, warehouses, or CRMs.

### Why use this Booksy scraper?

- ✅ **Flat output:** every row works in CSV and spreadsheet exports
- ✅ **Public sources:** no Booksy login or account credentials required
- ✅ **Price context:** current, previous, discounted, and `from` signals
- ✅ **Traceability:** every row includes its provider and source search URL
- ✅ **Repeatability:** schedule the same territory inputs on Apify
- ✅ **Controlled scope:** cap records and pages to control time and cost

Manual research becomes outdated quickly. A saved input can refresh the same public market view whenever you need it.

### What Booksy data can you extract?

| Field | Description |
|---|---|
| `providerId` | Numeric ID parsed from the public Booksy URL |
| `providerName` | Public business/provider name |
| `providerUrl` | Canonical public Booksy provider URL |
| `providerType` | Schema.org provider category, when available |
| `address` | Flat street address text |
| `city` | Locality shown in structured data |
| `region` | State or region |
| `postalCode` | Postal or ZIP code |
| `country` | Country code |
| `latitude`, `longitude` | Public provider coordinates |
| `rating` | Aggregate rating |
| `reviewCount` | Public review count |
| `promoted` | Whether the search card is marked promoted |
| `recommended` | Whether Booksy marks the provider recommended |
| `mobileService` | Whether the search card advertises mobile service |
| `serviceName` | Public service/menu name |
| `serviceVariant` | Variant label, when present |
| `price` | Current public price |
| `previousPrice` | Struck-through or prior price |
| `currency` | ISO-style currency code |
| `discountPercent` | Visible discount percentage |
| `priceFrom` | Whether Booksy marks the price as starting/from |
| `durationMinutes` | Duration normalized to minutes |
| `hasAddons` | Whether add-ons are shown |
| `pageNumber`, `position` | Search pagination context |
| `searchUrl` | Input source URL |
| `scrapedAt` | UTC extraction timestamp |

### How much does it cost to scrape Booksy salon prices?

This Actor uses pay-per-event pricing:

- **Start:** a small one-time fee per run
- **Service price record:** one event per saved dataset row

The formula-derived price is $0.005 per start. Per-record pricing is $0.000072551 on Free, $0.000063088 on Bronze, $0.000049208 on Silver, $0.000037853 on Gold, $0.000025235 on Platinum, and $0.000017665 on Diamond. Apify shows your exact total before each run.

A 25-record test is intentionally small. Increase `maxItems` only after confirming the target and output fit your workflow.

Free-plan users can use the same small prefilled example to assess output quality within available platform credits.

### How to scrape Booksy salons and prices

1. Open the Actor on Apify.
2. Copy a public Booksy category/city search URL or provider URL.
3. Paste it into **Booksy search or provider URLs**.
4. Set the maximum number of service-price records.
5. For search URLs, choose the maximum number of result pages.
6. Click **Start**.
7. Preview the dataset while the run is active.
8. Export results as JSON, CSV, Excel, XML, or another Apify format.

### Input parameters

#### `startUrls`

Required array of public Booksy URLs.

Supported paths include:

- Search/category pages such as `https://booksy.com/en-us/s/hair-salon/30067_new-york-city`
- Provider pages such as `https://booksy.com/en-us/213922_allenstcutshave_hair-salon_30067_new-york-city`

Other hosts and unsupported Booksy paths fail closed.

#### `maxItems`

Maximum unique provider-service-price rows across all inputs.

Default: `25`.

Prefill: `10` for a quick first run.

#### `maxPages`

Maximum search-result pages per search URL.

Default: `1`.

This setting is ignored for direct provider URLs.

### Example input

```json
{
  "startUrls": [
    {
      "url": "https://booksy.com/en-us/s/hair-salon/30067_new-york-city"
    }
  ],
  "maxItems": 25,
  "maxPages": 1
}
````

For a provider-menu extraction:

```json
{
  "startUrls": [
    {
      "url": "https://booksy.com/en-us/213922_allenstcutshave_hair-salon_30067_new-york-city"
    }
  ],
  "maxItems": 50,
  "maxPages": 1
}
```

### Example output

```json
{
  "providerId": "213922",
  "providerName": "Allenstcutshave",
  "providerUrl": "https://booksy.com/en-us/213922_allenstcutshave_hair-salon_30067_new-york-city",
  "providerType": "HairSalon",
  "address": "127 Allen StNew York NY 10002, New York, 10002",
  "city": "New York, NY",
  "region": "New York",
  "postalCode": "10002",
  "country": "US",
  "latitude": 40.71996,
  "longitude": -73.99028,
  "rating": 4.673758865248227,
  "reviewCount": 141,
  "promoted": true,
  "recommended": false,
  "mobileService": false,
  "serviceName": "Shape Up",
  "price": 27,
  "previousPrice": 30,
  "currency": "USD",
  "discountPercent": 10,
  "priceFrom": false,
  "durationMinutes": 25,
  "hasAddons": false,
  "pageNumber": 1,
  "position": 1,
  "searchUrl": "https://booksy.com/en-us/s/hair-salon/30067_new-york-city",
  "scrapedAt": "2026-07-21T00:00:00.000Z"
}
```

Optional fields may be absent when Booksy does not publish them for that service or provider.

### Search pages versus provider pages

Search pages are best for territory rosters and side-by-side service-price comparisons.

They expose multiple providers and the services Booksy chooses to preview.

Provider pages are best when you need a deeper public menu for one known business.

Use both modes in separate saved tasks when you want broad discovery followed by focused enrichment.

### Pagination and limits

For search URLs, the Actor follows Booksy's public `businessesPage` parameter.

Set `maxPages` to the minimum that answers your question.

The Actor stops as soon as `maxItems` unique rows have been saved.

Rows are deduplicated by provider URL, service, variant, and price.

A naturally short result set is returned as-is; the Actor does not manufacture volume.

### Data quality tips

- 🎯 Use a precise Booksy category and city URL
- 📉 Start with one page before expanding a territory
- 🔗 Save `providerUrl` as the stable join key for follow-up runs
- 🕒 Compare `scrapedAt` timestamps when monitoring price changes
- 💱 Group records by `currency` before cross-country analysis
- 🏷️ Treat `promoted` as placement context, not an organic rank
- 📊 Keep `pageNumber` and `position` when studying search visibility

### Scheduling a Booksy price monitor

Create an Apify task with a stable city/category URL.

Schedule it daily, weekly, or monthly according to your market's rate of change.

Send each run to a named dataset or external warehouse.

Compare records by `providerUrl`, `serviceName`, and `serviceVariant`.

Alert only when `price`, `previousPrice`, or `discountPercent` changes.

This avoids repeatedly reviewing unchanged menu rows.

### Integrations and workflows

#### Google Sheets territory roster

Send new dataset rows to Google Sheets, then filter by city, rating, and service.

#### CRM lead enrichment

Match provider URLs to existing accounts and append public service/category context before outreach.

#### BigQuery or Snowflake benchmark

Load scheduled datasets, partition by `scrapedAt`, and calculate price distributions by market.

#### Slack price-change alert

Use an Apify webhook to call Make or Zapier after a run, compare the newest snapshot, and post material changes.

#### Supplier prospect scoring

Combine service names, location, and review volume to prioritize relevant beauty-business prospects.

### Run with the Apify API using JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/booksy-salons-services-prices-scraper').call({
  startUrls: [{ url: 'https://booksy.com/en-us/s/hair-salon/30067_new-york-city' }],
  maxItems: 25,
  maxPages: 1,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with the Apify API using Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/booksy-salons-services-prices-scraper').call(run_input={
    'startUrls': [{'url': 'https://booksy.com/en-us/s/hair-salon/30067_new-york-city'}],
    'maxItems': 25,
    'maxPages': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Run with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~booksy-salons-services-prices-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls":[{"url":"https://booksy.com/en-us/s/hair-salon/30067_new-york-city"}],
    "maxItems":25,
    "maxPages":1
  }'
```

Read dataset items after the run succeeds:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"
```

### Use this Booksy scraper with MCP

Connect the Actor to AI tools through the Apify MCP server.

Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/booksy-salons-services-prices-scraper"
```

Claude Desktop, Cursor, or VS Code configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/booksy-salons-services-prices-scraper"
    }
  }
}
```

Example prompts:

- “Extract 25 public Booksy hair salon service prices from this New York search URL.”
- “Get the public service menu and durations for this Booksy provider.”
- “Compare current and previous prices in the resulting dataset.”

### Reliability and error handling

The Actor makes sequential HTTP requests with realistic browser headers and bounded retries.

HTTP 403 and 429 responses fail visibly rather than returning an empty successful dataset.

Unsupported URLs fail before scraping starts.

A page that yields no service-price records also fails non-zero, so monitors do not silently accept extraction regressions.

Individual duplicate rows are skipped.

### Troubleshooting

#### Why did my URL fail validation?

Confirm the hostname is `booksy.com` and the path is either a public search/category path containing `/s/` or a public provider path beginning with a numeric provider ID.

#### Why did I receive HTTP 403 or 429?

Booksy may temporarily rate-limit repeated traffic. Reduce pages, wait before retrying, and avoid launching many concurrent runs for the same market.

#### Why are only a few services shown for a provider?

Search cards often preview a subset. Use the provider's direct public Booksy URL to extract the fuller visible menu.

#### Why is an optional price field missing?

Some Booksy services do not expose a numeric price, previous price, discount, duration, or variant. Missing optional data is not replaced with invented values.

### Legal and ethical use

This Actor extracts information displayed publicly on Booksy pages without logging in.

Use it responsibly and comply with Booksy's terms, applicable laws, and contractual obligations.

Do not use the Actor to access private calendars, customer identities, booking details, or authenticated information.

Avoid excessive request volume and collect only data necessary for a legitimate purpose.

Personal-data and outreach rules vary by jurisdiction; obtain legal advice for your specific use case.

### Related scrapers

Build broader local-business workflows with other automation-lab Actors:

- [Google Maps Scraper](https://apify.com/automation-lab/google-maps-scraper)
- [Yelp Scraper](https://apify.com/automation-lab/yelp-scraper)
- [Booking Scraper](https://apify.com/automation-lab/booking-scraper)

Use Booksy-specific output when service menu and beauty-provider price context are the central requirement.

### FAQ

#### Does this Actor require a Booksy account?

No. V1 is limited to public anonymous search and provider pages.

#### Can it book appointments?

No. Booking actions and private availability are intentionally out of scope.

#### Can I scrape several cities?

Yes. Add multiple public Booksy search URLs and set a combined `maxItems` limit.

#### Does it output one row per provider?

No. It outputs one row per provider-service-price combination so prices and durations remain flat and exportable.

#### Can I export CSV or Excel?

Yes. Use the standard Apify dataset export controls or API formats.

#### Can I monitor price changes?

Yes. Schedule a stable input and compare snapshots downstream by provider URL and service name.

#### Are ratings and reviews included?

The aggregate rating and public review count are included when Booksy exposes them in structured data.

#### Is pagination automatic?

Yes, up to your `maxPages` and `maxItems` limits for search URLs.

#### Does the Actor scrape individual review text?

No. This product focuses on provider, service-menu, and price intelligence.

#### What happens if Booksy changes its page?

The Actor fails when no valid records can be extracted instead of silently returning a successful empty result. Report the failing public URL through the Actor issue form.

### Support

For reproducible support, include:

- The public Booksy URL
- The run ID
- The expected service or provider
- Whether the page works in a normal anonymous browser

Do not include account credentials or private booking data.

# Actor input Schema

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

Add public Booksy category/city search URLs or individual provider URLs.

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

Stop after saving this many unique provider-service rows across all targets.

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

Follow up to this many Booksy search-result pages. Provider URLs always use one page.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://booksy.com/en-us/s/hair-salon/30067_new-york-city"
    }
  ],
  "maxItems": 10,
  "maxPages": 1
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://booksy.com/en-us/s/hair-salon/30067_new-york-city"
        }
    ],
    "maxItems": 10,
    "maxPages": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/booksy-salons-services-prices-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": [{ "url": "https://booksy.com/en-us/s/hair-salon/30067_new-york-city" }],
    "maxItems": 10,
    "maxPages": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/booksy-salons-services-prices-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": [
    {
      "url": "https://booksy.com/en-us/s/hair-salon/30067_new-york-city"
    }
  ],
  "maxItems": 10,
  "maxPages": 1
}' |
apify call automation-lab/booksy-salons-services-prices-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Booksy Salons, Services & Prices Scraper",
        "description": "💇 Extract public Booksy salons, locations, ratings, service menus, prices, discounts, and durations for territory research, lead generation, and recurring market benchmarks.",
        "version": "0.1",
        "x-build-id": "dceYFObvryv74273S"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~booksy-salons-services-prices-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-booksy-salons-services-prices-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~booksy-salons-services-prices-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-booksy-salons-services-prices-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~booksy-salons-services-prices-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-booksy-salons-services-prices-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 or provider URLs",
                        "type": "array",
                        "description": "Add public Booksy category/city search URLs or individual provider URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum service-price records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique provider-service rows across all targets.",
                        "default": 25
                    },
                    "maxPages": {
                        "title": "Maximum search pages per URL",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Follow up to this many Booksy search-result pages. Provider URLs always use one page.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```