# Acute Care Nurse Practitioners Email Scraper (`scraperoka/acute-care-nurse-practitioners-email-scraper`) Actor

🏥 Acute Care Nurse Practitioners Email Scraper extracts verified NP email contacts from targeted acute care directories. ⚡ Perfect for B2B outreach, recruiting, and healthcare marketing. 📧 Save time, reduce manual search, and boost lead accuracy.

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

### Acute Care Nurse Practitioners Email Scraper 🎯

Manually visiting business websites to find the right contact emails wastes hours you don’t have. **Acute Care Nurse Practitioners Email Scraper** automates the process by scraping publicly available business listings and extracting contact information (emails, phone numbers, and social media profiles) for outreach at scale. The Acute Care Nurse Practitioners Email Scraper is built for marketers, recruiters, and growth teams looking for an acute care NP lead generation–ready email list—delivering results quickly for thousands of records in a single run (depending on your limits and chosen locations).

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "street_address": "1234 W River Rd",
  "city": "New York",
  "zip": "10001",
  "state": "NY",
  "country_code": "US",
  "full_address": "1234 W River Rd New York NY 10001 US",
  "website": "https://examplehospital.org",
  "avg_rating": 4.3,
  "total_reviews": 128,
  "name": "Example Health Clinic",
  "place_id": "ChIJN1t_tDeuEmsRUsoyG83frY4",
  "phone": "+1 212-555-0199",
  "lat": 40.7506,
  "long": -73.9970,
  "scraped_phones": ["+1 212-555-0199", "+1 212-555-0102"],
  "scraped_social_media": ["https://www.linkedin.com/company/examplehealth/"],
  "emails_found": 2,
  "pages_scraped": 6,
  "avg_rating": 4.3,
  "total_reviews": 128,
  "scrape_status": "success",
  "email_found": "np.contact@examplehospital.org",
  "country_code": "US"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `name` | string | The business name you can reference in your outreach |
| `website` | string | The official site you can verify quickly and use for personalization |
| `phone` | string | A direct business phone line for backup outreach (or validation) |
| `full_address` | string | A complete address string for mapping, routing, and CRM fields |
| `city` | string | City for regional segmentation (great for acute care staffing NP email outreach) |
| `state` | string | State/province for compliance-aware targeting and filtering |
| `zip` | string | Postal code for accurate geographic enrichment |
| `country_code` | string | Country code for normalization in multi-region datasets |
| `scraped_emails` | array | Emails detected from the business website (not present in the per-email rows; see `email_found`) |
| `scraped_phones` | array | Additional phone numbers scraped from the website |
| `scraped_social_media` | array | Social profile links found on the website (useful for multi-channel outreach) |
| `emails_found` | number | How many emails were found for that business |
| `pages_scraped` | number | How many pages were processed while searching the website |
| `avg_rating` | number | Public listing rating for lightweight lead qualification |
| `total_reviews` | number | Review count to help prioritize higher-signal locations |
| `scrape_status` | string | Indicates success/failure state for the record |

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

***

### Why Acute Care Nurse Practitioners Email Scraper?

There are a lot of ways to pull provider contact data from public web pages — here’s what sets **Acute Care Nurse Practitioners Email Scraper** apart.

#### Fast list-building for outreach teams

You set a `maxBusinesses` target, and the actor works through the provided locations until it reaches your limit. This is designed for acute care NP contact email scraper use cases where speed and volume matter.

#### Clean, CRM-ready business records

The output is structured so you get business identity fields (like `name`, `website`, `full_address`) alongside scraped contacts (`email_found`, `scraped_phones`, `scraped_social_media`). It’s a straightforward foundation for a healthcare provider email scraper workflow.

#### Resilient scraping with status visibility

When website pages can’t be processed, the actor records failure state using `scrape_status` and `scrape_error`. That way you can filter out problematic rows in your acute care clinic nurse practitioner email list.

#### Built-in email-focused saving

In “email-only mode,” the actor is designed to keep scraping until it has enough businesses with emails, so your dataset stays relevant for advanced practice registered nurse email scraper and similar email outreach campaigns.

***

### Configuring Your Run

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

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

