# Booksy Leads Scraper (`solidcode/booksy-scraper`) Actor

\[💰 $1.9 / 1K] Extract salon, barber, spa, and beauty business leads from Booksy — names, contact details, ratings, social links, and location. Search by keyword and location or paste Booksy URLs.

- **URL**: https://apify.com/solidcode/booksy-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 $1.90 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Leads Scraper

Pull salon, barber, spa, and beauty business leads from Booksy at scale — business name, full address, geo-coordinates, precise rating and review count, price range, and website plus Instagram and Facebook links for every provider. Built for beauty-industry lead-gen teams, salon-marketing agencies, and local-services sales reps who need verified salon and barber leads with contact details — without manually copying listings off Booksy one profile at a time.

### Why This Scraper?

- **7-country coverage** — search the United States, United Kingdom, Poland, Spain, South Africa, Ireland, and Australia from a single actor; flip one dropdown to switch regions.
- **Website + Instagram + Facebook on every lead** — each business is enriched with its booking-page website and social handles, so your list lands sales-ready instead of name-only.
- **Precise ratings, not rounded stars** — the exact numeric rating (e.g. 4.87) and the underlying review count, so you can rank and filter prospects on real reputation signals.
- **Price-range, mobile-service, and Booksy-recommended flags** — see each provider's low-to-high price band, whether they offer at-home/mobile appointments, and whether Booksy badges them as recommended.
- **Geo-coordinates on every business** — latitude and longitude plus the full street address, ready to plot on a map or drop into a territory-planning tool.
- **De-duplicated results across searches** — the same business is never returned twice, even when overlapping keywords or locations pull it into multiple search runs.
- **Keyword-by-location matrix** — pair any service term ("barber", "nail salon", "massage", "hair salon") with any city and the actor runs every combination automatically.
- **Up to unlimited results per run** — set a cap of 100 to test or 0 for the entire result set of a market.
- **Direct booking URL per business** — every row carries the live Booksy profile link, so reps can open the provider's page in one click.

### Use Cases

**Lead Generation**
- Build sales-ready prospect lists of salons and barbershops with website and social links attached
- Target a city or neighborhood and pull every provider in a given service category
- Prioritize outreach by rating and review volume to focus on established businesses
- Identify mobile-service providers who travel to clients for partnership offers

**Market Research**
- Map provider density by city across 7 countries
- Compare price ranges for the same service across neighborhoods and markets
- Track which providers carry the "Booksy Recommended" badge in a region
- Size a beauty or wellness market before launching a product or service

**Competitive Analysis**
- Benchmark a salon's rating and review count against nearby competitors
- Monitor the social presence (Instagram/Facebook) of competing providers
- Find under-rated or under-reviewed providers ripe for a service pitch
- Track new entrants appearing in a target service category

**Local Services Outreach**
- Recruit salons and barbers for marketplaces, software, or supplier programs
- Source providers for affiliate, referral, or directory partnerships
- Build geo-targeted call lists by category and city
- Feed verified business profiles into a CRM or cold-outreach sequence

### Getting Started

#### Search by Keyword and Location

The simplest way to start — one service term and a city:

