# Adult Care Nurse Practitioner Email Scraper (`scraperoka/adult-care-nurse-practitioner-email-scraper`) Actor

📧 Adult Care Nurse Practitioner Email Scraper extracts verified NP contact emails for adult care providers. ✅ Accurate, privacy-friendly data for outreach, lead gen, and recruitment. 🚀 Perfect for healthcare marketing and staffing teams.

- **URL**: https://apify.com/scraperoka/adult-care-nurse-practitioner-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Jobs, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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

### Adult Care Nurse Practitioner Email Scraper 🚀

Manually hunting down nurse practitioner contact details wastes hours you don't have. **Adult Care Nurse Practitioner Email Scraper** finds businesses for your target adult care nurse practitioner niche and extracts their contact information—including emails, phone numbers, and social media profiles—ideal for marketers, recruiters, and growth teams. Use this **Adult Care Nurse Practitioner email scraper** to generate outreach-ready leads with thousands of records in a single run.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "street_address": "1234 Main St",
  "city": "New York",
  "zip": "10001",
  "state": "NY",
  "country_code": "US",
  "full_address": "1234 Main St New York NY 10001 US",
  "website": "https://examplehealthclinic.com",
  "avg_rating": 4.6,
  "total_reviews": 128,
  "name": "Example Health Clinic",
  "place_id": "ChIJ123exampleplaceid",
  "phone": "+1 212-555-0199",
  "lat": 40.7128,
  "long": -74.006,
  "scraped_emails": [],
  "scraped_phones": ["+1-212-555-0101"],
  "scraped_social_media": ["https://www.linkedin.com/company/examplehealthclinic"],
  "emails_found": 1,
  "pages_scraped": 6,
  "scrape_status": "success",
  "email_found": "contact@examplehealthclinic.com"
}
````

> Note: Output is flattened so you’ll see one dataset row per discovered email when emails are found (see `email_found`). If a business has no website, it is saved with `scrape_status: "no_website"` and empty contact arrays.

#### Output Fields

| Field | Type | What It Tells You |
|---|---|---|
| `name` | string | The business name you can use to identify the right adult care clinic or provider. |
| `website` | string | The homepage/website URL used as the starting point for email and contact extraction. |
| `phone` | string | The phone number associated with the business listing itself. |
| `full_address` | string | The complete mailing-style address for mapping, deduping, or CRM matching. |
| `city` | string | Helps you segment your outreach by metro area. |
| `state` | string | State-level filtering for campaigns and compliance workflows. |
| `zip` | string | Postal code for routing, field teams, and record verification. |
| `country_code` | string | Country code for international lead lists and normalization. |
| `scraped_emails` | array | The email addresses extracted from the business website (typically present before flattening). |
| `scraped_phones` | array | Extra phone numbers found on the business site to enrich your lead profile. |
| `scraped_social_media` | array | Social links found on the business site (useful for omnichannel outreach). |
| `emails_found` | number | Count of extracted emails for this business. |
| `pages_scraped` | number | How many pages were processed during website scraping. |
| `avg_rating` | number | Listing rating (handy for prioritizing high-trust providers). |
| `total_reviews` | number | Number of reviews on the business listing for context and scoring. |
| `scrape_status` | string | Tells you whether the scraping succeeded, failed, or had no website (`success`, `failed`, `no_website`, `error`). |
| `email_found` | string | The specific email value stored on each flattened row (one row per email when available). |

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

***

### Why Adult Care Nurse Practitioner Email Scraper?

There are a lot of ways to pull healthcare provider contact data from the web — here’s what sets **Adult Care Nurse Practitioner email scraper** leads apart.

#### Purpose-built for adult care provider outreach

This **adult care NP lead generation** workflow targets businesses using your adult care nurse practitioner search term, then focuses on extracting usable contact information for outreach and enrichment.

#### Clean, outreach-ready lead rows

The actor produces structured output fields like `website`, `full_address`, `scraped_emails`, and `email_found`, so you can drop results directly into your lead pipeline without building custom joins.

#### Built-in robustness for real-world sites

Website scraping includes resiliency (with configuration options like `max_pages`) and supports proxy configuration for more reliable large-scale runs—useful when building a nurse practitioner directory email scraper at scale.

