# Nursing Homes Email Scraper (`solid-scraper/nursing-homes-email-scraper`) Actor

🏥 Find nursing home decision-makers fast! This Nursing Homes Email Scraper extracts verified B2B emails by location and keywords, helping sales teams, agencies, and recruiters reach the right care providers instantly. 📩

- **URL**: https://apify.com/solid-scraper/nursing-homes-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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Nursing Homes Email Scraper 📬

**Nursing Homes Email Scraper** automatically searches nursing homes and extracts their publicly available contact information—especially email addresses—so you can build a targeted nursing home lead list faster. If you’re looking to **scrape nursing homes emails**, **generate nursing home mailing lists**, or enrich outreach for **skilled nursing facilities email scraping**, this tool helps you turn location-based research into structured results at scale. Whether you’re a marketer, a healthcare data researcher, or a data analyst, you can use this nursing home directory email extractor to save hours of manual work.

---

### Why choose Nursing Homes Email Scraper?

| Feature | Benefit |
|---|---|
| ✅ All-in-one contact extraction | Extracts business details first, then scrapes websites for emails, phone numbers, and social media profiles |
| ✅ Reliability built in | Includes resilient scraping behavior with fallbacks and stop conditions to keep runs stable |
| ✅ Structured dataset output | Saves consistent fields like `name`, `website`, `scraped_emails`, and email-level `email_found` rows |
| ✅ Scale-friendly targeting | Uses `maxBusinesses` and optional per-location limits to control how many nursing homes you collect |
| ✅ Proxy configuration support | Built-in proxy configuration helps improve success rates on large runs |
| ✅ Immediate dataset saving | Pushes results to the Apify dataset as it goes, reducing risk of lost progress |

---

### Key features

- 🌐 **Website-first enrichment**: Visits the business `website` to extract contact emails, phone numbers, and social links  
- 🧾 **Structured business + email rows**: Outputs one dataset row per discovered email via `email_found`, plus business-level fields  
- ✅ **Email-only results mode support**: When enabled, it saves fewer rows by focusing on businesses that actually have emails  
- 🛡️ **Proxy configuration for stability**: Lets you provide proxy settings (recommended for higher-volume healthcare facilities email scraper runs)  
- 🔎 **Niche-focused searching**: Uses your `googleMapsSearchTerm` plus a location list to find relevant senior care facility email scraper candidates  
- 📊 **Operational metrics included**: Tracks fields like `emails_found`, `pages_scraped`, `avg_rating`, and `total_reviews` per business  
- 💾 **Dataset-friendly structure**: Captures `full_address`, `lat`, `long`, and `place_id` alongside scraped contact details  
- 🔁 **Stops at your quota**: Stops when the target number of businesses with emails is reached (and can apply per location if you choose)

---

### Input

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

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

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `googleMapsSearchTerm` | Yes | The business type or niche to search for in the nursing homes email scraping workflow (example: `Nursing Homes`). |
| `googleMapsLocation` | Yes | A list of target geographic locations (for example: `["New York"]`). |
| `maxBusinesses` | No | Target number of businesses to find (1–1000). The scraper stops when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | No | If enabled, the scraper collects up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit. |
| `proxyConfiguration` | No | Proxy settings for scraping (recommended for large-scale runs). Includes proxy configuration fields supported by Apify proxy input. |
| `proxyConfiguration.proxy support` | No | When prefilled, enables Apify Proxy support for the run. |

> Note: The actor also uses internal defaults for website scraping behavior, including enabling phone and social extraction by default, and optional email validation depending on your input (see FAQ for details on how validation is controlled).

***

### Output

The actor saves results to the **Apify dataset** in JSON form, using a flattened structure that includes business fields and an email-level `email_found` field (one row per email).

Example output item:

```json
{
  "street_address": "",
  "city": "New York",
  "zip": "10001",
  "state": "NY",
  "country_code": "US",
  "full_address": "123 Main St New York NY 10001 US",
  "website": "https://example.com",
  "avg_rating": 4.6,
  "total_reviews": 120,
  "name": "Example Nursing Home",
  "place_id": "ChIExamplePlaceId",
  "phone": "",
  "lat": 40.7128,
  "long": -74.006,
  "scraped_phones": ["+1-555-123-4567"],
  "scraped_social_media": ["https://www.linkedin.com/company/example/"],
  "emails_found": 2,
  "pages_scraped": 6,
  "scrape_status": "success",
  "email_found": "contact@example.com"
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `name` | string | Business name. |
| `website` | string | Business website URL (used for email extraction). |
| `phone` | string | Phone value from the business listing stage. |
| `full_address` | string | Combined address string. |
| `city` | string | City name. |
| `state` | string | State name. |
| `zip` | string | ZIP/postal code. |
| `country_code` | string | Country code. |
| `scraped_emails` | array | Emails found during website scraping (internal list; removed from email-level rows). |
| `scraped_phones` | array | Phone numbers scraped from the website. |
| `scraped_social_media` | array | Social media profile links scraped from the website. |
| `emails_found` | number | Count of emails found for the business. |
| `pages_scraped` | number | How many pages were processed for the website scraping job. |
| `avg_rating` | number | Average rating value from the business listing stage. |
| `total_reviews` | number | Total reviews from the business listing stage. |
| `lat` | number | Latitude for the business. |
| `long` | number | Longitude for the business. |
| `place_id` | string | Place identifier for the business. |
| `scrape_status` | string | Scrape status, such as `success`, `failed`, `no_website`, or `error`. |
| `email_found` | string | The specific email address for this dataset row (present when emails are found). |
| `scrape_error` | string | Error details when a website scrape fails or errors. |

**Export formats:** You can export the dataset from Apify Console to common formats (for example JSON or CSV), depending on your workflow.

***

### How to use Nursing Homes Email Scraper (via Apify Console)

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

2. **Find the actor**\
   Search for **Nursing Homes Email Scraper** and open the actor page.

3. **Configure INPUT**\
   Use the built-in form and set:
   `googleMapsSearchTerm` (for example `Nursing Homes`)\
   `googleMapsLocation` (for example `["New York"]`)

4. **Set your limits**\
   Choose `maxBusinesses` (1–1000) and decide whether you want `scrapeMaxBusinessesPerLocation` enabled for per-location quotas.

5. **(Optional) Add proxy configuration** 🛡️\
   In **Proxy Configuration**, set `proxyConfiguration` (including `proxy support`) if you plan to run at larger scale.

6. **Click Run** 🚀\
   Start the actor and monitor progress in the logs. The actor will scrape websites for contact information and push results to the dataset as it finds them.

7. **Open the OUTPUT dataset** 📦\
   After the run completes, open the dataset view and export your results.

No coding required—get targeted nursing homes contact email database data in minutes.

***

### Advanced features & SEO optimization

- 💡 **Optimized lead list scraping**: The actor is engineered to excel at **nursing home lead list scraper** and **skilled nursing facilities email scraper** use cases by combining listing info (address, rating, place id) with website-based email extraction
- 🧠 **Per-location vs global quotas**: Toggle `scrapeMaxBusinessesPerLocation` to switch between per-city caps and a single overall limit for elder care marketing email list building
- 🧾 **Clear completeness signals**: The dataset includes `emails_found`, `pages_scraped`, and `scrape_status`, helping analysts quickly filter out incomplete results
- 🌐 **Works for nearby pipeline enrichment**: Use outputs like `scraped_social_media` and `scraped_phones` to complement **healthcare facilities email scraper** workflows beyond just email outreach
- 🔄 **Built for scale**: Proxy configuration and controlled max limits make it suitable as a nursing home directory email extractor for larger research projects

***

### Best use cases

- 📈 **Marketing teams building a mailing list**: Generate a nursing home mailing list by extracting emails and website contact info for outreach campaigns
- 🧠 **Healthcare researchers**: Scrape nursing homes emails across multiple locations and analyze patterns using address and rating metadata
- ✉️ **Senior living sales ops**: Create a senior living email list scraper dataset that includes `scraped_phones` and `scraped_social_media` for multi-channel follow-up
- 🏥 **Long term care facility lead gen**: Build licensed nursing facility email lists targeted to skilled nursing facilities email scraping needs
- 📊 **Data analysts & enrichment specialists**: Join business contact fields like `full_address`, `lat`, `long`, and `place_id` with email results for deeper segmentation
- 🛠️ **CRM and automation workflows**: Feed the email-level rows (`email_found`) directly into your pipeline to automate prospecting for care home email scraping tool use cases

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `googleMapsSearchTerm` as a string (business type or niche)
  - ✅ `googleMapsLocation` as an array of location strings
  - ✅ Optional controls: `maxBusinesses`, `scrapeMaxBusinessesPerLocation`, `proxyConfiguration`

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

- **Retry Mechanism**
  - ✅ Built-in resilience is enabled for scraping jobs (exact retry counts and delays are handled internally)

- **Dataset Structure**
  - ✅ Business fields are saved with website scraping outcomes
  - ✅ Email-level flattening: one dataset row per `email_found` when emails are present

- **Rate Limits & Performance**
  - ✅ Uses controlled concurrency and stop conditions based on your `maxBusinesses` target

- **Limitations**
  - ❌ Not every business will have a website, and some websites may not expose emails publicly
  - ❌ Some results may fail website scraping, indicated via `scrape_status` and `scrape_error`

***

### FAQ

#### What does Nursing Homes Email Scraper extract?

✅ It searches for nursing homes and extracts business contact information including emails, phone numbers, and social media profiles. Website scraping results are reflected in fields like `scraped_emails` (internal list), `scraped_phones`, `scraped_social_media`, plus counts like `emails_found` and `pages_scraped`.

#### How do I control how many results I get?

You control the business quota using `maxBusinesses`. If you enable `scrapeMaxBusinessesPerLocation`, the actor targets up to `maxBusinesses` per location; otherwise it uses a combined total limit across all provided locations.

#### Does it save results even if it’s interrupted?

✅ Yes. The actor pushes data to the Apify dataset during execution (it pushes website results immediately), which helps reduce the risk of losing progress.

#### Can I scrape only businesses that have emails?

✅ Yes—there is an email-only mode implemented in the website scraping step. When enabled, the actor focuses on saving businesses with emails and reports the count of businesses with emails.

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

When no website is available, the actor sets `scrape_status` to `no_website` and saves the record depending on whether email-only mode is enabled. In email-level rows, `email_found` will only appear when emails are found.

#### How do I validate emails?

✅ Email validation is supported internally and is controlled by an input named `validateEmails` (the actor reads it from `actor_input.get('validateEmails', False)`). When enabled, it validates extracted emails during website scraping.

#### Can I use this for compliance-sensitive marketing lists?

✅ You can use it for publicly available data enrichment, but it’s your responsibility to comply with applicable privacy laws (including GDPR/CCPA), spam regulations, and each source website’s terms. Always use the data ethically and lawfully.

***

### Support & feature requests

Have ideas to improve Nursing Homes Email Scraper for nursing home email scraper workflows? 💡

- **Feature Requests**: For example, enhancements like better CSV export controls, additional output fields, or custom email filtering logic for elder care marketing email list creation.
- **Contact**: Reach out at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for this nursing home lead list scraper.

***

### Final thoughts on Nursing Homes Email Scraper

*If you need a reliable nursing home email scraper that turns location-based business research into structured outreach-ready results, Nursing Homes Email Scraper is built for exactly that.* *Get started today and build nursing homes contact email database datasets faster at scale.*

***

### Disclaimer

**This tool accesses publicly accessible sources only**. It does not access private profiles, authenticated data, or password-protected content. You are responsible for complying with applicable laws and regulations (including GDPR/CCPA), spam and marketing rules, and source website terms.

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Nursing Homes Email Scraper",
        "description": "🏥 Find nursing home decision-makers fast! This Nursing Homes Email Scraper extracts verified B2B emails by location and keywords, helping sales teams, agencies, and recruiters reach the right care providers instantly. 📩",
        "version": "1.0",
        "x-build-id": "u0HwWTehdZgAQd7bF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~nursing-homes-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-nursing-homes-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~nursing-homes-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-nursing-homes-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~nursing-homes-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-nursing-homes-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": "Nursing Homes"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
