# Fresha Salon Scraper (`automation-lab/fresha-salon-scraper`) Actor

Extract public Fresha salon, spa, barber, nail, massage, and beauty business leads with ratings, reviews, addresses, images, and profile URLs.

- **URL**: https://apify.com/automation-lab/fresha-salon-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, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Fresha Salon Scraper

Extract public salon, spa, barber, nail, massage, and beauty business leads from Fresha marketplace pages.

### What does Fresha Salon Scraper do?

Fresha Salon Scraper collects structured business data from public Fresha listing pages.

Use it when you need a clean dataset of beauty and wellness venues listed on Fresha.

The actor reads server-rendered Fresha marketplace pages and extracts public Schema.org business data.

It is designed for lead generation, market research, competitor monitoring, and local business analysis.

### Who is it for?

💇 Beauty SaaS teams can find salons and spas that already use online booking marketplaces.

📣 Local marketing agencies can build prospect lists for outreach campaigns.

📊 Marketplace analysts can compare venue density, ratings, and review counts by city or service category.

🧴 Beauty brands can discover salons, barbers, nail studios, and spas in target regions.

🧑‍💼 Sales teams can export Fresha profile URLs and addresses into CRM workflows.

### Why use this actor?

Fresha pages include rich public business metadata, but collecting it manually is slow.

This actor turns those pages into rows you can sort, filter, export, enrich, and analyze.

It avoids browser automation for the main flow and uses fast HTTP extraction from public HTML.

That keeps runs lightweight and affordable for frequent lead-list generation.

### What Fresha data can I scrape?

The actor extracts one row per business profile discovered on each input listing page.

| Field | Description |
| --- | --- |
| `name` | Business or location name |
| `url` | Fresha profile URL |
| `category` | Listing category such as Hair Salon |
| `address` | Public address text from Fresha |
| `city` | Parsed city/locality when available |
| `region` | Parsed state/region when available |
| `postalCode` | Parsed postal code when available |
| `rating` | Public aggregate rating |
| `reviewCount` | Public review count |
| `priceRange` | Fresha price range such as `From $65` |
| `imageUrl` | Public profile image URL |
| `latitude` / `longitude` | Public coordinates when present |
| `rank` | Position in the extracted list |
| `sourceUrl` | Listing page where the profile was found |
| `profileDescription` | Optional profile meta description |
| `extractedAt` | Timestamp of extraction |

### How much does it cost to scrape Fresha salons?

The actor uses pay-per-event pricing.

There is a small start charge for each run and a tiered per-result charge for each saved Fresha business.

Your final cost depends mostly on `maxResults` and whether you enable profile-page enrichment.

For the cheapest run, keep `includeProfileDetails` disabled and start with 20-50 businesses.

| Example run | Typical input | What you get | Estimated platform charge* |
| --- | --- | --- | --- |
| Quick test | 20 businesses from one Fresha city/category page | Small lead sample for validation | About $0.006 on the Bronze tier |
| City prospecting list | 100 businesses from one or more local listing pages | CSV/JSON lead list with ratings and addresses | About $0.009 on the Bronze tier |
| Market snapshot | 500 businesses across several categories or cities | Larger beauty-market dataset for analysis | About $0.023 on the Bronze tier |

\*Estimates use the current $0.005 run-start charge plus Bronze-tier result pricing. Your actual bill can vary by Apify plan tier, configured result limit, retries, and optional profile-page enrichment.

On Apify's free plan, the monthly platform credits are typically enough for many small test runs of this actor. Start with the prefilled 20-result input, inspect the output, and then scale `maxResults` once the listing URLs are correct.

### How to use Fresha Salon Scraper

1. Open the actor on Apify.

2. Paste one or more public Fresha listing URLs into **Fresha listing URLs**.

3. Set **Maximum businesses** to the number of leads you want.

4. Leave **Fetch each profile page** off unless you need profile meta descriptions.

5. Start the run.

6. Download the dataset as JSON, CSV, Excel, XML, or HTML.

### Input example