```json
{
    "searchTerms": ["barber"],
    "location": "New York, NY",
    "maxResults": 50
}
````

#### Multiple Service Terms

Run several categories against the same location in one go:

```json
{
    "searchTerms": ["nail salon", "hair salon", "massage"],
    "location": "Newport Beach",
    "country": "us",
    "maxResults": 300
}
```

#### Using Booksy URLs

Paste any Booksy search or business URL directly:

```json
{
    "startUrls": [
        "https://booksy.com/en-us/s/haircut-beard/102522_newport-beach"
    ],
    "maxResults": 100,
    "includeContactDetails": true
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | string\[] | `["barber"]` | What kind of business to find on Booksy (e.g. "barber", "nail salon", "massage", "hair salon"). Each term is combined with the Location below. Leave empty if you paste full Booksy URLs instead. |
| `location` | string | `"New York, NY"` | City or area to search in (e.g. "New York, NY", "Newport Beach", "London"). Combined with each Search Term. Leave empty if you paste full Booksy URLs. |
| `startUrls` | string\[] | `[]` | Paste Booksy search or business URLs directly. When provided, these are scraped in addition to any Search Terms above. |

#### 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). Start with 20-50 to test, then increase. |
| `country` | select | `United States` | Which Booksy region to search: United States, United Kingdom, Poland, Spain, South Africa, Ireland, or Australia. Affects the businesses returned for keyword + location searches. |
| `includeContactDetails` | boolean | `true` | Fetch each business's website, Facebook, and Instagram links. This is the core value of a leads list, so it is on by default. Turn it off for a faster, lighter run when you only need names, ratings, and locations. |

### Output

Each business lead is a single flat row. Here's a representative result with contact details enabled:

```json
{
    "businessId": 102522,
    "name": "Fresh Cuts Barber Studio",
    "url": "https://booksy.com/en-us/102522_fresh-cuts-barber-studio_barber-shop_12345_new-york",
    "bookingUrl": "https://booksy.com/en-us/102522_fresh-cuts-barber-studio_barber-shop_12345_new-york",
    "category": "Barber Shop",
    "address": "215 W 38th St, New York, NY 10018",
    "city": "New York",
    "latitude": 40.7536,
    "longitude": -73.9912,
    "distance": 820,
    "phone": "+1 212-555-0142",
    "website": "https://freshcutsnyc.com",
    "facebook": "https://facebook.com/freshcutsnyc",
    "instagram": "https://instagram.com/freshcutsnyc",
    "rating": 4.87,
    "reviewCount": 342,
    "priceFrom": 25,
    "priceTo": 65,
    "mobileService": false,
    "booksyRecommended": true,
    "imageUrl": "https://cdn.booksy.com/example/cover.jpg",
    "country": "us",
    "searchTerm": "barber",
    "scrapedAt": "2026-05-29T14:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `businessId` | number | Unique Booksy business identifier |
| `name` | string | Business name |
| `category` | string | Business category (e.g. "Barber Shop", "Nail Salon") |
| `url` | string | Direct Booksy profile URL |
| `bookingUrl` | string | Live Booksy booking page link |
| `imageUrl` | string | Cover image URL |

#### Location

| Field | Type | Description |
|-------|------|-------------|
| `address` | string | Full street address |
| `city` | string | City |
| `latitude` | number | Latitude |
| `longitude` | number | Longitude |
| `distance` | number | Distance from the search center, in meters |

#### Contact

Website and social links populate when `includeContactDetails` is on. Phone is included when the business lists one publicly.

| Field | Type | Description |
|-------|------|-------------|
| `phone` | string | Phone number, when listed |
| `website` | string | Business website |
| `facebook` | string | Facebook page link |
| `instagram` | string | Instagram profile link |

#### Ratings & Pricing

| Field | Type | Description |
|-------|------|-------------|
| `rating` | number | Precise average rating (e.g. 4.87) |
| `reviewCount` | number | Total number of reviews |
| `priceFrom` | number | Lowest listed service price |
| `priceTo` | number | Highest listed service price |
| `mobileService` | boolean | Whether the provider offers mobile / at-home appointments |
| `booksyRecommended` | boolean | Whether Booksy badges the business as recommended |

#### Metadata

| Field | Type | Description |
|-------|------|-------------|
| `country` | string | Booksy region the result came from (us, gb, pl, es, za, ie, au) |
| `searchTerm` | string | The keyword that surfaced this business |
| `scrapedAt` | string | ISO timestamp of data extraction |

### 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 to a full market.
- **Turn off contact details for speed** — switch `includeContactDetails` off for a faster, lighter run when you only need names, ratings, and locations; turn it on when you want a sales-ready list with websites and social handles.
- **Match the region to the location** — set `country` to the same region as your `location` (e.g. United Kingdom for "London"). A Poland-scoped search will return zero hints for a UK city, since each Booksy region is geo-bound to its own country.
- **Run a keyword matrix** — list several service terms ("barber", "nail salon", "massage") against one location to sweep an entire local beauty market in a single run.
- **Filter on review count** — rating alone can be misleading; pair a high `rating` with a healthy `reviewCount` to focus outreach on established, busy providers.
- **Paste URLs for exact control** — when you already have a specific Booksy search or business page, paste it into `startUrls` to pull precisely that result set.

### Pricing

**$1.90 per 1,000 results** — flat, pay-per-result pricing. No compute charges — you only pay per result returned.

| Results | Estimated Cost |
|---------|----------------|
| 100 | $0.19 |
| 1,000 | $1.90 |
| 10,000 | $19.00 |
| 100,000 | $190.00 |

A "result" is any business lead row in the output dataset. Platform fees 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 business research, market analysis, and lead generation. Users are responsible for complying with applicable laws, data-protection regulations, and Booksy's Terms of Service. Do not use extracted contact data for spam, harassment, or any unlawful purpose, and respect the privacy of the businesses and individuals in your results.

# Actor input Schema

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

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

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

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

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

Paste Booksy search or listing URLs directly, e.g. https://booksy.com/en-us/s/haircut-beard/102522\_newport-beach. When provided, these are scraped in addition to any Search Terms above.

## `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). Tip: start with 20-50 to test, then increase.

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

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

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

