# Med Spa Email Scraper (`scrapers-hub/med-spa-email-scraper`) Actor

📧 Med Spa Email Scraper (med-spa-email-scraper) quickly extracts verified email contacts from med spa websites—perfect for targeted outreach, lead generation, and B2B sales. ⚡ Save time, improve accuracy, and grow your pipeline.

- **URL**: https://apify.com/scrapers-hub/med-spa-email-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.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

### Med Spa Email Scraper 📬

**Med Spa Email Scraper** helps you find med spa businesses in specific locations and extract their contact information—especially email addresses—so you can build outreach-ready lists faster. Whether you’re looking for a *med spa email scraper*, an *email scraper for med spas*, or a *med spa lead email scraper*, this actor focuses on scraping contact details from **publicly available data** and producing structured results you can analyze or import right away—saving you hours of manual work.

Whether you’re a marketer, data analyst, or researcher, **Med Spa Email Scraper** is designed to turn “where do I find decision-makers and contact emails?” into a repeatable workflow at scale.

---

### Why choose Med Spa Email Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ All-in-one business discovery + website scraping | Extract emails (plus phone numbers and social media links) tied to the business website |
| ✅ Reliability-focused scraping flow | Includes resilience via retries and fallbacks for more consistent outcomes |
| ✅ Output limited by your goals (`Maximum Businesses With Emails`) | Controls how many business email results you want per run |
| ✅ Structured dataset fields | Returns a consistent table schema with contact and business details ready for CRM/analysis |
| ✅ Scale-ready with proxy support | Built for larger batches with proxy configuration to help avoid IP blocks and rate limits |
| ✅ Automation-friendly results saving | Pushes results to the Apify dataset as it goes, so you don’t wait for everything to finish |

---

### Key features

- 🧾 **Business contact discovery for med spas:** Uses your business niche and location inputs to target relevant med spa businesses.
- 📧 **Email extraction from business websites:** Scrapes websites for contact emails and returns them in a structured dataset.
- 📞 **Phone number extraction:** Captures phone numbers alongside emails when available.
- 🔗 **Social media link extraction:** Extracts social media profiles found on the business website.
- 🛡️ **Proxy support for reliable scraping:** Works with your `proxyConfiguration` settings to help keep scraping stable at scale.
- 🔄 **Resilient workflow:** Designed with resilience (including fallback behavior) to improve results consistency.
- 💾 **Real-time dataset saving:** Saves results immediately to the Apify dataset during execution.

---

### Input

Provide input via an `input.json` file. Example structure:

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

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `googleMapsSearchTerm` | Yes | The business type or niche you want to search for (example: `Med Spa`). |
| `googleMapsLocation` | Yes | One or more geographic locations to target (example format: `Miami, Florida` or `New York`). |
| `maxBusinesses` | No | Target number of businesses to find that have emails (range: 1–1000). The actor stops when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | No | Choose whether to enforce `maxBusinesses` per location (`true`) or treat it as a single global limit across all locations (`false`). |
| `proxyConfiguration` | No | Proxy settings for scraping. Recommended for large-scale scraping. Currently supports `proxy support`. |
| • `proxy support` | No | If set to `true`, the actor will use Apify Proxy (prefilled to `true`). |

***

### Output

The actor saves each scraped business (and, when emails are found, each email result) to the Apify dataset in JSON format.

Example dataset rows (shape derived from the pushed fields):