```json
{
  "startUrls": [
    { "url": "https://www.fresha.com/lp/en/bt/hair-salons/in/us-new-york" }
  ],
  "maxResults": 20,
  "includeProfileDetails": false,
  "maxRequestRetries": 3
}
````

### Output example

```json
{
  "name": "H2 Salon Brooklyn",
  "url": "https://www.fresha.com/a/h2-salon-brooklyn-new-york-473-tompkins-avenue-oyclntrv",
  "sourceUrl": "https://www.fresha.com/lp/en/bt/hair-salons/in/us-new-york",
  "category": "Hair Salon",
  "address": "473 Tompkins Avenue, New York Brooklyn, Stuyvesant Heights, 11216",
  "city": "New York Brooklyn",
  "region": "New York",
  "postalCode": "11216",
  "country": null,
  "latitude": 40.6812867,
  "longitude": -73.943286,
  "rating": 4.9,
  "reviewCount": 6459,
  "priceRange": "From $65",
  "imageUrl": "https://images.fresha.com/locations/location-profile-images/...jpg",
  "rank": 1,
  "serviceArea": "New York",
  "extractedAt": "2026-05-16T00:00:00.000Z"
}
```

### Finding Fresha listing URLs

Open Fresha and navigate to a public category/location page.

Copy the URL from your browser.

Good examples usually contain `/lp/` and include a service category plus a region.

Examples include hair salons in New York, nail salons in London, barbers in Toronto, or massage venues in Sydney.

### Tips for better results

🔎 Use specific city/category listing pages instead of the Fresha home page.

📦 Increase `maxResults` when a page has many profiles.

⚡ Keep profile enrichment disabled for fast lead-list exports.

🧪 Test one URL first before adding many markets.

🧹 Deduplicate by `url` when combining multiple overlapping city pages.

### Integrations

Export CSV files into HubSpot, Salesforce, Pipedrive, Airtable, or Google Sheets.

Send JSON output to a webhook for enrichment with email-finding or company-data tools.

Use Apify integrations to schedule monthly market snapshots for the same Fresha pages.

Combine Fresha leads with geocoding, review monitoring, or outreach automation workflows.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fresha-salon-scraper').call({
  startUrls: [{ url: 'https://www.fresha.com/lp/en/bt/hair-salons/in/us-new-york' }],
  maxResults: 50,
  includeProfileDetails: false
});

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

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/fresha-salon-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.fresha.com/lp/en/bt/hair-salons/in/us-new-york'}],
    'maxResults': 50,
    'includeProfileDetails': False,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~fresha-salon-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{"url":"https://www.fresha.com/lp/en/bt/hair-salons/in/us-new-york"}],
    "maxResults": 50,
    "includeProfileDetails": false
  }'
```

### Using with MCP and AI agents

You can use this actor through Apify MCP from Claude Code, Claude Desktop, Cursor, VS Code, or any other MCP-compatible client.

MCP URL:

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

#### Claude Code setup

```bash
claude mcp add --transport http apify-fresha \
  https://mcp.apify.com/?tools=automation-lab/fresha-salon-scraper
```

After adding the server, ask Claude Code to run `automation-lab/fresha-salon-scraper` with a Fresha listing URL and your desired `maxResults`.

#### Claude Desktop, Cursor, and VS Code setup

Add this server to your MCP configuration file:

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

If your MCP client requires headers, add your Apify API token as an authorization header according to that client's MCP documentation.

Example prompts:

- "Scrape 50 Fresha hair salon profiles in New York and summarize the highest review counts."
- "Find Fresha salons from this listing page and export names, profile URLs, ratings, and addresses."
- "Compare Fresha business ratings between these two city listing pages."
- "Create a CSV-ready prospecting list from Fresha nail salon pages and flag locations with more than 500 reviews."

### Scheduling

Create a scheduled Apify task when you want repeatable monitoring.

For example, run the same city pages every month and compare review counts over time.

Scheduled runs work well for sales territories, market-entry research, and competitor tracking.

### Data quality notes

The actor extracts data that Fresha exposes publicly in listing-page HTML.

Some fields may be missing if Fresha does not publish them for a business.

City and region are parsed from address text when Fresha does not provide structured locality fields.

The original address string is always kept so you can apply your own parsing downstream.

### Limitations

This actor does not log into Fresha.

It does not book appointments, collect private user data, or bypass access controls.

It does not guarantee every business on Fresha is available from a single listing URL.

