# Florida DBPR Professional & Contractor License Search Scraper (`crawlerbros/florida-dbpr-license-search-scraper`) Actor

Search Florida DBPR's public license registry by licensee name, license number, or profession/board. No login required.

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

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Florida DBPR Professional & Contractor License Search Scraper

Search Florida's Department of Business & Professional Regulation (DBPR) public license registry — the same data available at [myfloridalicense.com](https://www.myfloridalicense.com), public per Florida Statute Chapter 119. Search by licensee name, exact license number, or by profession/board (contractors, real estate, cosmetology, engineering, and 35+ other regulated professions), optionally narrowed by Florida county or city. No login, no API key.

### What this actor does

- **Three search modes:** `byName`, `byLicenseNumber`, `byProfession`
- **39 DBPR boards/professions** covered — construction, real estate, cosmetology, engineering, electrical contractors, barbers, veterinary medicine, and more
- **309 license sub-types** across those boards (e.g. "Certified General Contractor", "Real Estate Broker or Sales")
- **70 Florida counties** available as a filter, plus free-text city filter
- **Full detail-page enrichment** (on by default) — every result's detail page is fetched to add county, licensure (issue) date, DBA name, alternate names, and special qualifications
- **Status filter** — active / inactive / pending / any
- **Empty fields are omitted** — a record only contains data DBPR actually published for that licensee

### Output per license record

