# Florida DBPR License Verification Scraper (`automation-lab/florida-dbpr-license-verification-scraper`) Actor

Verify Florida DBPR licenses and export public license records for compliance, recruiting, lead generation, and vendor screening.

- **URL**: https://apify.com/automation-lab/florida-dbpr-license-verification-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## Florida DBPR License Verification Scraper

Extract Florida Department of Business and Professional Regulation license search results for compliance checks, recruiting, market research, and lead generation.

### What does Florida DBPR License Verification Scraper do?

This Apify Actor searches the public Florida DBPR licensing portal and saves structured license records.

It can search by:

- Licensee last name
- First name
- Business or organization name
- License number
- DBPR board or category code
- License type code
- City
- County
- State
- Historic license option

The Actor returns one dataset item per matching DBPR license record.

### Who is it for?

Compliance teams use it to verify whether a Florida professional or business has an active license.

Recruiters use it to find licensed real estate, construction, cosmetology, hospitality, and other DBPR-regulated professionals.

Insurance and risk teams use it to screen vendors and contractors.

B2B lead-generation teams use it to build targeted lists from public license records.

Data vendors use it to refresh internal Florida license databases.

### Why use this scraper?

- It converts DBPR search pages into clean JSON.
- It supports batch searches for repeat workflows.
- It includes source URLs for auditability.
- It can fetch detail pages when you need issue dates or county data.
- It runs in Apify, so you can schedule it and export results automatically.

### What data can you extract?

| Field | Description |
| --- | --- |
| `licenseeName` | Person, business, or establishment name |
| `licenseNumber` | DBPR license number |
| `licenseRank` | Rank such as Sales Associate or Broker |
| `licenseType` | DBPR profession/category label |
| `status` | Current, inactive, null and void, or another DBPR status |
| `expirationDate` | Expiration date shown by DBPR |
| `issueDate` | Licensure date from the detail page when enabled |
| `address` | Main public address text |
| `city` | Parsed city when available |
| `state` | Parsed state when available |
| `postalCode` | Parsed ZIP code when available |
| `county` | County from detail pages when enabled |
| `detailUrl` | DBPR detail page URL |
| `sourceUrl` | DBPR search URL used by the Actor |

### How much does it cost to scrape Florida DBPR license records?

This Actor uses pay-per-event pricing.

You pay a small run-start fee and a per-record result fee.

The default input is intentionally small so first runs stay inexpensive.

For larger jobs, use batch searches with `maxResults` set to the number of records you need.

### Quick start

1. Open the Actor on Apify.
2. Enter a last name, business name, or license number.
3. Optionally add a DBPR board code such as `25` for Real Estate.
4. Set `maxResults`.
5. Run the Actor.
6. Download JSON, CSV, Excel, XML, or HTML from the dataset.

### Input example

