# Psychotherapists Email Scraper (`solid-scraper/psychotherapists-email-scraper`) Actor

🧠 Psychotherapists Email Scraper finds therapist leads by specialty, location & keywords. Instantly generate outreach lists for clinics, agencies & mental health startups. 📧🚀 Save time, reach the right professionals faster.

- **URL**: https://apify.com/solid-scraper/psychotherapists-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

### Psychotherapists Email Scraper 🔍

**Psychotherapists Email Scraper** automatically searches for psychotherapists for businesses and extracts their contact information, including email addresses, phone numbers, and social media profiles. If you’ve been manually building a **therapist email scraper** list or trying to find **licensed therapist contact scraper** leads one by one, this tool helps you save hours by turning public web data into a structured dataset you can use for outreach and research—at scale.

Whether you’re a marketer, recruiter, researcher, or data analyst looking for a **psychotherapist email database**, this actor focuses on getting usable contact fields quickly and consistently, so you can move from prospecting to action faster.

---

### 🚀 Why choose Psychotherapists Email Scraper?

| Feature | Benefit |
|---|---|
| ✅ **All-in-One Lead Collection** | Extracts emails, phone numbers, and social media profiles in one workflow. |
| ✅ **Location-Based Prospecting** | Finds psychotherapists for specified locations using your search term. |
| ✅ **Reliability & Resilience** | Includes safeguards like fallback behaviors and resilient processing so runs complete successfully more often. |
| ✅ **Structured, Dataset-Ready Output** | Pushes results into an Apify dataset with consistent, analysis-friendly fields. |
| ✅ **Built-in Proxy Support** | Helps improve scraping stability for larger batches using configurable proxy settings. |
| ✅ **Scale Controls** | Lets you cap how many businesses to collect (and stop when your target is reached). |

---

### 🔎 Key features

- 💾 **Real-time dataset saving**: Each business (and each found email) is pushed to the dataset as scraping progresses.
- 🗺️ **Multi-location targeting**: Scrape by one or more locations and control how results are limited across them.
- 📧 **Therapist email scraping**: Collects `scraped_emails` from business websites and outputs `email_found` as a flattened value.
- 📞 **Phone extraction**: Captures `scraped_phones` from the website domain (when available).
- 🔗 **Social media profile extraction**: Captures `scraped_social_media` from the website domain (when available).
- 🧾 **Business-level contact context**: Stores business name, website, phone, and address fields alongside extracted contacts.
- 🛡️ **Proxy configuration support**: You can enable proxy settings via `proxyConfiguration` (recommended for larger runs).
- 📊 **Progress & quality signals**: Includes `emails_found`, `pages_scraped`, and `scrape_status` to track what happened.

---

### 📝 Input

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

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

#### Input Fields

| Field | Required | Description |
|---|---|---|
| `googleMapsSearchTerm` | Yes | The business type or niche your email scraper should look for (prefilled as `Psychotherapists`). |
| `googleMapsLocation` | Yes | One or more geographic locations to target (for example: `["New York"]`). |
| `maxBusinesses` | No | Target number of businesses to find that have emails. Must be between 1 and 1000. Default: `5`. |
| `scrapeMaxBusinessesPerLocation` | No | When enabled, the scraper aims for up to `maxBusinesses` results per location. When disabled, it combines locations into a single total limit. Default: `false`. |
| `proxyConfiguration` | No | Proxy settings for scraping. Using proxies helps avoid IP blocks and rate limits. Default prefill includes `proxy support: true`. |
| `proxyConfiguration.proxy support` | No | When set, enables Apify Proxy usage (prefilled to `true`). |

***

### 📦 Output

The actor saves results into the Apify dataset **one row per email** when emails are found (it flattens `scraped_emails` into `email_found`). It also includes business-level fields and scrape status metadata.

Example dataset row:

```json
{
  "name": "Example Psychotherapy Practice",
  "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",
  "scraped_emails": ["contact@example.com"],
  "scraped_phones": ["+1 555 987 6543"],
  "scraped_social_media": ["https://www.linkedin.com/company/example"],
  "emails_found": 1,
  "pages_scraped": 3,
  "avg_rating": 4.6,
  "total_reviews": 120,
  "lat": 40.7128,
  "long": -74.006,
  "place_id": "ChIJN1t_tDeuEmsRUsoyG83frY4",
  "scrape_status": "success",
  "email_found": "contact@example.com"
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `name` | string | Business name (from the business listing). |
| `website` | string | Business website URL (normalized). |
| `phone` | string | Business phone number (from the listing). |
| `full_address` | string | Full concatenated address (`street_address city state zip country_code`). |
| `city` | string | City name. |
| `state` | string | State/region name. |
| `zip` | string | Postal/ZIP code. |
| `country_code` | string | Country code from the listing address fields. |
| `scraped_emails` | array | Emails found on the website (only present when the business is pushed with email lists; flattened output uses `email_found`). |
| `scraped_phones` | array | Phone numbers extracted from the website domain. |
| `scraped_social_media` | array | Social links extracted from the website domain. |
| `emails_found` | number | Count of emails found for the business. |
| `pages_scraped` | number | Number of processed URLs/pages during website scraping. |
| `avg_rating` | number | Average rating value (from the business listing). |
| `total_reviews` | number | Total review count (from the business listing). |
| `lat` | number | Latitude of the business. |
| `long` | number | Longitude of the business. |
| `place_id` | string | Listing place identifier. |
| `scrape_status` | string | Scrape outcome status (e.g., `success`, `failed`, `no_website`, `error`). |
| `email_found` | string | Flattened email value for each dataset row when emails are found. |
| `scrape_error` | string | Error message when scraping fails (included in failure/error paths). |

Notes on behavior:

- If a business has no website, the actor can push it with empty `scraped_emails`, `scraped_phones`, and `scraped_social_media` depending on the flow, and sets `scrape_status` to `no_website`.
- When emails are found, the actor pushes **one row per email** and sets `email_found` accordingly.

***

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

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

2. **Find and open the actor**\
   Search for **Psychotherapists Email Scraper** and open the actor page.

3. **Enter your Input settings**\
   Use the input form and set:
   - `googleMapsSearchTerm` (default is `Psychotherapists`)
   - `googleMapsLocation` (e.g. `New York`)

4. **Choose your limits**\
   Set `maxBusinesses` (default: `5`) and decide whether to enable `scrapeMaxBusinessesPerLocation`.

5. **(Optional) Configure proxy settings** 🛡️\
   If you’re scraping at higher scale, use `proxyConfiguration` (prefilled with `proxy support: true`).

6. **Run the actor**\
   Click **Run**. Watch the logs during the run—this actor proceeds in stages (location collection, then website scraping), pushing results to the dataset as it goes.

7. **Open the dataset and export**\
   After completion, check the **OUTPUT** dataset view and export to your preferred format (JSON/CSV depending on Apify’s dataset options).

No coding required—get accurate results in minutes with **Psychotherapists Email Scraper**. ✅

***

### ⚙️ Advanced features & SEO optimization

- 🧠 **Engineered for therapist lead generation email scraper workflows**: Designed specifically for psychotherapists and related mental health professional lead collection tasks.
- 🗺️ **City-bound filtering mindset**: Results are kept relevant to the target area rather than mixing unrelated regions.
- 🧾 **Confidence-friendly dataset structure**: Output includes rating/reviews and scrape health fields like `emails_found`, `pages_scraped`, and `scrape_status` for quick triage.
- 🔄 **Email-only style output readiness**: When emails are present, the dataset is flattened into clean `email_found` rows—perfect for downstream CRM imports or bulk outreach lists.
- 📋 **Works great as a healthcare provider email scraper** foundation: Combine results across runs and normalize contacts in your pipeline.

***

### 🎯 Best use cases

- 📈 **Marketing teams building a psychotherapist email database**: Generate targeted email lists for campaigns focused on mental health services.
- 🔎 **Research analysts studying private practice therapist contact patterns**: Collect outreach-ready contact fields with location and website context.
- 🧑‍💼 **BD & partnerships teams doing licensed therapist contact scraper outreach**: Speed up finding decision-makers and contact routes for collaboration.
- 🗂️ **Data enrichment workflows for a counselor email scraper**: Enrich lead records with website, phones, and social profiles alongside emails.
- 💻 **CRM onboarding for therapist lead generation email scraper use**: Import flattened `email_found` rows and match back to business details.
- 🏥 **Healthcare provider email scraper foundation**: Build a reusable lead dataset from publicly available sources for ongoing list refreshes.

***

### 🔧 Technical specifications

- **Supported Input Formats**
  - ✅ `googleMapsSearchTerm` as a string (e.g., `Psychotherapists`)
  - ✅ `googleMapsLocation` as an array of strings (e.g., `["New York"]`)
  - ✅ Optional limits: `maxBusinesses` (1–1000), `scrapeMaxBusinessesPerLocation` (boolean)

- **Proxy Support**
  - ✅ `proxyConfiguration` object is supported
  - ✅ `proxyConfiguration.proxy support` is available (prefilled to `true`)

- **Retry Mechanism**
  - ✅ Includes retries/fallback behaviors for resilience during scraping (high level)

- **Dataset Structure**
  - ✅ Apify Dataset view with table fields including:\
    `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`

- **Limitations**
  - ⚠️ Businesses without websites won’t yield emails; they may be pushed with empty email/phone/social fields and `scrape_status` set accordingly.
  - ⚠️ Output is capped by `maxBusinesses` and can stop early once the target is reached.

***

### ❓ FAQ

#### Is Psychotherapists Email Scraper a real therapist email scraper or just a directory scraper?

✅ It’s designed as a psychotherapists email scraper: it searches for relevant businesses and then scrapes their websites to extract contact information, including emails, phone numbers, and social media profiles.

#### What data does Psychotherapists Email Scraper output?

✅ It saves business fields like `name`, `website`, and `full_address`, plus extracted fields such as `scraped_emails`, `scraped_phones`, and `scraped_social_media`. It also includes counters like `emails_found` and `pages_scraped`, and a `scrape_status` field.

#### Does it save one row per business or one row per email?

✅ It pushes **one row per email** when emails are found by flattening results into `email_found` rows, alongside the business context fields.

#### Can I control how many businesses are collected?

✅ Yes. Use `maxBusinesses` to set the target number of businesses with emails (1–1000). You can also control whether the cap applies per location via `scrapeMaxBusinessesPerLocation`.

#### Do I need coding to run this actor?

✅ No coding required. You can run it directly in Apify Console by configuring `googleMapsSearchTerm`, `googleMapsLocation`, and (optionally) limits and proxy settings.

#### Does Psychotherapists Email Scraper handle proxies?

✅ Yes. You can configure `proxyConfiguration` (including `proxy support`) to improve scraping stability for larger batches.

#### How can I export the results after the run?

✅ Open the actor’s dataset in the Apify OUTPUT tab and export to JSON/CSV using Apify’s dataset export options.

#### Is it legal to use this for email harvesting and therapist email lead generation?

✅ The actor collects from publicly available sources, but your use must comply with applicable laws and platform rules (for example, GDPR/CCPA and anti-spam regulations). You’re responsible for compliance.

***

### 🤝 Support & feature requests

Want to improve Psychotherapists Email Scraper for your therapist email scraper or counselor email scraper workflows? 💡 Share feedback and enhancement ideas.

- 💡 **Feature Requests**: Examples include CSV export improvements, additional filtering options, or CRM-friendly output tweaks for therapist lead generation email scraper pipelines.
- 📧 **Contact**: Email <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for the most comprehensive psychotherapists email scraper experience. 🙌

***

### *Final thoughts on Psychotherapists Email Scraper* ✨

*If you’re serious about building a psychotherapist marketing email list or a licensed therapist contact scraper workflow, Psychotherapists Email Scraper is the most comprehensive option to run at scale.*\
*Get started now and let your dataset fill itself with contact details from publicly available sources.*

***

### Disclaimer

**This actor accesses publicly accessible sources** to collect business contact information. It does not access private profiles, authenticated data, or password-protected content.

You are responsible for ensuring your usage complies with applicable laws and regulations (including GDPR/CCPA), spam and marketing rules, and any relevant platform terms of service. For data removal requests, contact <dataforleads@gmail.com>.

Use **Psychotherapists Email Scraper** 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": "Psychotherapists",
  "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": "Psychotherapists",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Psychotherapists Email Scraper",
        "description": "🧠 Psychotherapists Email Scraper finds therapist leads by specialty, location & keywords. Instantly generate outreach lists for clinics, agencies & mental health startups. 📧🚀 Save time, reach the right professionals faster.",
        "version": "1.0",
        "x-build-id": "hhsSrukGaHMlKkent"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~psychotherapists-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-psychotherapists-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~psychotherapists-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-psychotherapists-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~psychotherapists-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-psychotherapists-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": "Psychotherapists"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
