# Doctors Email Scraper (`contacts-api/doctors-email-scraper`) Actor

Doctors Email Scraper to collect verified physician emails and contact details by specialty; location; and organization from medical directories and clinic websites 🩺📧 Perfect for healthcare B2B outreach; medtech sales; recruiting; and lead generation.

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

## Pricing

$9.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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

### ⭐ Doctors Email Scraper — Build Verified Doctors Email Lists at Scale 🤖

Doctors Email Scraper is a powerful, end-to-end lead-generation tool that discovers doctors and clinics on Google Maps, visits their websites, and automatically extracts public contact details — including doctors emails, phone numbers, social media profiles, ratings, and more. It’s the easiest way to generate a clean, structured doctors email list for outbound campaigns, sales, and market research.

With the Doctors Email Scraper, you simply enter your medical niche and target locations — like “Cardiologists” in “Miami, Florida” — set a limit, and let the doctors email finder collect fresh data fast. Whether you need a doctors email list for B2B outreach, a doctors lead scraper for pipeline growth, or a doctors finder for local prospecting, this tool delivers.

—  
 
### 📩 What can the Doctors Email Scraper extract?

Below is a quick breakdown of data points the Doctors Email Scraper can deliver ⬇️

| Data Type 📊          | Description                                                                 |
| --------------------- | --------------------------------------------------------------------------- |
| Business Name         | Clinic or practitioner name                                                 |
| Website               | Official website link                                                       |
| Phone                 | Primary phone number                                                        |
| Full Address          | Complete formatted address                                                  |
| City / State / ZIP    | Parsed location components                                                  |
| Country Code          | ISO 2-letter country code (e.g., US)                                        |
| Emails Found          | Array of public emails discovered on site (doctors emails)                  |
| Phone Numbers         | Any additional numbers found on website                                     |
| Social Media          | Links to Facebook, LinkedIn, Instagram, X, etc.                             |
| # Emails              | Count of emails discovered                                                  |
| Pages Scraped         | Number of website pages crawled to collect data                             |
| Rating & Reviews      | Average rating and total reviews from Google Maps                           |
| Coordinates           | Latitude and longitude                                                      |
| Place ID              | Google Maps place identifier                                                |
| Status                | Scrape status (success, no-website, no-email, etc.)                         |

⏱ Ideal for building niche-targeted, geo-specific doctors b2b leads and robust doctors email lists.

---

### 🧩 Input Parameters

#### Example Input JSON

