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

🦷 Pediatric Dentists Email Scraper extracts verified email contacts for pediatric dentistry practices—perfect for B2B outreach, lead generation, and targeted campaigns. ⚡ Fast, accurate, and privacy-aware. Use emojis.

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

## Pricing

from $1.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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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 🚀

Manually compiling contact emails for pediatric dental practices from scattered public pages wastes hours you don’t have. **Pediatric Dentists Email Scraper** finds pediatric dentist contact details and extracts emails, phone numbers, and social links into a ready-to-use dataset. This pediatric dental email scraper is ideal for marketers, lead researchers, and growth teams building a pediatric dental marketing email list at scale—often in minutes for thousands of records.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "name": "Bright Smiles Pediatric Dentistry",
  "website": "https://www.brightsmilespediatrics.com",
  "phone": "+1 (212) 555-0199",
  "full_address": "1234 Madison Ave New York NY 10001 US",
  "city": "New York",
  "state": "NY",
  "zip": "10001",
  "country_code": "US",
  "scraped_emails": [],
  "scraped_phones": ["+1 (212) 555-0199"],
  "scraped_social_media": ["https://www.facebook.com/brightsmilespeds"],
  "emails_found": 1,
  "pages_scraped": 6,
  "avg_rating": 4.6,
  "total_reviews": 214,
  "lat": 40.741895,
  "long": -73.989308,
  "place_id": "ChIJD7fiBh9u5kcR0uJ8wT5QJx0",
  "scrape_status": "success",
  "email_found": "hello@brightsmilespediatrics.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `name` | string | The business name so you can identify the pediatric dentist instantly. |
| `website` | string | The practice website you can use as a source and for outreach context. |
| `phone` | string | The phone number surfaced from the business listing (useful for verification and backup contact). |
| `full_address` | string | A single formatted address string for easy CRM import. |
| `city` | string | Helps you segment by geography for pediatric dental leads email campaigns. |
| `state` | string | State-level grouping for outreach routing and reporting. |
| `zip` | string | Postal code for more precise targeting and list cleanup. |
| `country_code` | string | Country code to support multi-region workflows. |
| `scraped_emails` | array | The underlying collected emails list (flattened output uses `email_found`). |
| `scraped_phones` | array | All phone numbers found on the website for additional confirmation. |
| `scraped_social_media` | array | Social links associated with the practice for omnichannel enrichment. |
| `emails_found` | number | How many emails were found on the practice website. |
| `pages_scraped` | number | How many site pages were processed, useful for estimating effort/coverage. |
| `avg_rating` | number | Practice rating from the business listing to help prioritize outreach. |
| `total_reviews` | number | Review count to gauge popularity and list quality. |
| `scrape_status` | string | Run outcome at the business level (for example: `success`, `failed`, `no_website`). |
| `place_id` | string | A stable identifier to deduplicate across runs. |
| `email_found` | string | The specific email value for this row (this is the “flattened” contact you’ll import). |
| `scrape_error` | string | Present when scraping fails, so you can troubleshoot and re-run selectively. |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Pediatric Dentists Email Scraper?

There are a lot of ways to pull data from public web sources—here’s what sets Pediatric Dentists Email Scraper apart.

#### Lead-focused email + contact extraction

This pediatric dentist lead scraper is designed to produce outreach-ready rows: it collects the practice listing info and then extracts contact details from the practice website so you can build a pediatric dental practice email list faster.

#### Flexible location targeting

You can run by multiple locations (each provided in `googleMapsLocation`) and control how many businesses you want, making it practical for local pediatric dentistry outreach emails and multi-region marketing email list building.

#### Real-time dataset writing

The actor pushes results to the Apify dataset immediately as each business is processed, so you don’t lose progress if something interrupts mid-run.

#### Resilient scraping workflow

The actor includes built-in resilience (including retries and fallbacks) and supports proxyConfiguration to improve reliability for larger jobs—useful for a dentist email scraping tool workflow at scale.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

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

