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

🚀 Acute Care Nurse Practitioners Email Scraper helps you quickly find verified email leads for NP professionals in acute care—ideal for healthcare sales, recruiting, and outreach. 🔎📩 Save time, boost accuracy, and reach the right contacts faster.

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

## Pricing

from $2.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### Acute Care Nurse Practitioners Email Scraper 📬

**Acute Care Nurse Practitioners Email Scraper** helps you build an outreach-ready contact list by searching for acute care nurse practitioners business listings and extracting their contact information (including **emails, phone numbers, and social media profiles**). If you’re looking for an **acute care nurse practitioner email scraper** or a **healthcare email scraper for NP** to speed up lead sourcing, this actor is designed for you—whether you’re a marketer, researcher, or data analyst. It automates the workflow of finding relevant providers at scale and turning publicly available data into structured results you can use right away.  

---

### Why choose Acute Care Nurse Practitioners Email Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ **All-in-one contact extraction** | Collect emails, phone numbers, and social media profiles in one run per business |
| ✅ **Reliability-focused scraping** | Uses built-in proxy support for more consistent data collection at scale |
| ✅ **Resilient website scraping pipeline** | Includes fallbacks when websites are missing and supports skipping failed/empty results based on your settings |
| ✅ **Structured dataset output** | Saves results into a consistent dataset schema ready for exporting and analysis |
| ✅ **Scales across multiple locations** | Supports multiple `googleMapsLocation` entries and combines or splits output depending on your limit strategy |
| ✅ **Proxy configuration support** | Lets you configure `proxyConfiguration` for more stable execution |

---

### Key features

- 🔍 **Acute care NP focused discovery**: Uses your `googleMapsSearchTerm` and `googleMapsLocation` inputs to target the right business listings.
- 🌐 **Website-based contact harvesting**: Extracts contact info from business websites and stores it in the dataset.
- 📧 **Email extraction with email filtering options**: Supports email-only behavior so you can focus on businesses that actually yield emails.
- 📞 **Phone extraction**: Captures phone numbers (when available) alongside scraped emails.
- 🔗 **Social media extraction**: Collects social media profile links for fuller outreach targeting.
- 🛡️ **Proxy configuration support**: `proxyConfiguration` is available to help maintain scraping stability (especially for larger batches).
- 💾 **Real-time dataset saving**: Pushes results to the Apify dataset immediately as it finds them.
- 📊 **Built for marketing and research workflows**: Outputs a table-ready schema including addresses, coordinates, and scrape status.

---

### Input

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

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

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `googleMapsSearchTerm` | Yes | Enter the business type or niche for the email scraper (prefilled with **Acute Care Nurse Practitioners**). |
| `googleMapsLocation` | Yes | Target geographic location(s) for the email scraper (for example, `["Miami, Florida"]` or `["New York"]`). |
| `maxBusinesses` | No | Target number of businesses to find (allowed range: **1–1000**). The scraper stops when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | No | If `true`, it collects up to `maxBusinesses` results per location. If `false`, it combines all locations up to a single total limit. |
| `proxyConfiguration` | No | Proxy settings for scraping. Recommended for larger-scale scraping. Use your preferred proxy setup here (the example shows `proxy support`). |

> Note: The actor always enables phone and social extraction by default, and it also supports email validation via the website scraping step (configurable internally based on input).

***

### Output

The actor saves each result into the Apify dataset as JSON rows following the dataset schema “Business Contact Data”.

