# Biomedical Equipment Manufacturers Email Scraper (`solid-scraper/biomedical-equipment-manufacturers-email-scraper`) Actor

🏥 Streamline lead gen with our Biomedical Equipment Manufacturers email scraper—target manufacturers by keywords, location & industry for high-quality B2B contacts. ⚡ Perfect for sales & marketing teams seeking verified outreach fast.

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

## Pricing

from $2.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

### Biomedical Equipment Manufacturers Email Scraper 📬

**Biomedical Equipment Manufacturers Email Scraper** automatically searches for biomedical equipment manufacturers and extracts business contact information—including emails, phone numbers, and social media profiles—from publicly available web data. If you’re building a **medical device leads email scraper** workflow, researching **B2B medical device email scraper** targets, or trying to **find medical device manufacturer emails** at scale, this actor streamlines the process for marketers, analysts, and researchers by saving you hours of manual work.

---

### 🚀 Why choose Biomedical Equipment Manufacturers Email Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ All-in-one contact extraction | Extracts emails, phone numbers, and social media profiles in one run for each business |
| ✅ Reliability-focused scraping approach | Includes resilience and fallback handling to keep results coming |
| ✅ Scale-ready limits | Lets you control the number of businesses to scrape and stop when your target is reached |
| ✅ Structured dataset output | Produces clean, table-friendly fields such as `name`, `website`, `scraped_emails`, `scraped_phones`, and more |
| ✅ Proxy configuration support | Supports proxy usage to improve scraping reliability for larger batches |
| ✅ Immediate dataset saving | Pushes website scraping results into the dataset as it goes, so you can start using data quickly |

---

### 🔑 Key features

- 🧩 **Biomedical equipment manufacturer targeting:** Uses your `googleMapsSearchTerm` to focus the crawl on the right business niche (e.g., biomedical equipment manufacturers email scraping)
- 🌐 **Website-based contact extraction:** Scrapes contact details from each business website once a website is available (includes **medical technology company email scraping tool** use cases)
- 📧 **Email extraction + optional validation:** Extracts emails and supports validation via `validateEmails` when enabled
- 🛡️ **Built-in reliability mechanisms:** Designed to handle real-world variability with resilience for smoother runs
- 🔁 **Proxy support for dependable scraping:** Includes a configurable proxy setup to help avoid common rate-limiting issues
- 🔎 **Phone + social enrichment:** Also extracts `scraped_phones` and `scraped_social_media` so you get more than just email addresses
- 💾 **Real-time dataset writes:** Pushes results into the Apify dataset immediately during processing

---

### 📝 Input

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

```json
{
  "googleMapsSearchTerm": "Biomedical Equipment Manufacturers",
  "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 (for example, “Biomedical Equipment Manufacturers”). |
| `googleMapsLocation` | Yes | A list of geographic locations to target (for example, `["New York"]`). |
| `maxBusinesses` | No | Maximum number of businesses (1–1000) to find. The scraper stops when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | No | If enabled, the scraper aims for up to `maxBusinesses` results per location. If disabled, it combines locations up to a single total limit. |
| `proxyConfiguration` | No | Proxy settings for scraping. Recommended for larger-scale scraping runs. Includes `proxy support` (default prefill is enabled). |

***

### 📦 Output

After execution, the actor saves results to the **Business Contact Data** dataset. The dataset stores one row per scraped email (when emails are found).

Sample output row shape:

```json
{
  "name": "Example Biomedical Equipment Manufacturer",
  "website": "https://example.com",
  "phone": "+1-555-123-4567",
  "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"],
  "scraped_phones": ["+1-555-111-2222"],
  "scraped_social_media": ["https://www.linkedin.com/company/example"],
  "emails_found": 1,
  "pages_scraped": 3,
  "avg_rating": 4.2,
  "total_reviews": 120,
  "lat": 40.7128,
  "long": -74.006,
  "place_id": "ChIJ...",
  "scrape_status": "success",
  "email_found": "contact@example.com"
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `name` | string | Business name |
| `website` | string | Business website URL |
| `phone` | string | Primary phone value captured for the business |
| `full_address` | string | Full formatted address combining street/city/state/zip/country code when available |
| `city` | string | City |
| `state` | string | State/province |
| `zip` | string | Postal code |
| `country_code` | string | Country code |
| `scraped_emails` | array | Emails scraped from the business website(s) |
| `scraped_phones` | array | Phone numbers scraped from the business website |
| `scraped_social_media` | array | Social 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 while scraping the business website |
| `avg_rating` | number | Average rating value associated with the business entry |
| `total_reviews` | number | Total reviews count associated with the business entry |
| `lat` | number | Latitude |
| `long` | number | Longitude |
| `place_id` | string | Place identifier for the business entry |
| `scrape_status` | string | Status text (for example `success`, `failed`, `no_website`, or `error`) |
| `email_found` | string | The single email value for this row when emails are found (one row per email) |

