# Pediatric Dentists Email Scraper (`solid-scraper/pediatric-dentists-email-scraper`) Actor

🦷 Our Pediatric Dentists Email Scraper pinpoints email contacts for pediatric dental practices by location and keywords. 🏥 Ideal for outreach, lead generation, and marketing teams seeking verified prospects—fast, targeted, and scalable. 🚀

- **URL**: https://apify.com/solid-scraper/pediatric-dentists-email-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### Pediatric Dentists Email Scraper 📬

**Pediatric Dentists Email Scraper** is an Apify actor that helps you find pediatric dental practices in a target location and extract their contact information—including emails—so you can build a high-quality pipeline without manual searching. Whether you're looking for a **pediatric dentist email finder**, a **pediatric dental practice email list**, or an **email scraping tool for pediatric dentists**, this actor is designed to automate lead sourcing from publicly available web data. It’s useful for marketers, data analysts, and researchers who want “find pediatric dentist emails” results at scale—saving you hours of manual work.

---

### Why choose Pediatric Dentists Email Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ **End-to-end email lead building** | Scrapes business listings and then scrapes their websites for contact information |
| ✅ **Email-focused website scraping** | Extracts emails (and also phones + social links) from each business website |
| ✅ **Built-in reliability controls** | Uses proxy configuration and resilient website scraping with configurable pages per site |
| ✅ **Structured dataset output** | Saves consistent business fields plus extracted contacts into the Apify dataset |
| ✅ **Scale by location** | Supports multiple locations and stops when your target is reached |
| ✅ **Real-time saving** | Pushes results to the dataset immediately during website scraping |

---

### Key features

- 🎯 **Pediatric dentist lead generation emails:** Designed specifically for pediatric dentistry email lead sourcing using your search term and location filters  
- 🌐 **Website contact extraction:** Scrapes each business website to extract emails, phone numbers, and social media profiles  
- 🛡️ **Proxy configuration support:** Includes a `proxyConfiguration` option (recommended for larger batches) for more reliable scraping  
- 🔁 **Resilience across domains:** Includes retries and fallback behavior inside the website scraping pipeline (without you needing extra engineering)  
- 📊 **Dataset-ready results:** Produces flattened dataset rows per found email via `Actor.push_data`  
- 💾 **Immediate data saving:** Pushes results to the dataset as soon as each business is processed (reducing risk of losing progress)  
- 📞 **Phone + social link coverage:** In addition to email, collects `scraped_phones` and `scraped_social_media` when available  
- 🧾 **Clear scrape status tracking:** Saves `scrape_status` (for example: `success`, `failed`, `no_website`, `error`) so you can filter reliably  

---

### Input

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

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

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `googleMapsSearchTerm` | Yes | The business type or niche to search for (example value: `Pediatric Dentists`). |
| `googleMapsLocation` | Yes | Target geographic location(s). Provide as a list (example: `["New York"]`). |
| `maxBusinesses` | No | Maximum number of businesses to find (range: 1–1000). The scraper will stop when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | No | If `true`, collects up to `maxBusinesses` results per location. If `false`, it combines all locations up to a single total limit. |
| `proxyConfiguration` | No | Proxy settings for scraping. Recommended for large-scale scraping. Supports configuration via the actor’s proxy editor (`proxy support` is prefilled to `true`). |
| `proxyConfiguration.proxy support` | No | Enables Apify Proxy for scraping (pre-filled to `true`). |

***

### Output

The actor saves your results in the Apify **dataset** as JSON rows.

#### Example output object

```json
{
  "name": "Example Pediatric Dental Clinic",
  "website": "https://examplepediatricdentist.com",
  "phone": "+1 555-0100",
  "full_address": "123 Main St New York NY 10001 US",
  "city": "New York",
  "state": "NY",
  "zip": "10001",
  "country_code": "US",
  "scraped_emails": ["info@examplepediatricdentist.com"],
  "scraped_phones": ["+1 555-0100"],
  "scraped_social_media": ["https://www.facebook.com/examplepediatricdentist"],
  "emails_found": 1,
  "pages_scraped": 3,
  "avg_rating": 4.5,
  "total_reviews": 120,
  "lat": 40.7128,
  "long": -74.006,
  "place_id": "PLACE_ID_VALUE",
  "scrape_status": "success",
  "email_found": "info@examplepediatricdentist.com"
}
```

