# Treatwell Search Scraper (`automation-lab/treatwell-search-scraper`) Actor

💇 Extract Treatwell salon and spa listings with addresses, ratings, visible prices, discounts, images, and profile URLs from search pages.

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

## Pricing

from $0.04 / 1,000 treatwell venue listings

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Treatwell Search Scraper

Extract salon and spa listings from public Treatwell search, category, treatment, and location pages.

Use this actor to turn Treatwell browse pages into a clean dataset of venues, ratings, addresses, visible service prices, discounts, images, and profile URLs.

### What does Treatwell Search Scraper do?

Treatwell Search Scraper reads public Treatwell search pages and saves one structured record per venue listing.

It is designed for search and category URLs such as London haircuts, Manchester massages, nail salons, spa treatments, and other public Treatwell browse pages.

The actor follows Treatwell pagination and stops when your maximum item limit is reached.

### Who is it for?

#### Local-services lead generation teams

Find salons, spas, barbers, nail studios, and beauty venues in a target city or neighbourhood.

#### Beauty brands and suppliers

Build lists of venues that may be relevant for outreach, sampling, partnership, or distribution.

#### Market analysts

Monitor how many venues appear in a treatment category and compare visible pricing across cities.

#### Salon operators

Track competitor ratings, review counts, and listed prices in your local area.

#### Agencies and data teams

Schedule recurring runs and export Treatwell venue data to CRM, BI, or spreadsheet workflows.

### Why use this actor?

- 💇 Extracts public Treatwell venue listings at scale.
- 📍 Captures address, locality, region, postcode, and country fields.
- ⭐ Includes ratings and review counts when Treatwell exposes them.
- 💷 Saves visible service prices, minimum price, maximum price, and discount labels.
- 🖼️ Collects venue image URLs from Treatwell search pages.
- 🔗 Includes venue profile URLs and source search URLs.
- ⚡ Uses HTTP and Cheerio, so it is lightweight and fast.
- 🧾 Outputs a clean Apify dataset ready for export.

### What data can you extract?

| Field | Description |
| --- | --- |
| `venueName` | Treatwell venue name |
| `venueUrl` | Public Treatwell venue profile URL |
| `venueId` | Treatwell listing ID when exposed |
| `position` | Position on the current search page |
| `searchUrl` | Original input URL |
| `pageUrl` | Paginated page that produced the venue |
| `address` | Combined address string |
| `streetAddress` | Street address |
| `locality` | Locality or city field |
| `region` | Region field when available |
| `postalCode` | Postcode |
| `country` | Country code |
| `rating` | Average rating |
| `reviewCount` | Number of reviews |
| `serviceCount` | Number of services visible in the listing telemetry |
| `displayedPrices` | Visible service prices from the search page |
| `discountTypes` | Discount labels such as `from`, `offpeak`, or `sale_price` |
| `minPrice` | Minimum visible price |
| `maxPrice` | Maximum visible price |
| `imageUrl` | Main image URL |
| `imageUrls` | All exposed image URLs |
| `scrapedAt` | ISO timestamp |

### How much does it cost to scrape Treatwell listings?

This actor uses pay-per-event pricing.

You pay a small start fee plus a per-result fee for each Treatwell venue listing saved to the dataset.

The exact price is shown in the Apify Store pricing table before you run the actor.

Because the actor uses direct HTTP by default, normal runs avoid expensive browser automation and proxy bandwidth.

### How to use Treatwell Search Scraper

1. Open the actor on Apify.
2. Paste one or more public Treatwell search, category, treatment, or location URLs.
3. Set `maxItems` to the number of venues you want.
4. Keep `followPagination` enabled if you want more than one page.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, XML, or via API.

### Example Treatwell URLs

Use URLs like these:

```text
https://www.treatwell.co.uk/places/treatment-ladies-haircuts-1/offer-type-local/in-london-uk/
https://www.treatwell.co.uk/places/treatment-massage/offer-type-local/in-manchester-uk/
https://www.treatwell.co.uk/places/treatment-manicure/offer-type-local/in-london-uk/
````

Treatwell may redirect URLs to canonical versions. The actor records the final page URL in `pageUrl`.

### Input configuration

#### `startUrls`

Public Treatwell browse URLs to scrape.

The actor accepts normal search URLs and already-paginated URLs such as `/page-2/`.

#### `maxItems`

Maximum number of unique venue listings to save across all input URLs.

Use a small value for testing and a larger value for recurring collection.

#### `followPagination`

When enabled, the actor follows Treatwell `rel="next"` links until it reaches `maxItems`.

#### `proxyConfiguration`

Optional Apify Proxy settings.

Direct HTTP works for typical public Treatwell pages, so leave proxy disabled unless your environment is blocked.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.treatwell.co.uk/places/treatment-ladies-haircuts-1/offer-type-local/in-london-uk/" }
  ],
  "maxItems": 100,
  "followPagination": true,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

### Example output

```json
{
  "venueName": "Fringe",
  "venueUrl": "https://www.treatwell.co.uk/place/fringe-1/",
  "venueId": 529948,
  "position": 1,
  "searchUrl": "https://www.treatwell.co.uk/places/treatment-ladies-haircuts-1/offer-type-local/in-london-uk/",
  "pageUrl": "https://www.treatwell.co.uk/places/treatment-ladies-haircuts-1/offer-type-local/in-london-uk/",
  "address": "4 Market Place, London, NW11 6JG, GB",
  "rating": 5,
  "reviewCount": 32,
  "displayedPrices": [45, 50, 25],
  "minPrice": 25,
  "maxPrice": 50,
  "imageUrl": "https://cdn1.treatwell.net/images/view/example/",
  "scrapedAt": "2026-07-07T00:00:00.000Z"
}
```

### Tips for best results

- Start with a Treatwell category page that already shows the venue type you need.
- Set `maxItems` high enough to cover all paginated pages in your area.
- Use separate runs for different treatments or cities if you want clean segmentation.
- Keep the original `searchUrl` column when joining results back to campaigns.
- Schedule recurring runs to monitor price and rating changes over time.

### Lead generation workflow

1. Run the actor for a city and treatment category.
2. Export venues with high review counts or specific postcodes.
3. Enrich the venue URLs or addresses with your CRM workflow.
4. Segment leads by price range, rating, or locality.
5. Repeat weekly or monthly for new opportunities.

### Competitive pricing workflow

Use `displayedPrices`, `minPrice`, and `maxPrice` to compare visible Treatwell pricing.

For example, a salon operator can monitor haircut pricing in nearby neighbourhoods and identify venues advertising discounts.

### Market monitoring workflow

Run the same URLs on a schedule.

Compare review counts, new venue URLs, removed venue URLs, and visible price ranges over time.

This is useful for local market maps and category growth tracking.

### Integrations

Connect the dataset to:

- Google Sheets for sales lists.
- Airtable for lead management.
- HubSpot or Salesforce via Apify integrations.
- BigQuery or Snowflake for market analytics.
- Slack alerts when new venues appear.
- Make or Zapier for automated follow-up workflows.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/treatwell-search-scraper').call({
  startUrls: [{ url: 'https://www.treatwell.co.uk/places/treatment-ladies-haircuts-1/offer-type-local/in-london-uk/' }],
  maxItems: 100,
  followPagination: true
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/treatwell-search-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.treatwell.co.uk/places/treatment-ladies-haircuts-1/offer-type-local/in-london-uk/'}],
    'maxItems': 100,
    'followPagination': True,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~treatwell-search-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.treatwell.co.uk/places/treatment-ladies-haircuts-1/offer-type-local/in-london-uk/"}],"maxItems":100,"followPagination":true}'
```

### MCP usage

Use the actor from Apify MCP with Claude Code or Claude Desktop.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/treatwell-search-scraper
```

Add it in Claude Code:

```bash
claude mcp add apify-treatwell "https://mcp.apify.com/?tools=automation-lab/treatwell-search-scraper"
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-treatwell": {
      "url": "https://mcp.apify.com/?tools=automation-lab/treatwell-search-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 100 Treatwell haircut venues in London and summarize the price range."
- "Find Treatwell spa venues in Manchester and export the dataset as CSV."
- "Monitor this Treatwell category page weekly and list new venue URLs."

### Data quality notes

The actor extracts data that Treatwell exposes in public search HTML.

Some pages may show fewer prices or discounts than full venue profile pages.