Fetch each business's website, Facebook, and Instagram links. 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, and locations.

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

Proxy settings. Datacenter proxies are used by default and work well for Booksy.

## Actor input object example

```json
{
  "searchTerms": [
    "barber"
  ],
  "location": "New York, NY",
  "startUrls": [],
  "maxResults": 100,
  "country": "us",
  "includeContactDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

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

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

Table of contact information: phone, website, and social links.

# 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": [
        "barber"
    ],
    "location": "New York, NY",
    "startUrls": [],
    "maxResults": 100,
    "country": "us",
    "includeContactDetails": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "searchTerms": ["barber"],
    "location": "New York, NY",
    "startUrls": [],
    "maxResults": 100,
    "country": "us",
    "includeContactDetails": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "searchTerms": [
    "barber"
  ],
  "location": "New York, NY",
  "startUrls": [],
  "maxResults": 100,
  "country": "us",
  "includeContactDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call solidcode/booksy-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Booksy Leads Scraper",
        "description": "[💰 $1.9 / 1K] Extract salon, barber, spa, and beauty business leads from Booksy — names, contact details, ratings, social links, and location. Search by keyword and location or paste Booksy URLs.",
        "version": "1.0",
        "x-build-id": "0cZve9nLeivmQsI0R"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~booksy-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-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/solidcode~booksy-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-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/solidcode~booksy-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-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": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "What kind of business to find on Booksy (e.g. 'barber', 'nail salon', 'massage', 'hair salon'). Each term is combined with the Location below. Leave empty if you paste full Booksy URLs instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or area to search in (e.g. 'New York, NY', 'Newport Beach', 'London'). Combined with each Search Term. Leave empty if you paste full Booksy URLs."
                    },
                    "startUrls": {
                        "title": "Booksy URLs",
                        "type": "array",
                        "description": "Paste Booksy search or listing URLs directly, e.g. https://booksy.com/en-us/s/haircut-beard/102522_newport-beach. When provided, these are scraped in addition to any Search Terms above.",
                        "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). Tip: start with 20-50 to test, then increase.",
                        "default": 100
                    },
                    "country": {
                        "title": "Country / Region",
                        "enum": [
                            "us",
                            "gb",
                            "pl",
                            "es",
                            "za",
                            "ie",
                            "au"
                        ],
                        "type": "string",
                        "description": "Which Booksy region to search. Affects the businesses returned for keyword + location searches.",
                        "default": "us"
                    },
                    "includeContactDetails": {
                        "title": "Include Contact Details (website & social links)",
                        "type": "boolean",
                        "description": "Fetch each business's website, Facebook, and Instagram links. 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, and locations.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Datacenter proxies are used by default and work well for Booksy.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
