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

Oral Pathologists Email Scraper extracts verified emails and profiles from directories; associations; and clinic sites 📧🦷 Ideal for B2B outreach; dental lab partnerships; medical device sales; and specialist lead generation.

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

### ⭐ Oral Pathologists Email Scraper — Build Verified B2B Contact Lists from Google Maps + Websites 🤖

The Oral Pathologists Email Scraper is a specialized lead-generation tool that discovers oral pathology practices via Google Maps and automatically extracts public contact data from their websites — including emails, phone numbers, and social media links. Designed for marketing teams, agencies, labs, and dental SaaS vendors, this Oral Pathologists Email Scraper helps you collect targeted Oral Pathologists emails and Oral Pathologists leads with speed and precision.

Simply provide a search term (e.g., “Oral Pathologists”) and one or more locations (e.g., “Miami, Florida”), set your maximum number of businesses with emails, and let the Oral Pathologists Email Scraper crawl profiles and websites to deliver a clean Oral Pathologists email list you can plug straight into your CRM. Whether you want an Oral Pathologists email scraper for outreach or an Oral Pathologists email finder for enrichment, this actor gives you structured, high-value data at scale.

Looking to build an Oral Pathologists email list for B2B campaigns? This oral pathologists email list scraper is engineered for accuracy: it scans listings, visits official websites, parses contact pages, and consolidates verified results. It’s an ideal Oral Pathologists b2b email scraper for agencies and vendors who need reliable Oral Pathologists b2b leads fast. Use it as your go-to Oral Pathologists finder, Oral Pathologists lead scraper, and Oral Pathologists lead finder across multiple cities and regions.

---

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

Below is a quick breakdown of the data types this Oral Pathologists Email Scraper can deliver ⬇️

| Data Type 📊            | Description                                                                 |
| ----------------------- | --------------------------------------------------------------------------- |
| Business Name           | Official practice or lab name                                               |
| Website                 | Website URL collected from listing or found during crawl                    |
| Phone                   | Primary phone number                                                        |
| Full Address            | Street address from the Google listing                                      |
| City / State / ZIP      | Parsed location details for targeting and segmentation                      |
| Country Code            | ISO country code (e.g., US)                                                 |
| Emails (Array)          | Scraped Oral Pathologists emails discovered on the website                  |
| Phone Numbers (Array)   | Additional phone numbers found on-site                                      |
| Social Media (Array)    | Detected LinkedIn, Facebook, Instagram, X/Twitter links                     |
| # Emails                | Count of unique emails captured                                             |
| Pages Scraped           | Number of website pages crawled                                             |
| Rating                  | Average Google Maps rating                                                  |
| Reviews                 | Total number of reviews on Google Maps                                      |
| Latitude / Longitude    | Coordinates of the practice                                                 |
| Place ID                | Google Maps place identifier                                                |
| Status                  | Scrape status for each record                                               |

⏱ Perfect for building a large, niche-targeted Oral Pathologists email list for outreach and research. This Oral Pathologists finder consolidates the essentials you need for high-quality prospecting.

---

### 🧩 Input Parameters

#### Example Input JSON