| Parameter | Required | What It Does |
|---|---|---|
| `googleMapsSearchTerm` | ✅ | The business type or niche the scraper searches for (defaults to “Acute Care Nurse Practitioners”) |
| `googleMapsLocation` | ✅ | Target geographic locations to search (an array of locations like “New York”) |
| `maxBusinesses` | ⬜ | Target number of businesses to find (range 1–1000). The scraper stops once this target is reached |
| `scrapeMaxBusinessesPerLocation` | ⬜ | If enabled, collect up to `maxBusinesses` results per location; if disabled, it combines all locations up to a single total limit |
| `proxyConfiguration` | ⬜ | Proxy settings for scraping (recommended for larger-scale runs) |
| ↳ `proxyConfiguration.proxy support` | ⬜ | Set `true` to route scraping traffic through Apify Proxy for improved reliability |

***

### Core Capabilities

#### Location-based business discovery

You provide `googleMapsLocation` and a `googleMapsSearchTerm`, and the actor generates a location coverage plan internally to gather relevant businesses. This makes it practical for provider contact list acquisition across multiple regions.

#### Website contact enrichment (emails, phones, social)

After collecting business listings, the actor scrapes their websites and extracts contact information including emails, phone numbers, and social media profiles. This supports healthcare provider email scraper and medical staff directory email scraper workflows.

#### Email-focused output rows (`email_found`)

When emails are found, the dataset is pushed as flattened records: one row per email via `email_found`. This is especially convenient for acute care staffing NP email outreach, where you want to import directly into outreach tools.

#### Optional email validation & robust scraping behavior

You can enable `validateEmails` and control how many pages to scrape per site using `maxPagesPerSite`. The run also supports resilience features such as stop conditions and error capture using `scrape_status` and `scrape_error`.

#### Proxy support for reliable runs

A `proxyConfiguration` input is available, including `proxy support`, which helps keep scraping reliable as you scale your acute care NP lead generation efforts.

***

### Who Gets the Most Out of This

Here's how different teams put **Acute Care Nurse Practitioners Email Scraper** to work:

**Marketing & Growth Teams** — Use it to build an acute care clinic nurse practitioner email list by targeting specific regions, then enrich the results with phone and social links for multi-channel outreach. The output helps you move from lead discovery to first contact without manual website hunting.

**Sales Development Representatives** — Start with a list of targets by location, then use scraped emails for high-conversion sequences. One row per email (`email_found`) makes it easy to push directly into a sales pipeline.

**Recruiters & Staffing Operations** — Use it to find credentialed provider email scraper contacts in acute care settings and segment by city/state. It’s a practical approach for hospitalist nurse practitioner email finder and urgent care nurse practitioner email scraper workflows.

**Healthcare Analysts & Researchers** — Build structured datasets that include business identity, ratings/reviews, addresses, and extracted contact fields. This makes it easier to validate and analyze healthcare provider email scraper coverage across regions.

**Automation & Integration Specialists** — Pull results via the Apify API and route them into your systems. Since the dataset is structured consistently, it’s straightforward to connect to downstream enrichment and CRM updates.

***

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

No coding needed. Here's how to run **Acute Care Nurse Practitioners Email Scraper** from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find **Acute Care Nurse Practitioners Email Scraper**.
2. **Enter your inputs** — set `googleMapsSearchTerm` and `googleMapsLocation` first, then optionally tune `maxBusinesses` and `scrapeMaxBusinessesPerLocation`.
3. **Configure proxy settings** — if you’re running larger jobs, enable `proxyConfiguration.proxy support` to improve reliability.
4. **Hit Run and watch the live log** — monitor progress and make sure you’re getting the expected output for your target cities.
5. **View results in the dataset tab** — each record includes business info plus extracted contact fields like `email_found`, `scraped_phones`, and `scraped_social_media`.
6. **Export as JSON, CSV, or Excel** — download from the dataset tab and import into your CRM or outreach stack.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **Acute Care Nurse Practitioners Email Scraper** plugs directly into your existing workflow.

You can export your dataset in **JSON, CSV, or Excel** from the Apify dataset tab. This makes it easy to use as an acute care NP contact email scraper input for CRMs, spreadsheets, or lead scoring models.

You can also connect your runs through the Apify ecosystem: **API access** to pull results programmatically, and **webhooks / automation tools** like Zapier or Make to push fresh contacts downstream. For deeper setup details, refer to Apify’s documentation at https://apify.com/docs/api.

***

