# Allergist Email Scraper (`scraperoka/allergist-email-scraper`) Actor

🧑‍⚕️ Allergist Email Scraper finds allergist email addresses from targeted profiles/pages for fast B2B outreach. ✅ Cleaner lists, higher deliverability & lead generation. 🚀 Perfect for marketing, sales, and recruitment campaigns.

- **URL**: https://apify.com/scraperoka/allergist-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Other
- **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

### Allergist Email Scraper 📬

**Allergist Email Scraper** is an actor that helps you scrape allergist business listings and extract their contact information from publicly available sources—especially email addresses—so you can quickly build a targeted **allergist email list scraper** for outreach, research, or analysis. It supports both a **find allergist emails** workflow and broader **medical specialty email scraper** use cases, including building an **allergy clinic email scraper** style dataset by location.

Whether you're a marketer, recruiter, or data enthusiast, this **doctor email extraction tool** streamlines the manual work of collecting specialist practice contact details at scale, saving you hours of manual work.

---

### Why choose Allergist Email Scraper? ✅

| Feature | Benefit |
| --- | --- |
| ✅ **All-in-one business + website contact enrichment** | Extracts business details plus scraped contact emails, phone numbers, and social media profiles in one run |
| ✅ **Reliability with built-in resilience** | Includes retries and fallbacks for more consistent results when sites are difficult to access |
| ✅ **Structured, dataset-ready output** | Saves results to an Apify dataset with consistent fields for easy export and downstream use |
| ✅ **Built for scale across multiple locations** | Use multi-location input and limits to control how many businesses you collect |
| ✅ **Proxy support for smoother scraping** | Includes **proxyConfiguration** support to help reduce scraping interruptions at higher volumes |
| ✅ **Progressive saving to reduce data loss** | Pushes results to the dataset as it processes businesses so you don’t lose everything if a run stops |

---

### Key features 🔑

- 📌 **Allergist-focused lead discovery**: Uses your search term and geographic location(s) to target allergist businesses for contact extraction.
- 🌐 **Website contact extraction**: Scrapes each business website to collect **scraped_emails**, **scraped_phones**, and **scraped_social_media**.
- 🧠 **Email-only dataset control**: When enabled, it can save only businesses that actually have emails (great for **allergist marketing email list** building).
- 🛡️ **ProxyConfiguration support**: Helps improve reliability during large-scale scraping.
- 🔄 **Resilient scraping behavior**: Includes resilience patterns so the run can keep going when individual sites fail.
- 💾 **Real-time dataset saving**: Results are pushed to the Apify dataset immediately while businesses are processed.
- 📊 **Detailed contact + location fields**: Produces records with name, website, phone, full address, city/state/zip/country code, and coordinates when available.
- 🧾 **Email-level rows**: If emails are found, the dataset can contain one row per email via the flattened output approach (useful for CRM import and validation workflows).

---

### Input

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

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

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `googleMapsSearchTerm` | Yes | The business type or niche you want to scrape (for example, `Allergist`, or any other niche you’d like to convert into an **allergist lead email scraper** style list). |
| `googleMapsLocation` | Yes | Target geographic location(s) you want to scrape for (for example, `["Miami, Florida"]`). You can pass multiple locations. |
| `maxBusinesses` | No | Maximum number of businesses to find (range: `1-1000`). The scraper stops when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | No | Controls whether the actor collects up to `maxBusinesses` results **per location** (`true`) or combines all locations up to a **single total limit** (`false`). |
| `proxyConfiguration` | No | Proxy settings for scraping. Recommended for larger runs. Includes an option `proxy support` (prefilled to `true`). |

***

### Output

After execution, the actor saves results in the Apify dataset **as JSON records** (pushed via `Actor.push_data`). Each dataset row represents a business enriched with scraped contact info, and when emails are present it can also be flattened to one row per email.

#### Example output

