# Pathologists Email Scraper (`contacts-api/pathologists-email-scraper`) Actor

Pathologists Email Scraper to collect verified pathologist emails from hospitals; labs; and medical directories 📧🔬 Ideal for healthcare B2B outreach; medtech sales; lab partnerships; and recruiter lead generation.

- **URL**: https://apify.com/contacts-api/pathologists-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, 0 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

### ⭐ Pathologists Email Scraper — Build Targeted Pathology Lead Lists Fast 🤖

Pathologists Email Scraper is a powerful B2B lead-generation tool that discovers and collects public contact data for pathology clinics and laboratory medicine providers. This Pathologists Email Scraper crawls Google Maps business results and the companies’ websites to extract Pathologists emails, phone numbers, and social profiles — producing a clean Pathologists email list you can plug directly into your outreach or CRM.

💡 Just enter your search term (e.g., “Pathologists” or “Anatomic pathology”), add locations like “Miami, Florida,” set your maximum businesses with emails, and let the Pathologists Email Scraper deliver verified, structured Pathologists leads in minutes.

---

### 📩 What can the Pathologists Email Scraper extract?

Below is a quick breakdown of the data this Pathologists email scraper can deliver ⬇️

| Data Type 📊             | Description                                                                 |
| ------------------------ | --------------------------------------------------------------------------- |
| Business Name            | Official clinic or practice name                                            |
| Website                  | Company website, if available                                               |
| Phone                    | Primary phone number                                                        |
| Full Address             | Street, city, and postal info                                               |
| City / State / Zip       | Parsed location components                                                  |
| Country Code             | ISO country code (e.g., US)                                                 |
| Emails Found             | Pathologists emails discovered on websites and public pages                 |
| Phone Numbers (extra)    | Additional phone numbers scraped from websites                              |
| Social Media Profiles    | Links to LinkedIn, Facebook, Instagram, etc.                                |
| # Emails                 | Count of emails extracted                                                   |
| Pages Scraped            | Number of web pages crawled per business                                    |
| Average Rating           | Google Maps rating                                                          |
| Total Reviews            | Number of Google reviews                                                    |
| Latitude / Longitude     | Geo coordinates for mapping                                                 |
| Place ID                 | Google Maps place identifier                                                |
| Scrape Status            | Status of each business scrape                                              |

⏱ Ideal for agencies, sales teams, and vendors building a quality Pathologists email list or automating Pathologists b2b leads discovery.

---

### 🧩 Input Parameters

#### Example Input JSON

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

#### Input Parameters Table

| Parameter                          | Description                                                                                                                                       |
| ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| googleMapsSearchTerm               | Search term or niche used to find businesses on Google Maps (e.g., “Pathologists”, “anatomic pathology”, “laboratory pathology”).                 |
| googleMapsLocation                 | Array of target locations (city, state, region, or country). Supports multiple locations (e.g., “Miami, Florida”, “Dallas, Texas”).              |
| maxBusinesses                      | Maximum number of businesses with emails to extract (1–1000). The actor stops when this target is reached.                                       |
| scrapeMaxBusinessesPerLocation     | If true, collects up to maxBusinesses per location; if false, combines all locations to a single total limit.                                    |
| proxyConfiguration                 | Proxy settings for large-scale scraping and reliability. Recommended to reduce blocks and boost throughput.                                       |

***

### 📤 Output Format

#### Example Output JSON

```json
[
  {
    "name": "Miami Pathology Associates",
    "website": "https://www.miamipathology.com",
    "phone": "+1 305-555-0136",
    "full_address": "1200 NW 14th St, Miami, FL 33136, United States",
    "city": "Miami",
    "state": "FL",
    "zip": "33136",
    "country_code": "US",
    "scraped_emails": [
      "info@miamipathology.com",
      "billing@miamipathology.com"
    ],
    "scraped_phones": [
      "+1 305-555-0136",
      "+1 305-555-0172"
    ],
    "scraped_social_media": [
      "https://www.linkedin.com/company/miami-pathology",
      "https://www.facebook.com/miamipathology"
    ],
    "emails_found": 2,
    "pages_scraped": 7,
    "avg_rating": 4.6,
    "total_reviews": 38,
    "lat": 25.787501,
    "long": -80.210123,
    "place_id": "ChIJ6c5y8n282YgRkP9c0mTq1rQ",
    "scrape_status": "success"
  }
]
```

#### Output Fields Table