```json
{
  "name": "Sample Med Spa",
  "website": "https://example.com",
  "phone": "+1 (555) 123-4567",
  "full_address": "123 Main St New York NY 10001 US",
  "city": "New York",
  "state": "NY",
  "zip": "10001",
  "country_code": "US",
  "avg_rating": 4.6,
  "total_reviews": 230,
  "lat": 40.7128,
  "long": -74.006,
  "place_id": "some_place_id",
  "scraped_emails": [],
  "scraped_phones": ["+1 (555) 123-4567"],
  "scraped_social_media": ["https://instagram.com/sample"],
  "emails_found": 1,
  "pages_scraped": 5,
  "scrape_status": "success",
  "email_found": "hello@example.com"
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `name` | string | Business name. |
| `website` | string | Business website URL (cleaned of `/url` and stripped of query string). |
| `phone` | string | Primary phone extracted from the business listing data. |
| `full_address` | string | Combined address string including street, city, state, zip, and country code. |
| `city` | string | City value from the listing data. |
| `state` | string | State value from the listing data. |
| `zip` | string | ZIP/postal code from the listing data. |
| `country_code` | string | Country code from the listing data. |
| `scraped_emails` | array | Emails extracted from the business website (used internally for flattening). |
| `scraped_phones` | array | Phone numbers extracted from the business website. |
| `scraped_social_media` | array | Social media links extracted from the business website. |
| `emails_found` | number | Count of emails found for this business. |
| `pages_scraped` | number | Number of processed URLs/pages during website scraping. |
| `avg_rating` | number | Average rating from the business listing data. |
| `total_reviews` | number | Total number of reviews from the business listing data. |
| `lat` | number | Latitude coordinate for the business listing. |
| `long` | number | Longitude coordinate for the business listing. |
| `place_id` | string | Place identifier from the business listing data. |
| `scrape_status` | string | Scraping status text (e.g., `success`, `failed`, `no_website`, `error`). |
| `email_found` | string | When emails are found, this row is one email instance for the business (the pushed flat value). |

Note: If `email_only_results`-style behavior is triggered by the run logic (when enabled internally), businesses without emails may not be pushed as dataset rows.

***

### How to use Med Spa Email Scraper (via Apify Console)

1. **Open Apify Console**: Log in at https://console.apify.com and go to the **Actors** tab.
2. **Find this actor**: Search for **Med Spa Email Scraper** in the marketplace and open the actor page.
3. **Set your input in the INPUT panel**:\
   Add `googleMapsSearchTerm` (e.g., `Med Spa`) and at least one `googleMapsLocation` (e.g., `New York`).
4. **Choose your limits**:\
   Set `maxBusinesses` to control how many businesses you want with emails, and decide whether `scrapeMaxBusinessesPerLocation` should be `true` or `false`.
5. **Configure proxies (recommended for scale)**:\
   In `proxyConfiguration`, keep `proxy support: true` for large runs, or adjust based on your scraping needs.
6. **Run the actor**:\
   Click **Run** and monitor the live logs while it discovers businesses and scrapes their websites for contact information.
7. **Open the dataset**:\
   After completion, check the actor **OUTPUT** dataset to view the saved rows. From there you can export the data (JSON/CSV, depending on your workflow).

No coding required—get accurate, structured results in minutes with **Med Spa Email Scraper**. 🚀

***

### Advanced features & SEO optimization

- 🧠 **Engineered for med spa email scraping workflows:** Built as a practical *med spa lead email scraper* for outreach and list building.
- 🔍 **Keyword-driven targeting by niche + location:** Combines your `googleMapsSearchTerm` with `googleMapsLocation` inputs to focus results on the med spa category you care about (useful for “scrape emails for med spa” campaigns).
- 🛡️ **Proxy resilience for stable runs:** Uses your `proxyConfiguration` settings to improve reliability and reduce the chance of scraping interruptions during bulk email extraction for med spas.
- 📊 **Structured output for analysis:** The dataset includes business fields plus scraped contact fields, making it easier to build a marketing email list scraper or run healthcare lead email scraper analytics.
- 💾 **Automation-friendly dataset saving:** Results are pushed as they’re produced, which supports faster downstream CRM import workflows (e.g., patient outreach email list building).

***

### Best use cases

- 💼 **Marketing teams building outreach lists:** Generate a patient outreach email list by collecting business emails and website-linked contact details in one run.
- 🧪 **Lead generation research:** Quickly find med spa business contacts to support healthcare lead email scraper research by region.
- 📦 **Direct mail prep:** Create a direct mail email list scraper for med spas by pairing business details (address, website) with extracted emails.
- 📈 **Data analysts enriching CRM datasets:** Use the structured dataset fields (emails found, phones, social links) to augment business contact records.
- 🧠 **Business development teams finding decision-maker contacts:** Use it as a medical spa email finder to locate business-level email contacts for follow-ups.
- 🛠️ **Automation pipelines for sales ops:** Feed results into your pipeline as part of a marketing email list scraper workflow, without manual copying.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `googleMapsSearchTerm` as a string niche (example: `Med Spa`)
  - ✅ `googleMapsLocation` as an array of location strings

- **Proxy Support**
  - ✅ `proxyConfiguration` object
  - ✅ `proxy support` boolean (prefilled to `true`)

- **Retry Mechanism**
  - ✅ Includes resilience with retries and fallbacks to improve scraping stability

- **Dataset Structure**
  - ✅ Output is saved to the Apify dataset with fields defined in the dataset transformation:
    `name, website, phone, full_address, city, state, zip, country_code, scraped_emails, scraped_phones, scraped_social_media, emails_found, pages_scraped, avg_rating, total_reviews, lat, long, place_id, scrape_status`

- **Rate Limits & Performance**
  - ✅ Designed for batch runs with concurrent website scraping (speed depends on site responsiveness)

- **Limitations**
  - ❌ If a business has no website or no contact emails found on the website, `scrape_status` may reflect `no_website` and emails will be empty.
  - ❌ Results depend on the availability of publicly accessible contact details on business websites.

***

### FAQ

#### Does this Med Spa Email Scraper only find emails on med spa websites?

✅ Yes. It scrapes the business website for contact information and extracts emails (plus phones and social media links) into the dataset.

#### What does “Maximum Businesses With Emails” control?

It controls your target number of businesses to find that have emails. The actor stops when the target is reached, and you can optionally enforce this limit per location using `scrapeMaxBusinessesPerLocation`.

#### Can I scrape multiple locations in one run?

✅ Yes. Provide multiple entries in `googleMapsLocation`. You can either treat `maxBusinesses` as a global cap or apply it per location with `scrapeMaxBusinessesPerLocation`.

#### Do I need to provide proxy settings?

Not required for basic usage, but ✅ recommended for larger batches. You can configure `proxyConfiguration.proxy support` to improve scraping reliability.

#### What fields will I get in the dataset?

The dataset includes business and contact fields such as `name`, `website`, `phone`, `full_address`, `city`, `state`, `zip`, `country_code`, `scraped_emails`, `scraped_phones`, `scraped_social_media`, `emails_found`, `pages_scraped`, `avg_rating`, `total_reviews`, `lat`, `long`, `place_id`, and `scrape_status`.

#### Is email validation included?

Email validation is controlled by `validate_emails`, which is set from input (internally read from `actor_input.get('validateEmails', False)`). If enabled, the actor will validate extracted emails.

#### Can I use the output for outreach or marketing?

✅ You can use the output for legitimate outreach and list-building workflows, but it’s your responsibility to comply with applicable privacy and messaging laws (including GDPR/CCPA where relevant) and with platform/website terms.

***

### Support & feature requests

If you’re using **Med Spa Email Scraper** and want improvements (for example, better export options for marketing email list scraper workflows or enhanced filtering for medical spa patient outreach email list building), we’d love to hear from you.

- 💡 **Feature Requests**: Share enhancements you want like CSV export improvements, stronger post-processing, or additional dataset fields that match your workflow.
- 📧 **Contact**: Reach us at <dataforleads@gmail.com>.

User feedback directly shapes the roadmap for this med spa email scraper. 🙌

***

### Closing CTA / Final thoughts

*If you need a fast, reliable way to scrape emails for med spa outreach, **Med Spa Email Scraper** is built to help you scale contact discovery without the manual spreadsheet grind.* 🔍✨

***

### Disclaimer

This tool only accesses **publicly accessible sources**. It does not access private profiles, authenticated data, or password-protected content.

You are responsible for complying with applicable laws and regulations (including GDPR and CCPA where relevant), as well as with the terms of service of the websites you scrape. For data removal requests, contact <dataforleads@gmail.com>.

Use this tool responsibly, ethically, and only for legitimate purposes. ✅

# Actor input Schema

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

Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').

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

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

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

Target number of businesses 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": "Med Spa",
  "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": "Med Spa",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/med-spa-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": "Med Spa",
    "googleMapsLocation": ["New York"],
    "maxBusinesses": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Med Spa Email Scraper",
        "description": "📧 Med Spa Email Scraper (med-spa-email-scraper) quickly extracts verified email contacts from med spa websites—perfect for targeted outreach, lead generation, and B2B sales. ⚡ Save time, improve accuracy, and grow your pipeline.",
        "version": "1.0",
        "x-build-id": "R32hHwvM0ezKcHkUc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~med-spa-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-med-spa-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/scrapers-hub~med-spa-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-med-spa-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/scrapers-hub~med-spa-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-med-spa-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., 'coffee shops', 'dentists').",
                        "default": "Med Spa"
                    },
                    "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 businesses 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