### Pricing & Free Trial

**Acute Care Nurse Practitioners Email Scraper** runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You can use the free tier to test your workflow and confirm your acute care nurse practitioner email scraper output quality before scaling. Runs are generally pay-as-you-go based on Apify compute usage, and Apify plans vary by usage level—check the Apify pricing page for the latest details. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limit resilience | Uses your proxy configuration to help reduce blocking and throttling |
| Output consistency | Produces structured records with `scrape_status` for success/failure visibility |
| Email-first usefulness | Saves email results in flattened rows using `email_found` when available |
| Scalability | Supports multiple locations and adjustable business limits |

Limitations: The actor relies on publicly available data and website content, so results vary by how complete each business website is. If a business has no accessible email contact on its website, it won’t produce an `email_found` value for that row.

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

***

### Frequently Asked Questions

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

Yes. Apify offers a free tier for testing actors, so you can validate the Acute Care Nurse Practitioners Email Scraper output before running large batches.

#### Do I need to log in to use this?

No login is required from you. The actor is designed to work from publicly available data and scrape the business websites it discovers.

#### How accurate is the data?

Accuracy depends on what the business publishes on its website. The actor extracts emails, phone numbers, and social media profiles from the website content it processes, and provides status via `scrape_status` (and `scrape_error` when applicable).

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

You control volume with `maxBusinesses` (range 1–1000). If you enable `scrapeMaxBusinessesPerLocation`, you can collect up to `maxBusinesses` results per location; otherwise it combines locations up to a single total limit.

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

Data freshness is tied to when you run the actor. Each run re-collects business listing information and then scrapes the businesses’ websites, so the output reflects the state of publicly available pages at run time.

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

The actor is intended for extracting **publicly available data**. It’s your responsibility to ensure your use complies with GDPR, CCPA, platform terms, and applicable anti-spam laws.

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

Yes. You can export your dataset as JSON, CSV, or Excel directly from the Apify dataset tab, and then move it into Google Sheets or your preferred spreadsheet tool.

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

Yes. You can schedule actor runs using Apify’s scheduling capabilities. This is useful for continuously growing an acute care clinic nurse practitioner email list.

#### Can I access this via API?

Yes. You can access run results programmatically via the Apify API. For details, see https://apify.com/docs/api.

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

If a website scrape fails for a business, the record will reflect that in `scrape_status` (and `scrape_error` where available). You can filter these rows out during analysis while keeping successful results.

***

### Need Help or Have a Request?

Got a question about **Acute Care Nurse Practitioners Email Scraper** or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like better output filtering for email outreach, and webhook notifications when runs complete.

***

### Disclaimer & Responsible Use

*Acute Care Nurse Practitioners Email Scraper is the fastest, most reliable way to build an outreach-ready email dataset from public business websites — start your free run today.*

This actor collects **publicly available data**. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for using the output in compliance with GDPR, CCPA, platform Terms of Service, and any applicable anti-spam laws. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `googleMapsSearchTerm` (type: `string`):

Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').

## `googleMapsLocation` (type: `array`):

Target geographic location for the email scraper (e.g., 'Miami, Florida').

## `maxBusinesses` (type: `integer`):

Target number of businesses to find (1-1000). The scraper will stop when this target is reached.

## `scrapeMaxBusinessesPerLocation` (type: `boolean`):

If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.

## `proxyConfiguration` (type: `object`):

Proxy settings for scraping. Recommended for large-scale scraping.

## Actor input object example

```json
{
  "googleMapsSearchTerm": "Acute Care Nurse Practitioners",
  "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": "Acute Care Nurse Practitioners",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Acute Care Nurse Practitioners Email Scraper",
        "description": "🏥 Acute Care Nurse Practitioners Email Scraper extracts verified NP email contacts from targeted acute care directories. ⚡ Perfect for B2B outreach, recruiting, and healthcare marketing. 📧 Save time, reduce manual search, and boost lead accuracy.",
        "version": "1.0",
        "x-build-id": "uvuLvR2V3L5x0T8NY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~acute-care-nurse-practitioners-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-acute-care-nurse-practitioners-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~acute-care-nurse-practitioners-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-acute-care-nurse-practitioners-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~acute-care-nurse-practitioners-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-acute-care-nurse-practitioners-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": "Acute Care Nurse Practitioners"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
