# Diagnostic Radiologist Email Scraper (`scraperoka/diagnostic-radiologist-email-scraper`) Actor

🩻 Diagnostic Radiologist Email Scraper pulls verified radiologist email contacts from public profiles—covering specialists, practice details, and locations. 🚀 Perfect for B2B outreach, recruitment & research with fast, targeted lead lists.

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

## Pricing

from $0.01 / 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.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

### Diagnostic Radiologist Email Scraper 📬

**Diagnostic Radiologist Email Scraper** automates finding diagnostic radiology practices in a target location and extracting their contact information (including emails, phone numbers, and social media profiles). If you’re looking for a **diagnostic radiologist email scraper** or a **radiologist email extractor** to build a **radiology practice email list**, this tool helps you turn public web data into structured leads—fast. Whether you’re a marketer, data analyst, or researcher, it’s designed to support **radiology clinic lead generation** at scale, saving you hours of manual work.

---

### 🚀 Why choose Diagnostic Radiologist Email Scraper?

| Feature | Benefit |
|---|---|
| ✅ All-in-one workflow | Finds matching diagnostic radiology businesses, then scrapes their websites for contact details in one run |
| ✅ Proxy configuration support | Helps improve reliability for larger scraping tasks |
| ✅ Built for scale with limits | Lets you control volume via `maxBusinesses` and optional per-location limits |
| ✅ Structured dataset output | Saves contact results to a dataset with consistent fields for analysis and enrichment |
| ✅ Resilient website scraping options | Includes configurable extraction behaviors (emails, phones, social links) and optional email validation |
| ✅ Immediate dataset saving | Pushes results during execution, reducing the risk of losing work |

---

### 🔑 Key features

- 🎯 **Location + niche targeting**: Use `googleMapsSearchTerm` and `googleMapsLocation` to focus on diagnostic radiology businesses in specific regions.
- 📊 **Email, phone, and social extraction**: Scrapes websites for `scraped_emails`, `scraped_phones`, and `scraped_social_media`.
- 🌐 **Business contact enrichment fields**: Captures `name`, `website`, `phone`, and address/location details like `full_address`, `city`, `state`, `zip`, and `country_code`.
- 🛡️ **Proxy-ready scraping**: Includes a dedicated `proxyConfiguration` input for smoother large-scale runs.
- 📇 **De-duplicated business discovery**: Avoids repeating businesses using a `place_id`-based uniqueness check.
- 💾 **Real-time dataset pushing**: Writes each result to the Apify dataset during execution (including “no_website” and empty-email cases depending on settings).
- 🔍 **Optional email validation**: Toggle `validate_emails` behavior (controlled by the actor input) to improve contact quality.
- 🔄 **Automation-friendly limits**: Control how many businesses are collected via `maxBusinesses` and `scrapeMaxBusinessesPerLocation`.

---

### 📝 Input

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

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

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `googleMapsSearchTerm` | ✅ | The business type or niche to look for (example: `Diagnostic Radiologist`). |
| `googleMapsLocation` | ✅ | One or more geographic locations to target (example: `["New York"]`). |
| `maxBusinesses` | ❌ | The target number of businesses to find (1–1000). The scraper stops when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | ❌ | When enabled, it collects up to `maxBusinesses` results per location. When disabled, it combines locations under a single overall limit. |
| `proxyConfiguration` | ❌ | Proxy settings for scraping. Recommended for larger runs. Includes `proxy support` support. |

Nested fields inside `proxyConfiguration`:

| Field | Required | Description |
|---|---:|---|
| `proxyConfiguration.proxy support` | ❌ | Set to `true` to enable Apify Proxy (default prefill is `true`). |

***

### 📦 Output

After execution, the actor saves each result’s data into an Apify dataset as rows with business + extracted contact fields. Each dataset row represents a flattened record based on the scraped business and (when available) individual `email_found` values.

Example dataset row (shape based on what gets pushed to the dataset):

```json
{
  "name": "Example Diagnostic Radiology Clinic",
  "website": "https://example-clinic.com",
  "phone": "+1 555-123-4567",
  "full_address": "123 Main St Example State 12345 US",
  "city": "Example City",
  "state": "Example State",
  "zip": "12345",
  "country_code": "US",
  "scraped_emails": [],
  "scraped_phones": [],
  "scraped_social_media": [],
  "emails_found": 0,
  "pages_scraped": 0,
  "avg_rating": 4.5,
  "total_reviews": 120,
  "lat": 40.7128,
  "long": -74.006,
  "place_id": "ChIJ...",
  "scrape_status": "no_website",
  "email_found": ""
}
```