Address formatting can vary by venue and country.

Ratings and review counts are saved only when Treatwell exposes them on the page.

### Limitations

This actor does not log in, book appointments, bypass paywalls, or access private Treatwell account data.

It does not scrape customer review text in the MVP.

It does not fetch every venue detail page by default, which keeps runs faster and cheaper.

### Legality

This actor extracts publicly available information from Treatwell pages.

You are responsible for ensuring your use case complies with applicable laws, Treatwell terms, privacy rules, and data protection obligations.

Do not use scraped data for spam, harassment, or unlawful profiling.

### FAQ

#### Does this actor scrape Treatwell reviews?

No. The MVP captures review counts and ratings from search pages, not full review text.

#### Can I scrape multiple Treatwell cities in one run?

Yes. Add multiple Treatwell search URLs to `startUrls` and set `maxItems` high enough for the combined run.

### Troubleshooting

#### The run returned fewer items than expected

Check whether the Treatwell URL has enough pages and whether `maxItems` is high enough.

Some locations or treatments have fewer venues than broad categories.

#### A field is missing for some venues

Treatwell does not expose every field for every venue on search pages.

Missing optional fields are omitted rather than filled with fake values.

#### The page is blocked in my environment

Enable Apify Proxy in the advanced input settings and try again.

The actor is designed to work without proxy for normal public pages, but some networks may be blocked.

### Related scrapers

Explore other Automation Lab actors on Apify:

- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/fresha-salon-scraper
- https://apify.com/automation-lab/booking-com-scraper
- https://apify.com/automation-lab/yelp-business-scraper

### Changelog

#### 0.1

Initial version: Treatwell search pagination, JSON-LD venue extraction, ratings, addresses, images, and visible price telemetry.

### Support

If a Treatwell page stops working or you need additional fields, open an Apify issue with the input URL and run ID.

### Summary

Treatwell Search Scraper is a lightweight extractor for public Treatwell salon and spa search pages.

It helps sales, research, and market-monitoring teams collect clean local beauty venue data with low operating cost.

# Actor input Schema

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

Public Treatwell browse URLs such as treatment/category/location pages. Paginated /page-2/ URLs are also supported.

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

Maximum number of unique Treatwell venue records to save across all start URLs.

## `followPagination` (type: `boolean`):

Automatically follow Treatwell next-page links until the maximum venue listing limit is reached.

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

Optional. Direct HTTP works for normal public Treatwell pages; enable Apify Proxy only if your environment is blocked.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.treatwell.co.uk/places/treatment-ladies-haircuts-1/offer-type-local/in-london-uk/"
    }
  ],
  "maxItems": 20,
  "followPagination": true,
  "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 = {
    "startUrls": [
        {
            "url": "https://www.treatwell.co.uk/places/treatment-ladies-haircuts-1/offer-type-local/in-london-uk/"
        }
    ],
    "maxItems": 20,
    "followPagination": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/treatwell-search-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://www.treatwell.co.uk/places/treatment-ladies-haircuts-1/offer-type-local/in-london-uk/" }],
    "maxItems": 20,
    "followPagination": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/treatwell-search-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://www.treatwell.co.uk/places/treatment-ladies-haircuts-1/offer-type-local/in-london-uk/"
    }
  ],
  "maxItems": 20,
  "followPagination": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/treatwell-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Treatwell Search Scraper",
        "description": "💇 Extract Treatwell salon and spa listings with addresses, ratings, visible prices, discounts, images, and profile URLs from search pages.",
        "version": "0.1",
        "x-build-id": "UOqavtRKpEWoebqRE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~treatwell-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-treatwell-search-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~treatwell-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-treatwell-search-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~treatwell-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-treatwell-search-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": "Treatwell search/category URLs",
                        "type": "array",
                        "description": "Public Treatwell browse URLs such as treatment/category/location pages. Paginated /page-2/ URLs are also supported.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum venue listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique Treatwell venue records to save across all start URLs.",
                        "default": 20
                    },
                    "followPagination": {
                        "title": "Follow pagination",
                        "type": "boolean",
                        "description": "Automatically follow Treatwell next-page links until the maximum venue listing limit is reached.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Direct HTTP works for normal public Treatwell pages; enable Apify Proxy only if your environment is blocked."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
