# Beauty Salon Email Scraper (`scraperoka/beauty-salon-email-scraper`) Actor

✨ Beauty Salon Email Scraper extracts verified email contacts from beauty salon websites for outreach. 📩 Perfect for lead generation, marketing, partnerships & bookings. 🚀 Fast, accurate, and SEO-friendly—grow your client list effortlessly.

- **URL**: https://apify.com/scraperoka/beauty-salon-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### Beauty Salon Email Scraper 🚀

Manually hunting down salon contact emails across the web wastes hours you don’t have. **Beauty Salon Email Scraper** is a purpose-built *beauty salon email scraper* that extracts salon contact details—ideal for marketers, researchers, and growth teams—so you can build targeted outreach lists in minutes, not days.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "name": "Bella Glow Beauty Salon",
  "website": "https://bellaglow.example.com",
  "phone": "+1 (212) 555-0199",
  "full_address": "125 Madison Ave New York NY 10016 US",
  "city": "New York",
  "state": "NY",
  "zip": "10016",
  "country_code": "US",
  "email_found": "hello@bellaglow.example.com",
  "scraped_phones": ["+1 (212) 555-0199", "+1 (212) 555-0133"],
  "scraped_social_media": [
    "https://www.instagram.com/bellaglowbeauty/",
    "https://www.facebook.com/bellaglowbeautysalon/"
  ],
  "emails_found": 2,
  "pages_scraped": 6,
  "avg_rating": 4.6,
  "total_reviews": 214,
  "lat": 40.7502,
  "long": -73.9875,
  "place_id": "ChIJN1t_tDeuEmsRUsoyG83frY4",
  "scrape_status": "success"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `name` | string | The business name you can match in your CRM or outreach tool |
| `website` | string | The official website link to reference in your campaign |
| `phone` | string | A primary phone number found for the business |
| `full_address` | string | A ready-to-use, formatted location string for list enrichment |
| `city` | string | The city used for filtering and reporting |
| `state` | string | The state for regional segmentation |
| `zip` | string | Postal code for routing and analytics |
| `country_code` | string | Country code for market-level rollups |
| `email_found` | string | The specific email address saved as a contact |
| `scraped_phones` | array | Additional phone numbers found on the business website |
| `scraped_social_media` | array | Social profile links extracted alongside email scraping |
| `emails_found` | number | How many emails were detected for that business on its website |
| `pages_scraped` | number | How much site content was processed (useful for troubleshooting) |
| `avg_rating` | number | Star rating value useful for prioritization |
| `total_reviews` | number | Review count to gauge popularity and credibility |
| `scrape_status` | string | Indicates the overall result status for that business record |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Beauty Salon Email Scraper?

There are a lot of ways to pull contact data from the web — here’s what sets **Beauty Salon Email Scraper** apart for beauty industry email leads.

#### Salon-focused contact fields (emails, phones, social)

This *salon email finder* extracts emails from business websites and also captures phone numbers and social media profiles so your list is more outreach-ready, not just “email-only”. It’s great for building a *beauty salon marketing email list* you can actually use.

#### Uses your locations + search term for targeted discovery

You provide the beauty search term and one or more geographic locations, and the actor targets the businesses it finds there. This makes it ideal for *local business email scraping* and *beauty salon lead generation* workflows.

#### Deduplicated, consistent results for cleaner CRM import

The actor tracks uniqueness using a `place_id` and returns structured records with consistent fields like `full_address`, `website`, `email_found`, and `scrape_status`. That means less manual cleanup when you’re importing into a CRM.

#### Resilient website scraping with configurable email validation

Website scraping is configured with `ScrapingConfig(validate_emails=..., max_pages=...)`, and the actor supports email validation and common extraction modes (phones and social). When accuracy matters, this is a practical *email scraping tool for small business* teams.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "googleMapsSearchTerm": "Beauty Salon",
  "googleMapsLocation": ["New York"],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `googleMapsSearchTerm` | ✅ | The business type or niche to search for (for example, “beauty salons” or “hair stylists”). |
| `googleMapsLocation` | ✅ | One or more target geographic locations (for example, “Miami, Florida” or a list like `["New York"]`). |
| `maxBusinesses` | ⬜ | Sets the target number of businesses with emails to find (range 1–1000). The scraper stops once the target is reached. |
| `scrapeMaxBusinessesPerLocation` | ⬜ | If enabled, the actor aims to collect up to `maxBusinesses` results per location. If disabled, it combines locations up to one total cap. |
| `proxyConfiguration` | ⬜ | Proxy settings for scraping. Recommended for larger runs to improve reliability. |
| ↳ `proxy support` | ⬜ | When set to `true`, requests route through Apify Proxy for better stability. |