```json
{
  "name": "Sample Allergist Clinic",
  "website": "https://example.com",
  "phone": "+1-555-555-5555",
  "full_address": "123 Main St New York NY 10001 US",
  "city": "New York",
  "state": "NY",
  "zip": "10001",
  "country_code": "US",
  "scraped_emails": [
    "contact@example.com",
    "info@example.com"
  ],
  "scraped_phones": [
    "+1-555-000-0000"
  ],
  "scraped_social_media": [
    "https://www.facebook.com/exampleclinic"
  ],
  "emails_found": 2,
  "pages_scraped": 5,
  "avg_rating": 4.6,
  "total_reviews": 128,
  "lat": 40.7128,
  "long": -74.006,
  "place_id": "ChIJN1t_tDeuEmsRUsoU7Y9sVtQ",
  "scrape_status": "success",
  "email_found": "contact@example.com"
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `name` | string | Business name for the allergist listing. |
| `website` | string | Business website URL (used as the starting point for contact extraction). |
| `phone` | string | Phone number from the business listing (not necessarily the phone found on the website). |
| `full_address` | string | Full address combined from the available address parts. |
| `city` | string | City component of the address. |
| `state` | string | State component of the address. |
| `zip` | string | Postal/ZIP code component. |
| `country_code` | string | Country code component of the address. |
| `scraped_emails` | array | Emails extracted from the business website. |
| `scraped_phones` | array | Phone numbers extracted from the business website. |
| `scraped_social_media` | array | Social media profile links extracted from the business website. |
| `emails_found` | number | Count of emails found for the business. |
| `pages_scraped` | number | Number of processed URLs/pages during the website scraping phase. |
| `avg_rating` | number | Average rating value from the business listing (when available). |
| `total_reviews` | number | Total review count from the business listing (when available). |
| `lat` | number | Latitude coordinate (when available). |
| `long` | number | Longitude coordinate (when available). |
| `place_id` | string | Place identifier from the listing (used internally for uniqueness). |
| `scrape_status` | string | Status of the website scraping step (e.g. `success`, `failed`, `no_website`, `error`). |
| `email_found` | string | Present when emails are flattened into email-level rows; contains the email for that specific row. May be empty when no emails are saved in non-email-only mode. |
| `scrape_error` | string | Present when scraping fails; contains the error message (as pushed into the dataset). |

You can export the dataset from Apify to JSON (and typically also CSV from the dashboard), then plug it directly into your outreach workflows or analysis.

***

### How to use Allergist Email Scraper (via Apify Console) 🚀

1. **Open Apify Console**
   Go to [console.apify.com](https://console.apify.com) and sign in.

2. **Find the actor**
   Search for **Allergist Email Scraper** in the Actors marketplace.

3. **Configure input**
   In the **INPUT** section, fill in:
   `googleMapsSearchTerm` (for example, `Allergist`) and one or more `googleMapsLocation` values.
   Optionally set `maxBusinesses`, `scrapeMaxBusinessesPerLocation`, and `proxyConfiguration`.

4. **Choose proxy settings (optional)**
   If you’re running larger batches, enable proxy support via `proxyConfiguration` (the form is prefilled with `proxy support: true`).

5. **Run the actor**
   Click **Run** to start. During the run, you’ll see logs showing progress per location and per business.

6. **Monitor progress**
   Watch the logs for progress updates (including how many businesses are found) and status outcomes like success or failed website scrapes.

7. **Open the dataset**
   After completion, go to the **OUTPUT** tab and open the dataset (Business Contact Data).

8. **Export your results**
   Export your dataset records for use in tools like spreadsheets, CRMs, or your **allergy clinic email scraper** pipelines.

No coding required—get targeted allergist contact data in minutes with this **allergist email list scraper**.

***

### Advanced features & SEO optimization ✨

- 🧾 **Engineered for allergist email lists**: Built specifically for **Allergist Email Scraper** lead generation patterns—turning a specialist niche + location into a ready-to-use **allergist contact email finder** dataset.
- 🔄 **Email-only quality mode (email-first)**: When email-only mode is enabled in the workflow, it focuses the output on businesses that have emails—ideal for a cleaner **custom allergist email outreach list**.
- 🌐 **Rich contact enrichment**: Not only emails—also extracts phones and social profiles, which helps you verify and enrich a **medical directory email scraper** output.
- 🛡️ **Proxy support for stability**: Helps improve reliability when scraping at higher volumes, especially when you’re building an **allergist marketing email list** across multiple cities.

***

### Best use cases 📌

- 📈 **Lead generation for allergist practices**: Build a ready-to-import **allergist email list scraper** dataset by city for outreach campaigns.
- 🔬 **Market research by location**: Compare allergist clinics across multiple `googleMapsLocation` inputs and analyze availability of contact details.
- 🧠 **Healthcare sales prospecting**: Enrich CRM records with emails and additional contact channels for **healthcare lead generation email scraper** workflows.
- 🗂️ **Data enrichment for specialist programs**: Create a **specialist practice email database** including websites, phone(s), and social links.
- 🧾 **Email outreach verification prep**: Use extracted email domains to support **verify doctor email addresses** steps downstream.
- 💻 **Automation pipeline ingestion**: Feed dataset rows into your scripts for segmentation, deduplication, and **doctor email extraction tool** workflows.
- 📊 **Analyst-friendly datasets**: Use consistent fields like `avg_rating`, `total_reviews`, coordinates (`lat`, `long`), and `place_id` to drive reporting.

***

### Technical specifications

#### Supported Input Formats

✅ `googleMapsSearchTerm` as a string (e.g., `Allergist`)\
✅ `googleMapsLocation` as an array of locations (each location is a string)

#### Proxy Support

✅ `proxyConfiguration` (includes `proxy support` in the provided schema)

#### Retry Mechanism

✅ Includes resilience patterns and fallback logic during scraping to improve success rates when individual sites fail.

#### Dataset Structure

✅ Uses the Apify dataset named **Business Contact Data** with the listed 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 multi-location collection with limits controlled by `maxBusinesses` and (optionally) per-location limits via `scrapeMaxBusinessesPerLocation`.

#### Limitations

❌ Output quality depends on whether businesses have accessible websites and whether the emails are publicly present on those sites.\
❌ Some entries may be returned with `scrape_status` such as `no_website`, `failed`, or `error` if enrichment can’t complete.

***

### FAQ

#### Can I scrape more than one location at a time?

✅ Yes. Provide multiple values in `googleMapsLocation` as an array. You can also control whether `maxBusinesses` is applied per location (`scrapeMaxBusinessesPerLocation: true`) or as one global cap.

#### How many businesses will it collect?

You can set `maxBusinesses` (range `1-1000`). The actor stops when it reaches the target based on whether you enable `scrapeMaxBusinessesPerLocation`.

#### Does it extract emails only, or more contact fields too?

It extracts emails (`scraped_emails`) and also gathers `scraped_phones` and `scraped_social_media` from the business website where available.

#### What does `scrape_status` mean?

`score_status` is a text field indicating the outcome of the website scraping step. Values pushed into the dataset include `success`, `failed`, `no_website`, and `error` depending on what happened during extraction.

#### Will the dataset include one row per business or per email?

When emails are found, the actor pushes a flattened email-level row using `email_found` (and removes `scraped_emails` from that flattened row). If no emails are found, behavior depends on whether email-only mode is active; otherwise it can push a business row with `email_found` empty.

#### Do I need to use proxies?

No. Proxy support is optional via `proxyConfiguration`. For larger-scale scraping, proxies are recommended for reliability and to reduce interruptions.

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

In that case, the actor sets `scraped_emails` to an empty list, sets `scrape_status` to `no_website`, and (in non-email-only mode) can still push the business record to the dataset.

#### Is it legal to use this for healthcare lead generation?

✅ This tool reads **publicly accessible sources**. Compliance with GDPR/CCPA, spam regulations, and each website’s terms of service is your responsibility.

***

### Support & feature requests 🤝

If you’re using **Allergist Email Scraper** for an **allergist lead email scraper** workflow and you’d like improvements, we’d love to hear from you.

- 💡 **Feature Requests**: CSV export enhancements, custom output shaping for your **allergist email list scraper** pipelines, and CRM-ready formatting are great examples.
- 📧 **Contact**: email us at <dataforleads@gmail.com>

Your feedback helps shape the roadmap for this **doctor email extraction tool**.

***

### Final thoughts on Allergist Email Scraper 💬

*Allergist Email Scraper*\* gives you an SEO-friendly, structured way to build an allergist email list scraper for location-based outreach.\* Run it at scale, export the results, and turn your contact research into action.

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Allergist Email Scraper",
        "description": "🧑‍⚕️ Allergist Email Scraper finds allergist email addresses from targeted profiles/pages for fast B2B outreach. ✅ Cleaner lists, higher deliverability & lead generation. 🚀 Perfect for marketing, sales, and recruitment campaigns.",
        "version": "1.0",
        "x-build-id": "CfFETHRbL2WH5oFLJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~allergist-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-allergist-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~allergist-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-allergist-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~allergist-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-allergist-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": "Allergist"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