> Note: The actor flattens results by email. For each business with `emails_found > 0`, it pushes one dataset row per extracted email using `Actor.push_data` and includes `email_found` while removing `scraped_emails`.

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `name` | string | Business name from the listings stage |
| `website` | string | Business website URL (cleaned) |
| `phone` | string | Phone number from the listings stage |
| `full_address` | string | Combined address string (`street_address city state zip country_code`) |
| `city` | string | City |
| `state` | string | State |
| `zip` | string | ZIP/postal code |
| `country_code` | string | Country code |
| `scraped_emails` | array | Emails extracted from the business website (present on non-flattened rows; removed for email-level rows) |
| `scraped_phones` | array | Phone numbers extracted from the business website |
| `scraped_social_media` | array | Social media links extracted from the business website |
| `emails_found` | number | Count of emails extracted for the business |
| `pages_scraped` | number | Number of processed URLs during website scraping (from `job.progress.processed_urls`) |
| `avg_rating` | number | Average rating from the listings stage |
| `total_reviews` | number | Total review count from the listings stage |
| `lat` | number | Latitude for the business |
| `long` | number | Longitude for the business |
| `place_id` | string | Unique listing identifier |
| `scrape_status` | string | Status such as `success`, `failed`, `no_website`, or `error` |
| `email_found` | string | The specific email value for the flattened row (`""` when pushed in no-email scenarios) |

You can export the dataset to JSON or CSV from the Apify Console after the run completes.

***

### How to use Pediatric Dentists Email Scraper (via Apify Console)

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

2. **Find Pediatric Dentists Email Scraper**\
   Search for the actor card and open it to view inputs and dataset outputs.

3. **Set your search term**\
   In the **INPUT** panel, set `googleMapsSearchTerm` to your niche (for example, `Pediatric Dentists`).

4. **Add one or more locations**\
   Add your target places in `googleMapsLocation` as a list (for example, `["New York"]`).

5. **Choose your scale controls**\
   Set `maxBusinesses` (1–1000). If you want a per-location cap, enable `scrapeMaxBusinessesPerLocation`.

6. **(Optional) Configure proxies**\
   If you’re running larger campaigns, set `proxyConfiguration` (the UI supports enabling/disabling Apify Proxy via `proxy support`).

7. **Run the actor and monitor progress**\
   Watch the logs for the two phases: locating businesses first, then scraping their websites for contacts.

8. **Open the dataset and export**\
   When the run finishes, open the dataset in the **OUTPUT** tab. Export your results in JSON or CSV.

No coding required—get pediatric dentist prospecting emails in minutes with this SEO-friendly **Pediatric Dentists Email Scraper**.

***

### Advanced features & SEO optimization

- 📬 **Engineered for pediatric dentistry contact discovery:** Built to excel at “pediatric dentist email finder” workflows and “pediatric dental clinic email contacts” lead generation
- 🔎 **Location-aware lead sourcing:** Uses your provided `googleMapsLocation` values and stops once your `maxBusinesses` target is reached
- 🔁 **Email extraction from real business websites:** Focuses on scraping websites for emails and supporting contacts (phones + social links) for better enrichment
- 🧾 **Flattened email-level rows for outreach:** Each extracted email becomes a dataset row (great for CRM import and dedup workflows)
- 🛡️ **Proxy-assisted reliability:** Includes `proxyConfiguration` support to help avoid blocks and rate-limit issues during large runs

***

### Best use cases

- 📈 **Marketing teams building pediatric dental marketing email lists:** Quickly assemble a ready-to-import outreach dataset for kids dentistry email scraper campaigns
- 🧠 **Lead researchers validating pediatric dentist contact information scraper outputs:** Verify coverage and enrichment by comparing website contacts and listing metadata
- ✉️ **Sales development reps running pediatric dental practice email outreach:** Turn public business websites into structured prospecting leads with `email_found` rows
- 🗂️ **Data analysts enriching healthcare email scraper pediatric dental datasets:** Combine address, coordinates, and extracted contacts for segmentation and geo-based analysis
- 🧩 **CRM automation pipelines for dental office email extractor flows:** Push clean, standardized rows into tools where you need one row per email
- 🧑‍💻 **Automation engineers orchestrating bulk collection:** Use `maxBusinesses` + multi-location input to scale pediatric dentist prospecting emails reliably

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `googleMapsSearchTerm` (string)
  - ✅ `googleMapsLocation` (array of strings)

- **Proxy Support**
  - ✅ `proxyConfiguration` (recommended for large-scale scraping)
  - ✅ `proxyConfiguration.proxy support` is supported via the actor’s proxy configuration