***

### Core Capabilities

#### Beauty industry email discovery

**Beauty Salon Email Scraper** starts from business discovery inputs and then extracts contact data from business websites, including an `email_found` field you can feed directly into outreach workflows. This is a practical *website email scraper for salons* when you need *extract salon emails online* results fast.

#### Input flexibility for cities and salon niches

Use `googleMapsSearchTerm` to define the niche (for example, *beauty industry email leads* targeting “beauty salons”), and pass `googleMapsLocation` as a list to cover multiple regions in one run. This helps you generate *targeted email list for salons* by market.

#### Email validation and quality-focused extraction

The actor supports email validation via the internal `validate_emails` configuration (controlled by `validateEmails` in input) while extracting phones and social media by default. This improves the usefulness of your *salon contact email scraper* output when you’re building lists for outreach or CRM enrichment.

#### Real-time, dataset-first saving

For businesses with websites, the actor pushes results to the Apify dataset immediately (and flattens one row per found email via `email_found`). That means you can stop early and still have useful *beauty salon lead generation* output rather than waiting for a full batch to finish.

#### Built-in proxy support for reliable scraping

The actor accepts `proxyConfiguration` and supports proxy routing, which helps reduce disruption during larger scraping jobs. For a *email scraping tool for small business* or analyst workflow at scale, proxy support improves run stability.

***

### Who Gets the Most Out of This

**Growth teams and marketers** use Beauty Salon Email Scraper to generate a *beauty salon marketing email list* by city and salon niche, then prioritize leads using fields like `avg_rating` and `total_reviews`. The end result is more reliable segmentation and faster campaign launch cycles.

**Sales development reps** rely on a *salon CRM email enrichment* workflow: they start with discovered businesses, extract `email_found`, and add phones and social links to improve deliverability and personalization. Instead of starting from scratch, they build targeted outreach lists quickly.

**Local SEO and research analysts** use the structured location outputs (`city`, `state`, `zip`, `country_code`, `lat`, `long`) to analyze coverage by region. They can also compare result density across multiple `googleMapsLocation` values and refine targeting over time.

**Automation specialists and developers** appreciate that the actor writes consistent, integration-ready records to the Apify dataset with stable field names like `place_id`, `website`, `scrape_status`, and `pages_scraped`. That makes it easier to schedule runs and pipe results into downstream systems.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Beauty Salon Email Scraper from start to finish:

1. **Open the actor on Apify** — visit [console.apify.com](https://console.apify.com) and open Beauty Salon Email Scraper.
2. **Enter your inputs** — set `googleMapsSearchTerm` and `googleMapsLocation` (required), then optionally configure `maxBusinesses` and `scrapeMaxBusinessesPerLocation`.
3. **Configure proxy settings** — for more reliable scraping, enable `proxyConfiguration` (for example, `proxy support: true`).
4. **Hit Run and watch the live log** — follow progress as the actor searches and then scrapes websites for contact information.
5. **View results in the dataset tab** — your dataset rows include fields like `name`, `website`, `email_found`, and `scrape_status`.
6. **Export as JSON, CSV, or Excel** — download directly from the Apify dashboard in the format you need.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **Beauty Salon Email Scraper** plugs directly into your existing workflow.

You can export your results from the Apify dataset tab in **JSON, CSV, or Excel** formats, which makes it easy to move into spreadsheets, CRMs, and analyst pipelines.

You can also connect the actor to automation and data workflows via **Apify API access**, and trigger downstream actions using **webhooks** when runs complete. For no-code options like **Zapier** or **Make**, you can push dataset results to other tools without writing custom code—check Apify docs for the latest integration paths.

***

### Pricing & Free Trial

Beauty Salon Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

In general, Apify usage is **pay-as-you-go** based on Actor compute units (CU), with no need for a monthly subscription just to test. You’ll want to review the current pricing and plan details on Apify’s pricing page, since offers and credits can change over time.

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Scraping stability at scale | Built-in proxy support and rate-limit friendly behavior |
| Incomplete pages | Fallback handling with clear `scrape_status` results |
| Website variability | Extracts phones and social media alongside email discovery |
| Output usefulness | Returns structured fields like `email_found`, `scraped_phones`, and `scraped_social_media` |
| Targeted limits | Stops when it reaches your `maxBusinesses` target |

Limitations: results are based on **publicly available data** and what businesses publish on their websites. If a business does not have a visible website or no relevant contact information is present, you may see fewer or empty email fields.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial for Beauty Salon Email Scraper?

Yes, Apify offers a free tier for testing. You can start a run and export a dataset to evaluate list quality before deciding whether to scale up.

#### Do I need to log in to use Beauty Salon Email Scraper?

No. Beauty Salon Email Scraper works with publicly available web data and does not require a user login to collect contact details.

#### How accurate is the data from Beauty Salon Email Scraper?

Accuracy depends on what businesses publish on their websites. The actor extracts `email_found` and supports configurable email validation to help improve contact quality.

#### How many results can I get per run?

You control this using `maxBusinesses`, which is limited to values between 1 and 1000. The actor stops when the target is reached, and `scrapeMaxBusinessesPerLocation` determines whether the cap is per location or global.

#### How fresh is the data?

The data freshness depends on what’s currently available on the web at the time of your run. Each run produces results captured during that run and saved into your Apify dataset.

#### Is this legal? Does it comply with GDPR or CCPA?

This actor is designed to work with **publicly available data** that can be viewed without login. It is your responsibility to ensure your use, storage, and outreach comply with GDPR, CCPA, platform terms, and applicable laws in your region.

#### Can I export results to Google Sheets or Excel?

Yes. You can export from the Apify dataset tab as JSON, CSV, or Excel. From there, you can import into Google Sheets or other tools as needed.

#### Can I run Beauty Salon Email Scraper automatically on a schedule?

Yes. With the Apify platform, you can schedule actor runs automatically so your beauty industry email leads are refreshed on a cadence you choose.

#### Can I access results via API?

Yes. You can access actor results programmatically using the Apify API. This is useful for CRM ingestion, dashboards, and automated list building.

#### What happens if the actor hits an error?

The dataset will reflect failures through fields like `scrape_status` and, when applicable, an error field such as `scrape_error`. This helps you identify which businesses succeeded and which need a rerun.

***

### Need Help or Have a Request?

Got a question about Beauty Salon Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like webhook notifications on completion and batch import/export improvements.

***

### Disclaimer & Responsible Use

*Beauty Salon Email Scraper is the fastest, most reliable way to extract salon contact emails, phones, and social links from publicly available data — start your free run today.*

This actor collects **publicly available data**. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, applicable laws, and platform terms. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `googleMapsSearchTerm` (type: `string`):

Enter the business type or niche for email scraper (e.g., 'beauty salons', 'hair stylists').

## `googleMapsLocation` (type: `array`):

Target geographic location for the email scraper (e.g., 'Miami, Florida').

## `maxBusinesses` (type: `integer`):

Target number of emails to find (1-1000). The scraper will stop when this target is reached.

## `scrapeMaxBusinessesPerLocation` (type: `boolean`):

If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.

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

Proxy settings for scraping. Recommended for large-scale scraping.

## Actor input object example

```json
{
  "googleMapsSearchTerm": "Beauty Salon",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "googleMapsSearchTerm": "Beauty Salon",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/beauty-salon-email-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 = {
    "googleMapsSearchTerm": "Beauty Salon",
    "googleMapsLocation": ["New York"],
    "maxBusinesses": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/beauty-salon-email-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 '{
  "googleMapsSearchTerm": "Beauty Salon",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scraperoka/beauty-salon-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Beauty Salon Email Scraper",
        "description": "✨ Beauty Salon Email Scraper extracts verified email contacts from beauty salon websites for outreach. 📩 Perfect for lead generation, marketing, partnerships & bookings. 🚀 Fast, accurate, and SEO-friendly—grow your client list effortlessly.",
        "version": "1.0",
        "x-build-id": "4hEHFd8CjAsxoDXHn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~beauty-salon-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-beauty-salon-email-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/scraperoka~beauty-salon-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-beauty-salon-email-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/scraperoka~beauty-salon-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-beauty-salon-email-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": [
                    "googleMapsLocation",
                    "googleMapsSearchTerm"
                ],
                "properties": {
                    "googleMapsSearchTerm": {
                        "title": "Search Term",
                        "type": "string",
                        "description": "Enter the business type or niche for email scraper (e.g., 'beauty salons', 'hair stylists').",
                        "default": "Beauty Salon"
                    },
                    "googleMapsLocation": {
                        "title": "Location",
                        "type": "array",
                        "description": "Target geographic location for the email scraper (e.g., 'Miami, Florida').",
                        "default": [
                            "New York"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxBusinesses": {
                        "title": "Maximum Businesses With Emails",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Target number of emails to find (1-1000). The scraper will stop when this target is reached.",
                        "default": 5
                    },
                    "scrapeMaxBusinessesPerLocation": {
                        "title": "Scrape Max Businesses Per Location",
                        "type": "boolean",
                        "description": "If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for scraping. Recommended for large-scale scraping."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