Use multiple targeted listing pages if you need broader coverage.

### Troubleshooting

If you get zero results, check that your input URL is a public Fresha listing page and not a search form, home page, or private account page.

If you see fewer results than expected, increase `maxResults` and add more specific city/category pages.

If profile enrichment is slow, turn off **Fetch each profile page** and rely on listing-page fields.

### FAQ

**Why did my run return fewer businesses than the page headline suggests?**

Fresha listing pages expose a finite set of public business cards in the initial HTML. Add more city/category URLs for broader coverage.

**Can this actor collect phone numbers or emails?**

It extracts public Fresha marketplace metadata. If Fresha does not publish a phone or email in the page data, the actor does not invent it.

### Legality

This actor is intended to extract publicly available business information from public pages.

You are responsible for ensuring your use case complies with applicable laws, Fresha terms, and privacy rules.

Do not use the output for spam, harassment, or unlawful profiling.

### Related scrapers

Explore other Automation Lab actors on Apify:

- https://apify.com/automation-lab/google-maps-scraper
- https://apify.com/automation-lab/tripadvisor-scraper
- https://apify.com/automation-lab/yelp-scraper
- https://apify.com/automation-lab/booking-scraper

### Support

If a Fresha page stops returning data, open an issue from the Apify actor page.

Include the input URL, expected result, and run ID so the team can reproduce it quickly.

### Changelog

Initial version extracts public Fresha listing-page business records using HTTP and JSON-LD parsing.

### Example workflow for agencies

1. Choose the city and beauty category you sell into.

2. Copy the corresponding Fresha listing URL.

3. Run the actor for 100-300 businesses.

4. Export CSV.

5. Import into your CRM.

6. Segment by rating, review count, or city.

7. Enrich profile URLs with your outreach stack.

### Example workflow for analysts

1. Collect listing pages across multiple cities.

2. Run the actor with the same result limit per market.

3. Compare average rating and review-count distribution.

4. Track high-ranking businesses by category.

5. Repeat monthly to watch marketplace changes.

# Actor input Schema

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

Public Fresha marketplace/listing pages to scrape, for example category + city pages under /lp/.

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

Maximum number of Fresha businesses to save across all input pages.

## `includeProfileDetails` (type: `boolean`):

Open every Fresha profile URL to add the public meta description. Leave off for faster listing-page lead extraction.

## `maxRequestRetries` (type: `integer`):

Retry attempts for failed Fresha HTTP requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.fresha.com/lp/en/bt/hair-salons/in/us-new-york"
    }
  ],
  "maxResults": 20,
  "includeProfileDetails": false,
  "maxRequestRetries": 3
}
```

# 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.fresha.com/lp/en/bt/hair-salons/in/us-new-york"
        }
    ],
    "maxResults": 20,
    "includeProfileDetails": false,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fresha-salon-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.fresha.com/lp/en/bt/hair-salons/in/us-new-york" }],
    "maxResults": 20,
    "includeProfileDetails": False,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fresha-salon-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.fresha.com/lp/en/bt/hair-salons/in/us-new-york"
    }
  ],
  "maxResults": 20,
  "includeProfileDetails": false,
  "maxRequestRetries": 3
}' |
apify call automation-lab/fresha-salon-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fresha Salon Scraper",
        "description": "Extract public Fresha salon, spa, barber, nail, massage, and beauty business leads with ratings, reviews, addresses, images, and profile URLs.",
        "version": "0.1",
        "x-build-id": "Q2g4hRbka6dbDsxay"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~fresha-salon-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-fresha-salon-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~fresha-salon-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-fresha-salon-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~fresha-salon-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-fresha-salon-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": "Fresha listing URLs",
                        "type": "array",
                        "description": "Public Fresha marketplace/listing pages to scrape, for example category + city pages under /lp/.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Maximum businesses",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Fresha businesses to save across all input pages.",
                        "default": 50
                    },
                    "includeProfileDetails": {
                        "title": "Fetch each profile page",
                        "type": "boolean",
                        "description": "Open every Fresha profile URL to add the public meta description. Leave off for faster listing-page lead extraction.",
                        "default": false
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Retry attempts for failed Fresha HTTP requests.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