```json
[
  {
    "name": "Example Clinic",
    "website": "https://example.com",
    "phone": "+1-555-123-4567",
    "full_address": "123 Example St New York NY 10001 US",
    "city": "New York",
    "state": "NY",
    "zip": "10001",
    "country_code": "US",
    "scraped_emails": ["contact@example.com"],
    "scraped_phones": ["+1-555-987-6543"],
    "scraped_social_media": ["https://www.linkedin.com/company/example"],
    "emails_found": 1,
    "pages_scraped": 6,
    "avg_rating": 4.5,
    "total_reviews": 120,
    "lat": 40.7128,
    "long": -74.006,
    "place_id": "ChIJN1t_tDeuEmsRUsoyG83frY4",
    "scrape_status": "success"
  }
]
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `name` | string | Business name from the listings stage. |
| `website` | string | Website URL associated with the business. |
| `phone` | string | Phone value from the listing (if present). |
| `full_address` | string | Combined full address string built from address parts. |
| `city` | string | City extracted for the business. |
| `state` | string | State extracted for the business. |
| `zip` | string | Postal/ZIP code extracted for the business. |
| `country_code` | string | Country code extracted for the business. |
| `scraped_emails` | array | Emails scraped from the business website(s). |
| `scraped_phones` | array | Phone numbers extracted from the business website(s). |
| `scraped_social_media` | array | Social media profile links extracted from the business website(s). |
| `emails_found` | number | Count of scraped emails found for the business. |
| `pages_scraped` | number | How many pages were processed as part of the website scraping step. |
| `avg_rating` | number | Average rating from the listings stage. |
| `total_reviews` | number | Total number of reviews from the listings stage. |
| `lat` | number | Latitude coordinate associated with the business listing. |
| `long` | number | Longitude coordinate associated with the business listing. |
| `place_id` | string | Listing place identifier used for uniqueness. |
| `scrape_status` | string | Status of the scrape (for example: `success`, `failed`, `no_website`, or `error`). |

You can export the dataset from Apify Console in common formats (such as JSON or CSV) depending on your workflow.

***

### How to use Acute Care Nurse Practitioners Email Scraper (via Apify Console)

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

2. **Find this actor**\
   Search for **Acute Care Nurse Practitioners Email Scraper** in the marketplace and open its page.

3. **Go to the INPUT section**\
   Use the built-in form (or paste an `input.json`) with:
   - `googleMapsSearchTerm` (defaults to **Acute Care Nurse Practitioners**)
   - one or more values in `googleMapsLocation`

4. **Set your limits**\
   Choose `maxBusinesses` and decide whether you want `scrapeMaxBusinessesPerLocation` enabled to control whether the limit applies per location or globally.

5. **(Optional) Configure proxy settings**\
   In **proxyConfiguration**, keep `proxy support` enabled for larger batches if you want more stable scraping.

6. **Run the actor**\
   Click **Run** to start. You’ll see progress in the logs as it searches for businesses and then scrapes their websites for contact info.

7. **Check the OUTPUT dataset**\
   After the run completes, open the dataset **Business Contact Data** to review rows (including `scraped_emails`, `scraped_phones`, and `scraped_social_media`).

8. **Export your results**\
   Export the dataset to your preferred format (JSON/CSV) and import it into your CRM, spreadsheet, or analytics pipeline.

No coding required — get an acute care NP contact database ready for outreach in minutes.

***

### Advanced features & SEO optimization

- 🚦 **Email-only focus for outreach**: When email-only behavior is enabled, the actor is designed to prioritize saving businesses that actually have emails, which improves list quality for an acute care NP email contact database.
- 🧠 **Location-aware scraping**: Supports multiple `googleMapsLocation` entries and either applies limits per location or globally, depending on `scrapeMaxBusinessesPerLocation`.
- 🛡️ **Stability at scale**: Built-in proxy configuration support helps reduce the chances of interruptions while scraping medical provider contact data.
- 💾 **Dataset-ready structure**: The output schema includes address parts and geocoordinates (`lat`, `long`) so you can segment inpatient acute care NP email addresses by region.
- 🔍 **Keyword-driven targeting**: Uses `googleMapsSearchTerm` to align results with your nurse practitioner marketing contact email goals, including variations like urgent care nurse practitioner outreach or critical care nurse practitioner lists.

***

### Best use cases

- 📈 **Lead generation for nurse practitioner outreach**: Build targeted nurse practitioner email list scraping for campaigns with consistent fields for importing into outreach tools.
- 🏥 **Hospital marketing contact research**: Rapidly compile hospital nurse practitioner email scraping results with websites, phone numbers, and social links.
- 🔬 **Healthcare data analysis**: Analyze provider density and distribution using `city`, `state`, and `lat`/`long` fields alongside emails found.
- ✉️ **Email marketing list enrichment**: Use the healthcare email scraper for NP workflows to enrich APRN email scraper contact list segments.
- 🧾 **Agency prospecting for advanced practice registered nurse outreach**: Assemble a structured acute care provider email finder dataset for multiple locations and consistent schema.
- 🧑‍⚕️ **Role-based targeting for practice sales**: Use extracted contact data to support targeted messaging across inpatient acute care NP email addresses and related segments.
- 💻 **Developer pipeline ingestion**: Pull results programmatically from the Apify dataset into a data warehouse or CRM integration for ongoing contact data refresh.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `googleMapsLocation`: array of strings (required)
  - ✅ `googleMapsSearchTerm`: string (required)
  - ✅ `maxBusinesses`: integer (optional, range **1–1000**)
  - ✅ `scrapeMaxBusinessesPerLocation`: boolean (optional)
  - ✅ `proxyConfiguration`: object (optional)

- **Proxy Support**
  - ✅ `proxyConfiguration` with `proxy support` (recommended for larger-scale scraping)

- **Dataset Structure**
  - ✅ One dataset: **Business Contact Data**
  - ✅ Fields include `name`, `website`, `scraped_emails`, `emails_found`, `pages_scraped`, `avg_rating`, `total_reviews`, `lat`, `long`, `place_id`, and `scrape_status`

- **Retry Mechanism**
  - ✅ Includes resilience in the scraping workflow (configured internally for reliability)

- **Rate Limits & Performance**
  - ✅ Designed to run across multiple businesses and locations using controlled concurrent scraping of websites

- **Limitations**
  - ❌ If a business has no website available, it cannot scrape website-based contacts; the output will reflect this via `scrape_status` (for example, `no_website`).
  - ❌ Output quality depends on the availability and accessibility of publicly available contact information on business websites.

***

### FAQ

#### ✅ Does Acute Care Nurse Practitioners Email Scraper only save businesses with emails?

If email-only behavior is enabled, the actor prioritizes saving businesses that yield scraped emails. Otherwise, it can also push a business record even when no emails are found (with email fields empty/blank and `scrape_status` indicating the outcome).

#### ❌ Do I need to write any code to use this actor?

No. You can run **Acute Care Nurse Practitioners Email Scraper** directly from Apify Console by providing the `input.json` fields (like `googleMapsLocation` and `googleMapsSearchTerm`) and then exporting the dataset.

#### 💻 What fields does the dataset include?

The dataset “Business Contact Data” includes fields such as `name`, `website`, `phone`, `full_address`, `city`, `state`, `zip`, `country_code`, `scraped_emails`, `scraped_phones`, `scraped_social_media`, `emails_found`, `pages_scraped`, `avg_rating`, `total_reviews`, `lat`, `long`, `place_id`, and `scrape_status`.

#### 🌐 What contact data does it extract?

It extracts emails (stored in `scraped_emails`) and can also extract `scraped_phones` and `scraped_social_media` from business websites. The listing-stage `phone` and business address fields are also included.

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

Yes. You can pass multiple entries in `googleMapsLocation`. Use `scrapeMaxBusinessesPerLocation` to control whether the `maxBusinesses` limit applies per location or globally.

#### 🛡️ Do I need proxies?

You don’t have to, but the actor supports `proxyConfiguration` (including `proxy support`) which is recommended for more stable scraping when running larger jobs—especially for nurse practitioner marketing contact email list scraping.

#### 🔎 Is there an email validation option?

The website scraping step includes an email validation toggle. In the code, `validate_emails` is controlled internally based on input (`validate_emails = actor_input.get('validateEmails', False)`), so you can enable validation when appropriate.

#### ⚖️ How should I use the scraped data?

✅ You should use the results responsibly and in compliance with applicable privacy laws and platform/website terms. The actor collects information from publicly available sources, but your compliance obligations (such as GDPR/CCPA and spam rules) are your responsibility.

***

### Support & feature requests

If you’re using **Acute Care Nurse Practitioners Email Scraper** for nurse practitioner email list scraping and want improvements, we’d love to hear what would make your workflow better.

- 💡 **Feature Requests**: Examples include stronger export options, additional deduplication controls, or CRM-ready field formatting.
- 📧 **Contact**: Email us at <dataforleads@gmail.com>

Your feedback helps shape the roadmap for this acute care NP contact database scraping tool.

***

### *Acute Care Nurse Practitioners Email Scraper* — final thoughts

*If you want the most comprehensive acute care nurse practitioner email scraper workflow—without manual searching—this one is built to help you move fast while keeping results structured and export-friendly.*

Get started with the **Acute Care Nurse Practitioners Email Scraper** and build your next outreach list at scale. 🚀

***

### Disclaimer

This tool **only accesses publicly accessible sources**. It does not access private profiles, authenticated data, or password-protected pages.

Using this actor for healthcare-related outreach may involve privacy and compliance obligations (for example, GDPR/CCPA and spam regulations) and you are responsible for ensuring your usage complies with applicable laws and the terms of service of the websites you access.

For data removal requests, contact <dataforleads@gmail.com>. Please use this tool 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": "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("solid-scraper/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("solid-scraper/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 solid-scraper/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=solid-scraper/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 helps you quickly find verified email leads for NP professionals in acute care—ideal for healthcare sales, recruiting, and outreach. 🔎📩 Save time, boost accuracy, and reach the right contacts faster.",
        "version": "1.0",
        "x-build-id": "lqYYcdaDiAHd4huDk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~acute-care-nurse-practitioners-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-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/solid-scraper~acute-care-nurse-practitioners-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-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/solid-scraper~acute-care-nurse-practitioners-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