> Note: When emails are found, the actor pushes **one row per email** by copying the business data and setting `email_found` to the specific email, while removing `scraped_emails` from that pushed row.

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `name` | string | Business name. |
| `website` | string | Business website URL. |
| `phone` | string | Business phone number (from business listing data). |
| `full_address` | string | Combined address string from street/city/state/zip/country code. |
| `city` | string | City. |
| `state` | string | State/region. |
| `zip` | string | Postal code. |
| `country_code` | string | Country code. |
| `scraped_emails` | array | List of scraped emails (pushed only when not flattened into `email_found`). |
| `scraped_phones` | array | Phone numbers scraped from the business website. |
| `scraped_social_media` | array | Social media profile links scraped from the business website. |
| `emails_found` | number | Count of emails found for that business. |
| `pages_scraped` | number | Number of processed URLs/pages used during website scraping (from scraper progress). |
| `avg_rating` | number | Average rating for the business listing. |
| `total_reviews` | number | Total number of reviews for the business listing. |
| `lat` | number | Latitude. |
| `long` | number | Longitude. |
| `place_id` | string | Listing identifier used for uniqueness checks. |
| `scrape_status` | string | Status such as `success`, `failed`, `no_website`, or `error`. |
| `email_found` | string | The specific email for that row (present when emails are flattened into individual rows). |

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

***

### 🔧 How to use Diagnostic Radiologist Email Scraper (via Apify Console)

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

2. **Find this actor**\
   Search for **Diagnostic Radiologist Email Scraper** and open the actor page.

3. **Add your input**\
   In the **INPUT** panel, set:
   `googleMapsSearchTerm` (e.g., `Diagnostic Radiologist`) and `googleMapsLocation` (e.g., `["New York"]`).\
   Optionally set `maxBusinesses` and `scrapeMaxBusinessesPerLocation`.

4. **(Optional) Configure proxy settings**\
   If you’re scraping at scale, use `proxyConfiguration` and enable `proxy support` (default prefill is `true`).

5. **Click Run**\
   Start the run. You’ll see logs for both the business discovery phase and the website scraping phase, including progress updates.

6. **Monitor progress in logs**\
   The actor logs when it completes discovery for a location and when it finishes scraping websites and pushing results.

7. **Open the dataset output**\
   When finished, open the actor’s dataset (e.g., **Businesses with Contact Information**) and preview results.

8. **Export your data**\
   Export from the dataset UI to **JSON** or **CSV** for your CRM, outreach workflows, or radiology lead generation tool pipeline.

No coding required—get accurate results in minutes with this Diagnostic Radiologist Email Scraper.

***

### ⭐ Advanced features & SEO optimization

- 🔎 **Engineered for diagnostic radiologist email scraper use cases**: Designed to find diagnostic radiology practices and extract outreach-ready emails plus phone and social links—helpful for radiology practice email outreach.
- 🧭 **Smart volume control**: Use `maxBusinesses` to define scale, and `scrapeMaxBusinessesPerLocation` to decide whether each location gets its own cap or the run uses one combined quota.
- 🧰 **Website contact completeness**: Extracts `scraped_emails`, `scraped_phones`, and `scraped_social_media` from the discovered websites to support physician contact data scraper workflows.
- 🧾 **Structured outputs for analysis**: The dataset includes fields like `emails_found`, `pages_scraped`, `avg_rating`, `total_reviews`, and geolocation (`lat`, `long`) for downstream filtering (e.g., prioritizing higher-rated groups).

***

### ✅ Best use cases

- 📈 **Marketing teams building a radiologist mailing list**: Generate an initial outreach database of diagnostic radiology practices with website-based contact details.
- 🧪 **Data analysts enriching provider datasets**: Join scraped contact emails and phones with your internal radiology clinic lead generation datasets.
- 🏥 **Healthcare sales teams targeting radiology group email database lists**: Collect radiology department contact emails for scalable business development.
- 🗺️ **Local lead gen specialists building diagnostic imaging email list by region**: Run the actor per city/state using `googleMapsLocation`.
- 💼 **Recruiters researching physician contacts**: Use extracted contact data as a starting point for outreach and introductions (where appropriate).
- 🔁 **Automation engineers integrating into pipelines**: Feed dataset rows into your CRM or workflow tools to power radiology practice email outreach campaigns.
- 📚 **Researchers studying publicly available contact patterns**: Analyze fields like ratings, review counts, and scraped contact availability across locations.