**Export formats:** In Apify, you can download/export dataset contents from the **output** tab (commonly JSON and CSV workflows depending on your setup).

***

### 🧭 How to use Biomedical Equipment Manufacturers Email Scraper (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and open the Actors page.

2. **Find the actor**\
   Search for **Biomedical Equipment Manufacturers Email Scraper** in the marketplace and open the actor details.

3. **Configure INPUT**\
   In the **INPUT** section, provide:

   - `googleMapsSearchTerm` (business niche)
   - `googleMapsLocation` (one or more locations)

   Optionally set `maxBusinesses` and `scrapeMaxBusinessesPerLocation` to control how many results you want.

4. **(Optional) Set proxy settings**\
   Use `proxyConfiguration` (notably `proxy support`) when you expect larger batches or need extra reliability.

5. **Run the actor**\
   Click **Run**. During the run, you’ll see progress in logs and the actor will push results into the dataset as it scrapes websites.

6. **Check results in the dataset**\
   When finished, open the **OUTPUT** tab and open the dataset named **Business Contact Data** (table view).

7. **Export your data**\
   Export to your preferred format from the dataset view (for example, JSON/CSV depending on your workflow).

No coding required — get biomedical equipment manufacturer contact emails and related details in minutes with this **Biomedical Equipment Manufacturers Email Scraper**.

***

### ⚡ Advanced features & SEO optimization

- 🧠 **Purpose-built for medical device outreach:** Engineered to excel at “biomedical equipment manufacturers email scraper” and “medical device manufacturer email scraper” style lead discovery workflows.
- 🔎 **Email-focused enrichment:** Designed for “B2B medical device email scraper” and “medtech company email finder” use cases—emails plus supporting contact signals like phones and social profiles.
- 🌍 **Location-aware targeting:** Lets you provide multiple locations via `googleMapsLocation` while controlling how results are capped with `maxBusinesses` and `scrapeMaxBusinessesPerLocation`.
- 🧩 **Website-first contact extraction:** After identifying businesses, it focuses on their websites to gather contact details, making it useful as a “biomedical equipment contact email extractor”.
- 🛡️ **Operational resilience:** Built with reliability in mind so that runs stay productive even when some sites don’t yield results.

***

### 🎯 Best use cases

- 📈 **B2B lead generation:** Build a **medical device leads email scraper** list for targeted outreach with emails and phone numbers from vendor sites
- 🏥 **Hospital equipment vendors outreach:** Create vendor prospecting datasets for “hospital equipment vendors email scraper” campaigns by region
- 🔬 **Market research & supplier mapping:** Identify and compare “biomedical equipment supplier email scraping” contacts across multiple locations
- 💼 **Sales development ops:** Speed up **medtech prospecting email scraping** for OEM medical device manufacturer email list building
- 🧾 **Data analysis & enrichment:** Combine contact fields (emails, phones, social links, ratings/reviews) for analysis-ready datasets
- 🤝 **CRM onboarding:** Feed a “B2B medical device email scraper” output into CRM workflows for automated sequences and segmentation
- 🏢 **Distributor prospecting:** Support “biomedical equipment distributor email scraper” research by collecting consistent contact fields per business

***

### 🔧 Technical specifications

- **Supported Input Formats**
  - ✅ JSON input matching the actor schema (`googleMapsSearchTerm`, `googleMapsLocation`, etc.)

- **Proxy Support**
  - ✅ `proxyConfiguration` is supported (including `proxy support`)

