# Physical Therapist Email Scraper (`solid-scraper/physical-therapist-email-scraper`) Actor

📩 Find verified physical therapist contacts fast! Our SEO-optimized email scraper pulls targeted leads by specialty, location, and keywords—ideal for clinics, recruiting, and marketing teams. ⚡ Accurate, compliant, and built for speed.

- **URL**: https://apify.com/solid-scraper/physical-therapist-email-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (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

### Physical Therapist Email Scraper 📬

**Physical Therapist Email Scraper** is an Apify actor that helps you find physical therapist businesses in target locations and extract their contact information—especially email addresses—so you can build a clean outreach list faster. Whether you’re using a **physical therapist email scraper** for B2B lead generation for physical therapy, a **PT email scraper** for follow-ups, or a **physical therapy email extractor** for research, this tool focuses on turning public business info into actionable contact data at scale. Great for marketers, researchers, and data analysts who want to save hours of manual list building and enrichments.

---

### 🚀 Why choose Physical Therapist Email Scraper?

| Feature | Benefit |
|---|---|
| ✅ **All-in-one contact extraction** | Extracts business details and scrapes contact emails from the business website |
| ✅ **Reliability with fallback behavior** | Includes resilience across website scraping tasks and continues safely when sites can’t be processed |
| ✅ **Email-first dataset output** | Saves results per discovered email (one row per email) and also supports saving businesses even if no email is found |
| ✅ **Structured output for easy importing** | Produces consistent, dataset-ready fields for downstream CRM, spreadsheets, or analysis |
| ✅ **Scale across multiple locations** | Processes multiple geographic locations with configurable limits to match your lead goals |
| ✅ **Built-in proxy support** | Supports proxyConfiguration for more stable large-scale scraping runs |

---

### 🔑 Key features

- 📇 **Physical therapist business targeting**: Uses your search term and locations to compile a business list to investigate further  
- 🌐 **Website contact scraping**: Scrapes contact info from each business website and extracts emails into results  
- 🧾 **One row per email (flattened output)**: When emails are found, each discovered email is pushed as its own dataset row using `email_found`  
- 📞 **Phone and social media extraction**: Alongside emails, it also captures `scraped_phones` and `scraped_social_media` (when available)  
- 🛡️ **Resilient scraping flow**: Includes safeguards for cases like missing websites and failed scraping jobs, with clear `scrape_status` values  
- 💾 **Immediate dataset saving**: Pushes results as it scrapes (not only at the end), reducing the risk of losing data mid-run  
- 🧠 **Email-only mode option**: Supports `email_only_results` behavior to focus output on businesses with emails (driven by the actor’s scraping workflow)  
- ⚙️ **Proxy configuration support**: Takes `proxyConfiguration` as input so you can run more reliably at larger volumes  

---

### 📝 Input

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

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

#### Input Fields

| Field | Required | Description |
|---|---|---|
| `googleMapsSearchTerm` | Yes | The business type or niche to look for when building the initial physical therapist business list (for example, “Physical Therapist”). |
| `googleMapsLocation` | Yes | One or more geographic locations to target (for example, `["New York"]`). |
| `maxBusinesses` | No | Target number of businesses to find (1–1000). The run stops when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | No | If enabled, the scraper aims to collect up to `maxBusinesses` results per location; if disabled, it combines all locations up to a single overall total limit. |
| `proxyConfiguration` | No | Proxy settings for scraping. Recommended for larger runs to help avoid IP blocks and rate limits. |

***

### 📦 Output

The actor saves the results into the **Business Contact Data** dataset view, with one dataset row pushed via `Actor.push_data(...)` for each business email discovered (flattened), and additional rows for businesses without websites depending on mode.

Example dataset record (flattened per email):

```json
{
  "name": "Example Physical Therapy Clinic",
  "website": "https://examplept.com",
  "phone": "+1-555-123-4567",
  "full_address": "123 Example St New York NY 10001 US",
  "city": "New York",
  "state": "NY",
  "zip": "10001",
  "country_code": "US",
  "scraped_emails": [],
  "scraped_phones": [],
  "scraped_social_media": [],
  "emails_found": 1,
  "pages_scraped": 3,
  "avg_rating": 4.7,
  "total_reviews": 120,
  "lat": 40.7128,
  "long": -74.006,
  "place_id": "ChIJ...example",
  "scrape_status": "success",
  "email_found": "contact@examplept.com",
  "email_found_source": null,
  "scraped_emails_found": null
}
```

