# Virginia Nurse License Verification Scraper (`crawlerbros/virginia-nurse-license-scraper`) Actor

Verify registered nurse, licensed practical nurse, advanced practice registered nurse, nurse aide, and nursing home administrator licenses issued by the Virginia Department of Health Professions (DHP) Board of Nursing. Search by name or look up an exact license number.

- **URL**: https://apify.com/crawlerbros/virginia-nurse-license-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Agents, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Virginia Nurse License Verification Scraper

Verify **registered nurse, licensed practical nurse, advanced practice registered
nurse, nurse aide, and nursing home administrator** licenses issued by the
**Virginia Department of Health Professions (DHP)**, Board of Nursing. Search by
name and/or ZIP code, or look up an exact license number — straight from the
DHP's own public License Lookup tool (dhp.virginiainteractive.org). No login, no
API key, no proxy required.

### What this actor does

- **Two modes:** `search` (name / ZIP / occupation / status) and `byLicenseNumber`
  (exact license-number lookup, one or many)
- **Fourteen Board of Nursing occupation types:** Registered Nurse, Licensed
  Practical Nurse, Advanced Practice Registered Nurse, Clinical Nurse Specialist,
  Authorization to Prescribe, Nurse Aide, Advanced Certified Nurse Aide,
  Medication Aide, Nursing Home Administrator (and its in-training/preceptor
  variants), plus restricted-volunteer variants — search one at a time, pick a
  custom multi-select subset, or search across all of them at once
- **License status:** filter to current or expired licensees, or filter
  client-side by the exact status text on file (e.g. "Active", "Suspended",
  "Revoked", "Probation", "Expired-Compact" for multistate Nurse Licensure
  Compact licenses)
- **Full record:** license number, occupation, name, raw mailing address plus
  parsed city/state/ZIP, Nurse Licensure Compact designation (Multi-State
  Privilege vs. Valid Virginia Only, where published), initial license date,
  expiration date, current status, and whether DHP has additional public
  disciplinary information on file (with a link when available)
- **Empty fields are omitted** — a field only appears when DHP actually published
  that data for the licensee

### Output per license

