# NY Office of the Professions License Search (`crawlerbros/ny-office-of-professions-license-scraper`) Actor

Verify New York State professional licenses (nursing, medicine, pharmacy, psychology, engineering, accountancy, dentistry, veterinary and 80+ other professions), business entities, pharmacy establishments, and permits by name or ID. Returns status, dates, and enforcement history.

- **URL**: https://apify.com/crawlerbros/ny-office-of-professions-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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## NY Office of the Professions License Search

Verify **New York State professional licenses**, **business entities**, **pharmacy establishments**, and **limited/temporary permits** — nursing, medicine, dentistry, pharmacy, psychology, engineering, accountancy (CPA), veterinary medicine, physical therapy, social work, and 80+ other professions regulated by the NYSED Office of the Professions. Search by name or look up an exact license/entity/registration/permit number and get registration status, dates, and professional-misconduct/enforcement history. HTTP-only via the official public verification API. No auth, no proxy, no CAPTCHA.

### What this actor does

- **Seven modes**, matching every tab of NYSED's public verification portal:
  - `search` — individual licensee by name
  - `byLicenseNumber` — individual license, exact lookup
  - `businessEntitySearch` — business entities (PCs/PLLCs/firms) by name, including an "All Business Entities" cross-profession option
  - `byBusinessEntityId` — business entity, exact PSC-number lookup
  - `pharmacySearch` — pharmacy establishments by name
  - `byPharmacyRegistrationNumber` — pharmacy establishment, exact registration-number lookup
  - `permitteeSearch` — limited/temporary permit holders by name
- **89 professions/boards** covered for individual licensees and permits, **76 for business entities** (plus "All Business Entities") — nursing, medicine, pharmacy, dentistry, psychology, engineering, accountancy, veterinary medicine, physical/occupational therapy, social work, and more
- **Registration/entity/permit status** — current status, issue/filing dates, expiry/registered-through dates
- **Enforcement/discipline history** — professional-misconduct actions on file, when present, for both individuals and business entities
- **Optional detail enrichment** — name searches (individual and business) return a light listing by default; each result can be enriched with the full record (status, dates, principals, discipline) in the same run
- **Empty fields are omitted** — a field only appears when the source actually has a value for it

### Output per record

Individual license (`recordType: "license"`):
- `name`, `profession`, `professionCode`, `licenseNumber`, `address`, `dateOfLicensure`
- `status`, `registeredThroughDate` — detail lookups / `fetchFullDetails` only
- `additionalQualifications`, `privileges`, `additionalLicenses`, `certificateOfAuthorizations` — when on file
- `hasDisciplinaryAction` (`true`/`false`), `enforcementActions[]` — when present

Business entity (`recordType: "businessEntity"`):
- `name`, `profession`, `professionCode`, `entityType`, `pscNumber`, `address`
- `status`, `initialFilingDate`, `currentThroughDate`, `closeDate` — detail lookups / `fetchFullDetails` only
- `principals[]` (name + licenseNumber of officers/shareholders), `certificateOfAuthorizations` — when on file
- `hasEnforcementAction` (`true`/`false`), `enforcementActions[]` — when present

Pharmacy establishment (`recordType: "pharmacy"`):
- `name`, `tradeName`, `legalName`, `registrationNumber`, `establishmentType`, `address`, `county`, `status`
- `dateFirstRegistered`, `dateRegistrationBegins`, `dateRegisteredThrough`, `deletedDate`
- `supervisor`, `successor`, `successorRegistrationNumber` — when on file
- `hasEnforcementAction` (`true`/`false`), `enforcementActions[]` — when present

Permittee (`recordType: "permit"`):
- `name`, `profession`, `professionCode`, `address`, `permitType`, `permitStatus`, `permitNumber`
- `issueDate`, `expireDate`, `supervisors[]` — when on file

All record types share: `sourceUrl` (the NYSED verification portal) and `scrapedAt`.

