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

Physical therapist email scraper to collect verified therapist emails from clinics, rehab centers, and healthcare directories 📧🏥 Ideal for outreach, partnerships, and healthcare lead generation.

- **URL**: https://apify.com/contacts-api/physical-therapist-email-scraper.md
- **Developed by:** [Lead Heaven](https://apify.com/contacts-api) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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 — Find Verified Leads in Minutes

> The fastest way to build a targeted physical therapist list. This actor searches Google Maps for Physical Therapists across any location, crawls their websites, and extracts verified physical therapist email addresses, phone numbers, and social media profiles — all in one clean, export-ready dataset.

---

#### 🚀 Quick Start

1. Enter your search term — e.g., "Physical Therapist"
2. Add one or more target locations — e.g., "New York"
3. Set your maximum number of businesses with emails
4. Hit Run and get your results in minutes

No coding required. Export to CSV, JSON, or Excel instantly. Whether you need a quick physical therapist email pull or a large-scale physical therapist list, this is built for speed.

---

#### 💡 What Is the Physical Therapist Email Scraper?

The Physical Therapist Email Scraper is a purpose-built lead generation and contact discovery tool designed for:

- Healthcare marketing teams and agencies
- Physical therapy clinic owners and network builders
- B2B outreach and sales teams
- Researchers and data analysts

It combines Google Maps listing discovery with deep website crawling to extract publicly available contact data — producing an accurate, deduplicated physical therapist list ready for immediate use.

Whether you need a physical therapist email finder, a physical therapist lead scraper, or a physical therapist lead finder — this actor covers all three in a single automated run. It also works as a physical therapist contact scraper and physical therapist contact finder when you’re focused on broader contact details beyond emails. If you’re building pipelines or enrichment workflows, it doubles as a reliable physical therapist data scraper.

---

#### 📦 What Data Does It Extract?

| Field | Description |
|---|---|
| Business Name | Clinic or practice name from Google Maps |
| Website | Official website URL |
| Phone | Primary phone from the listing or website |
| Full Address | Complete address as listed |
| City / State / ZIP | Parsed location components for targeting and filtering |
| Country Code | ISO country code where available |
| Emails | All public physical therapist email addresses extracted from website pages |
| Additional Phones | Extra phone numbers discovered during crawl |
| Social Media Links | Facebook, Instagram, LinkedIn, Twitter/X, and more |
| Email Count | Total unique emails found per business |
| Pages Scraped | Number of website pages crawled per domain |
| Rating | Average Google Maps star rating |
| Reviews | Total number of Google reviews |
| Latitude / Longitude | Geo-coordinates for mapping and analysis |
| Place ID | Google Maps place identifier |
| Scrape Status | Per-record status: success, partial, or error |

This contact and metadata bundle is ideal for physical therapist leads generation and enrichment.

---

#### ⚙️ Input Configuration

##### Minimal Example

```json
{
  "googleMapsSearchTerm": "Physical Therapist",
  "googleMapsLocation": ["New York"],
  "maxBusinesses": 50
}
````

##### Full Example with All Options

```json
{
  "googleMapsSearchTerm": "Physical Therapist",
  "googleMapsLocation": [
    "New York",
    "Boston, Massachusetts",
    "Philadelphia, Pennsylvania"
  ],
  "maxBusinesses": 200,
  "scrapeMaxBusinessesPerLocation": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

##### Input Parameters

| Parameter | Type | Required | Description |
|---|---|---|---|
| `googleMapsSearchTerm` | String | ✅ Yes | Business type or niche to search — e.g., "Physical Therapist", "sports physical therapy", "pediatric physical therapy" |
| `googleMapsLocation` | Array | ✅ Yes | One or more locations — e.g., \["New York", "Austin, Texas"] |
| `maxBusinesses` | Number | ✅ Yes | Max businesses with emails to return (1–1,000). The physical therapist email scraper stops as soon as this is reached |
| `scrapeMaxBusinessesPerLocation` | Boolean | ❌ No | If true, applies the cap per location. If false, it's a combined total across all locations |
| `proxyConfiguration` | Object | ❌ No | Proxy settings. Strongly recommended for large runs to minimize rate-limiting |

***

#### 📤 Sample Output

```json
[
  {
    "name": "BalancePT NYC",
    "website": "https://www.balanceptnyc.com",
    "phone": "+1 212-555-0148",
    "full_address": "245 W 57th St, New York, NY 10019, United States",
    "city": "New York",
    "state": "NY",
    "zip": "10019",
    "country_code": "US",
    "scraped_emails": [
      "info@balanceptnyc.com",
      "appointments@balanceptnyc.com"
    ],
    "scraped_phones": ["+1 212-555-0148", "+1 212-555-0192"],
    "scraped_social_media": [
      "facebook:https://facebook.com/balanceptnyc",
      "instagram:https://instagram.com/balanceptnyc",
      "linkedin:https://www.linkedin.com/company/balanceptnyc"
    ],
    "emails_found": 2,
    "pages_scraped": 12,
    "avg_rating": 4.9,
    "total_reviews": 218,
    "lat": 40.7651,
    "long": -73.9804,
    "place_id": "ChIJ-EXAMPLEID-nyc",
    "scrape_status": "success"
  }
]
```

***

#### 🔧 How It Works — Under the Hood

```
Step 1 → Search Google Maps using your term + location
Step 2 → Collect business listings (name, address, phone, website)
Step 3 → Visit each website and crawl key pages (Home, Contact, About, FAQs, Footer)
Step 4 → Extract public emails, phone numbers, and social media links
Step 5 → Deduplicate and normalize all contact data
Step 6 → Return structured results ready for export or API consumption
```

The actor is built to work as both a discovery engine and an extraction pipeline — acting as a physical therapist email extractor and physical therapist lead scraper in a single automated workflow. It also functions as a flexible physical therapist contact finder when you need broader contact points beyond email.

***

#### ✨ Key Features

##### 🎯 Precise Location Targeting

Pinpoint clinics in any city, state, or region. Ideal for building geo-targeted physical therapist leads and rolling out campaigns city by city.

##### 🔍 Deep Website Crawl

Goes beyond Google listings. Crawls homepages, contact pages, about pages, and footers to surface every available public physical therapist email and phone number — functioning as a practical physical therapist email extractor.

##### 🧭 Keyword & Niche Flexibility

Use any search phrase relevant to your niche: "sports physical therapy", "pelvic floor therapist", "vestibular rehab", and more. The physical therapist contact scraper adapts to broad and long-tail queries.

##### 🧹 Smart De-Duplication

Automatically removes duplicate emails per domain and normalizes contact fields. Clean outputs keep your CRM accurate and your physical therapist list campaign-ready.

##### 📊 Structured, CRM-Ready Output

Consistent field names and normalized values make it easy to drop into HubSpot, Salesforce, Apollo, or any outreach tool. Perfect for teams scaling physical therapist leads and enrichment workflows.

##### 🛡️ Proxy-Ready for Reliability

Built-in proxy support enables stable, large-scale runs without rate-limiting or IP blocks — essential for agency-grade use of a physical therapist data scraper.

##### ⏱️ Stop at Your Target

The run halts as soon as your `maxBusinesses` limit is hit — no wasted compute. Efficient for rapid testing and repeatable scrapes with your physical therapist lead finder.

##### 🔄 Schedulable & Repeatable

Run daily, weekly, or monthly to continuously grow and refresh your physical therapist list. Great for clinics, agencies, and data teams.

***

#### 🎯 Use Cases

##### 💼 B2B Outreach & Sales

Build pitch lists for independent clinics, hospital outpatient rehab, and multi-location practices. Use this as your physical therapist lead finder to fuel cold email and calling sequences.

##### 🧑‍⚕️ Healthcare Staffing & Recruiting

Identify hiring managers and clinics that fit your placement focus. The physical therapist contact finder surfaces direct inboxes you won’t get from job boards alone.

##### 📣 Local & Regional Marketing

Create geo-targeted campaigns with verified emails and phones pulled from clinic websites. Perfect for agencies selling local SEO, PPC, or SaaS to physical therapist leads.

##### 🤝 Partnership & Referral Development

Find complementary providers for referral programs — orthopedic clinics, sports medicine centers, chiropractors. Your physical therapist contact scraper helps locate the right partners.

##### 🗃️ CRM Enrichment & Data Hygiene

Enrich existing records with missing emails, phones, and social profiles. Think of this as your backend physical therapist data scraper to keep records current.

##### 📚 Academic Research & Surveys

Compile contact info for surveys or studies. Quickly gather public physical therapist email addresses across multiple cities.

##### 🏢 Agency Client Delivery

Run weekly scrapes and deliver fresh physical therapist leads to clients. Position it as a physical therapist lead scraper and physical therapist email finder rolled into one.

***

#### 📈 How Many Results Can You Get?

Scale from a small prospect list to a large regional database — results depend on:

- Number of locations added
- Search term breadth (narrow vs. broad niche)
- Website density and email visibility in each market
- `maxBusinesses` setting and per-location vs. combined mode
- Proxy configuration and run timeout

##### Typical Output Ranges

| Campaign Size | Businesses with Emails |
|---|---|
| Small (1–3 cities) | 20 – 100 |
| Medium (5–15 cities) | 200 – 600 |
| Large (20+ cities / states) | 800 – 1,000+ per run |

Run multiple times across different regions to continuously grow your physical therapist list without hitting hard platform limits.

***

#### 🔌 Integrations & Export Options

Once your run completes, you can:

| Option | Details |
|---|---|
| JSON | Full structured data download |
| CSV / Excel | Import directly into spreadsheets |
| Apify API | Stream results into your own apps or workflows |
| Zapier / Make | Trigger automations when new leads are found |
| Webhooks | Push results to your CRM or pipeline on run completion |

Plug directly into Instantly, Smartlead, Apollo, HubSpot, Salesforce, Pipedrive, or any outreach platform that accepts CSV/JSON imports. Ideal for activating physical therapist leads quickly.

***

#### 🛠️ Step-by-Step Usage Guide

Step 1 — Log in to Apify\
Create a free account or sign in at apify.com.

Step 2 — Open the Actor\
Search for "Physical Therapist Email Scraper" in the Apify Store and click Try for free.

Step 3 — Set Your Search Term\
Enter "Physical Therapist" or a niche variant like "sports physical therapy" or "pediatric physical therapy" to tailor your physical therapist leads.

Step 4 — Add Target Locations\
Enter one or more city/state combos — e.g., "New York", "Austin, Texas".

Step 5 — Set Your Limit\
Choose how many businesses with emails you want — 20 for a quick test, up to 1,000 for a larger physical therapist list.

Step 6 — Choose Scaling Strategy

- Combined cap: The total across all locations combined
- Per-location cap: Applies your limit independently to each city

Step 7 — Enable Proxies\
Turn on Apify Proxy for stable, uninterrupted crawling at scale.

Step 8 — Run 🚀\
Click Start and let the Physical Therapist Email Scraper do the work.

Step 9 — Export\
Download as JSON, CSV, or Excel — or pull via API straight into your stack.

***

#### ⚖️ Legal & Compliance

This actor collects only publicly available business contact information — emails and phone numbers published openly on websites.

Best practices to stay compliant:

- Only use publicly visible contact data
- Do not bypass login walls or paywalls
- Respect each website's robots.txt and Terms of Service
- Include an unsubscribe option in all outreach
- Follow applicable laws in your jurisdiction

Relevant regulations to be aware of:

- GDPR (EU)
- CAN-SPAM Act (United States)
- CASL (Canada)
- PECR (United Kingdom)

This tool is intended for ethical business prospecting only. You are responsible for how you use the data collected.

***

#### ❓ Frequently Asked Questions

Q: Does this scrape private or personal emails?\
A: No. The actor only extracts emails that are publicly visible on business websites — clinic inboxes, admin contacts, and general inquiry addresses. It acts as a compliant physical therapist email extractor.

Q: Can I search multiple cities in one run?\
A: Yes. Add as many locations as needed. Use per-location capping for even geographic distribution across your physical therapist leads.

Q: Does it deduplicate results?\
A: Yes. Emails are deduplicated per domain to keep your physical therapist list accurate and clean.

Q: Can I schedule recurring runs?\
A: Absolutely. Use Apify's built-in scheduler to run weekly or monthly and keep your data fresh. Great for a hands-off physical therapist contact scraper workflow.

Q: What niches does the search term support?\
A: Any Google Maps searchable term — try "sports physical therapy", "pelvic floor therapist", "vestibular rehab", or "manual therapy clinic". This flexibility helps the physical therapist lead finder adapt to your niche.

Q: Are proxies required?\
A: Not for small runs, but proxies are strongly recommended for 200+ business runs to avoid rate limits and maintain stability with this physical therapist data scraper.

Q: What export formats are available?\
A: JSON, CSV, and Excel. You can also consume results via the Apify API or webhook.

Q: How is this different from manual Google searching?\
A: Manual search is slow, inconsistent, and doesn’t extract emails at scale. This automates discovery and extraction — working as a physical therapist email finder and physical therapist lead scraper in minutes.

Q: Can agencies white-label or resell this?\
A: Yes. Run it on behalf of clients and deliver fresh physical therapist leads on a recurring basis.

***

#### 🧑‍💻 Support & Custom Solutions

Have a question, feature request, or need a custom build?

Email: scrapermindapi@gmail.com

We’re happy to help with:

- Custom input/output configurations
- Niche-specific adaptations (e.g., sports, pediatric, pelvic floor)
- Bulk or enterprise run support
- Integration assistance

Built for marketers, staffing professionals, and outreach teams who need accurate physical therapist email data and scalable physical therapist leads — fast.

For any help or custom solution, contact via this mail: scrapermindapi@gmail.com

# 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("contacts-api/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("contacts-api/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 contacts-api/physical-therapist-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Physical Therapist Email Scraper",
        "description": "Physical therapist email scraper to collect verified therapist emails from clinics, rehab centers, and healthcare directories 📧🏥 Ideal for outreach, partnerships, and healthcare lead generation.",
        "version": "1.0",
        "x-build-id": "l0yFP5PZGL8cT23lO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/contacts-api~physical-therapist-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-contacts-api-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/contacts-api~physical-therapist-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-contacts-api-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/contacts-api~physical-therapist-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-contacts-api-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