- **Retry Mechanism**
  - ✅ Includes resilience and fallback handling for more reliable scraping runs

- **Dataset Structure**
  - ✅ One dataset: **Business Contact Data**
  - ✅ Fields include `scraped_emails`, `scraped_phones`, `scraped_social_media`, plus address and rating/review fields

- **Rate Limits & Performance**
  - ✅ Performance depends on business website availability and response variability; you can manage output size with `maxBusinesses`

- **Limitations**
  - ❌ If a business has no website captured, emails/phones/social may not be available for that business
  - ❌ Not every business will have publicly available contact emails

***

### ❓ FAQ

#### ✅ Does this Biomedical Equipment Manufacturers Email Scraper extract emails, phone numbers, and social media links?

Yes. It extracts contact information from business websites, including `scraped_emails`, `scraped_phones`, and `scraped_social_media`, and it also provides dataset fields like `emails_found` and `pages_scraped`.

#### ✅ How do I control how many businesses I get?

Use `maxBusinesses` to set your target number of businesses (1–1000). If you set `scrapeMaxBusinessesPerLocation` to `true`, the actor targets up to `maxBusinesses` results per location; otherwise it combines locations into one total cap.

#### ✅ What if a business doesn’t have a website?

If no website is available, the actor records a `scrape_status` such as `no_website` and the email-related fields reflect that no emails were scraped for that business.

#### 💻 How is the output saved—one record per business or per email?

The actor pushes results as it scrapes websites, and when emails are found it saves one dataset row per scraped email using `email_found`.

#### 🛡️ Can I use proxies for more reliable scraping?

Yes. Configure `proxyConfiguration` and `proxy support` to use Apify proxy support. This is recommended for larger-scale runs.

#### 📦 Can I validate emails?

Email validation is supported via the input flag `validateEmails` (note: it’s wired in the actor input as `actor_input.get('validateEmails', False)`).

#### ⚖️ Is this suitable for compliant lead generation?

It collects information from publicly available sources, but you are responsible for complying with applicable laws and terms of service (including GDPR/CCPA requirements and spam regulations) for your intended use.

#### ❌ What should I do if I need data removal?

For data removal requests, contact <dataforleads@gmail.com>.

***

### 🤝 Support & feature requests

If you’re using **Biomedical Equipment Manufacturers Email Scraper** for biomedical equipment supplier email scraping or medical device lead generation and want improvements, we’d love to hear from you.

- 💡 **Feature Requests:** Ideas like CSV-first exports, CRM-ready field shaping, or additional filtering options (for example tighter email/domain quality controls) are welcome.
- 📧 **Contact:** Send feedback to <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for this biomedical equipment manufacturer email extraction workflow.

***

### *Biomedical Equipment Manufacturers Email Scraper* — final thoughts

*Built as an SEO-optimized, purpose-ready biomedical equipment manufacturers email scraper for fast B2B contact enrichment.* Run it with the right `googleMapsSearchTerm` and `googleMapsLocation`, and start building your email-ready medtech prospect lists at scale.

***

### Disclaimer

**This tool accesses publicly accessible sources.** It does not access private profiles, authenticated data, or password-protected content. You are responsible for complying with applicable laws (including GDPR and CCPA where relevant), spam regulations, and the terms of service of the websites and platforms from which data originates.

For any data removal requests, contact <dataforleads@gmail.com>. Please use this actor 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": "Biomedical Equipment Manufacturers",
  "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": "Biomedical Equipment Manufacturers",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Biomedical Equipment Manufacturers Email Scraper",
        "description": "🏥 Streamline lead gen with our Biomedical Equipment Manufacturers email scraper—target manufacturers by keywords, location & industry for high-quality B2B contacts. ⚡ Perfect for sales & marketing teams seeking verified outreach fast.",
        "version": "1.0",
        "x-build-id": "vHM0JfW6TGiQFrMOo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~biomedical-equipment-manufacturers-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-biomedical-equipment-manufacturers-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solid-scraper~biomedical-equipment-manufacturers-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-biomedical-equipment-manufacturers-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solid-scraper~biomedical-equipment-manufacturers-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-biomedical-equipment-manufacturers-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": "Biomedical Equipment Manufacturers"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