Invalid input (unknown profession code, malformed ID, no match found) produces a `recordType: "error"` record instead, with `error`, `message`, and `input` fields.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | One of the seven modes above |
| `profession` | string | `022` (RN) | Profession code for `search`/`byLicenseNumber` — see the dropdown for all 89 professions |
| `licenseeName` | string | `Smith` | Last name, or `Last First` (mode=search) |
| `licenseNumber` | string | `500000` | Exact license number (mode=byLicenseNumber) |
| `businessProfession` | string | `003` (Architecture) | Profession code for `businessEntitySearch`/`byBusinessEntityId` (76 options + "All Business Entities") |
| `businessEntityName` | string | `Medical` | Firm/business name (mode=businessEntitySearch) |
| `pscNumber` | string | `035673` | Exact professional-service-corporation number (mode=byBusinessEntityId) |
| `pharmacyName` | string | `CVS` | Pharmacy legal or trade name (mode=pharmacySearch) |
| `pharmacyRegistrationNumber` | string | `017682` | Exact 6-digit pharmacy registration number (mode=byPharmacyRegistrationNumber) |
| `permitProfession` | string | `060` (Physician) | Profession code for `permitteeSearch` (89 options) |
| `permitteeName` | string | `Smith` | Permit holder's last name, or `Last First` (mode=permitteeSearch) |
| `fetchFullDetails` | boolean | `true` | For mode=search/businessEntitySearch, also fetch full status + discipline/principal data per result |
| `maxItems` | int | `50` | Hard cap on emitted records (1–2000) |

#### Example: search nurses named Garcia with full detail