> Note: The exact values depend on what is found on each site. When emails are found, the dataset rows are flattened and include `email_found`.

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `name` | string | Business name as captured during the business listing phase |
| `website` | string | The business website URL (cleaned from tracked URLs when present) |
| `phone` | string | Business phone as captured from the business listing data |
| `full_address` | string | Full address assembled from street address, city, state, zip, and country code |
| `city` | string | City for the business |
| `state` | string | State/region for the business |
| `zip` | string | Postal/ZIP code |
| `country_code` | string | Country code |
| `scraped_emails` | array | List of scraped emails (may be empty on flattened email rows, depending on the push logic) |
| `scraped_phones` | array | Extracted phone numbers from the business website (if available) |
| `scraped_social_media` | array | Extracted social media links from the business website (if available) |
| `emails_found` | number | Count of extracted emails found for the business |
| `pages_scraped` | number | Number of processed URLs during the website scraping |
| `avg_rating` | number | Average rating value from the business listing data |
| `total_reviews` | number | Total review count from the business listing data |
| `lat` | number | Latitude |
| `long` | number | Longitude |
| `place_id` | string | Place identifier from the business listing data |
| `scrape_status` | string | Status such as `success`, `failed`, `no_website`, or `error` |
| `email_found` | string | The specific email address used for each flattened dataset row when emails are found |

**Exports:** After the run, you can export the dataset from Apify in formats like JSON/CSV via the dataset interface.

***

### 🧭 How to use Physical Therapist Email Scraper (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and go to the **Actors** page.

2. **Find the actor**\
   Search for **Physical Therapist Email Scraper** and open its actor page.

3. **Add your input**\
   In the **INPUT** panel, fill in:
   - `googleMapsSearchTerm` (your niche, e.g. “Physical Therapist”)
   - `googleMapsLocation` (one or more locations)

4. **Set your limits (optional but recommended)**\
   Choose:
   - `maxBusinesses` (1–1000)
   - `scrapeMaxBusinessesPerLocation` depending on whether you want per-location caps or a single overall cap

5. **Configure proxies (optional)**\
   If you expect higher volume or want more stability, set `proxyConfiguration` (with `proxy support` enabled).

6. **Run the actor**\
   Click **Run**. Watch the log stream for progress updates while it builds the physical therapist directory list and then scrapes emails from each website.

7. **Open results in the dataset**\
   After completion, open the **Business Contact Data** dataset and review the rows (you’ll typically see one row per discovered email, with `email_found`).

8. **Export for outreach or analysis**\
   Export the dataset to JSON/CSV and import it into your CRM or spreadsheet.

No coding required—get physical therapist outreach email lists in minutes with **Physical Therapist Email Scraper**.

***

### 🚀 Advanced features & SEO optimization

- 🧠 **Engineered for physical therapy lead generation**: Built specifically to help you **find physical therapist emails** using a search term plus geographic targeting—ideal for email scraping for PT clinics and healthcare email harvesting software workflows.
- 🌐 **Directory-style discovery + website verification**: It combines business listing data with website scraping so your **therapist contact email extractor** results are more directly tied to real business sites.
- 📊 **Richer contact context**: Alongside emails, it also returns `scraped_phones` and `scraped_social_media`, making it a practical **medical provider email scraper** for multi-channel outreach.
- 💾 **Designed for downstream enrichment**: Structured fields like `avg_rating`, `total_reviews`, `lat`, `long`, and `place_id` support research and ranking—even after your initial email data extraction for PT clinics.

***

### 🎯 Best use cases

- 📈 **B2B lead generation for physical therapy**: Build a targeted pipeline of therapist outreach email lists for campaigns and follow-ups
- 🧑‍🔬 **Healthcare directory research**: Compare clinics by location, rating, and reviews while extracting emails for future studies
- ✉️ **Cold email outreach ops**: Automate list building so you can focus on messaging strategy, not manual searching
- 🗂️ **CRM enrichment pipelines**: Feed **physical therapy lead list emails** into your CRM to personalize outbound contact workflows
- 🧾 **Marketing data analysts**: Join email contact data with business metadata (address, rating, review counts) for segmentation
- 🧑‍💻 **Developer-driven data workflows**: Use the dataset output from Physical Therapist Email Scraper as a structured input for your own automations
- 🌍 **Physical therapist directory email scraper for multi-location coverage**: Scale across multiple cities or regions while keeping output consistent