- `licenseNumber` — 10-digit Virginia DHP license number
- `occupation` — e.g. `Registered Nurse`, `Licensed Practical Nurse`, `Nurse Aide`
- `specialization` — Nurse Licensure Compact designation ("Multi-State
  Privilege" or "Valid Virginia Only"), when DHP publishes one for the
  licensee's occupation (RN/LPN only; not shown for e.g. Nurse Aide)
- `fullName`
- `address` — raw mailing address string as published by DHP
- `city`, `state`, `zipCode` — parsed from `address` (may be outside Virginia)
- `initialLicenseDate`, `expireDate` — ISO dates
- `licenseStatus` — raw status text as published by DHP (includes Nurse
  Licensure Compact status where applicable)
- `hasAdditionalPublicInformation` — `true` when DHP must make additional
  disciplinary/administrative records available under Virginia Code §54.1-2400.2.H
- `additionalPublicInformationUrl` — link to that additional information, when provided
- `profileUrl` / `sourceUrl` — canonical DHP License Lookup detail page
- `recordType: "nurseLicense"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byLicenseNumber` |
| `lastName` | string | `Johnson` | Licensee last name (mode=search; required unless `zipCode` given) |
| `firstName` | string | `Mary` | Licensee first name (mode=search) |
| `zipCode` | string | – | Licensee mailing ZIP (mode=search; required unless `lastName` given) |
| `occupation` | string | `Registered Nurse` | One Board of Nursing occupation, or "Any" (mode=search) |
| `occupations` | array | – | Custom multi-select subset of occupations (mode=search); overrides `occupation` when non-empty |
| `addressState` | string | – | Filter by licensee's mailing-address US state (mode=search) |
| `licenseStatus` | string | `any` | `any` / `current` / `expired` (mode=search) |
| `statusContainsFilter` | string | – | Only emit records whose status text contains this (case-insensitive) |
| `licenseNumbers` | array | `["0001019704"]` | License numbers to verify (mode=byLicenseNumber) |
| `maxItems` | int | `20` | Hard cap on emitted records (1–300) |

### Examples

#### Example: search by last name (default occupation = Registered Nurse)

```json
{
  "mode": "search",
  "lastName": "Johnson",
  "firstName": "Mary",
  "maxItems": 20
}
````

#### Example: search across all nursing occupation types

```json
{
  "mode": "search",
  "lastName": "Patel",
  "occupation": "any",
  "maxItems": 50
}
```

#### Example: exact license number lookup

```json
{
  "mode": "byLicenseNumber",
  "licenseNumbers": ["0001019704", "0002012345"]
}
```

#### Example: current licensed practical nurses in a ZIP code

```json
{
  "mode": "search",
  "zipCode": "23219",
  "occupation": "2",
  "licenseStatus": "current",
  "maxItems": 50
}
```

#### Example: custom occupation subset (RN + LPN only)

```json
{
  "mode": "search",
  "lastName": "Williams",
  "firstName": "Mary",
  "occupations": ["1", "2"],
  "maxItems": 30
}
```

### Use cases

- **Credentialing & primary source verification** — confirm a nurse's license is
  current before onboarding, matching Joint Commission primary-source
  verification requirements
- **Staffing agencies & travel nursing platforms** — bulk-verify nurse licenses
  across a roster, including multistate Nurse Licensure Compact status
- **Healthcare compliance & KYC** — screen providers for disciplinary flags
  before contracting
- **Long-term care & nursing home operators** — verify nurse aide and nursing
  home administrator credentials
- **Patient safety research & journalism** — check license status and public
  disciplinary history for accountability reporting

### FAQ

**What is the data source?**
The Virginia Department of Health Professions' public License Lookup tool
(dhp.virginiainteractive.org/Lookup/Index). This actor is not affiliated with or
endorsed by DHP or the Commonwealth of Virginia.

**Is a login or API key required?**
No. DHP's License Lookup is fully public and free to use.

**Why did filtering `statusContainsFilter: "active"` also return an "Inactive" record?**
The filter is a plain case-insensitive substring match against the exact status text
DHP publishes, and "Inactive" contains the substring "active". Use a more specific
phrase (e.g. "Current Active") if you need to exclude Inactive records. Note this
filter also triggers a detail-page fetch per candidate (to read the real status
text), so searches using it take a little longer than the default summary search.

**Why does this only cover Virginia?**
DHP licenses nurses who practice in Virginia (some of whom live out of state
under the Nurse Licensure Compact). It is a single-state authoritative source,
the same scope as this repository's other state-licensing-board actors (e.g.
contractor and real estate license scrapers). It does not aggregate Nursys or
other states' boards of nursing.

**What does "Your search returned too many records" mean?**
DHP's own search caps very broad queries (e.g. a common surname with no other
filters). Add a first name, ZIP code, or narrow the occupation to get results
under that cap — this actor reports the condition via a clean status message
rather than guessing at a partial result set.

**Why do some license numbers in `byLicenseNumber` return nothing?**
DHP's lookup only returns unexpired records back to January 1, 2000, plus all
currently active records. A license expired before that date, or a mistyped
number, will return no match.

**How fresh is the data?**
Every run fetches live pages directly from dhp.virginiainteractive.org — DHP
itself refreshes the underlying data continuously ("Current as of" timestamp is
shown on every page). There is no caching in this actor.

**Why does `byLicenseNumber` with many numbers (or `statusContainsFilter`, which
fetches one detail page per candidate) sometimes take longer than expected?**
DHP occasionally gates its License Detail page behind a reCAPTCHA challenge
after several detail-page requests land close together on one session. This
actor detects that challenge page and backs off before retrying (rather than
reporting the license as not found), so detail-page-heavy runs (many license
numbers, or a name search combined with `statusContainsFilter`) are throttled
to one request at a time with a short delay between them. This trades a little
speed for reliability — every requested license is still resolved.

### Data Source / Limitations

- **For complete, reliable results, include a first name.** DHP's own backend
  applies stricter rate-limiting to broad "last name only" searches (no first
  name) from automated/cloud clients, which can return noticeably fewer
  records than the true total. Combining first name + last name (or an exact
  license number) — the natural way to verify one specific nurse — is not
  affected and returns complete, accurate results every time. If you need a
  broad roster of everyone with a given surname, run the search from a
  residential connection instead.
- Single-state scope (Virginia DHP, Board of Nursing occupations only).
- `licenseStatus` is free text exactly as published by DHP — it is not a fixed
  enum, since DHP does not publish an exhaustive list of every possible status.
- Looking up by license number returns whatever license is on file for that
  number, even if it belongs to an occupation outside this actor's nursing
  scope (DHP license numbers are shared across all professions it regulates).
- Addresses are mailing addresses only (city/state/ZIP) — DHP does not publish
  street addresses in the public lookup.
- DHP's site also offers a third search form (last 4 digits of SSN + last name).
  This actor does not expose it — the two modes above already cover every
  reliable name/ZIP/occupation/status and exact-license-number lookup path, and
  we intentionally avoid asking users to submit even partial SSN data.

# Actor input Schema

## `mode` (type: `string`):

What to search.

## `lastName` (type: `string`):

(mode=search) Licensee last name. Required unless zipCode is given.

## `firstName` (type: `string`):

(mode=search) Licensee first name. Optional, narrows results.

## `zipCode` (type: `string`):

(mode=search) Licensee mailing ZIP code. Required unless lastName is given.

## `occupation` (type: `string`):

(mode=search) Restrict the search to one Board of Nursing occupation type. Leave as "Any" to search across all nursing-related occupations (issues one request per occupation).

## `occupations` (type: `array`):

(mode=search) Search a specific custom subset of two or more Board of Nursing occupation types in one run (e.g. RN + LPN only, or Nurse Aide + Medication Aide only) -- issues one request per selected occupation. Overrides `occupation` when non-empty; leave empty to use the single `occupation` selection above.

## `addressState` (type: `string`):

(mode=search) Filter by the licensee's mailing address US state (licensees can live outside Virginia).

## `licenseStatus` (type: `string`):

(mode=search) Filter to current or expired licensees as recorded by DHP.

## `statusContainsFilter` (type: `string`):

Only emit records whose detail-page license status contains this text (case-insensitive), e.g. "Active", "Suspended", "Revoked", "Probation", "Compact". Applied client-side after fetching each record's detail page.

## `licenseNumbers` (type: `array`):

(mode=byLicenseNumber) One or more exact 10-digit Virginia DHP license numbers to verify directly.

## `maxItems` (type: `integer`):

Hard cap on emitted license records.

## Actor input object example

```json
{
  "mode": "search",
  "lastName": "Johnson",
  "firstName": "Mary",
  "occupation": "1",
  "occupations": [],
  "addressState": "",
  "licenseStatus": "any",
  "licenseNumbers": [
    "0001019704"
  ],
  "maxItems": 20
}
```

# Actor output Schema

## `licenses` (type: `string`):

Dataset containing all scraped Virginia DHP nurse license records.

# 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 = {
    "mode": "search",
    "lastName": "Johnson",
    "firstName": "Mary",
    "occupation": "1",
    "occupations": [],
    "addressState": "",
    "licenseStatus": "any",
    "licenseNumbers": [
        "0001019704"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/virginia-nurse-license-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 = {
    "mode": "search",
    "lastName": "Johnson",
    "firstName": "Mary",
    "occupation": "1",
    "occupations": [],
    "addressState": "",
    "licenseStatus": "any",
    "licenseNumbers": ["0001019704"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/virginia-nurse-license-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 '{
  "mode": "search",
  "lastName": "Johnson",
  "firstName": "Mary",
  "occupation": "1",
  "occupations": [],
  "addressState": "",
  "licenseStatus": "any",
  "licenseNumbers": [
    "0001019704"
  ],
  "maxItems": 20
}' |
apify call crawlerbros/virginia-nurse-license-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Virginia Nurse License Verification Scraper",
        "description": "Verify registered nurse, licensed practical nurse, advanced practice registered nurse, nurse aide, and nursing home administrator licenses issued by the Virginia Department of Health Professions (DHP) Board of Nursing. Search by name or look up an exact license number.",
        "version": "1.0",
        "x-build-id": "GfHhMjf0GUb2fauQ2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~virginia-nurse-license-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-virginia-nurse-license-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/crawlerbros~virginia-nurse-license-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-virginia-nurse-license-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/crawlerbros~virginia-nurse-license-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-virginia-nurse-license-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byLicenseNumber"
                        ],
                        "type": "string",
                        "description": "What to search.",
                        "default": "search"
                    },
                    "lastName": {
                        "title": "Last name",
                        "type": "string",
                        "description": "(mode=search) Licensee last name. Required unless zipCode is given.",
                        "default": "Johnson"
                    },
                    "firstName": {
                        "title": "First name",
                        "type": "string",
                        "description": "(mode=search) Licensee first name. Optional, narrows results.",
                        "default": "Mary"
                    },
                    "zipCode": {
                        "title": "ZIP code",
                        "type": "string",
                        "description": "(mode=search) Licensee mailing ZIP code. Required unless lastName is given."
                    },
                    "occupation": {
                        "title": "Occupation",
                        "enum": [
                            "any",
                            "1",
                            "2",
                            "24",
                            "15",
                            "17",
                            "32",
                            "33",
                            "34",
                            "1401",
                            "1403",
                            "31",
                            "1701",
                            "1732",
                            "1703"
                        ],
                        "type": "string",
                        "description": "(mode=search) Restrict the search to one Board of Nursing occupation type. Leave as \"Any\" to search across all nursing-related occupations (issues one request per occupation).",
                        "default": "1"
                    },
                    "occupations": {
                        "title": "Occupation types (multi-select)",
                        "type": "array",
                        "description": "(mode=search) Search a specific custom subset of two or more Board of Nursing occupation types in one run (e.g. RN + LPN only, or Nurse Aide + Medication Aide only) -- issues one request per selected occupation. Overrides `occupation` when non-empty; leave empty to use the single `occupation` selection above.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "24",
                                "15",
                                "17",
                                "32",
                                "33",
                                "34",
                                "1401",
                                "1403",
                                "31",
                                "1701",
                                "1732",
                                "1703"
                            ],
                            "enumTitles": [
                                "Registered Nurse (RN)",
                                "Licensed Practical Nurse (LPN)",
                                "Advanced Practice Registered Nurse (APRN)",
                                "Clinical Nurse Specialist",
                                "Authorization to Prescribe",
                                "Registered Nurse Restricted Volunteer",
                                "Licensed Practical Nurse Restricted Volunteer",
                                "Licensed Nurse Practitioner Restricted Volunteer",
                                "Nurse Aide (CNA)",
                                "Advanced Certified Nurse Aide",
                                "Medication Aide",
                                "Nursing Home Administrator",
                                "Nursing Home Administrator-In-Training",
                                "Nursing Home Preceptor"
                            ]
                        },
                        "default": []
                    },
                    "addressState": {
                        "title": "Mailing address state",
                        "enum": [
                            "",
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "DC",
                            "FL",
                            "GA",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NC",
                            "ND",
                            "OH",
                            "OK",
                            "OR",
                            "PA",
                            "RI",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY"
                        ],
                        "type": "string",
                        "description": "(mode=search) Filter by the licensee's mailing address US state (licensees can live outside Virginia).",
                        "default": ""
                    },
                    "licenseStatus": {
                        "title": "License status",
                        "enum": [
                            "any",
                            "current",
                            "expired"
                        ],
                        "type": "string",
                        "description": "(mode=search) Filter to current or expired licensees as recorded by DHP.",
                        "default": "any"
                    },
                    "statusContainsFilter": {
                        "title": "Filter by license status text",
                        "type": "string",
                        "description": "Only emit records whose detail-page license status contains this text (case-insensitive), e.g. \"Active\", \"Suspended\", \"Revoked\", \"Probation\", \"Compact\". Applied client-side after fetching each record's detail page."
                    },
                    "licenseNumbers": {
                        "title": "License numbers",
                        "type": "array",
                        "description": "(mode=byLicenseNumber) One or more exact 10-digit Virginia DHP license numbers to verify directly.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Hard cap on emitted license records.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
