# Texas TREC License Search Scraper (`crawlerbros/texas-trec-scraper`) Actor

Search Texas Real Estate Commission (TREC) license-holder records: real estate brokers, sales agents, inspectors, easement/right-of-way agents, appraisers, and appraisal management companies. Search by name or license number, get status, expiration date, and sponsoring broker.

- **URL**: https://apify.com/crawlerbros/texas-trec-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Real estate, Agents, Jobs
- **Stats:** 1 total users, 0 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

## Texas TREC License Search Scraper

Search **Texas Real Estate Commission (TREC)** license-holder records — real estate brokers, sales agents, inspectors, easement/right-of-way agents, appraisers, and appraisal management companies. Search by license holder name or jump straight to a license number. Get license status, issue/expiration dates, license type, and (for sales agents) the sponsoring broker. HTTP-only against TREC's own official public license dataset — no login, no CAPTCHA, no proxy required.

### Data source & limitations

TREC's interactive search UI (`trec.texas.gov/apps/license-holder-search/`) is currently unreachable from standard internet infrastructure (a persistent connection-level block/timeout, not a CAPTCHA or rate limit). This actor instead uses **TREC's own official license-holder datasets**, published directly by the Texas Real Estate Commission on the Texas Open Data Portal (`data.texas.gov`) as public, structured APIs — the same underlying license records the search UI draws from, refreshed on a daily schedule. No functionality is lost: name search, license number lookup, license-type/status filtering all work the same way, across all five TREC-regulated license categories.

### What this actor does

- **Two modes:** search by license holder / business `name`, or direct `license number` lookup
- **Five license categories:** Real Estate Broker/Sales Agent, Real Estate Inspector, Easement/Right-of-Way Agent, Real Estate Appraiser, Appraisal Management Company — searchable individually or all at once
- **Filters:** license type (within category), license status, active-only shortcut
- **Sponsoring broker:** for Sales Agent records, the broker the agent is sponsored by (name + license number) is automatically resolved and surfaced
- **Empty fields are omitted** — a field only appears when TREC actually published that data for the license

### Output per license

- `licenseNumber` — TREC license number (category-suffixed, e.g. `854692-SA`, `490032-BB`)
- `licenseCategory` / `licenseCategoryLabel` — which of the 5 TREC categories this license belongs to
- `licenseType` — TREC-defined license type (e.g. `Sales Agent`, `Broker Individual`, `Certified Residential`)
- `fullName`, `firstName`, `middleName`, `lastName`, `suffix` — license holder name (business licenses populate `fullName` only)
- `licenseStatus` — TREC's own published status (e.g. `Active`, `Expired less than 6 months`, `Revoked`)
- `isActive` — `true`/`false`, derived from `licenseStatus == "Active"`
- `originalLicenseDate`, `licenseExpirationDate` — ISO dates
- `isDesignatedSupervisor` — `true`/`false`, when TREC publishes this flag for the license
- `currentlySupervisesTrainees` — `true`/`false`, for Appraiser/AMC licenses that publish this flag
- `relatedLicenseType`, `relatedLicenseNumber`, `relatedLicenseFullName`, `relatedLicenseSuffix`, `relatedLicenseStartDate` — the license's linked/associated license (e.g. a Sales Agent's sponsoring broker, or a Broker Company's designated broker)
- `sponsoringBrokerName`, `sponsoringBrokerLicenseNumber` — friendly alias of the related license, populated specifically when the related license is a broker
- `agencyIdentifier` — TREC's internal identifier for the license holder
- `recordUpdatedAt` — the date TREC last updated this specific record, when published
- `datasetLastUpdated` — the date the underlying Texas Open Data Portal dataset itself was last refreshed
- `sourceUrl` — a live, queryable link to the official record on the Texas Open Data Portal
- `recordType: "license"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byName` | `byName` or `byLicenseNumber` |
| `licenseCategory` | select | `brokerSalesAgent` | One of 5 categories, or `all` |
| `nameQuery` | string | `Smith` | License holder or business name (mode=byName) |
| `licenseNumber` | string | `854692-SA` | TREC license number (mode=byLicenseNumber) |
| `licenseType` | select | – | Exact TREC license type within the chosen category |
| `statusFilter` | select | – | Exact TREC license status |
| `activeOnly` | boolean | `false` | Shortcut for `statusFilter: Active` |
| `sortBy` | select | `licenseNumber` | `licenseNumber`, `fullName`, or `expirationDate` |
| `sortDirection` | select | `asc` | `asc` or `desc` |
| `maxItems` | int | `20` | Hard cap on emitted license records (1–5000) |

#### Example: search by name