***

### 🔧 Technical specifications

#### Supported Input Formats

✅ JSON input via `input.json` (fields listed in the Input section)\
Required fields are `googleMapsLocation` and `googleMapsSearchTerm`.

#### Proxy Support

✅ `proxyConfiguration` with `proxy support` to support web scraping at scale.

#### Retry Mechanism

✅ Includes resilience via website scraping job configuration and internal robustness (you control outcomes through options like pages and email validation).

#### Dataset Structure

✅ Saves to the Apify dataset named **Business Contact Data** with a tabular view of these fields:
`name`, `website`, `phone`, `full_address`, `city`, `state`, `zip`, `country_code`, `scraped_emails`, `scraped_phones`, `scraped_social_media`, `emails_found`, `pages_scraped`, `avg_rating`, `total_reviews`, `lat`, `long`, `place_id`, `scrape_status`.

#### Rate Limits & Performance

✅ Designed for batch runs with controlled concurrency during website scraping.

#### Limitations

❌ If a business has no `website`, the actor pushes the business with empty scraped contact fields (and `scrape_status` is set to `no_website`).\
❌ The actor extracts contact data only from **publicly available sources** and does not access private or authenticated content.

***

### ❓ FAQ

#### Is this a HIPAA compliant physician contact scraping tool?

✅ The actor collects information from **publicly accessible sources**, but whether your use is HIPAA compliant depends on your organization, data handling, and the purposes for which you use the data. This actor does not provide legal or compliance guarantees.

#### What contact types does the Diagnostic Radiologist Email Scraper extract?

✅ It extracts business contact information from discovered websites, including `scraped_emails`, `scraped_phones`, and `scraped_social_media`. The dataset also includes business listing fields such as `name`, `website`, `phone`, and full address details.

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

✅ Use `maxBusinesses` to set a 1–1000 target. If you enable `scrapeMaxBusinessesPerLocation`, the actor targets up to `maxBusinesses` per location; otherwise it uses a single combined quota across all locations.

#### What happens if a business has no website?

✅ The actor sets contact fields to empty values (`scraped_emails`, `scraped_phones`, `scraped_social_media`) and sets `scrape_status` to `no_website`. Depending on email-only behavior, it may also set `email_found` to an empty string when pushed.

#### Does it save results during the run?

✅ Yes. It pushes data to the Apify dataset during execution, so you don’t have to wait for the entire job to finish to see output.

#### Can I validate emails?

✅ The actor supports email validation via `validate_emails` behavior (it is controlled internally from input: `validate_emails` is set based on the actor input, and the website scraping step logs whether email validation is enabled).

#### Can I use proxies for large runs?

✅ Yes. Configure `proxyConfiguration` and set `proxy support` to `true` to improve scraping reliability for larger jobs.

***

### 🤝 Support & feature requests

Want to improve your Diagnostic Radiologist Email Scraper workflow? Share feedback or feature ideas!

- 💡 **Feature Requests**: Examples include CSV export tweaks, additional filtering options, or more dataset fields for radiology lead generation tool workflows.
- 📧 **Contact**: Email us at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for this Diagnostic Radiologist Email Scraper.

***

### *Diagnostic Radiologist Email Scraper* — final thoughts

If you need a **most comprehensive** diagnostic radiologist email scraper for radiology outreach at scale, this actor is a strong starting point—**SEO-optimized** for structured contact discovery and lead list building.

***

### Disclaimer

**This tool only accesses publicly accessible sources**. It does not access private profiles, authenticated data, or password-protected content. Compliance with applicable laws (including GDPR/CCPA), spam regulations, and platform terms is your responsibility.

If you need data removal, contact <dataforleads@gmail.com>. Please use this Diagnostic Radiologist 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": "Diagnostic Radiologist",
  "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": "Diagnostic Radiologist",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Diagnostic Radiologist Email Scraper",
        "description": "🩻 Diagnostic Radiologist Email Scraper pulls verified radiologist email contacts from public profiles—covering specialists, practice details, and locations. 🚀 Perfect for B2B outreach, recruitment & research with fast, targeted lead lists.",
        "version": "1.0",
        "x-build-id": "cxPKOkU5c1UpluuMw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~diagnostic-radiologist-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-diagnostic-radiologist-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~diagnostic-radiologist-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-diagnostic-radiologist-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~diagnostic-radiologist-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-diagnostic-radiologist-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": "Diagnostic Radiologist"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