```json
{
  "googleMapsSearchTerm": "Oral Pathologists",
  "googleMapsLocation": ["Miami, 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., “Oral Pathologists”, “dentists”, “dental pathology labs”).                      |
| googleMapsLocation                 | One or more locations to target (e.g., “Miami, Florida”). Accepts a list of cities/states/countries for broader coverage.          |
| maxBusinesses                      | Maximum number of businesses with emails to collect (1–1000). The run stops when this cap is reached.                              |
| scrapeMaxBusinessesPerLocation     | If enabled, the actor will attempt to collect up to maxBusinesses for each location separately. If disabled, uses a single total. |
| proxyConfiguration                 | Proxy settings for scale and stability. Recommended for larger runs to avoid rate limits and IP blocks.                            |

***

### 📤 Output Format

#### Example Output JSON

```json
[
  {
    "name": "Miami Oral & Maxillofacial Pathology Associates",
    "website": "https://www.miamioralpathology.com",
    "phone": "+1 305-555-0142",
    "full_address": "120 SE 2nd Ave, Suite 400, Miami, FL 33131, United States",
    "city": "Miami",
    "state": "FL",
    "zip": "33131",
    "country_code": "US",
    "scraped_emails": ["info@miamioralpathology.com", "labs@miamioralpathology.com"],
    "scraped_phones": ["+1 305-555-0142", "+1 305-555-0199"],
    "scraped_social_media": [
      "https://www.linkedin.com/company/miami-oral-pathology",
      "https://www.facebook.com/miamioralpathology"
    ],
    "emails_found": 2,
    "pages_scraped": 7,
    "avg_rating": 4.7,
    "total_reviews": 38,
    "lat": 25.7735,
    "long": -80.1892,
    "place_id": "ChIJPw5X0nE2MIgR2dS3Q8mT5yc",
    "scrape_status": "success"
  }
]
```

#### Output Fields Table

| Field                 | Description                                                                 |
| --------------------- | --------------------------------------------------------------------------- |
| name                  | Business or practice name                                                   |
| website               | Official website URL                                                        |
| phone                 | Primary business phone number                                               |
| full\_address          | Complete address from Google Maps                                           |
| city                  | City of the practice                                                        |
| state                 | State/Region code                                                           |
| zip                   | Postal/ZIP code                                                             |
| country\_code          | Country code (e.g., US, CA, UK)                                             |
| scraped\_emails        | Array of discovered Oral Pathologists emails from the website               |
| scraped\_phones        | Additional phone numbers found on the site                                  |
| scraped\_social\_media  | Array of social media URLs (LinkedIn, Facebook, Instagram, X/Twitter, etc.) |
| emails\_found          | Total unique emails captured                                                |
| pages\_scraped         | Number of web pages crawled                                                 |
| avg\_rating            | Average Google Maps rating                                                  |
| total\_reviews         | Count of Google Maps reviews                                                |
| lat                   | Latitude coordinate                                                         |
| long                  | Longitude coordinate                                                        |
| place\_id              | Google Maps place ID                                                        |
| scrape\_status         | Status of the record (e.g., success, partial, no\_website)                   |

***

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

- 🎯 Keyword + Location Targeting\
  Use exact search terms (e.g., “Oral Pathologists”) and multiple cities or regions to find the right practices with this Oral Pathologists finder and Oral Pathologists lead finder.

- 🌍 Location-Specific Scraping\
  Target single cities like “Miami, Florida” or scale to statewide and national searches. The Oral Pathologists Email Scraper works across regions for broad coverage.

- 🧠 Website Deep Crawl & Contact Discovery\
  The actor visits practice websites and parses contact pages, footers, and about pages to surface emails and phones — a reliable Oral Pathologists email finder for real-world outreach.

- 🧰 B2B-Focused Data Extraction\
  Built as an Oral Pathologists b2b email scraper, it helps you collect Oral Pathologists b2b leads you can immediately use for partnerships, referrals, and vendor outreach.

- 📈 Lead Capture & Enrichment\
  Acts as an Oral Pathologists lead scraper to compile Oral Pathologists leads with emails, phones, ratings, and reviews — giving teams context for smarter outreach.

- 📌 Per-Location Result Caps\
  Enable “Scrape Max Businesses Per Location” to aim for maxBusinesses in each city. Ideal when using this oral pathologists email list scraper across multiple locations.

- 📦 Clean, Structured Output\
  Export JSON or CSV and plug into your CRM, email tools, or automation pipelines — perfect for building and refreshing an Oral Pathologists email list.

- 🛡️ Scalable & Reliable\
  Use Apify proxies to reduce blocks and keep throughput high on larger crawls with the Oral Pathologists email scraper.

***

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

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

2. Select the Actor\
   Search for “Oral Pathologists Email Scraper” in the Apify Store and open it.

3. Enter Search Term\
   Set googleMapsSearchTerm to “Oral Pathologists” (or your niche variant).

4. Add Locations\
   Provide one or more googleMapsLocation values (e.g., “Miami, Florida”, “Orlando, Florida”, “Tampa, Florida”).

5. Choose Max Businesses\
   Set maxBusinesses to the number of practices you want with emails (e.g., 20). This Oral Pathologists email scraper stops once the target is hit.

6. Configure Per-Location Behavior\
   Toggle scrapeMaxBusinessesPerLocation on if you want to hit your max per city.

7. Add Proxies (Recommended)\
   Keep useApifyProxy enabled for stable, large-scale runs.

8. Run the Actor 🚀\
   The scraper finds practices on Google Maps, visits websites, and collects contact data.

9. Download Results\
   Export your Oral Pathologists email list as JSON/CSV and import into your CRM or marketing tools.

A fast, consistent workflow — ideal for teams using an Oral Pathologists email finder for repeatable B2B outreach.

***

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

- 💼 B2B Outreach to Practices & Labs\
  Build Oral Pathologists b2b leads for partnerships, solution demos, and service offerings.

- 🤝 Referral Network Development\
  Grow a regional Rolodex of Oral Pathologists leads you can connect with for cross-referrals.

- 📚 Market Mapping & Research\
  Use the actor as an Oral Pathologists finder to map who operates in a given city, compare ratings, and analyze review counts.

- 🧩 CRM Enrichment & Data Cleansing\
  Turn fragmented records into a verified Oral Pathologists email list with phones, social links, and addresses.

- 📣 Agency Lead Generation\
  Agencies can leverage this Oral Pathologists lead scraper for clients in healthcare, dental tech, pathology labs, and staffing.

- 📧 Cold Outreach & Events\
  Quickly compile contacts ahead of conferences, webinars, and local events with a dependable Oral Pathologists email scraper.

***

### 💎 Why choose us?

Choosing the Oral Pathologists Email Scraper gives you:

- ⚡ Fast, scalable collection using robust crawling logic
- 🔎 Accurate contact discovery with smart on-site parsing
- 🧠 Purpose-built Oral Pathologists lead finder for niche targeting
- 🌐 Multi-location support for regional and national coverage
- 🧱 Clean, deduplicated outputs ready for automation
- 🛡️ Safe, compliant use of publicly available data
- 📞 Dedicated support for onboarding and custom needs
- 🚀 Proven as an Oral Pathologists b2b email scraper for high-quality pipelines

If you need a dependable Oral Pathologists email finder to deliver consistent Oral Pathologists b2b leads, this actor is built for you.

***

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

The Oral Pathologists Email Scraper is engineered for scalability. It can collect anywhere from a handful to thousands of Oral Pathologists leads across multiple cities, depending on:

- The number and size of locations you provide
- The availability of websites and public contact info
- Your maxBusinesses limit and per-location settings
- Crawl depth and timeout settings for larger runs
- Proxy configuration and network performance

Typical ranges:

- Small campaigns: 10–100 practices
- Medium campaigns: 200–2,000 practices across several cities
- Large datasets: 5,000+ leads by running multiple regions and schedules

Use this oral pathologists email list scraper to grow your Oral Pathologists email list at your own pace. For very large searches, increase run timeouts in your Apify settings and use proxies to maintain stability.

***

### ⚖️ Is it legal to scrape Oral Pathologists contact data?

Scraping publicly available information is generally legal, provided you:

- Do not bypass authentication or access private data
- Respect website and platform terms of service
- Use the data ethically for legitimate business purposes

This Oral Pathologists Email Scraper only collects publicly available contact information (e.g., emails shown on practice websites). Always ensure your outreach complies with GDPR, CAN-SPAM, and local privacy regulations.

***

### ❓ FAQ — Oral Pathologists Email Scraper

1. Does this tool collect private emails?\
   No. It only collects publicly listed Oral Pathologists emails found on websites or publicly available pages.

2. Can it build an Oral Pathologists email list for multiple cities?\
   Yes. Provide multiple locations in googleMapsLocation and choose whether to cap maxBusinesses per location or across the entire run.

3. Is this an Oral Pathologists email scraper for Google Maps?\
   Yes. It starts from Google Maps search results, extracts practice details, and then crawls the website for contact info.

4. Can I get Oral Pathologists b2b leads suitable for sales?\
   Absolutely. It’s a focused Oral Pathologists b2b email scraper that compiles decision-ready contacts for campaigns.

5. Does it work as an Oral Pathologists email finder and a lead finder?\
   Yes. It identifies websites (finder) and extracts emails/phones (email finder and lead finder), giving you complete Oral Pathologists leads.

6. How do I avoid blocks on larger runs?\
   Enable the Apify Proxy in proxyConfiguration and run multiple smaller, scheduled tasks if necessary.

7. What output formats are supported?\
   You can export JSON, CSV, Excel, or connect via the Apify API.

***

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": "Oral 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": "Oral 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/oral-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": "Oral Pathologists",
    "googleMapsLocation": ["New York"],
    "maxBusinesses": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Oral Pathologists Email Scraper",
        "description": "Oral Pathologists Email Scraper extracts verified emails and profiles from directories; associations; and clinic sites 📧🦷 Ideal for B2B outreach; dental lab partnerships; medical device sales; and specialist lead generation.",
        "version": "1.0",
        "x-build-id": "fkWANmT2rZ1Wpq9zy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/contacts-api~oral-pathologists-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-contacts-api-oral-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~oral-pathologists-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-contacts-api-oral-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~oral-pathologists-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-contacts-api-oral-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": "Oral 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