```json
{
  "mode": "byName",
  "licenseCategory": "brokerSalesAgent",
  "nameQuery": "Smith",
  "maxItems": 20
}
````

#### Example: active sales agents named Garcia

```json
{
  "mode": "byName",
  "licenseCategory": "brokerSalesAgent",
  "nameQuery": "Garcia",
  "licenseType": "Sales Agent",
  "activeOnly": true,
  "maxItems": 50
}
```

#### Example: direct license number lookup

```json
{
  "mode": "byLicenseNumber",
  "licenseCategory": "brokerSalesAgent",
  "licenseNumber": "854692-SA"
}
```

#### Example: search across every license category

```json
{
  "mode": "byName",
  "licenseCategory": "all",
  "nameQuery": "Johnson",
  "maxItems": 100
}
```

#### Example: browse active real estate appraisers

```json
{
  "mode": "byName",
  "licenseCategory": "appraiser",
  "nameQuery": "a",
  "licenseType": "Certified Residential",
  "activeOnly": true,
  "maxItems": 50
}
```

### Use cases

- **Buyer/seller vetting** — confirm a real estate agent or broker's TREC license is active and see who sponsors them
- **Brokerage compliance** — verify all agents at a brokerage are properly licensed and sponsored
- **Home inspection & appraisal** — confirm an inspector or appraiser's license status before hiring
- **Lead & vendor validation** — confirm a TREC license number resolves to a real, active license
- **Market research** — enumerate licensed real estate professionals by type and status

### FAQ

**What is the data source?**
The Texas Real Estate Commission's official license-holder datasets, published on the Texas Open Data Portal (`data.texas.gov`). This actor is an independent, third-party tool and is not affiliated with or endorsed by TREC or the State of Texas.

**Why not scrape the TREC search website directly?**
The interactive search UI was unreachable during testing (a persistent connection-level block/timeout affecting all external access, not a CAPTCHA or IP rate limit). The Texas Open Data Portal serves the identical underlying license records as a stable, public API, so no data or functionality is lost.

**How fresh is the data?**
The Texas Open Data Portal datasets are refreshed by TREC on a daily cadence. They are not a live real-time feed of the search UI, but reflect the same licensing records.

**Why does `licenseCategory: all` return fewer results per category than searching one category alone?**
When searching all 5 categories at once, `maxItems` is a combined cap shared across categories (fetched in category order), so each category may only get a share of the budget. Set `licenseCategory` to a specific category and raise `maxItems` for a deeper single-category pull.

**Why do some records lack a `county` field?**
TREC's published datasets do not reliably populate a county column for these license types (it is blank or contains non-geographic codes on virtually every row), so it is omitted from this actor's output rather than shown as an unreliable/garbage value.

**Does this actor need a login, CAPTCHA solve, or proxy?**
No. The Texas Open Data Portal is fully public. The actor uses Apify's free `AUTO` proxy group only as a courtesy fallback.

**How is `isActive` determined?**
It's derived by comparing `licenseStatus` to TREC's exact string `"Active"` — TREC's own status field already distinguishes active from every inactive/expired/revoked/suspended state, so no separate date-based derivation is needed.

# Actor input Schema

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

How to look up TREC licenses.

## `licenseCategory` (type: `string`):

Which TREC-regulated profession to search. `All categories` searches every category in turn (slower, uses more of your `maxItems` budget per category).

## `nameQuery` (type: `string`):

Matches the license holder's full name, first name, or last name (e.g. `Smith` or `Star Realty`). Case-insensitive partial match. Optional if `licenseType` is set — leaving it blank then browses all licenses of that type.

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

The TREC license number, e.g. `854692-SA` (Sales Agent), `490032-BB` (Broker Company). TREC suffixes license numbers by type, so pair with `licenseCategory` for an exact match.

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

Only emit licenses of this exact TREC-defined license type. The valid set depends on `licenseCategory` (e.g. `Sales Agent`/`Broker Individual`/`Broker Company` for Broker/Sales Agent; `Certified Residential`/`Trainee`/etc. for Appraiser). Leave unset for all types within the chosen category.

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

Only emit licenses with this exact TREC-published status. Leave unset for all statuses.

## `activeOnly` (type: `boolean`):

When enabled, only emit licenses whose status is exactly `Active` (a shortcut for `statusFilter: Active`).

## `sortBy` (type: `string`):

Order results are fetched/emitted in. Defaults to license number.

## `sortDirection` (type: `string`):

Ascending or descending order for `sortBy`.

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

Hard cap on emitted license records. When `licenseCategory` is `all`, this cap applies across all categories combined.

## Actor input object example

```json
{
  "mode": "byName",
  "licenseCategory": "brokerSalesAgent",
  "nameQuery": "Smith",
  "licenseNumber": "854692-SA",
  "licenseType": "",
  "statusFilter": "",
  "activeOnly": false,
  "sortBy": "licenseNumber",
  "sortDirection": "asc",
  "maxItems": 20
}
```

# Actor output Schema

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

Dataset containing all scraped TREC license-holder 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",
    "licenseCategory": "brokerSalesAgent",
    "nameQuery": "Smith",
    "licenseNumber": "854692-SA",
    "licenseType": "",
    "statusFilter": "",
    "activeOnly": false,
    "sortBy": "licenseNumber",
    "sortDirection": "asc",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/texas-trec-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",
    "licenseCategory": "brokerSalesAgent",
    "nameQuery": "Smith",
    "licenseNumber": "854692-SA",
    "licenseType": "",
    "statusFilter": "",
    "activeOnly": False,
    "sortBy": "licenseNumber",
    "sortDirection": "asc",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/texas-trec-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",
  "licenseCategory": "brokerSalesAgent",
  "nameQuery": "Smith",
  "licenseNumber": "854692-SA",
  "licenseType": "",
  "statusFilter": "",
  "activeOnly": false,
  "sortBy": "licenseNumber",
  "sortDirection": "asc",
  "maxItems": 20
}' |
apify call crawlerbros/texas-trec-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Texas TREC License Search Scraper",
        "description": "Search Texas Real Estate Commission (TREC) license-holder records: real estate brokers, sales agents, inspectors, easement/right-of-way agents, appraisers, and appraisal management companies. Search by name or license number, get status, expiration date, and sponsoring broker.",
        "version": "1.0",
        "x-build-id": "K64NJyMiLObpkeb8i"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~texas-trec-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-texas-trec-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~texas-trec-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-texas-trec-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~texas-trec-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-texas-trec-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",
                    "licenseCategory"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "byName",
                            "byLicenseNumber"
                        ],
                        "type": "string",
                        "description": "How to look up TREC licenses.",
                        "default": "byName"
                    },
                    "licenseCategory": {
                        "title": "License category",
                        "enum": [
                            "brokerSalesAgent",
                            "inspector",
                            "easementAgent",
                            "appraiser",
                            "appraisalManagementCompany",
                            "all"
                        ],
                        "type": "string",
                        "description": "Which TREC-regulated profession to search. `All categories` searches every category in turn (slower, uses more of your `maxItems` budget per category).",
                        "default": "brokerSalesAgent"
                    },
                    "nameQuery": {
                        "title": "License holder / business name (mode=byName)",
                        "type": "string",
                        "description": "Matches the license holder's full name, first name, or last name (e.g. `Smith` or `Star Realty`). Case-insensitive partial match. Optional if `licenseType` is set — leaving it blank then browses all licenses of that type.",
                        "default": "Smith"
                    },
                    "licenseNumber": {
                        "title": "License number (mode=byLicenseNumber)",
                        "type": "string",
                        "description": "The TREC license number, e.g. `854692-SA` (Sales Agent), `490032-BB` (Broker Company). TREC suffixes license numbers by type, so pair with `licenseCategory` for an exact match."
                    },
                    "licenseType": {
                        "title": "Filter by license type",
                        "enum": [
                            "",
                            "Broker Company",
                            "Broker Individual",
                            "Sales Agent",
                            "Apprentice",
                            "Real Estate",
                            "Professional",
                            "Easement ROW - Business License",
                            "Easement ROW - Individual License",
                            "Certified Residential",
                            "Certified General",
                            "Licensed Residential",
                            "Temporary Non-Resident",
                            "Trainee",
                            "Appraisal Management Company (AMC) License"
                        ],
                        "type": "string",
                        "description": "Only emit licenses of this exact TREC-defined license type. The valid set depends on `licenseCategory` (e.g. `Sales Agent`/`Broker Individual`/`Broker Company` for Broker/Sales Agent; `Certified Residential`/`Trainee`/etc. for Appraiser). Leave unset for all types within the chosen category.",
                        "default": ""
                    },
                    "statusFilter": {
                        "title": "Filter by license status",
                        "enum": [
                            "",
                            "Active",
                            "Archived",
                            "Canceled",
                            "Closed - Upgraded",
                            "Deceased",
                            "Deleted",
                            "Denied",
                            "Expired",
                            "Expired less than 6 months",
                            "Expired more than 6 months",
                            "Inactive",
                            "Inactive - Suspended",
                            "Inactive - Unsupervised",
                            "Military",
                            "Probated Revocation - Active",
                            "Probated Revocation - Inactive",
                            "Probated Suspension - Active",
                            "Probation - Active",
                            "Probation - Inactive",
                            "Relinquished",
                            "Revoked",
                            "Surrendered",
                            "Suspended",
                            "Upgraded",
                            "Withdrawn"
                        ],
                        "type": "string",
                        "description": "Only emit licenses with this exact TREC-published status. Leave unset for all statuses.",
                        "default": ""
                    },
                    "activeOnly": {
                        "title": "Active licenses only",
                        "type": "boolean",
                        "description": "When enabled, only emit licenses whose status is exactly `Active` (a shortcut for `statusFilter: Active`).",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "licenseNumber",
                            "fullName",
                            "expirationDate"
                        ],
                        "type": "string",
                        "description": "Order results are fetched/emitted in. Defaults to license number.",
                        "default": "licenseNumber"
                    },
                    "sortDirection": {
                        "title": "Sort direction",
                        "enum": [
                            "asc",
                            "desc"
                        ],
                        "type": "string",
                        "description": "Ascending or descending order for `sortBy`.",
                        "default": "asc"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on emitted license records. When `licenseCategory` is `all`, this cap applies across all categories combined.",
                        "default": 20
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