| Field                  | Description                                                                 |
| ---------------------- | --------------------------------------------------------------------------- |
| name                   | Business or practice name                                                   |
| website                | Detected company website                                                    |
| phone                  | Primary phone number on Google or website                                   |
| full\_address           | Full formatted address                                                      |
| city                   | Parsed city                                                                 |
| state                  | Parsed state/region                                                         |
| zip                    | Postal/ZIP code                                                             |
| country\_code           | ISO country code (e.g., US, CA, GB)                                         |
| scraped\_emails         | Array of Pathologists emails discovered across public pages                 |
| scraped\_phones         | Array of additional phone numbers gathered from websites                    |
| scraped\_social\_media   | Array of social profile URLs (LinkedIn, Facebook, etc.)                     |
| emails\_found           | Number of unique emails extracted                                           |
| pages\_scraped          | Number of web pages crawled per business                                    |
| avg\_rating             | Google Maps average rating                                                  |
| total\_reviews          | Google Maps total reviews                                                   |
| lat                    | Latitude of the business                                                    |
| long                   | Longitude of the business                                                   |
| place\_id               | Google Maps place ID                                                        |
| scrape\_status          | Result status (success, no-website, no-email, error)                        |

***

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

- 🎯 Precise Google Maps Targeting
  Use keywords like “Pathologists,” “pathology lab,” or “anatomic pathology” with specific cities and states to produce a niche Pathologists email list.

- 🔎 Website Crawler + Email Extraction
  Acts as a Pathologists email finder by visiting each company’s website, scanning contact pages and footers to extract verified Pathologists emails.

- 🌍 Multi-Location Support
  Add multiple locations; choose whether your limit applies per location or across all — perfect for building a nationwide Pathologists email list.

- 🧠 Lead Quality Controls
  Tracks pages scraped and emails found per business to help you assess list quality; ideal for a Pathologists lead scraper workflow.

- 🛡️ Resilient Proxy Support
  Built-in proxy configuration increases reliability at scale and reduces blocking — essential for a robust pathologists email list scraper.

- 📦 Clean, Structured Output
  Delivers JSON/CSV with consistent fields for fast import into CRMs, sequences, or enrichment tools — a practical Pathologists b2b email scraper.

- 🚀 Scalable and Fast
  Efficient scraping and parsing pipeline helps you generate Pathologists b2b leads at volume.

- 🔁 Flexible Search
  Works as a Pathologists finder for different subspecialties and related queries (e.g., histopathologists, cytology labs).

This combination of accuracy, speed, and flexibility makes the Pathologists Email Scraper the go-to Pathologists lead finder for modern sales and marketing teams.

***

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

1. Log in to Apify
   Sign in to your Apify dashboard or create a free account.

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

3. Enter Search Term
   Set googleMapsSearchTerm to “Pathologists” or a subspecialty. This powers the Pathologists email scraper logic.

4. Add Target Locations
   Provide one or more cities/regions in googleMapsLocation (e.g., “Miami, Florida”, “Orlando, Florida”).

5. Set Business Limit
   Choose maxBusinesses (e.g., 20). Enable scrapeMaxBusinessesPerLocation if you want the limit applied per city.

6. Configure Proxy (Recommended)
   Keep useApifyProxy = true for stability at scale — perfect for a busy pathologists email list scraper.

7. Run the Actor 🚀
   The scraper finds businesses, crawls websites, and compiles your Pathologists email list.

8. Download Results
   Export JSON/CSV, connect via API, and launch your outreach, enrichment, or analytics.

A simple, repeatable workflow to fill your funnel with qualified Pathologists leads.

***

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

- 💼 B2B Sales & Partnerships
  Build a verified Pathologists email list for diagnostic suppliers, LIS vendors, medical device reps, and RCM solutions.

- 🧪 Lab Services & Reference Networks
  Use the Pathologists lead scraper to identify clinics and labs for referral partnerships.

- 📣 Marketing & Outreach
  Generate Pathologists b2b leads and run hyper-targeted campaigns to pathology groups and independent practices.

- 🧩 CRM Enrichment
  Fill missing emails and social links with a reliable Pathologists email finder to boost reply rates.

- 🗺️ Territory Planning
  Map Pathologists leads by city/state to plan routes and market coverage.

- 📚 Market Research
  Analyze density, ratings, and review counts across regions — ideal for a Pathologists finder focused on competitive insights.