- `licenseeName` — individual or business name on file
- `dbaName` — "doing business as" name, when on file
- `alternateNames[]` — other names associated with the license
- `nameType` — `Primary`, `Alternate`, or `DBA`
- `licenseNumber`, `licenseType` (profession), `rank` (license sub-category abbreviation)
- `status`, `statusCategory` (`active` / `inactive` / `pending` / `unknown`), `expirationDate`
- `licensureDate` — original issue date (from the detail page)
- `county` — Florida county on file (from the detail page)
- `mainAddress`, `mailingAddress`, `licenseLocationAddress` — each `{ street, city, state, zip, fullAddress }` when the format is parseable, `{ fullAddress }` otherwise
- `specialQualifications[]` — `{ qualification, effectiveDate }`
- `profession` — the board/profession category searched (mode=byProfession)
- `sourceUrl` — canonical DBPR licensee detail page
- `searchType`, `searchTerm` — the query that produced this record
- `recordType: "license"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string (select) | `byName` | `byName` / `byLicenseNumber` / `byProfession` |
| `lastName` | string | – | Last name or business name (mode=byName) |
| `firstName` | string | – | First name, narrows a last-name search |
| `orgName` | string | – | Business/establishment name (mode=byName) |
| `licenseNumber` | string | – | Exact license number, e.g. `CFC056678` (mode=byLicenseNumber) |
| `board` | string (select) | – | One of 39 DBPR boards/professions (mode=byProfession) |
| `licenseType` | string | – | Sub-type within the board, e.g. `Certified General Contractor` (mode=byProfession, optional) |
| `county` | string (select) | – | One of 70 Florida counties. Optional for byName; **required (or set `city`) for byProfession** |
| `city` | string | – | City filter. Optional for byName; **required (or set `county`) for byProfession** |
| `statusFilter` | string (select) | `any` | `any` / `active` / `inactive` / `pending` |
| `fetchDetails` | boolean | `true` | Enrich each result with its full detail page |
| `maxItems` | integer | `20` | Hard cap on emitted records (1–200) |
| `proxyConfiguration` | object | Apify Proxy (auto) | Not needed in normal operation (the site is publicly reachable); used automatically only if direct requests start getting blocked |

#### Example: search by last name

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

#### Example: exact license number lookup

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

#### Example: active general contractors in a county

```json
{
  "mode": "byProfession",
  "board": "06",
  "licenseType": "Certified General Contractor",
  "county": "58",
  "statusFilter": "active",
  "maxItems": 25
}
```

#### Example: real estate licensees in a city

```json
{
  "mode": "byProfession",
  "board": "25",
  "licenseType": "Real Estate Broker or Sales",
  "city": "Miami",
  "maxItems": 25
}
```

### Use cases

- **Due diligence** — verify a contractor, real estate agent, or other Florida professional's license status before hiring or signing a contract
- **Compliance / KYC** — confirm a business or individual's active licensure and expiration date
- **Lead generation** — pull licensee lists for a profession and county (e.g. all active general contractors in Orange County)
- **Consumer protection research** — check disciplinary/status history via the licensee's DBPR detail page link
- **Market research** — count active licensees per profession per county across Florida

### FAQ

**What is the data source?**
The actor scrapes the public license search portal at `myfloridalicense.com`, operated by the Florida Department of Business and Professional Regulation. It is not affiliated with the State of Florida. Access is public per Florida Statute Chapter 119 (public records law) — no login is required on the official site either.

**Why does a name search sometimes return licensees whose name doesn't contain my search term?**
DBPR's name search performs a starts-with / nearest-alphabetical match against its sorted licensee index, identical to the official search UI. Results are ordered alphabetically from your search term.

**Does `licenseNumber` search support partial matches?**
No — it requires the license number in the exact format DBPR issued it (including any letter prefix, e.g. `CFC056678`, not just `056678`).

**Why do I need to pick a `board` for profession search, and what is `licenseType`?**
A "board" is DBPR's top-level regulatory category (e.g. Construction Industry, Real Estate, Cosmetology). Each board has several license sub-types (e.g. Construction Industry includes "Certified General Contractor", "Certified Plumbing Contractor", etc). If you don't specify `licenseType`, the actor uses the board's first available sub-type — for full control, set `licenseType` to the exact sub-type label.

**Why do I need to set `county` or `city` for mode=byProfession?**
DBPR's own profession/board search (both the official site's client-side validation and its server) requires a location filter — either a Florida county or a city — for this search type; it returns zero results without one. `byName` and `byLicenseNumber` searches don't have this restriction.

**Why are some fields like `county` or `licensureDate` missing on some records?**
Those fields are only available from the licensee's detail page. Set `fetchDetails: true` (the default) to populate them; disabling it returns faster but with only the summary-table fields (name, license number, type, status, expiration, main address).

**How current is the data?**
DBPR serves live data directly from the state's licensing system, so results reflect the registry at the time the actor runs. The search results page shows "Data current as of" the scrape date.

**Does this actor need a login, cookies, or proxy?**
No. DBPR's license search portal is fully public. A proxy is only used automatically as a fallback if the source starts blocking direct requests.

# Actor input Schema

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

How to search the DBPR licensee registry.

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

Licensee or business last name. DBPR name searches are starts-with / nearest-alphabetical matches, same as the official site. Leave empty to search by firstName or orgName 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.

## `orgName` (type: `string`):

Search by business/establishment name instead of an individual's name.

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

Exact DBPR license number, e.g. `CFC056678`.

## `board` (type: `string`):

The DBPR board/profession category to browse.

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

Free-text sub-type within the selected board, e.g. `Certified General Contractor`, `Real Estate Broker or Sales`, `Cosmetologist`. Matched case-insensitively; if omitted or not found, the board's first license type is used.

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

Florida county filter. Optional for byName. REQUIRED (or set `city`) for mode=byProfession — DBPR's board/profession search does not return results without a location filter.

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

City filter, e.g. `Miami`, `Orlando`, `Tampa`. Optional for byName. REQUIRED (or set `county`) for mode=byProfession — DBPR's board/profession search does not return results without a location filter.

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

Filter results by license status category.

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

Enrich each result with the licensee's detail page (county, DBA name, licensure date, alternate names, special qualifications). Uses one extra request per result.

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

Hard cap on emitted license records.

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

Not needed in normal operation (myfloridalicense.com 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",
  "county": "",
  "statusFilter": "any",
  "fetchDetails": true,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped DBPR 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",
    "county": "",
    "statusFilter": "any",
    "fetchDetails": true,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/florida-dbpr-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",
    "county": "",
    "statusFilter": "any",
    "fetchDetails": True,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Florida DBPR Professional & Contractor License Search Scraper",
        "description": "Search Florida DBPR's public license registry by licensee name, license number, or profession/board. No login required.",
        "version": "1.0",
        "x-build-id": "AX1EBA8wlAYPzBffc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~florida-dbpr-license-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-florida-dbpr-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~florida-dbpr-license-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-florida-dbpr-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~florida-dbpr-license-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-florida-dbpr-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"
                        ],
                        "type": "string",
                        "description": "How to search the DBPR licensee registry.",
                        "default": "byName"
                    },
                    "lastName": {
                        "title": "Last name (mode=byName)",
                        "type": "string",
                        "description": "Licensee or business last name. DBPR name searches are starts-with / nearest-alphabetical matches, same as the official site. Leave empty to search by firstName or orgName 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."
                    },
                    "orgName": {
                        "title": "Organization / business name (mode=byName)",
                        "type": "string",
                        "description": "Search by business/establishment name instead of an individual's name."
                    },
                    "licenseNumber": {
                        "title": "License number (mode=byLicenseNumber)",
                        "type": "string",
                        "description": "Exact DBPR license number, e.g. `CFC056678`."
                    },
                    "board": {
                        "title": "Profession / board (mode=byProfession)",
                        "enum": [
                            "400",
                            "02",
                            "59",
                            "60",
                            "48",
                            "03",
                            "600",
                            "50",
                            "830",
                            "01",
                            "38",
                            "860",
                            "800",
                            "06",
                            "05",
                            "33",
                            "08",
                            "210",
                            "63",
                            "09",
                            "75",
                            "53",
                            "870",
                            "23",
                            "04",
                            "840",
                            "200",
                            "74",
                            "820",
                            "13",
                            "810",
                            "07",
                            "100",
                            "101",
                            "25",
                            "64",
                            "49",
                            "26",
                            "85"
                        ],
                        "type": "string",
                        "description": "The DBPR board/profession category to browse."
                    },
                    "licenseType": {
                        "title": "License type within board (mode=byProfession, optional)",
                        "type": "string",
                        "description": "Free-text sub-type within the selected board, e.g. `Certified General Contractor`, `Real Estate Broker or Sales`, `Cosmetologist`. Matched case-insensitively; if omitted or not found, the board's first license type is used."
                    },
                    "county": {
                        "title": "County",
                        "enum": [
                            "",
                            "11",
                            "12",
                            "13",
                            "14",
                            "15",
                            "16",
                            "17",
                            "18",
                            "19",
                            "20",
                            "21",
                            "22",
                            "23",
                            "24",
                            "25",
                            "26",
                            "27",
                            "28",
                            "80",
                            "29",
                            "30",
                            "31",
                            "32",
                            "33",
                            "34",
                            "35",
                            "36",
                            "37",
                            "38",
                            "39",
                            "40",
                            "41",
                            "42",
                            "43",
                            "44",
                            "45",
                            "46",
                            "47",
                            "48",
                            "49",
                            "50",
                            "51",
                            "52",
                            "53",
                            "54",
                            "55",
                            "56",
                            "57",
                            "58",
                            "59",
                            "79",
                            "60",
                            "61",
                            "62",
                            "63",
                            "64",
                            "67",
                            "68",
                            "69",
                            "65",
                            "66",
                            "70",
                            "71",
                            "72",
                            "73",
                            "78",
                            "74",
                            "75",
                            "76",
                            "77"
                        ],
                        "type": "string",
                        "description": "Florida county filter. Optional for byName. REQUIRED (or set `city`) for mode=byProfession — DBPR's board/profession search does not return results without a location filter.",
                        "default": ""
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City filter, e.g. `Miami`, `Orlando`, `Tampa`. Optional for byName. REQUIRED (or set `county`) for mode=byProfession — DBPR's board/profession search does not return results without a location filter."
                    },
                    "statusFilter": {
                        "title": "License status filter",
                        "enum": [
                            "any",
                            "active",
                            "inactive",
                            "pending"
                        ],
                        "type": "string",
                        "description": "Filter results by license status category.",
                        "default": "any"
                    },
                    "fetchDetails": {
                        "title": "Fetch full detail page per result",
                        "type": "boolean",
                        "description": "Enrich each result with the licensee's detail page (county, DBA name, licensure date, alternate names, special qualifications). 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 (myfloridalicense.com 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
