# Pennsylvania PALS License Verification Scraper (`crawlerbros/pennsylvania-pals-license-search-scraper`) Actor

Search Pennsylvania's PALS (BPOA Portal) public professional license registry by name, license number, profession/board, or facility. No login required.

- **URL**: https://apify.com/crawlerbros/pennsylvania-pals-license-search-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Agents
- **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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Pennsylvania PALS License Verification Scraper

Scrape **PALS** (Pennsylvania Licensing System), the official public license-verification portal for Pennsylvania's Bureau of Professional and Occupational Affairs (BPOA). Search by licensee name, exact license number, profession/board, or facility/business name, and get licensee identity, license number, license type, profession, board, status, issue/expiration/renewal dates, address, and any disciplinary actions on file. No login required.

### What this actor does

- **Four search modes:** `byName`, `byLicenseNumber`, `byProfession`, `byFacility`
- **32 boards/professions covered** in one tool — Accountancy, Cosmetology, Engineers, Medicine, Nursing, Pharmacy, Physical Therapy, Real Estate Commission, Social Work, Veterinary Medicine, and more
- **Detail enrichment (optional):** issue date, expiration date, last renewal date, status-effective date, disciplinary actions, and related/sponsoring licenses
- **Filters:** license status, Pennsylvania county, US state, license-type keyword
- **Empty fields are omitted** — every record only contains fields PALS actually returned

### Output per license record

- `licenseeName` / `firstName`, `middleName`, `lastName` — for person records
- `facilityName` — for facility/business records
- `licenseNumber`
- `licenseType` — e.g. `Certified Public Accountant`, `Registered Nurse`
- `profession` — e.g. `Accountancy`, `Nursing`
- `board` — e.g. `State Board of Accountancy`
- `status` — `Active` / `Inactive` / `Expired` / `Null and Void`
- `statusCategory` — normalized: `active` / `inactive` / `expired` / `nullAndVoid`
- `statusEffectiveDate`, `issueDate`, `expirationDate`, `lastRenewalDate`, `nextRenewalDate`, `associationDate`
- `city`, `state`, `county`, `country`, `zip`, `streetAddress`, `fullAddress`
- `disciplinaryActions[]` — action description + complaint number, when on file
- `relatedLicenses[]` — sponsoring/associated licenses, when applicable
- `personId`, `licenseId` — PALS' own internal identifiers
- `sourceUrl` — the PALS search portal URL
- `recordType: "license"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byName` | `byName` / `byLicenseNumber` / `byProfession` / `byFacility` |
| `lastName` | string | `Smith` | Licensee last name (mode=byName) |
| `firstName` | string | – | First name (mode=byName) |
| `middleName` | string | – | Middle name (mode=byName) |
| `licenseNumber` | string | – | Exact license number (mode=byLicenseNumber) |
| `facilityName` | string | – | Business/facility name (mode=byFacility) |
| `facilityStreetAddress` | string | – | Street address (mode=byFacility) |
| `profession` | string | – | Board/profession code (mode=byProfession; optional filter otherwise) |
| `licenseType` | string | – | Free-text license-type keyword, matched against each result |
| `city` | string | – | City filter |
| `zip` | string | – | ZIP code filter |
| `county` | string | – | Pennsylvania county filter (67 counties) |
| `state` | string | – | US state filter (name/facility/profession searches also return out-of-state licensees) |
| `statusFilter` | string | `any` | `any` / `active` / `inactive` / `expired` / `nullAndVoid` |
| `fetchDetails` | boolean | `true` | Enrich each result with its full detail record |
| `maxItems` | int | `20` | Hard cap (1–200) |

#### Example: search by name