| Parameter | Required | What It Does |
|---|---|---|
| `googleMapsSearchTerm` | ✅ | Sets the business type/niche for the pediatric dental email scraper (pre-filled with `Pediatric Dentists`). |
| `googleMapsLocation` | ✅ | Defines one or more target geographic locations for where to find pediatric dentists. |
| `maxBusinesses` | ⬜ | Limits how many businesses the actor targets (range: 1–1000). It stops when the target is reached. |
| `scrapeMaxBusinessesPerLocation` | ⬜ | If enabled, collects up to `maxBusinesses` results per location; if disabled, it combines all locations up to one total limit. |
| `proxyConfiguration` | ⬜ | Configures proxy settings for scraping. Recommended for larger-scale jobs. |
| ↳ `proxyConfiguration.proxy support` | ⬜ | Routes scraping traffic through Apify Proxy when set to `true`. |

***

### Core Capabilities

#### Pediatric dentist discovery by niche + location

You provide a `googleMapsSearchTerm` (for example, `Pediatric Dentists`) and one or more `googleMapsLocation` values to steer discovery. This supports building a pediatric dental marketing email list by region rather than working blind.

#### Website-first contact enrichment

After identifying businesses, the actor scrapes the practice websites to extract emails, phones, and social links. That means this pediatric dental practice contact emails workflow is more than just a directory grab—it’s closer to what you need for outreach.

#### Email-only control for cleaner lists

The actor saves businesses with emails according to its email-only behavior logic. If you’re building a pediatric dental leads email list for outreach, this helps reduce noise from practices that don’t publish contact emails.

#### Structured output ready for import

The dataset includes consistent business fields (like `name`, `website`, `phone`, `full_address`, and listing metadata) plus scraped contact fields and status indicators like `scrape_status`. That makes it straightforward to transform into CRM-ready rows for dentist email scraping tool use cases.

#### Built-in proxy support for reliability

Proxy configuration is available to help keep scraping stable for larger runs. This is especially helpful when you’re extracting a pediatric dental practice email list across multiple locations.

***

### Who Gets the Most Out of This

Here’s how different teams put Pediatric Dentists Email Scraper to work:

**Dental marketing teams** use it to assemble pediatric dental marketing email list segments by city/state, then prioritize outreach using `avg_rating` and `total_reviews` to focus on higher-signal practices first.

**Lead generation specialists** run a pediatric dentist contact list build using `maxBusinesses` and `googleMapsLocation`, then import the flattened `email_found` rows directly into their outreach workflow.

**Sales development reps** use the website-scraped fields (`scraped_emails`, `scraped_phones`, and `scraped_social_media`) to enrich lead records before first contact—so your follow-ups have more than just an email address.

**Researchers & data analysts** benefit from the structured dataset fields (`place_id`, `full_address`, geolocation `lat`/`long`, and `pages_scraped`) for deduplication, coverage analysis, and data quality reporting on pediatric dentistry outreach emails.

**Automation and integration builders** can pull results via the Apify API and feed them into pipelines that build a pediatric dental practice contact emails archive, keeping datasets consistent across scheduled runs.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Pediatric Dentists Email Scraper from start to finish:

1. **Open the actor on Apify** — use the Apify console to start a run: https://console.apify.com
2. **Enter your inputs** — set `googleMapsSearchTerm`, add one or more `googleMapsLocation` values, and optionally adjust `maxBusinesses` and `scrapeMaxBusinessesPerLocation`.
3. **Configure proxy settings** — if you’re running larger jobs, turn on proxyConfiguration (recommended for reliability).
4. **Hit Run and watch the live log** — follow progress as businesses are discovered and websites are scraped.
5. **View results in the dataset tab** — check records and use `scrape_status` and `emails_found` to judge coverage.
6. **Export as JSON, CSV, or Excel** — download the dataset from the Apify dashboard for your CRM or spreadsheets.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Pediatric Dentists Email Scraper plugs directly into your existing workflow.

You can export your dataset as **JSON, CSV, or Excel** from the Apify dataset tab for easy import into spreadsheets, CRMs, and BI tools. This is useful when you’re building a pediatric dental practice email list and want quick analysis or segmentation.