```json
{
  "mode": "search",
  "profession": "022",
  "licenseeName": "Garcia",
  "fetchFullDetails": true,
  "maxItems": 50
}
````

#### Example: fast name-only listing (no discipline enrichment)

```json
{
  "mode": "search",
  "profession": "060",
  "licenseeName": "Chen",
  "fetchFullDetails": false,
  "maxItems": 100
}
```

#### Example: look up one license by number

```json
{
  "mode": "byLicenseNumber",
  "profession": "022",
  "licenseNumber": "500000"
}
```

#### Example: verify a CPA's license and discipline history

```json
{
  "mode": "byLicenseNumber",
  "profession": "007",
  "licenseNumber": "N12345"
}
```

#### Example: search architecture/engineering firms named Smith across all professions

```json
{
  "mode": "businessEntitySearch",
  "businessProfession": "ALL",
  "businessEntityName": "Smith",
  "maxItems": 50
}
```

#### Example: look up a business entity by PSC number

```json
{
  "mode": "byBusinessEntityId",
  "businessProfession": "007",
  "pscNumber": "081283"
}
```

#### Example: search pharmacies named CVS

```json
{
  "mode": "pharmacySearch",
  "pharmacyName": "CVS",
  "maxItems": 50
}
```

#### Example: search physicians holding limited/temporary permits

```json
{
  "mode": "permitteeSearch",
  "permitProfession": "060",
  "permitteeName": "Patel",
  "maxItems": 50
}
```

### Use cases

- **Background checks** — verify a healthcare or licensed professional's credentials before hiring or referral
- **Compliance teams** — confirm a contractor, vendor, or firm holds an active, undisciplined license or registration
- **HR / staffing agencies** — bulk-verify nursing, therapy, or engineering license status
- **Insurance & credentialing** — cross-check practitioner and business-entity licensure and enforcement history
- **Consumer protection** — check a provider's or pharmacy's disciplinary record before engaging their services
- **Legal & due diligence** — pull professional-misconduct history for individuals and firms as part of investigations
- **Pharmacy network verification** — confirm a pharmacy's registration status, supervisor, and enforcement history

### FAQ

**What is the data source?**
The New York State Education Department (NYSED) Office of the Professions' official public license-verification service, the same data shown at [op.nysed.gov's Online Verification Searches](https://www.op.nysed.gov/services/verifications/online-verification-searches). The database is described by NYSED as updated daily.

**Is this affiliated with NYSED?**
No — this is an independent, third-party actor that queries NYSED's public verification API. It is not affiliated with or endorsed by the New York State Education Department.

**Why do I need to pick a profession before searching?**
NYSED's verification system scopes every individual, business-entity, and permit search to exactly one profession/board (or "All Business Entities" for business search), since license/entity numbers are only unique within a profession, not globally. Pharmacy search is not profession-scoped.

**Why does a name search sometimes return fewer fields than an ID lookup?**
Name-search listings (individual and business entity) only contain the summary fields (name, profession, address, ID, date). Turn on `fetchFullDetails` to also fetch status, dates, and discipline/principal data for every result (one extra request per result).

**What does `hasDisciplinaryAction: false` / `hasEnforcementAction: false` mean vs. no `enforcementActions` field?**
Both mean the same thing: no professional-misconduct action is on file. The boolean flag is always present so you can filter reliably; `enforcementActions` only appears when there is at least one action to show.

**How current is the license status?**
NYSED states its verification database is refreshed daily.

**Can I search by business/entity name instead of an individual?**
Yes — use `mode=businessEntitySearch` (by name) or `mode=byBusinessEntityId` (exact PSC number) to search professional service corporations, PLLCs, and firms.

**Can I search pharmacy establishments or temporary/limited permit holders?**
Yes — `mode=pharmacySearch`/`byPharmacyRegistrationNumber` covers pharmacy establishments, and `mode=permitteeSearch` covers holders of limited/temporary practice permits.

# Actor input Schema

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

What to fetch.

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

The profession/board to search within. Every individual-licensee search is scoped to exactly one profession.

## `licenseeName` (type: `string`):

Last name, or 'Last First', e.g. `Smith` or `Smith John`. At least 2 characters.

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

Exact license/registration number for the selected profession, e.g. `500000` or `N10859`.

## `businessProfession` (type: `string`):

The profession/board to search business entities (PCs, PLLCs, partnerships, firms) within. Pick `All Business Entities` to search across every profession at once.

## `businessEntityName` (type: `string`):

Business/firm name, e.g. `Smith Architecture` or `Medical`. At least 2 characters.

## `pscNumber` (type: `string`):

Exact professional service corporation/entity number for the selected business profession, e.g. `035673`.

## `pharmacyName` (type: `string`):

Pharmacy legal or trade name, e.g. `CVS` or `Walgreens`. At least 2 characters.

## `pharmacyRegistrationNumber` (type: `string`):

Exact 6-digit pharmacy establishment registration number, e.g. `017682`.

## `permitProfession` (type: `string`):

The profession/board to search limited/temporary permits within.

## `permitteeName` (type: `string`):

Permit holder's last name, or 'Last First', e.g. `Smith`. At least 2 characters.

## `fetchFullDetails` (type: `boolean`):

For mode=search and mode=businessEntitySearch, fetch each result's full record (status, dates, enforcement/discipline actions, principals) with one extra API call per result. Turn off for faster, lighter-weight name/address-only listings.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "profession": "022",
  "licenseeName": "Smith",
  "licenseNumber": "500000",
  "businessProfession": "003",
  "businessEntityName": "Medical",
  "pscNumber": "035673",
  "pharmacyName": "CVS",
  "pharmacyRegistrationNumber": "017682",
  "permitProfession": "060",
  "permitteeName": "Smith",
  "fetchFullDetails": true,
  "maxItems": 50
}
```

# Actor output Schema

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