```json
{
  "mode": "byName",
  "lastName": "Smith",
  "maxItems": 25
}
````

#### Example: search by license number

```json
{
  "mode": "byLicenseNumber",
  "licenseNumber": "AA002213L"
}
```

#### Example: browse a profession/board

```json
{
  "mode": "byProfession",
  "profession": "27",
  "county": "Philadelphia",
  "statusFilter": "active",
  "maxItems": 50
}
```

#### Example: search by facility/business name

```json
{
  "mode": "byFacility",
  "facilityName": "Care",
  "maxItems": 20
}
```

### Use cases

- **Employment screening** — verify a professional's license status before hiring
- **Compliance teams** — bulk-check license status/expiration across a roster
- **Consumer protection** — confirm a contractor, cosmetologist, or real estate agent is actively licensed
- **Legal & HR due diligence** — pull disciplinary history for a licensee
- **Market research** — count active licensees by profession or county

### FAQ

**What is the data source?**
The Pennsylvania Department of State's PALS portal (pals.pa.gov), the official public license-verification system for the Bureau of Professional and Occupational Affairs. Data is public record, updated daily by the Commonwealth.

**Is this affiliated with the Pennsylvania Department of State?**
No. This is an independent third-party actor that uses PALS' public search feature.

**Why do some records have fewer fields than others?**
PALS only returns fields the licensee's profession/record type has data for. Facility records don't have a `licenseeName`; person records don't have a `facilityName`. Detail-only fields (dates, disciplinary actions) only appear when `fetchDetails` is enabled.

**Why isn't a phone number or email included?**
PALS' underlying API happens to include a licensee's phone/email in some responses, but this actor deliberately excludes them — they aren't part of license verification and bulk-exporting personal contact details isn't the intended use of a public license-lookup tool.

**Does this actor search disciplinary actions directly?**
PALS' UI offers a dedicated "Disciplinary" search radio button, but disciplinary records didn't return distinct results through PALS' public search endpoint during testing (it appears to require the logged-in staff portal). Disciplinary-action data is still available per-licensee via `disciplinaryActions[]` on any `byName`/`byLicenseNumber`/`byFacility`/`byProfession` result when `fetchDetails` is enabled.

**How fresh is the data?**
PALS states its database is updated on a daily basis directly from the Pennsylvania Licensing System.

**Can I search across all 32 professions at once?**
Yes — `byName`, `byLicenseNumber`, and `byFacility` search across every board by default. Use `profession` to narrow to one board, or `mode=byProfession` to browse a single board's full roster.

**What counts as "Null and Void" status?**
A PALS-specific status meaning the license was voided (distinct from Expired or Inactive) — usually due to non-renewal beyond the grace period or a formal revocation-adjacent action.

# Actor input Schema

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

How to search the PALS licensee registry.

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

Licensee last name. PALS name searches are starts-with matches, same as the official site. Leave empty to search by firstName alone. If mode=byName and every filter is left empty, the actor falls back to a demo name ("Smith") so the daily test run still returns data.

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

Optional first name to narrow a last-name search.

## `middleName` (type: `string`):

Optional middle name/initial to narrow a last-name search.

## `licenseNumber` (type: `string`):

Exact PALS license number, e.g. `AA002213L`.

## `facilityName` (type: `string`):

Search by facility, firm, or business name instead of an individual's name.

## `facilityStreetAddress` (type: `string`):

Optional street address to narrow a facility-name search.

## `profession` (type: `string`):

The PALS board/profession category. Required for mode=byProfession; optionally narrows byName/byFacility searches too.

## `licenseType` (type: `string`):

Free-text sub-type within the selected profession, e.g. `Certified Public Accountant`, `Real Estate Salesperson`, `Registered Nurse`. Matched case-insensitively against each result's license type. Only meaningful together with `profession`.

## `city` (type: `string`):

City filter, e.g. `Philadelphia`, `Pittsburgh`, `Erie`. Optional for byName / byFacility / byProfession.

## `zip` (type: `string`):

5-digit ZIP code filter. Optional for byName / byFacility / byProfession.

## `county` (type: `string`):

Filter results to a single Pennsylvania county (applied after search, since PALS also returns out-of-state licensees).

## `state` (type: `string`):

Filter results to a single US state (applied after search, since PALS' name/facility/profession searches also return out-of-state licensees holding a PA license).

## `statusFilter` (type: `string`):

Filter results by license status.

## `fetchDetails` (type: `boolean`):

Enrich each result with its detail record (issue date, expiration date, last renewal date, disciplinary actions, restrictions). Uses one extra request per result.

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

Hard cap on emitted license records.

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

Not needed in normal operation (pals.pa.gov is publicly reachable). Used automatically as a fallback only if the source starts blocking direct requests.

## Actor input object example

```json
{
  "mode": "byName",
  "lastName": "Smith",
  "profession": "",
  "county": "",
  "state": "",
  "statusFilter": "any",
  "fetchDetails": true,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped PALS 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": "byName",
    "lastName": "Smith",
    "profession": "",
    "county": "",
    "state": "",
    "statusFilter": "any",
    "fetchDetails": true,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/pennsylvania-pals-license-search-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": "byName",
    "lastName": "Smith",
    "profession": "",
    "county": "",
    "state": "",
    "statusFilter": "any",
    "fetchDetails": True,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/pennsylvania-pals-license-search-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": "byName",
  "lastName": "Smith",
  "profession": "",
  "county": "",
  "state": "",
  "statusFilter": "any",
  "fetchDetails": true,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/pennsylvania-pals-license-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pennsylvania PALS License Verification Scraper",
        "description": "Search Pennsylvania's PALS (BPOA Portal) public professional license registry by name, license number, profession/board, or facility. No login required.",
        "version": "1.0",
        "x-build-id": "qPYlUbalPmRKm4QBo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~pennsylvania-pals-license-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-pennsylvania-pals-license-search-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~pennsylvania-pals-license-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-pennsylvania-pals-license-search-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~pennsylvania-pals-license-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-pennsylvania-pals-license-search-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": "Search mode",
                        "enum": [
                            "byName",
                            "byLicenseNumber",
                            "byProfession",
                            "byFacility"
                        ],
                        "type": "string",
                        "description": "How to search the PALS licensee registry.",
                        "default": "byName"
                    },
                    "lastName": {
                        "title": "Last name (mode=byName)",
                        "type": "string",
                        "description": "Licensee last name. PALS name searches are starts-with matches, same as the official site. Leave empty to search by firstName alone. If mode=byName and every filter is left empty, the actor falls back to a demo name (\"Smith\") so the daily test run still returns data.",
                        "default": ""
                    },
                    "firstName": {
                        "title": "First name (mode=byName)",
                        "type": "string",
                        "description": "Optional first name to narrow a last-name search."
                    },
                    "middleName": {
                        "title": "Middle name (mode=byName)",
                        "type": "string",
                        "description": "Optional middle name/initial to narrow a last-name search."
                    },
                    "licenseNumber": {
                        "title": "License number (mode=byLicenseNumber)",
                        "type": "string",
                        "description": "Exact PALS license number, e.g. `AA002213L`."
                    },
                    "facilityName": {
                        "title": "Facility / business name (mode=byFacility)",
                        "type": "string",
                        "description": "Search by facility, firm, or business name instead of an individual's name."
                    },
                    "facilityStreetAddress": {
                        "title": "Facility street address (mode=byFacility, optional)",
                        "type": "string",
                        "description": "Optional street address to narrow a facility-name search."
                    },
                    "profession": {
                        "title": "Profession / board (mode=byProfession, optional filter otherwise)",
                        "enum": [
                            "",
                            "3",
                            "1",
                            "31",
                            "15",
                            "5",
                            "2",
                            "20",
                            "41",
                            "13",
                            "28",
                            "17",
                            "10",
                            "7",
                            "12",
                            "37",
                            "6",
                            "43",
                            "24",
                            "9",
                            "26",
                            "36",
                            "8",
                            "42",
                            "33",
                            "30",
                            "39",
                            "27",
                            "29",
                            "40",
                            "35",
                            "38",
                            "23"
                        ],
                        "type": "string",
                        "description": "The PALS board/profession category. Required for mode=byProfession; optionally narrows byName/byFacility searches too.",
                        "default": ""
                    },
                    "licenseType": {
                        "title": "License type within profession (optional)",
                        "type": "string",
                        "description": "Free-text sub-type within the selected profession, e.g. `Certified Public Accountant`, `Real Estate Salesperson`, `Registered Nurse`. Matched case-insensitively against each result's license type. Only meaningful together with `profession`."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City filter, e.g. `Philadelphia`, `Pittsburgh`, `Erie`. Optional for byName / byFacility / byProfession."
                    },
                    "zip": {
                        "title": "ZIP code",
                        "type": "string",
                        "description": "5-digit ZIP code filter. Optional for byName / byFacility / byProfession."
                    },
                    "county": {
                        "title": "Pennsylvania county",
                        "enum": [
                            "",
                            "Adams",
                            "Allegheny",
                            "Armstrong",
                            "Beaver",
                            "Bedford",
                            "Berks",
                            "Blair",
                            "Bradford",
                            "Bucks",
                            "Butler",
                            "Cambria",
                            "Cameron",
                            "Carbon",
                            "Centre",
                            "Chester",
                            "Clarion",
                            "Clearfield",
                            "Clinton",
                            "Columbia",
                            "Crawford",
                            "Cumberland",
                            "Dauphin",
                            "Delaware",
                            "Elk",
                            "Erie",
                            "Fayette",
                            "Forest",
                            "Franklin",
                            "Fulton",
                            "Greene",
                            "Huntingdon",
                            "Indiana",
                            "Jefferson",
                            "Juniata",
                            "Lackawanna",
                            "Lancaster",
                            "Lawrence",
                            "Lebanon",
                            "Lehigh",
                            "Luzerne",
                            "Lycoming",
                            "McKean",
                            "Mercer",
                            "Mifflin",
                            "Monroe",
                            "Montgomery",
                            "Montour",
                            "Northampton",
                            "Northumberland",
                            "Perry",
                            "Philadelphia",
                            "Pike",
                            "Potter",
                            "Schuylkill",
                            "Snyder",
                            "Somerset",
                            "Sullivan",
                            "Susquehanna",
                            "Tioga",
                            "Union",
                            "Venango",
                            "Warren",
                            "Washington",
                            "Wayne",
                            "Westmoreland",
                            "Wyoming",
                            "York"
                        ],
                        "type": "string",
                        "description": "Filter results to a single Pennsylvania county (applied after search, since PALS also returns out-of-state licensees).",
                        "default": ""
                    },
                    "state": {
                        "title": "State",
                        "enum": [
                            "",
                            "Alabama",
                            "Alaska",
                            "Arizona",
                            "Arkansas",
                            "California",
                            "Colorado",
                            "Connecticut",
                            "Delaware",
                            "District of Columbia",
                            "Florida",
                            "Georgia",
                            "Hawaii",
                            "Idaho",
                            "Illinois",
                            "Indiana",
                            "Iowa",
                            "Kansas",
                            "Kentucky",
                            "Louisiana",
                            "Maine",
                            "Maryland",
                            "Massachusetts",
                            "Michigan",
                            "Minnesota",
                            "Mississippi",
                            "Missouri",
                            "Montana",
                            "Nebraska",
                            "Nevada",
                            "New Hampshire",
                            "New Jersey",
                            "New Mexico",
                            "New York",
                            "North Carolina",
                            "North Dakota",
                            "Ohio",
                            "Oklahoma",
                            "Oregon",
                            "Pennsylvania",
                            "Rhode Island",
                            "South Carolina",
                            "South Dakota",
                            "Tennessee",
                            "Texas",
                            "Utah",
                            "Vermont",
                            "Virginia",
                            "Washington",
                            "West Virginia",
                            "Wisconsin",
                            "Wyoming"
                        ],
                        "type": "string",
                        "description": "Filter results to a single US state (applied after search, since PALS' name/facility/profession searches also return out-of-state licensees holding a PA license).",
                        "default": ""
                    },
                    "statusFilter": {
                        "title": "License status filter",
                        "enum": [
                            "any",
                            "active",
                            "inactive",
                            "expired",
                            "nullAndVoid"
                        ],
                        "type": "string",
                        "description": "Filter results by license status.",
                        "default": "any"
                    },
                    "fetchDetails": {
                        "title": "Fetch full detail record per result",
                        "type": "boolean",
                        "description": "Enrich each result with its detail record (issue date, expiration date, last renewal date, disciplinary actions, restrictions). Uses one extra request per result.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Hard cap on emitted license records.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Not needed in normal operation (pals.pa.gov is publicly reachable). Used automatically as a fallback only if the source starts blocking direct requests.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