To automate delivery, you can use **Apify API access** (see https://apify.com/docs/api), **webhooks**, or no-code automation like **Zapier** / **Make (Integromat)**. If you want the process to run automatically, set up **scheduled runs** via Apify’s scheduling options.

***

### Pricing & Free Trial

Pediatric Dentists Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You’ll typically use the free trial credits for several test runs, then scale based on your needs.

After that, runs are billed based on Apify platform compute (CU), and you pay for Apify platform usage rather than a per-row extraction fee. For up-to-date plan details and limits, check Apify’s pricing page on the marketplace.

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limiting stability | Built-in resilience and pacing to keep runs moving smoothly. |
| Block avoidance at scale | Proxy support via `proxyConfiguration` for improved reliability on larger jobs. |
| Incomplete contact coverage | Businesses without websites are marked with `scrape_status` as `no_website`, and status fields help you filter results. |
| Error visibility | When issues happen, results include failure-state indicators like `scrape_status` and (when present) `scrape_error`. |
| List size control | `maxBusinesses` and `scrapeMaxBusinessesPerLocation` help cap results so you get predictable exports. |

Limitations: this actor scrapes and extracts from publicly available sources and practice websites; if a practice doesn’t publish an email, there may be fewer contact emails available for your pediatric dental marketing email list. For enterprise-scale needs or custom filtering, contact the team.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify provides a free tier so you can test Pediatric Dentists Email Scraper before scaling up. Exact limits depend on your Apify account and current offerings on the platform.

#### Do I need to log in to Pediatric Dentists Email Scraper?

No login is required to use the actor itself. You just run it on Apify and provide the required inputs like `googleMapsSearchTerm` and `googleMapsLocation`.

#### How accurate is the data?

The actor extracts contact details from practice websites and related publicly available information. Accuracy depends on what the practice actually publishes online, which is common for any pediatric dental email scraper workflow.

#### How many results can I get per run?

You control results with `maxBusinesses` (range 1–1000). You can also choose whether to apply the limit per location using `scrapeMaxBusinessesPerLocation`.

#### How often is the data updated / how fresh is it?

Data freshness depends on when you run the actor. Since Pediatric Dentists Email Scraper performs scraping during each run, new runs can reflect updated emails, phone numbers, and social links.

#### Is this legal? Does it comply with GDPR / CCPA?

The actor collects **publicly available data**. You are responsible for ensuring your use complies with GDPR, CCPA, platform terms, and applicable laws where you operate.

#### Can I export results to Google Sheets or Excel?

Yes. You can export your dataset as JSON, CSV, or Excel from the Apify dashboard, then import into Google Sheets or your spreadsheet/CRM system. This works well for building a pediatric dentist contact list with repeatable formatting.

#### Can I run this on a schedule automatically?

Yes. Apify supports scheduled runs, so you can automate repeated extraction for new pediatric dentist lead opportunities and maintain your pediatric dentistry outreach emails lists over time.

#### Can I access this via API?

Yes. You can pull run results programmatically via the Apify API (see https://apify.com/docs/api). This makes it easy to pipe pediatric dental practice email lists into internal systems.

#### What happens if the actor hits an error?

The output includes a `scrape_status` field so you can see whether a business was scraped successfully, failed, or had no website. If errors occur, `scrape_error` may be present to help you understand what went wrong and decide whether to re-run.

***

### Need Help or Have a Request?

Got a question about Pediatric Dentists Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to help with setup tips and improving your pediatric dentist lead scraper workflow. Feature ideas we’re considering include batch CSV upload for multiple searches and webhook delivery when runs finish.

***

### Disclaimer & Responsible Use

*Pediatric Dentists Email Scraper is the fastest, most reliable way to build a pediatric dental practice email list from publicly available sources—start your free run today.*

By using this actor, you agree that it collects **publicly available data** from the web. It does not access private/protected profiles, login-gated content, or password-protected pages. You’re responsible for complying with GDPR, CCPA, and any applicable platform terms and local regulations. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# 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("scraperoka/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("scraperoka/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 scraperoka/pediatric-dentists-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pediatric Dentists Email Scraper",
        "description": "🦷 Pediatric Dentists Email Scraper extracts verified email contacts for pediatric dentistry practices—perfect for B2B outreach, lead generation, and targeted campaigns. ⚡ Fast, accurate, and privacy-aware. Use emojis.",
        "version": "1.0",
        "x-build-id": "Cf74DKcCzHy3Kfm3Q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~pediatric-dentists-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-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/scraperoka~pediatric-dentists-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-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/scraperoka~pediatric-dentists-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