Dataset containing all scraped 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",
    "profession": "022",
    "licenseeName": "Smith",
    "licenseNumber": "500000",
    "businessProfession": "003",
    "businessEntityName": "Medical",
    "pscNumber": "035673",
    "pharmacyName": "CVS",
    "pharmacyRegistrationNumber": "017682",
    "permitProfession": "060",
    "permitteeName": "Smith",
    "fetchFullDetails": true,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/ny-office-of-professions-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",
    "profession": "022",
    "licenseeName": "Smith",
    "licenseNumber": "500000",
    "businessProfession": "003",
    "businessEntityName": "Medical",
    "pscNumber": "035673",
    "pharmacyName": "CVS",
    "pharmacyRegistrationNumber": "017682",
    "permitProfession": "060",
    "permitteeName": "Smith",
    "fetchFullDetails": True,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/ny-office-of-professions-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",
  "profession": "022",
  "licenseeName": "Smith",
  "licenseNumber": "500000",
  "businessProfession": "003",
  "businessEntityName": "Medical",
  "pscNumber": "035673",
  "pharmacyName": "CVS",
  "pharmacyRegistrationNumber": "017682",
  "permitProfession": "060",
  "permitteeName": "Smith",
  "fetchFullDetails": true,
  "maxItems": 50
}' |
apify call crawlerbros/ny-office-of-professions-license-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NY Office of the Professions License Search",
        "description": "Verify New York State professional licenses (nursing, medicine, pharmacy, psychology, engineering, accountancy, dentistry, veterinary and 80+ other professions), business entities, pharmacy establishments, and permits by name or ID. Returns status, dates, and enforcement history.",
        "version": "1.0",
        "x-build-id": "10axJIxTEsEeaJNMF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~ny-office-of-professions-license-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-ny-office-of-professions-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~ny-office-of-professions-license-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-ny-office-of-professions-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~ny-office-of-professions-license-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-ny-office-of-professions-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",
                            "businessEntitySearch",
                            "byBusinessEntityId",
                            "pharmacySearch",
                            "byPharmacyRegistrationNumber",
                            "permitteeSearch"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "profession": {
                        "title": "Profession (mode=search/byLicenseNumber)",
                        "enum": [
                            "007",
                            "008",
                            "025",
                            "003",
                            "067",
                            "057",
                            "078",
                            "048",
                            "091",
                            "085",
                            "070",
                            "094",
                            "092",
                            "090",
                            "CN",
                            "005",
                            "093",
                            "051",
                            "069",
                            "084",
                            "050",
                            "059",
                            "083",
                            "079",
                            "082",
                            "081",
                            "060",
                            "061",
                            "016",
                            "095",
                            "014",
                            "073",
                            "015",
                            "004",
                            "071",
                            "006",
                            "072",
                            "018",
                            "010",
                            "019",
                            "027",
                            "009",
                            "011",
                            "012",
                            "013",
                            "028",
                            "043",
                            "030",
                            "029",
                            "031",
                            "032",
                            "033",
                            "034",
                            "045",
                            "035",
                            "036",
                            "037",
                            "044",
                            "038",
                            "039",
                            "040",
                            "041",
                            "042",
                            "022",
                            "063",
                            "064",
                            "055",
                            "056",
                            "089",
                            "086",
                            "020",
                            "021",
                            "062",
                            "066",
                            "023",
                            "065",
                            "026",
                            "088",
                            "068",
                            "049",
                            "002",
                            "024",
                            "052",
                            "053",
                            "058",
                            "075",
                            "074",
                            "076",
                            "077"
                        ],
                        "type": "string",
                        "description": "The profession/board to search within. Every individual-licensee search is scoped to exactly one profession.",
                        "default": "022"
                    },
                    "licenseeName": {
                        "title": "Licensee name (mode=search)",
                        "type": "string",
                        "description": "Last name, or 'Last First', e.g. `Smith` or `Smith John`. At least 2 characters.",
                        "default": "Smith"
                    },
                    "licenseNumber": {
                        "title": "License number (mode=byLicenseNumber)",
                        "type": "string",
                        "description": "Exact license/registration number for the selected profession, e.g. `500000` or `N10859`."
                    },
                    "businessProfession": {
                        "title": "Business entity profession (mode=businessEntitySearch/byBusinessEntityId)",
                        "enum": [
                            "AC",
                            "025",
                            "ALL",
                            "017",
                            "003",
                            "067",
                            "057",
                            "078",
                            "048",
                            "091",
                            "085",
                            "070",
                            "094",
                            "092",
                            "005",
                            "093",
                            "049",
                            "051",
                            "050",
                            "059",
                            "060",
                            "061",
                            "016",
                            "088",
                            "095",
                            "014",
                            "047",
                            "015",
                            "004",
                            "071",
                            "073",
                            "072",
                            "010",
                            "006",
                            "027",
                            "009",
                            "011",
                            "012",
                            "013",
                            "018",
                            "028",
                            "043",
                            "030",
                            "031",
                            "032",
                            "033",
                            "034",
                            "045",
                            "035",
                            "036",
                            "037",
                            "044",
                            "038",
                            "039",
                            "040",
                            "041",
                            "042",
                            "063",
                            "064",
                            "055",
                            "056",
                            "089",
                            "086",
                            "020",
                            "066",
                            "062",
                            "023",
                            "065",
                            "026",
                            "019",
                            "068",
                            "022",
                            "024",
                            "052",
                            "053",
                            "058",
                            "075",
                            "076"
                        ],
                        "type": "string",
                        "description": "The profession/board to search business entities (PCs, PLLCs, partnerships, firms) within. Pick `All Business Entities` to search across every profession at once.",
                        "default": "003"
                    },
                    "businessEntityName": {
                        "title": "Business entity name (mode=businessEntitySearch)",
                        "type": "string",
                        "description": "Business/firm name, e.g. `Smith Architecture` or `Medical`. At least 2 characters."
                    },
                    "pscNumber": {
                        "title": "PSC number (mode=byBusinessEntityId)",
                        "type": "string",
                        "description": "Exact professional service corporation/entity number for the selected business profession, e.g. `035673`."
                    },
                    "pharmacyName": {
                        "title": "Pharmacy establishment name (mode=pharmacySearch)",
                        "type": "string",
                        "description": "Pharmacy legal or trade name, e.g. `CVS` or `Walgreens`. At least 2 characters."
                    },
                    "pharmacyRegistrationNumber": {
                        "title": "Pharmacy registration number (mode=byPharmacyRegistrationNumber)",
                        "type": "string",
                        "description": "Exact 6-digit pharmacy establishment registration number, e.g. `017682`."
                    },
                    "permitProfession": {
                        "title": "Permit profession (mode=permitteeSearch)",
                        "enum": [
                            "007",
                            "025",
                            "003",
                            "067",
                            "057",
                            "078",
                            "048",
                            "091",
                            "085",
                            "070",
                            "094",
                            "092",
                            "090",
                            "005",
                            "093",
                            "051",
                            "069",
                            "084",
                            "050",
                            "059",
                            "083",
                            "079",
                            "082",
                            "081",
                            "060",
                            "061",
                            "016",
                            "095",
                            "014",
                            "073",
                            "015",
                            "004",
                            "071",
                            "006",
                            "072",
                            "018",
                            "010",
                            "019",
                            "027",
                            "009",
                            "011",
                            "012",
                            "013",
                            "028",
                            "043",
                            "030",
                            "031",
                            "032",
                            "033",
                            "034",
                            "045",
                            "035",
                            "036",
                            "037",
                            "044",
                            "038",
                            "039",
                            "040",
                            "041",
                            "042",
                            "022",
                            "063",
                            "064",
                            "055",
                            "056",
                            "089",
                            "086",
                            "020",
                            "062",
                            "066",
                            "023",
                            "065",
                            "026",
                            "088",
                            "068",
                            "049",
                            "002",
                            "024",
                            "052",
                            "053",
                            "058",
                            "075",
                            "076"
                        ],
                        "type": "string",
                        "description": "The profession/board to search limited/temporary permits within.",
                        "default": "060"
                    },
                    "permitteeName": {
                        "title": "Permittee name (mode=permitteeSearch)",
                        "type": "string",
                        "description": "Permit holder's last name, or 'Last First', e.g. `Smith`. At least 2 characters."
                    },
                    "fetchFullDetails": {
                        "title": "Fetch full details for search results",
                        "type": "boolean",
                        "description": "For mode=search and mode=businessEntitySearch, fetch each result's full record (status, dates, enforcement/discipline actions, principals) with one extra API call per result. Turn off for faster, lighter-weight name/address-only listings.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