#### Multiple cities, controlled volume

You can run across multiple locations, cap results with `maxBusinesses`, and choose whether to limit per location or overall—ideal when you want predictable list sizes for your nurse practitioner contact list scraper.

***

### Configuring Your Run

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

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

#### Input Fields

| Parameter | Required | What It Does |
|---|---|---|
| `googleMapsSearchTerm` | ✅ | The business type or niche you want to search for when building your adult gerontology nurse practitioner email finder list. |
| `googleMapsLocation` | ✅ | One or more geographic locations to search in (for example, “New York”). |
| `maxBusinesses` | ⬜ | Sets the target number of businesses to find (1–1000). The run stops when the target is reached. |
| `scrapeMaxBusinessesPerLocation` | ⬜ | If enabled, the actor targets up to `maxBusinesses` results per location. If disabled, it combines locations into a single overall total limit. |
| `proxyConfiguration` | ⬜ | Proxy settings for scraping. Recommended for larger-scale runs to help avoid IP blocks and rate limits. |
| ↳ `proxy support` | ⬜ | Enables Apify Proxy for the run (pre-filled as `true`). |

***

### Core Capabilities

#### Provider list discovery across locations

Use `googleMapsSearchTerm` and `googleMapsLocation` to build your **healthcare provider email scraper** seed list across multiple cities, then enrich each business from its website.

#### Email, phone, and social extraction

For each business with a website, it extracts `scraped_emails`, `scraped_phones`, and `scraped_social_media`, turning your adult care clinic nurse email database into a contact-rich dataset for outreach.

#### Controlled scraping depth per site

The website phase uses `max_pages` from the actor’s internal scraping configuration (driven by the input field `maxPagesPerSite` in the main flow), so you can balance completeness vs. speed for your APRNs email scraping software workflow.

#### Resilient processing and status visibility

Each business row includes `scrape_status` (for example `success`, `failed`, `no_website`, or `error`) plus error context fields when applicable, so analysts can understand coverage and data quality immediately.

#### Deduplicated, targeted output volume

The actor keeps unique business entries using `place_id` and respects `maxBusinesses` limits, making it practical for controlled prospecting and predictable list building.

***

### Who Gets the Most Out of This

Here’s how different teams put **Adult Care Nurse Practitioner Email Scraper** to work:

**Sales Development Reps** can quickly build a provider email list for outreach by generating a nurse practitioner contact list scraper dataset that includes `email_found`, `website`, and location fields they can sync into their CRM.

**Healthcare marketers** can generate targeted leads for adult care NP lead generation by filtering results by city/state and prioritizing higher-rated businesses using `avg_rating` and `total_reviews`.

**Clinic administrators and researchers** can use the output for post-acute care nurse practitioner email and home health nurse practitioner email scraper research, enriching records with scraped phone numbers and social links.

**Automation and data engineering specialists** can integrate results into pipelines via the Apify API, using consistent fields like `full_address`, `place_id`, and flattened `email_found` rows for reliable downstream processing.

**Recruiters and talent teams** can build advanced practice registered nurse email scraper lists without manual browsing, then segment by geography for faster outreach campaigns.

***

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

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