***

### 🔧 Technical specifications

- **Supported input formats**\
  ✅ `googleMapsSearchTerm`: string\
  ✅ `googleMapsLocation`: array of location strings

- **Proxy support**\
  ✅ `proxyConfiguration` object (includes `proxy support`)

- **Retry mechanism**\
  ✅ Includes resilience in the website scraping workflow (failure states are recorded via `scrape_status`)

- **Dataset structure**\
  ✅ Dataset title: **Business Contact Data**\
  ✅ Includes fields such as `name`, `website`, `full_address`, `scraped_emails`, `emails_found`, `pages_scraped`, `scrape_status`, and more

- **Limit controls**\
  ✅ `maxBusinesses` (1–1000)\
  ✅ `scrapeMaxBusinessesPerLocation` toggles between per-location and overall caps

***

### ❓ FAQ

#### ✅ Can this extract physical therapist email addresses from business websites?

Yes. Physical Therapist Email Scraper first builds a list of relevant physical therapist businesses for your locations, then scrapes their websites to extract email addresses and stores them in the dataset.

#### ❌ Does the actor save results for businesses that have no website?

If a business has no website, the actor pushes a record with `scrape_status` set accordingly (for example `no_website`) and `scraped_emails` as an empty list, while controlling whether such records are saved based on the email-only behavior.

#### 💻 Can I use this for PT email scraper workflows with multiple cities?

Yes. Provide multiple values in `googleMapsLocation`. You can also control whether `maxBusinesses` is applied per location via `scrapeMaxBusinessesPerLocation`.

#### 📦 What contact data do I get besides emails?

In addition to emails, dataset fields include `scraped_phones` and `scraped_social_media` (when available), plus business metadata like `phone`, `full_address`, `avg_rating`, and `total_reviews`.

#### 🛡️ Do I need a proxy configuration?

Proxies are optional, but recommended for larger-scale scraping. You can set `proxyConfiguration` (including `proxy support`) to improve stability.

#### 🔁 How does it handle failures?

The actor records outcomes using `scrape_status` such as `success`, `failed`, `no_website`, or `error`. This helps you filter your dataset cleanly.

#### 🌱 Where can I request improvements or report an issue?

Share feedback directly by emailing <dataforleads@gmail.com>.

***

### 🤝 Support & feature requests

Have questions about Physical Therapist Email Scraper or want to improve how your therapist email scraper tool outputs lead lists?\
Send a note via <dataforleads@gmail.com>.

- 💡 **Feature Requests**: Examples include adding more export formats, expanding field coverage for physical therapy email extractor use cases, or tuning how outputs are flattened for CRM imports.
- 📧 **Contact**: Email <dataforleads@gmail.com>.

Your feedback helps shape what we build next for Physical Therapist Email Scraper.

***

### ✨ Final thoughts

*If you’re looking for a physical therapist email scraper that turns public business listings into outreach-ready data, Physical Therapist Email Scraper is built for that exact job.*\
*It’s one of the most comprehensive ways to automate therapist contact email extraction at scale.*

***

### Disclaimer

**Physical Therapist Email Scraper accesses publicly accessible sources only** and does not retrieve data from private profiles or password-protected content. You are responsible for ensuring your use complies with applicable laws and regulations (including GDPR/CCPA where relevant) and each website’s terms of service and platform policies.

For data removal requests, contact <dataforleads@gmail.com>.\
Please use this tool responsibly, ethically, and for legitimate purposes only.

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

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/physical-therapist-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": "Physical Therapist",
    "googleMapsLocation": ["New York"],
    "maxBusinesses": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Physical Therapist Email Scraper",
        "description": "📩 Find verified physical therapist contacts fast! Our SEO-optimized email scraper pulls targeted leads by specialty, location, and keywords—ideal for clinics, recruiting, and marketing teams. ⚡ Accurate, compliant, and built for speed.",
        "version": "1.0",
        "x-build-id": "5BYE8KfP35gy6a6eJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~physical-therapist-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-physical-therapist-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/solid-scraper~physical-therapist-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-physical-therapist-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/solid-scraper~physical-therapist-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-physical-therapist-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": "Physical Therapist"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