```json
{
  "googleMapsSearchTerm": "Cardiologists",
  "googleMapsLocation": ["Miami, Florida", "Orlando, Florida"],
  "maxBusinesses": 20,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

#### Input Parameters Table

| Parameter                         | Description                                                                                                                                                                   |
| --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| googleMapsSearchTerm              | Search term or niche to find on Google Maps (e.g., Doctors, Cardiologists, Dentists, Dermatologists).                                                                          |
| googleMapsLocation                | One or more target locations (e.g., “Miami, Florida”). Supports multi-location scraping.                                                                                      |
| maxBusinesses                     | Target number of businesses with emails to collect (1–1000). The run stops when this limit is reached.                                                                        |
| scrapeMaxBusinessesPerLocation    | If enabled, collects up to maxBusinesses per each location. If disabled, combines all locations toward a single total limit.                                                  |
| proxyConfiguration                | Proxy settings for scalable scraping. Recommended for larger runs to avoid IP blocks and rate limits.                                                                          |

Tip: Use specific specialties (e.g., “Pediatricians”, “Orthopedic surgeons”) and multiple cities to generate bigger, more relevant doctors leads.

***

### 📤 Output Format

#### Example Output JSON

```json
[
  {
    "name": "Miami Heart & Vascular Center",
    "website": "https://www.miamiheartvascular.com",
    "phone": "+1 305-555-0199",
    "full_address": "1450 Brickell Ave, Miami, FL 33131, United States",
    "city": "Miami",
    "state": "Florida",
    "zip": "33131",
    "country_code": "US",
    "scraped_emails": ["appointments@miamiheartvascular.com", "info@miamiheartvascular.com"],
    "scraped_phones": ["+1 305-555-0199", "+1 305-555-0120"],
    "scraped_social_media": [
      "https://www.facebook.com/miamiheartvascular",
      "https://www.linkedin.com/company/miami-heart-vascular"
    ],
    "emails_found": 2,
    "pages_scraped": 12,
    "avg_rating": 4.7,
    "total_reviews": 183,
    "lat": 25.7602,
    "long": -80.1921,
    "place_id": "ChIJ9xWZ1tc2MIgRkYbV6fQbqK0",
    "scrape_status": "success"
  }
]
```

#### Output Fields Table

| Field                 | Description                                                                              |
| --------------------- | ---------------------------------------------------------------------------------------- |
| name                  | Clinic or practitioner name                                                              |
| website               | Official website URL                                                                     |
| phone                 | Primary phone number from Google Maps listing                                            |
| full\_address          | Full formatted address                                                                   |
| city                  | City name                                                                                |
| state                 | State or region                                                                          |
| zip                   | ZIP or postal code                                                                       |
| country\_code          | ISO 2-letter country code                                                                |
| scraped\_emails        | Array of public emails discovered on the website (doctors emails)                        |
| scraped\_phones        | Array of additional phone numbers found on the website                                   |
| scraped\_social\_media  | Array of social profile URLs (Facebook, LinkedIn, Instagram, X, etc.)                    |
| emails\_found          | Number of emails detected                                                                |
| pages\_scraped         | How many website pages were crawled                                                      |
| avg\_rating            | Average Google rating                                                                    |
| total\_reviews         | Total Google reviews                                                                     |
| lat                   | Latitude                                                                                 |
| long                  | Longitude                                                                                |
| place\_id              | Google Maps place identifier                                                             |
| scrape\_status         | Process status for this record (e.g., success, no-website, website-timeout, no-email)    |

***

### ⚙️ Key Features of the Doctors Email Scraper ✨

- 🎯 Niche + Location Targeting
  Use precise search terms such as Cardiologists, Dermatologists, Dentists, or “Doctors” plus your city. This makes the Doctors email scraper and doctors email list scraper ideal for hyper-local campaigns.

- 🗺️ Google Maps Powered Discovery
  Finds real clinics and practitioners via Google Maps, then visits their sites to extract public contact data — a reliable pipeline for doctors leads.

- 🔎 Smart Website Crawling
  The built-in doctors email finder automatically scans multiple pages to surface doctors emails, additional phones, and social links for richer profiles.

- 📊 Enriched Business Context
  Collect ratings, reviews, and location details alongside emails, enabling quality scoring and prioritization for doctors b2b leads.

- 🌍 Multi-Location Scaling
  Add multiple cities or regions and decide whether to cap per-location results or combine them into one total using the scrapeMaxBusinessesPerLocation flag.

- ⚡ High-Throughput with Proxies
  Integrated proxy support for speed and stability at scale — perfect for large doctors email list builds.

- 📦 Clean, Structured Output
  Export consistent JSON/CSV for easy import into your CRM, outreach platforms, or analytics pipelines. Great for a Doctors lead scraper and Doctors lead finder workflow.

- 🧠 Flexible “Doctors Finder”
  From broad categories (Doctors) to specialties (Neurologists, Orthopedists), the Doctors finder adapts to your targeting strategy.

- 🧰 B2B-Friendly Data
  Built for sales, partnerships, and recruiting teams who need a dependable Doctors b2b email scraper.

***

### 🛠️ How to use the Doctors Email Scraper (Step-by-Step) 📘

Follow this simple guide to extract targeted doctors emails in minutes:

1. Log in to Apify
   Create a free account or sign in to your dashboard.

2. Select the Actor
   Search for “Doctors Email Scraper” in the Apify Store.

3. Enter Your Search Term
   Example: “Cardiologists” or simply “Doctors” for a broad doctors email list.

4. Add Locations
   Provide one or more cities or regions, e.g., “Miami, Florida” and “Orlando, Florida”.

5. Set Max Businesses
   Choose how many businesses with emails to collect (e.g., 20, 100, 500).

6. Choose Per-Location Logic
   - Enable scrapeMaxBusinessesPerLocation to cap each location separately.
   - Disable it to combine all locations toward a single total.

7. Configure Proxies (Recommended)
   Keep Apify Proxy enabled for larger runs to reduce blocks.

8. Run the Actor 🚀
   The Doctors email scraper finds clinics, visits websites, and extracts emails automatically.

9. Download Results
   Export JSON/CSV/Excel or use the API to feed your CRM and sequences.

A smooth, fast workflow — perfect for building an up-to-date doctors email list for B2B outreach.

***

### 🎯 Use Cases: What can you do with the Doctors Email Scraper?

This scraper unlocks dozens of high-value use cases, including:

- 💼 B2B Sales & Partnerships
  Build a doctors email list for medical device vendors, healthcare SaaS, staffing, and lab services. Perfect for generating Doctors b2b leads.

- 📣 Appointment Setting & Outreach
  Use the doctors email list scraper to fuel cold email, LinkedIn, and calling campaigns.

- 🧪 Healthcare Market Research
  Map specialties, ratings, and regions to benchmark providers and local markets.

- 🧲 Lead Generation for Agencies
  Agencies and consultants can use this Doctors lead scraper to deliver consistent pipeline to clients.

- 🧩 CRM Enrichment
  Add missing emails and phones to provider records with a reliable doctors email finder.

- 🗂️ Territory Planning
  Use the Doctors finder to segment by city, state, or ZIP and prioritize outreach.

- 🔁 Recurring Prospecting
  Schedule runs to keep your doctors email list fresh and current.

Whether you need a Doctors lead finder for local campaigns or a nationwide Doctors b2b email scraper for enterprise outreach, this tool adapts.

***

### 💎 Why choose us?

Choosing our Doctors Email Scraper gives you:

- ⚡ Faster & Scalable Scraping with proxy-backed crawling
- 🔍 Higher Coverage via Google Maps + website scanning
- 🧼 Clean, structured output ready for CRM and automation
- 📈 Data that converts — curated for doctors leads and B2B workflows
- 🌐 Multi-location, multi-specialty flexibility
- 🛡️ Ethical collection of publicly available info
- 📞 Dedicated Support (email: leadheavencontact@gmail.com)
- 🤖 End-to-end solution for doctors email list building, from discovery to enrichment

If you want reliable doctors emails and sustained Doctors b2b leads, this is the doctors email scraper built for performance.

***

### 📊 How many results can you scrape with Doctors Email Scraper?

The Doctors Email Scraper is engineered for scalability, suitable for local lists and large datasets alike. It can collect anywhere from a few to thousands of records with valid doctors emails, depending on:

- Your search term specificity (e.g., “Doctors” vs. “Pediatric Dermatologists”)
- Number and size of locations provided
- maxBusinesses limit you set (1–1000 per run)
- Whether you cap results per location or combine them
- Website density and public email availability
- Proxy usage and run timeout settings

Typical ranges:

- Small campaigns: 20–100 providers
- Medium campaigns: 200–1,000 providers
- Large datasets: 2,000–10,000+ providers across multiple runs

For very large doctors email list builds, schedule multiple runs per specialty and region. The doctors email list scraper design ensures consistent throughput and stability.

***

### ⚖️ Is it legal to scrape doctors email data?

Scraping publicly available information is generally legal — including public emails listed on business websites — as long as you:

- Do not bypass authentication or paywalls
- Do not collect private or sensitive data
- Respect websites’ terms of service and robots.txt guidelines where applicable
- Use the data ethically for legitimate outreach

The Doctors Email Scraper only extracts publicly visible business contact details that clinics or practitioners publish themselves. Always ensure your outreach follows:

- GDPR
- CAN-SPAM Act
- Local data privacy regulations

No protected health information (PHI) is collected; this tool focuses on public business contacts for compliant B2B use.

***

### ❓ FAQ — Doctors Email Scraper

1. Does this scrape private or personal emails?
   No. It only extracts publicly listed doctors emails found on clinic or practitioner websites.

2. Can I target specific specialties?
   Yes. Enter a niche like “Cardiologists”, “Dermatologists”, or “Pediatricians” in googleMapsSearchTerm. This makes the Doctors finder and Doctors lead finder highly precise.

3. How do I build a large doctors email list?
   Use broader specialties, add many locations, disable per-location capping to combine totals, and increase maxBusinesses. Run on a schedule to grow your Doctors b2b leads.

4. Will it remove duplicates across locations?
   The dataset is deduplicated by website/place where possible. We recommend final deduplication in your CRM for large merges.

5. Do I need proxies?
   For small runs, proxies are optional. For larger or frequent runs, enable Apify Proxy for stability — essential for a high-throughput doctors email list scraper.

6. Can I filter by ratings or reviews?
   The scraper captures avg\_rating and total\_reviews so you can filter post-run to prioritize top-rated providers.

7. Which output formats are available?
   Download as JSON, CSV, or Excel — or consume via API for automation. Perfect for a Doctors lead scraper workflow.

8. Does it work outside the United States?
   Yes. Add cities worldwide. Make sure your search term is in the local language for best results when building international doctors leads.

9. Is this a Doctors b2b email scraper?
   Yes. It’s designed for compliant B2B outreach, giving you a dependable pipeline of Doctors b2b leads.

***

For any help or custom solution, contact via this mail: leadheavencontact@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": "Doctors",
  "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": "Doctors",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Doctors Email Scraper",
        "description": "Doctors Email Scraper to collect verified physician emails and contact details by specialty; location; and organization from medical directories and clinic websites 🩺📧 Perfect for healthcare B2B outreach; medtech sales; recruiting; and lead generation.",
        "version": "1.0",
        "x-build-id": "Pgn31ucMBF8yZ2hJW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/contacts-api~doctors-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-contacts-api-doctors-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~doctors-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-contacts-api-doctors-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~doctors-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-contacts-api-doctors-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": "Doctors"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