- 🔁 List Maintenance
  Keep your Pathologists emails fresh by scheduling re-runs and appending new discoveries.

In short: Whether you’re selling equipment, software, or services, this pathologists email list scraper helps you reach decision makers faster.

***

### 💎 Why choose us?

Choosing our Pathologists Email Scraper gives you:

- ⚡ Speed & Scale with robust proxy support
- 🔍 Higher Accuracy via website-level scanning and validation
- 🌐 Multi-Location Control for local-to-national campaigns
- 📥 Clean, structured output ready for automation and CRMs
- 🔒 Ethical, public-only data collection
- 🧠 Purpose-Built Pathologists email finder and Pathologists lead finder capabilities
- 📈 Proven results for building high-quality Pathologists b2b leads

If you want reliable Pathologists emails with top-tier performance, this Pathologists Email Scraper is built for you.

***

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

The actor is engineered for scalability, making it suitable for both regional prospecting and large rollouts.

It can collect anywhere from 10 to 1,000+ businesses per run, depending on:

- Locations you target (bigger metros → more results)
- Search terms (broader “Pathologists” vs. niche subspecialties)
- maxBusinesses limit you set
- Whether you apply the limit per-location or globally
- Proxy settings and website density of contact pages

Recommended strategies:

- Small campaigns: 20–100 Pathologists leads
- Medium campaigns: 200–500 Pathologists leads
- Large datasets: 1,000+ Pathologists b2b leads across multiple regions

For very large jobs, run multiple schedules or increase run time. This pathologists email list scraper scales from quick tests to national rollouts.

***

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

Scraping publicly available business information is generally legal when:

- You do not bypass authentication walls
- You do not collect private or sensitive patient data
- You respect websites’ terms of service
- You use data ethically for legitimate B2B outreach

This Pathologists Email Scraper extracts publicly visible business emails and contact info that companies publish on their websites and profiles. It does not collect protected health information (PHI).

Always ensure your outreach follows:

- GDPR
- CAN-SPAM Act
- Local data privacy laws
- HIPAA considerations (no PHI collection; business contacts only)

***

### ❓ FAQ — Pathologists Email Scraper

1. Does this tool gather private or patient data?
   No. It only collects public B2B contact information (e.g., business emails) published on websites or profiles — never PHI.

2. Can I target multiple cities or states at once?
   Yes. Add multiple entries to googleMapsLocation. Use scrapeMaxBusinessesPerLocation to apply per-city limits.

3. How many emails do you find per business?
   It varies. Some practices list 1–3 emails; larger groups may list department contacts. pages\_scraped and emails\_found give visibility.

4. Is this a Pathologists email finder and Pathologists lead scraper in one?
   Yes. It discovers businesses, crawls their websites, and extracts contact emails — acting as a Pathologists finder end-to-end.

5. Can I build a Pathologists email list for B2B campaigns?
   Absolutely. This is a practical Pathologists b2b email scraper built to generate Pathologists b2b leads reliably.

6. What output formats are available?
   Download JSON, CSV, or access results via the Apify Dataset API for direct integrations.

7. Does it work for related queries (e.g., “anatomic pathology”, “cytology lab”)?
   Yes. Update googleMapsSearchTerm to your niche. The pathologists email list scraper adapts to many relevant search terms.

8. Do I need a Google Maps API key?
   No. The actor uses publicly available data and website crawling — no direct API key required.

9. Can I automate weekly updates to my Pathologists email list?
   Yes. Schedule runs in Apify to refresh your Pathologists leads automatically.

***

### SEO Notes and Keyword Coverage

- This Pathologists Email Scraper functions as a comprehensive Pathologists email scraper and Pathologists email finder for building high-quality Pathologists emails.
- Ideal for generating a curated Pathologists email list and ongoing Pathologists b2b leads.
- As a pathologists email list scraper and Pathologists lead scraper, it doubles as a versatile Pathologists lead finder and Pathologists finder.

***

### Support

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pathologists Email Scraper",
        "description": "Pathologists Email Scraper to collect verified pathologist emails from hospitals; labs; and medical directories 📧🔬 Ideal for healthcare B2B outreach; medtech sales; lab partnerships; and recruiter lead generation.",
        "version": "1.0",
        "x-build-id": "90zajzgqLHv2NKlko"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/contacts-api~pathologists-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-contacts-api-pathologists-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~pathologists-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-contacts-api-pathologists-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~pathologists-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-contacts-api-pathologists-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": "Pathologists"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
