# Virginia Physician License Verification Scraper (`crawlerbros/virginia-physician-license-scraper`) Actor

Verify physician, osteopathic physician, physician assistant, podiatrist, and chiropractor licenses issued by the Virginia Department of Health Professions (DHP) Board of Medicine. Search by name or look up an exact license number.

- **URL**: https://apify.com/crawlerbros/virginia-physician-license-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Integrations, Other
- **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 Physician License Verification Scraper

Verify **physician, osteopathic physician, physician assistant, podiatrist, and
chiropractor** licenses issued by the **Virginia Department of Health Professions
(DHP)**, Board of Medicine. 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)
- **Ten Board of Medicine occupation types:** Medicine (MD), Osteopathic Medicine
  (DO), Podiatry, Chiropractor, Physician Assistant, Interns & Residents, University
  Limited License, Permitted Physician, Physician Selling Controlled Substances
  (and its facility permit) — search one, search a **custom subset** (e.g. MD + DO
  only) via `occupations`, 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")
- **Full record:** license number, occupation, name, city/state/ZIP, 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. `Medicine`, `Osteopathic Medicine`, `Physician Assistant`
- `fullName`
- `address` — raw mailing address line as published by DHP (e.g. `Richmond, VA 23219`)
- `city`, `state`, `zipCode` — parsed from `address` (licensee's mailing address on file, may be outside Virginia)
- `initialLicenseDate`, `expireDate` — ISO dates
- `licenseStatus` — raw status text as published by DHP
- `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: "physicianLicense"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byLicenseNumber` |
| `lastName` | string | `Smith` | Licensee last name (mode=search; required unless `zipCode` given) |
| `firstName` | string | – | Licensee first name (mode=search) |
| `zipCode` | string | – | Licensee mailing ZIP (mode=search; required unless `lastName` given) |
| `occupation` | string | `Medicine` | One Board of Medicine occupation, or "Any" (mode=search) |
| `occupations` | array | – | Custom subset of two or more occupation types; overrides `occupation` when set (mode=search) |
| `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 | `["0101058086"]` | License numbers to verify (mode=byLicenseNumber) |
| `maxItems` | int | `20` | Hard cap on emitted records (1–300) |

### Examples

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

```json
{
  "mode": "search",
  "lastName": "Smith",
  "maxItems": 20
}
````

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

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

#### Example: exact license number lookup

```json
{
  "mode": "byLicenseNumber",
  "licenseNumbers": ["0101058086", "0102012345"]
}
```

#### Example: custom occupation subset (MD + DO only)

```json
{
  "mode": "search",
  "lastName": "Lee",
  "firstName": "David",
  "occupations": ["101", "102"],
  "maxItems": 20
}
```

#### Example: active osteopathic physicians in a ZIP code

```json
{
  "mode": "search",
  "zipCode": "23451",
  "occupation": "102",
  "licenseStatus": "current",
  "maxItems": 50
}
```

### Use cases

- **Credentialing & primary source verification** — confirm a physician's license
  is current before onboarding, matching Joint Commission primary-source
  verification requirements
- **Healthcare compliance & KYC** — screen providers for disciplinary flags before
  contracting
- **Telehealth & staffing platforms** — bulk-verify provider licenses across a roster
- **Patient safety research & journalism** — check license status and public
  disciplinary history for accountability reporting
- **Insurance & credentialing vendors** — automate license re-verification cycles

### 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 physicians who practice in Virginia (some of whom live out of state).
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 other states' medical boards.

**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.

### 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 physician — 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 Medicine 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 physician
  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.
- **No city or county search field exists upstream.** The License Lookup form
  only offers State (dropdown) and ZIP code as geographic filters — there is no
  separate city/county input on the live form to expose. `city` in the output
  is parsed from the licensee's mailing address, not searchable as an input.
- **No sort options exist on the results listing.** DHP's search-results table
  has plain (non-sortable) column headers; results come back in whatever order
  the database returns them, so this actor does not offer a `sortBy` input.
- **Board disciplinary case decisions (notices/orders) are not fetched as
  structured data.** When DHP has additional public information on a
  licensee, the "Yes" link on the detail page (`additionalPublicInformationUrl`)
  points to a *separate* legacy system at `dhp.virginia.gov/enforcement/cdecision/`
  (classic ASP, not the `dhp.virginiainteractive.org` site this actor scrapes).
  Verified live: the initial disclaimer page loads (200), but submitting it
  consistently returns `500 Internal Server Error` from DHP's own server —
  the endpoint itself is broken, not merely gated. This actor still surfaces
  the link exactly as DHP publishes it so users can try it manually; it does
  not attempt to scrape structured case content from it.
- DHP's homepage also advertises three **paid, subscription/login-gated**
  services — bulk "License Verification" ($95/user/year), a "License Database
  Download" (per-record fee), and "Case Decision Notification" emails
  ($200–500/user/year). None of these are exposed here; they require an
  account and payment, which conflicts with this actor's zero-cost,
  no-login design.

# Actor input Schema

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

What to search.

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

(mode=search) Licensee last name (or business 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 Medicine occupation type. Leave as "Any" to search across all physician-related occupations (issues one request per occupation).

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

(mode=search) Search a specific custom subset of two or more Board of Medicine occupation types in one run (e.g. MD + DO only, or PA + Podiatry 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": "Smith",
  "firstName": "John",
  "occupation": "101",
  "occupations": [],
  "addressState": "",
  "licenseStatus": "any",
  "licenseNumbers": [
    "0101058086"
  ],
  "maxItems": 20
}
```

# Actor output Schema

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

Dataset containing all scraped Virginia DHP physician 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": "Smith",
    "firstName": "John",
    "occupation": "101",
    "occupations": [],
    "addressState": "",
    "licenseStatus": "any",
    "licenseNumbers": [
        "0101058086"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/virginia-physician-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": "Smith",
    "firstName": "John",
    "occupation": "101",
    "occupations": [],
    "addressState": "",
    "licenseStatus": "any",
    "licenseNumbers": ["0101058086"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/virginia-physician-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": "Smith",
  "firstName": "John",
  "occupation": "101",
  "occupations": [],
  "addressState": "",
  "licenseStatus": "any",
  "licenseNumbers": [
    "0101058086"
  ],
  "maxItems": 20
}' |
apify call crawlerbros/virginia-physician-license-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Virginia Physician License Verification Scraper",
        "description": "Verify physician, osteopathic physician, physician assistant, podiatrist, and chiropractor licenses issued by the Virginia Department of Health Professions (DHP) Board of Medicine. Search by name or look up an exact license number.",
        "version": "1.0",
        "x-build-id": "n9r13Q8Q13nzBEgLU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~virginia-physician-license-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-virginia-physician-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-physician-license-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-virginia-physician-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-physician-license-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-virginia-physician-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 (or business name). Required unless zipCode is given.",
                        "default": "Smith"
                    },
                    "firstName": {
                        "title": "First name",
                        "type": "string",
                        "description": "(mode=search) Licensee first name. Optional, narrows results.",
                        "default": "John"
                    },
                    "zipCode": {
                        "title": "ZIP code",
                        "type": "string",
                        "description": "(mode=search) Licensee mailing ZIP code. Required unless lastName is given."
                    },
                    "occupation": {
                        "title": "Occupation",
                        "enum": [
                            "any",
                            "101",
                            "102",
                            "103",
                            "104",
                            "110",
                            "116",
                            "109",
                            "205",
                            "213",
                            "224"
                        ],
                        "type": "string",
                        "description": "(mode=search) Restrict the search to one Board of Medicine occupation type. Leave as \"Any\" to search across all physician-related occupations (issues one request per occupation).",
                        "default": "101"
                    },
                    "occupations": {
                        "title": "Occupation types (multi-select)",
                        "type": "array",
                        "description": "(mode=search) Search a specific custom subset of two or more Board of Medicine occupation types in one run (e.g. MD + DO only, or PA + Podiatry 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": [
                                "101",
                                "102",
                                "103",
                                "104",
                                "110",
                                "116",
                                "109",
                                "205",
                                "213",
                                "224"
                            ],
                            "enumTitles": [
                                "Medicine (MD)",
                                "Osteopathic Medicine (DO)",
                                "Podiatry",
                                "Chiropractor",
                                "Physician Assistant",
                                "Interns & Residents",
                                "University Limited License",
                                "Permitted Physician",
                                "Physician Selling Controlled Substances",
                                "Physician Selling Controlled Substances Facility Permit"
                            ]
                        },
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