1. **Open the actor on Apify** — visit [console.apify.com](https://console.apify.com) and open the *Adult Care Nurse Practitioner Email Scraper* actor.
2. **Enter your inputs** — set `googleMapsSearchTerm` and `googleMapsLocation`, then adjust `maxBusinesses` and `scrapeMaxBusinessesPerLocation` if you want tighter control.
3. **Configure proxy settings** — enable `proxyConfiguration` (such as Apify Proxy) for more reliable scraping on larger runs.
4. **Hit Run and watch the live log** — follow progress as businesses are discovered and websites are processed.
5. **View results in the dataset tab** — check the live dataset table with fields like `scrape_status`, `emails_found`, and `email_found`.
6. **Export as JSON, CSV, or Excel** — download your dataset from the Apify dashboard in your preferred format.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

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

You can export your results in **JSON**, **CSV**, or **Excel** from the Apify dataset tab. This makes it easy to feed a healthcare provider email scraper list into spreadsheets, CRMs, or BI tools.

For automation, you can connect runs using **Apify API** (programmatically pull results) and **webhooks** for downstream actions when a run completes. If you prefer no-code, use **Zapier** or **Make** to push the output wherever your team works—check Apify docs for details on API, webhooks, and integrations.

***

### Pricing & Free Trial

**Adult Care Nurse Practitioner Email Scraper** runs on the Apify platform, which offers a **free tier** — no credit card required to get started. After that, usage is typically pay-as-you-go based on Apify platform compute units (CU), so you can scale up when your adult care NP lead generation needs grow.

For exact limits, credits, and plan options, always refer to the Apify pricing page. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate limiting protection | Built-in proxy support for reliable scraping. |
| Large runs stability | Proxy configuration is supported to help maintain throughput. |
| Output clarity | Every row includes `scrape_status` plus counts like `emails_found` and `pages_scraped`. |
| Data freshness | Results are scraped during the run, and the dataset is written as the actor progresses. |
| Error visibility | Failed sites are captured with `scrape_status: "failed"` (and `scrape_error` when present). |

**Limitations:** This actor works from publicly available business data and extracts contacts from the websites it can reach during the run. If a business has no accessible website or no contact info on-page, you may see `scrape_status: "no_website"` or empty extracted arrays.

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 with usage credits so you can run the **Adult Care Nurse Practitioner Email Scraper** and validate results before scaling.

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

No. The actor is designed to scrape publicly available business and website information, so you don’t need special login credentials for the run.

#### How accurate is the data?

Accuracy depends on what the business publishes on its website. The actor extracts emails, phone numbers, and social links it can find on reachable public pages and surfaces counts like `emails_found` and `pages_scraped`.

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

You can control volume using `maxBusinesses` (1–1000). If you set `scrapeMaxBusinessesPerLocation` to `true`, the actor targets up to `maxBusinesses` per location; otherwise it enforces a single combined total limit across locations.

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

Data is collected during each run, so freshness reflects when you launch the actor. If you need updated nurse practitioner directory email scraper lists, run it again on your schedule.

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

The actor works with **publicly available data** and extracts contact details from websites it can access during the run. You’re responsible for ensuring your use complies with GDPR, CCPA, and applicable laws and platform terms.

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

Yes. You can export from the Apify dataset tab as JSON, CSV, or Excel, then import into Google Sheets or any compatible spreadsheet tool.

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

Yes. You can schedule Apify actor runs to run automatically (for example, recurring lead refreshes) using Apify scheduling features.

#### Can I access this via API?

Yes. You can trigger and retrieve run results programmatically via the Apify API (see Apify developer documentation).

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

For individual businesses where website scraping fails, the output includes `scrape_status` such as `failed` (and `scrape_error` when provided), while successful records still appear in the dataset so you keep partial progress.

***

### Need Help or Have a Request?

Got a question about **Adult Care Nurse Practitioner Email Scraper** or want a new feature added? Reach out at <dataforleads@gmail.com>. We respond quickly and actively maintain this actor based on user feedback—ideas like batch CSV upload and webhook notifications on completion are especially welcome.

***

### Disclaimer & Responsible Use

*Adult Care Nurse Practitioner Email Scraper is the fastest, most reliable way to build outreach-ready provider contact lists — start your free run today.*

This actor collects **publicly available data** and extracts contact details from websites that are publicly accessible during the run. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform terms, and applicable local regulations when using the data. 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": "Adult Care Nurse Practitioner",
  "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": "Adult Care Nurse Practitioner",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Adult Care Nurse Practitioner Email Scraper",
        "description": "📧 Adult Care Nurse Practitioner Email Scraper extracts verified NP contact emails for adult care providers. ✅ Accurate, privacy-friendly data for outreach, lead gen, and recruitment. 🚀 Perfect for healthcare marketing and staffing teams.",
        "version": "1.0",
        "x-build-id": "xeuHafxrIIoFlJQMJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~adult-care-nurse-practitioner-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-adult-care-nurse-practitioner-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~adult-care-nurse-practitioner-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-adult-care-nurse-practitioner-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~adult-care-nurse-practitioner-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-adult-care-nurse-practitioner-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": "Adult Care Nurse Practitioner"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