```json
{
  "lastName": "smith",
  "boardCode": "25",
  "state": "FL",
  "maxResults": 50,
  "resultsPerPage": 50,
  "includeDetails": false
}
````

### Batch input example

```json
{
  "searches": [
    { "lastName": "smith", "boardCode": "25", "state": "FL" },
    { "lastName": "jones", "boardCode": "25", "state": "FL" },
    { "lastName": "williams", "boardCode": "25", "state": "FL" }
  ],
  "maxResults": 120,
  "resultsPerPage": 50,
  "includeDetails": false
}
```

### License number lookup

Use `searchMode: "licenseNumber"` with `licenseNumber` for targeted verification.

```json
{
  "searchMode": "licenseNumber",
  "licenseNumber": "BK3330278",
  "maxResults": 1,
  "includeDetails": true
}
```

### Output example

```json
{
  "searchMode": "name",
  "searchQuery": "last=smith; board=25",
  "licenseeName": "SMITH , ADAM J",
  "nameType": "Primary",
  "licenseNumber": "BK3330278",
  "licenseRank": "Broker Sales",
  "licenseType": "Real Estate Broker or Sales",
  "profession": "Real Estate Broker or Sales",
  "status": "Current,Active",
  "expirationDate": "09/30/2027",
  "address": "1750 HARBOR PLACE SOUTH 202 SOUTH PASADENA Florida 33707",
  "county": "Pinellas",
  "detailUrl": "https://www.myfloridalicense.com/LicenseDetail.asp?...",
  "scrapedAt": "2026-07-04T05:02:02.404Z"
}
```

### DBPR board code tips

Common public DBPR board codes include:

- `25` Real Estate
- `06` Construction Industry
- `05` Cosmetology
- `200` Hotels and Restaurants
- `08` Electrical Contractors
- `04` Home Inspectors
- `64` Real Estate Appraisers

DBPR may change codes or labels, so verify unusual categories in the public form.

### Search strategy tips

Use narrow searches for compliance verification.

Use batch names for lead generation.

Use board codes to avoid unrelated professions.

Enable `includeDetails` only when you need issue dates or county values.

Keep `maxResults` low while testing.

### Integrations

Use this Actor with Apify schedules to refresh license records weekly or monthly.

Use webhooks to send completed datasets to your CRM or compliance system.

Use the Apify API to start runs from internal onboarding workflows.

Export to Google Sheets through Apify integrations for review queues.

Send dataset items to a database for deduplication and monitoring.

### API usage: Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/florida-dbpr-license-verification-scraper').call({
  lastName: 'smith',
  boardCode: '25',
  maxResults: 50
});
console.log(run.defaultDatasetId);
```

### API usage: Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/florida-dbpr-license-verification-scraper').call(run_input={
    'lastName': 'smith',
    'boardCode': '25',
    'maxResults': 50,
})
print(run['defaultDatasetId'])
```

### API usage: cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~florida-dbpr-license-verification-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"lastName":"smith","boardCode":"25","maxResults":50}'
```

### MCP usage

Use Apify MCP with Claude Desktop or Claude Code to run the scraper from natural-language workflows.

MCP endpoint:

`https://mcp.apify.com/?tools=automation-lab/florida-dbpr-license-verification-scraper`

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/florida-dbpr-license-verification-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/florida-dbpr-license-verification-scraper"
    }
  }
}
```

Example prompts:

- "Run the Florida DBPR scraper for real estate licensees named Smith."
- "Verify this DBPR license number and summarize the status."
- "Export Florida DBPR license matches to a CSV-ready dataset."

### Scheduling and monitoring

For recurring compliance checks, create an Apify schedule with a fixed set of license numbers or search names.

Compare new runs against older datasets to detect status or expiration changes.

Use the `detailUrl` field for manual audit review.

### Data quality notes

The Actor extracts data from the public DBPR portal.

Some older records may have incomplete address parts.

Some DBPR records show historic or inactive statuses.

Detail pages may contain richer dates than search results.

### Legality and ethical use

This Actor accesses publicly available government licensing information.

Use the data responsibly and comply with applicable laws, privacy rules, and DBPR terms.

Do not use scraped data for harassment, discrimination, or unlawful eligibility decisions.

### Troubleshooting

If you receive no results, broaden your search or remove a board code.

If a license type search returns no results, verify the DBPR license type code in the portal.

If a run is slower than expected, disable `includeDetails`.

If address parsing looks imperfect, use the original `address` field and `detailUrl` for audit.

### Related scrapers

Explore other public-record and compliance tools from Automation Lab:

- https://apify.com/automation-lab/texas-real-estate-license-scraper
- https://apify.com/automation-lab/georgia-real-estate-license-scraper
- https://apify.com/automation-lab/website-contact-finder

### FAQ

#### Can I search multiple names in one run?

Yes. Use the `searches` array to run multiple DBPR searches in one Actor run.

#### Can I verify a single license number?

Yes. Set `searchMode` to `licenseNumber` and provide `licenseNumber`.

#### Does it include complaint or discipline data?

The current dataset focuses on license search and detail fields. Use `detailUrl` for manual follow-up on DBPR pages.

#### Why are only 50 records returned for one search?

DBPR exposes up to 50 results per page. Use multiple targeted searches to collect larger batches reliably.

#### Is login required?

No. The Actor uses the public DBPR search portal.

### Changelog

- Initial version: DBPR name, license number, city, and license type search support.

### Support

If DBPR changes its portal or you need another license board added, open an issue on the Apify Actor page.

# Actor input Schema

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

Last name for DBPR name searches. Use searches\[] for multiple names.

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

Optional first name filter.

## `organizationName` (type: `string`):

Optional DBPR organization or establishment name filter.

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

Search for an exact DBPR license number. If set, searchMode defaults to licenseNumber.

## `searchMode` (type: `string`):

DBPR search tab to use. Auto-detected from your fields when omitted.

## `boardCode` (type: `string`):

Optional DBPR board/category code, e.g. 25 = Real Estate, 06 = Construction, 05 = Cosmetology, 200 = Hotels and Restaurants.

## `licenseTypeCode` (type: `string`):

Optional DBPR license type code. Leave blank unless you know the DBPR code for the selected category.

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

Optional Florida city filter.

## `countyCode` (type: `string`):

Optional DBPR county code, e.g. 58 = Orange, 60 = Palm Beach, 62 = Pinellas, 39 = Hillsborough.

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

State filter used by DBPR. Defaults to FL.

## `includeHistoric` (type: `boolean`):

Include historic/inactive licenses when DBPR supports it for the selected search.

## `searches` (type: `array`):

Optional list of DBPR searches. When provided, these are run instead of the top-level criteria.

## `maxResults` (type: `integer`):

Maximum license records to save across all searches.

## `resultsPerPage` (type: `integer`):

DBPR supports up to 50 records per search page.

## `includeDetails` (type: `boolean`):

Open each DBPR detail page for issue dates and county. Slower but richer.

## Actor input object example

```json
{
  "lastName": "smith",
  "searchMode": "name",
  "boardCode": "25",
  "state": "FL",
  "includeHistoric": false,
  "searches": [
    {
      "lastName": "smith",
      "boardCode": "25",
      "state": "FL"
    },
    {
      "lastName": "jones",
      "boardCode": "25",
      "state": "FL"
    }
  ],
  "maxResults": 20,
  "resultsPerPage": 50,
  "includeDetails": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "lastName": "smith",
    "searchMode": "name",
    "boardCode": "25",
    "state": "FL",
    "searches": [
        {
            "lastName": "smith",
            "boardCode": "25",
            "state": "FL"
        },
        {
            "lastName": "jones",
            "boardCode": "25",
            "state": "FL"
        }
    ],
    "maxResults": 20,
    "resultsPerPage": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/florida-dbpr-license-verification-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 = {
    "lastName": "smith",
    "searchMode": "name",
    "boardCode": "25",
    "state": "FL",
    "searches": [
        {
            "lastName": "smith",
            "boardCode": "25",
            "state": "FL",
        },
        {
            "lastName": "jones",
            "boardCode": "25",
            "state": "FL",
        },
    ],
    "maxResults": 20,
    "resultsPerPage": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/florida-dbpr-license-verification-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 '{
  "lastName": "smith",
  "searchMode": "name",
  "boardCode": "25",
  "state": "FL",
  "searches": [
    {
      "lastName": "smith",
      "boardCode": "25",
      "state": "FL"
    },
    {
      "lastName": "jones",
      "boardCode": "25",
      "state": "FL"
    }
  ],
  "maxResults": 20,
  "resultsPerPage": 50
}' |
apify call automation-lab/florida-dbpr-license-verification-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Florida DBPR License Verification Scraper",
        "description": "Verify Florida DBPR licenses and export public license records for compliance, recruiting, lead generation, and vendor screening.",
        "version": "0.1",
        "x-build-id": "WzZUEzHqnPJBo7xVm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~florida-dbpr-license-verification-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-florida-dbpr-license-verification-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/automation-lab~florida-dbpr-license-verification-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-florida-dbpr-license-verification-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/automation-lab~florida-dbpr-license-verification-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-florida-dbpr-license-verification-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",
                "properties": {
                    "lastName": {
                        "title": "Last name",
                        "type": "string",
                        "description": "Last name for DBPR name searches. Use searches[] for multiple names."
                    },
                    "firstName": {
                        "title": "First name",
                        "type": "string",
                        "description": "Optional first name filter."
                    },
                    "organizationName": {
                        "title": "Business / organization name",
                        "type": "string",
                        "description": "Optional DBPR organization or establishment name filter."
                    },
                    "licenseNumber": {
                        "title": "License number",
                        "type": "string",
                        "description": "Search for an exact DBPR license number. If set, searchMode defaults to licenseNumber."
                    },
                    "searchMode": {
                        "title": "Search mode",
                        "enum": [
                            "name",
                            "licenseNumber",
                            "city",
                            "licenseType"
                        ],
                        "type": "string",
                        "description": "DBPR search tab to use. Auto-detected from your fields when omitted.",
                        "default": "name"
                    },
                    "boardCode": {
                        "title": "License category code",
                        "type": "string",
                        "description": "Optional DBPR board/category code, e.g. 25 = Real Estate, 06 = Construction, 05 = Cosmetology, 200 = Hotels and Restaurants."
                    },
                    "licenseTypeCode": {
                        "title": "License type code",
                        "type": "string",
                        "description": "Optional DBPR license type code. Leave blank unless you know the DBPR code for the selected category."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Optional Florida city filter."
                    },
                    "countyCode": {
                        "title": "County code",
                        "type": "string",
                        "description": "Optional DBPR county code, e.g. 58 = Orange, 60 = Palm Beach, 62 = Pinellas, 39 = Hillsborough."
                    },
                    "state": {
                        "title": "State",
                        "type": "string",
                        "description": "State filter used by DBPR. Defaults to FL.",
                        "default": "FL"
                    },
                    "includeHistoric": {
                        "title": "Include historic licenses",
                        "type": "boolean",
                        "description": "Include historic/inactive licenses when DBPR supports it for the selected search.",
                        "default": false
                    },
                    "searches": {
                        "title": "Multiple searches",
                        "type": "array",
                        "description": "Optional list of DBPR searches. When provided, these are run instead of the top-level criteria.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "searchMode": {
                                    "title": "Search mode",
                                    "description": "DBPR search mode.",
                                    "type": "string",
                                    "enum": [
                                        "name",
                                        "licenseNumber",
                                        "city",
                                        "licenseType"
                                    ]
                                },
                                "lastName": {
                                    "title": "Last name",
                                    "description": "Last name filter.",
                                    "type": "string"
                                },
                                "firstName": {
                                    "title": "First name",
                                    "description": "First name filter.",
                                    "type": "string"
                                },
                                "organizationName": {
                                    "title": "Organization name",
                                    "description": "Business or establishment name filter.",
                                    "type": "string"
                                },
                                "licenseNumber": {
                                    "title": "License number",
                                    "description": "Exact DBPR license number.",
                                    "type": "string"
                                },
                                "boardCode": {
                                    "title": "Board code",
                                    "description": "DBPR category or board code.",
                                    "type": "string"
                                },
                                "licenseTypeCode": {
                                    "title": "License type code",
                                    "description": "DBPR license type code.",
                                    "type": "string"
                                },
                                "city": {
                                    "title": "City",
                                    "description": "City filter.",
                                    "type": "string"
                                },
                                "countyCode": {
                                    "title": "County code",
                                    "description": "DBPR county code.",
                                    "type": "string"
                                },
                                "state": {
                                    "title": "State",
                                    "description": "State filter.",
                                    "type": "string"
                                },
                                "includeHistoric": {
                                    "title": "Include historic",
                                    "description": "Include historic licenses.",
                                    "type": "boolean"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum license records to save across all searches.",
                        "default": 20
                    },
                    "resultsPerPage": {
                        "title": "DBPR results per page",
                        "minimum": 10,
                        "maximum": 50,
                        "type": "integer",
                        "description": "DBPR supports up to 50 records per search page.",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Fetch detail pages",
                        "type": "boolean",
                        "description": "Open each DBPR detail page for issue dates and county. Slower but richer.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```