- **Scale Controls**
  - ✅ `maxBusinesses` (range: 1–1000)
  - ✅ `scrapeMaxBusinessesPerLocation` to switch between global vs per-location limits

- **Retry Mechanism**
  - ✅ Website scraping pipeline includes retries/fallbacks for resilience (configured internally, no extra inputs required)

- **Dataset Structure**
  - ✅ One dataset row per business email using a flattened `email_found` field
  - ✅ Business metadata fields included alongside scraped contacts

- **Limitations**
  - ❌ If a business has no website, it’s tracked with `scrape_status = "no_website"` and emails will be empty
  - ❌ Email availability depends on what’s publicly discoverable on business websites

***

### FAQ

#### Does Pediatric Dentists Email Scraper require an API key or coding?

✅ No. You provide input through Apify Console using `input.json` fields like `googleMapsSearchTerm` and `googleMapsLocation`, then export results from the dataset.

#### What contact types are extracted?

✅ The actor extracts email addresses from business websites. It also captures `scraped_phones` and `scraped_social_media` alongside the email data.

#### How does the actor control how many businesses it finds?

✅ Use `maxBusinesses` to set the target cap (1–1000). If `scrapeMaxBusinessesPerLocation` is enabled, it caps results per location; otherwise, it uses one combined total limit.

#### Are results saved during the run or only at the end?

✅ Results are pushed to the dataset immediately during website scraping. This helps keep progress resilient during longer runs.

#### What happens when a listing has no website?

✅ Listings without a website are pushed with `scrape_status` set to `no_website`, and email-related fields are left empty.

#### Can I run it for multiple locations at once?

✅ Yes. Provide multiple entries in `googleMapsLocation` (as an array of strings) and choose whether you want per-location caps with `scrapeMaxBusinessesPerLocation`.

#### Can I validate emails?

✅ Email validation is controlled internally by the website scraping configuration via an input-derived `validateEmails` value. (If not enabled, the actor still extracts emails and returns them in the dataset.)

#### Is this tool suitable for building a pediatric dental practice email list for outreach?

✅ Yes—this actor is built for extracting pediatric dentist contact information scraper results from publicly available sources and structuring them into dataset rows for downstream outreach workflows.

***

### Support & feature requests

If you’re using Pediatric Dentists Email Scraper for pediatric dentist email database for kids workflows, we’d love your feedback on what to improve next.

- 💡 **Feature Requests:** Ideas like additional exports (CSV), more contact-field coverage, or CRM-friendly formatting are welcome.
- 📧 **Contact:** Reach out at <dataforleads@gmail.com>.

Your feedback directly shapes improvements and new capabilities for Pediatric Dentists Email Scraper.

***

**"Pediatric Dentists Email Scraper" is a practical, SEO-optimized way to go from location-based pediatric dentistry leads to structured outreach-ready email rows—without manual searching.**

### Disclaimer

**This actor accesses only publicly accessible sources** and extracts contact information available on business websites and public web data. It does not access private profiles, authenticated pages, or password-protected content.

Legal compliance (including GDPR, CCPA, spam regulations, and applicable platform terms) is the user’s responsibility. For data removal requests, contact <dataforleads@gmail.com>.

Use Pediatric Dentists Email Scraper responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

## `googleMapsSearchTerm` (type: `string`):

Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').

## `googleMapsLocation` (type: `array`):

Target geographic location for the email scraper (e.g., 'Miami, Florida').

## `maxBusinesses` (type: `integer`):

Target number of businesses to find (1-1000). The scraper will stop when this target is reached.

## `scrapeMaxBusinessesPerLocation` (type: `boolean`):

If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.

## `proxyConfiguration` (type: `object`):

Proxy settings for scraping. Recommended for large-scale scraping.

## Actor input object example

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pediatric Dentists Email Scraper",
        "description": "🦷 Our Pediatric Dentists Email Scraper pinpoints email contacts for pediatric dental practices by location and keywords. 🏥 Ideal for outreach, lead generation, and marketing teams seeking verified prospects—fast, targeted, and scalable. 🚀",
        "version": "1.0",
        "x-build-id": "WjfJPEhalTrtbpgYz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~pediatric-dentists-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-pediatric-dentists-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solid-scraper~pediatric-dentists-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-pediatric-dentists-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solid-scraper~pediatric-dentists-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-pediatric-dentists-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": "Pediatric Dentists"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
