# Texas TREC License Holder Search Scraper (`automation-lab/texas-trec-license-holder-search-scraper`) Actor

Search official Texas TREC public license-holder records by name, license number, type, status, county, sponsors, expiration, and profile URL.

- **URL**: https://apify.com/automation-lab/texas-trec-license-holder-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **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

## Texas TREC License Holder Search Scraper

Extract public Texas Real Estate Commission license-holder records from TREC's official search.

Use this actor to verify Texas real-estate brokers, sales agents, inspectors, appraisers, education providers, easement/right-of-way agents, and related license holders.

The actor queries the same public data used by the TREC License Holder Search and saves structured records to an Apify dataset.

It is designed for compliance checks, recruiting lists, broker/sponsor verification, market mapping, and proptech enrichment workflows.

### What does Texas TREC License Holder Search Scraper do?

This actor searches the public TREC license database and returns normalized license-holder records.

It supports name and keyword searches.

It supports exact license-number searches.

It supports broad searches with `*` when you need a statewide sample or export.

It can filter by TREC license type.

It can filter by public license status.

It can filter by county from the TREC search index.

It can optionally fetch detail records for richer fields such as city, address, opened date, sponsor data, and disciplinary action counts.

Each result includes a TREC profile URL so your team can audit the source page.

### Who is it for?

Brokerages use it to verify agents and identify recruiting targets.

Compliance teams use it to check license status and expiration dates.

Proptech vendors use it to enrich agent and broker records.

Lead-generation agencies use it to build Texas real-estate license-holder lists.

Data teams use it to monitor TREC public records in a repeatable workflow.

Recruiters use it to search by name, license category, and geography.

Operations teams use it to reconcile internal agent rosters against official public status.

### Why use this actor?

✅ Official source: results come from the Texas Real Estate Commission public search backend.

✅ Structured output: dataset rows are ready for CSV, JSON, Excel, API, and warehouse imports.

✅ Flexible search: combine names, license numbers, status, type, county, and result limits.

✅ Detail mode: fetch address/city/sponsor fields when your workflow needs deeper verification.

✅ Apify-ready: schedule runs, integrate with webhooks, or call from your own code.

### What data can you extract?

| Field | Description |
| --- | --- |
| `licenseHolderName` | Person or organization name shown by TREC |
| `licenseNumber` | TREC public license number |
| `licenseType` | License subtype such as Broker Individual or Salesperson |
| `status` | Public status text |
| `expirationDate` | Renewal expiration date when available |
| `county` | County from the public search index |
| `city` | City from detail data when available |
| `sponsoringBrokerNames` | Sponsor/broker names from detail data |
| `dbas` | DBA names where listed |
| `disciplinaryActionsCount` | Number of disciplinary action records exposed in detail data |
| `profileUrl` | Direct TREC license-search profile URL |
| `scrapedAt` | ISO timestamp for the extraction |

### How much does it cost to scrape Texas TREC license holders?

This actor uses pay-per-event pricing.

There is a small start charge per run.

There is a per-record charge for each license record saved.

Current pricing starts at $0.005 per run and $0.00002902 per result at the BRONZE tier.

Per-result tiers are FREE $0.000033373, BRONZE $0.00002902, SILVER $0.000022635, GOLD $0.000017412, PLATINUM $0.000011608, and DIAMOND $0.00001.

Keep `maxResults` small for trial runs.

Increase `maxResults` only after your input produces the expected license type and geography.

### Input options

#### `searchTerms`

Names, broker/company names, DBA names, or `*` for a broad search.

Example: `["smith"]`.

#### `licenseNumbers`

Exact TREC license numbers such as `406599-B`.

These are searched in addition to `searchTerms`.

#### `licenseType`

Choose one TREC category:

- Broker or Sales Agent (`Real Estate`)
- Inspector
- Easement & Right of Way Agent
- Real Estate Appraiser
- Appraisal Management Company
- Education Provider

#### `licenseStatus`

Choose all records or a public status such as Active, Inactive, Expired, or Expired less than 6 months.

#### `county`

Optional exact county filter from the TREC search index.

#### `city`

Optional exact city filter from detail records.

City filtering requires detail lookups.

#### `maxResults`

Maximum dataset records to save.

#### `includeDetails`

Enable detail fetches for richer address, sponsor, opened-date, and disciplinary fields.

### Example input: search by name

```json
{
  "searchTerms": ["smith"],
  "licenseType": "Real Estate",
  "licenseStatus": "all",
  "maxResults": 25,
  "includeDetails": true
}
````

### Example input: active statewide sample

```json
{
  "searchTerms": ["*"],
  "licenseType": "Real Estate",
  "licenseStatus": "Active",
  "maxResults": 100,
  "includeDetails": false
}
```

### Example input: exact license lookup

```json
{
  "licenseNumbers": ["406599-B"],
  "licenseType": "Real Estate",
  "maxResults": 5,
  "includeDetails": true
}
```

### Output example

```json
{
  "searchTerm": "smith",
  "detailId": "1555639",
  "licenseNumber": "406599-B",
  "licenseHolderName": "SMITH, BILLY JOE",
  "licenseType": "Broker Individual",
  "status": "Expired less than 6 months",
  "expirationDate": "2022-11-30 00:00:00",
  "profileUrl": "https://www.trec.texas.gov/license-search/?detail_id=1555639",
  "scrapedAt": "2026-07-04T02:14:43.155Z"
}
```

### How to run it

1. Open the actor on Apify.

2. Enter one or more names, keywords, or license numbers.

3. Choose the TREC license type.

4. Choose a status filter if needed.

5. Set `maxResults`.

6. Run the actor.

7. Export the dataset as CSV, JSON, Excel, or via API.

### Tips for better results

Use exact license numbers for verification workflows.

Use last names for recruiting and prospecting workflows.

Use `*` only when you want a broad statewide sample or bulk export.

Use `includeDetails: false` for fast index-only list building.

Use `includeDetails: true` when you need address, city, sponsor, or disciplinary counts.

Use county filters carefully because they must match TREC index values.

### Integrations

Send results to Google Sheets for recruiting lists.

Send records to a CRM for brokerage outreach.

Join `licenseNumber` against your internal roster for compliance monitoring.

Use Apify webhooks to notify your team when a scheduled run finishes.

Use the Apify API to run nightly or weekly license checks.

Export JSON to a data warehouse for enrichment and deduplication.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/texas-trec-license-holder-search-scraper').call({
  searchTerms: ['smith'],
  licenseType: 'Real Estate',
  maxResults: 25,
  includeDetails: true,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/texas-trec-license-holder-search-scraper").call(run_input={
    "searchTerms": ["smith"],
    "licenseType": "Real Estate",
    "maxResults": 25,
    "includeDetails": True,
})
print(run["defaultDatasetId"])
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~texas-trec-license-holder-search-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["smith"],"licenseType":"Real Estate","maxResults":25,"includeDetails":true}'
```

### MCP usage

Use this actor from Claude Desktop, Claude Code, or other MCP clients through Apify MCP.

Add the Apify MCP server in Claude Code:

```bash
claude mcp add apify-trec --url "https://mcp.apify.com/?tools=automation-lab/texas-trec-license-holder-search-scraper"
```

Claude Desktop MCP JSON configuration:

```json
{
  "mcpServers": {
    "apify-trec": {
      "url": "https://mcp.apify.com/?tools=automation-lab/texas-trec-license-holder-search-scraper"
    }
  }
}
```

MCP endpoint:

```text
https://mcp.apify.com/?tools=automation-lab/texas-trec-license-holder-search-scraper
```

Example prompts:

- "Search Texas TREC for active real-estate license holders named Garcia."
- "Verify this TREC license number and summarize the status and expiration date."
- "Create a CSV of active Texas brokers from the TREC license search."

### Data freshness

The actor reads TREC's public search backend at run time.

Freshness depends on the TREC public database and its update schedule.

Use `scrapedAt` to track when a record was collected.

### Limitations

The actor is not affiliated with the Texas Real Estate Commission.

It returns public data exposed by TREC's search experience.

Some address, phone, city, and sponsor fields may be blank when TREC does not publish them.

City filtering requires detail requests and can be slower than index-only searches.

TREC may change its public search backend, which can require an actor update.

### Legality and ethical use

Use this actor only for lawful purposes.

Respect privacy, anti-spam, and data protection laws.

Verify important compliance decisions directly against official TREC pages.

Do not use extracted contact data for unlawful solicitation.

### Troubleshooting

If you get zero results, try a broader name or `licenseStatus: all`.

If exact license lookup fails, make sure the suffix is included, such as `-B` or `-SA`.

If city filtering removes records, run without `city` first to inspect available detail fields.

If runs are slow, set `includeDetails` to false or lower `maxResults`.

If exported rows miss address data, TREC may not publish address fields for those licenses.

### Related scrapers

- [Georgia Real Estate License Lookup Scraper](https://apify.com/automation-lab/georgia-real-estate-license-lookup-scraper)
- [Texas State Bar Attorney Scraper](https://apify.com/automation-lab/texas-state-bar-attorney-scraper)
- [Contractor License Verification Scraper](https://apify.com/automation-lab/contractor-license-verification-scraper)
- [Realtor Scraper](https://apify.com/automation-lab/realtor-scraper)

### FAQ

#### Is this an official TREC product?

No. It is an independent Apify actor that reads public TREC search data.

#### Can I search all Texas real-estate agents?

Use `searchTerms: ["*"]`, `licenseType: "Real Estate"`, and a larger `maxResults` for broad exports.

#### Can I verify one license number?

Yes. Put the exact TREC license number in `licenseNumbers`.

#### Why are some sponsor fields empty?

Sponsor data is only returned when TREC publishes it for that license and detail mode is enabled.

#### Does this actor use proxies?

No proxy is used by default because the public API works over direct HTTP in testing.

#### Can I schedule recurring checks?

Yes. Use Apify schedules or API calls to run recurring compliance checks.

### Changelog

Initial version searches TREC public license records and supports detail enrichment.

# Actor input Schema

## `searchTerms` (type: `array`):

License holder names, broker/company names, DBA names, or '\*' for a broad search. Use specific names for targeted lookups.

## `licenseNumbers` (type: `array`):

Optional exact TREC license numbers such as 406599-B or 123456-SA. These are searched in addition to names/keywords.

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

TREC license category to search.

## `licenseStatus` (type: `string`):

Filter by TREC public status. Leave as all to include active and inactive records except upgraded records.

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

Optional exact county filter as listed by TREC, for example Harris or Dallas. Leave empty for statewide search.

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

Optional exact city filter. City is available from detail records, so enabling it requires detail lookups.

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

Maximum number of license records to save to the dataset.

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

Fetch TREC detail records for address, city, phone, opened date, sponsors, DBA/team names, and disciplinary action count. Recommended for compliance workflows.

## Actor input object example

```json
{
  "searchTerms": [
    "smith"
  ],
  "licenseNumbers": [],
  "licenseType": "Real Estate",
  "licenseStatus": "all",
  "maxResults": 20,
  "includeDetails": true
}
```

# 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 = {
    "searchTerms": [
        "smith"
    ],
    "licenseNumbers": [],
    "licenseType": "Real Estate",
    "licenseStatus": "all",
    "county": "",
    "city": "",
    "maxResults": 20,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/texas-trec-license-holder-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 = {
    "searchTerms": ["smith"],
    "licenseNumbers": [],
    "licenseType": "Real Estate",
    "licenseStatus": "all",
    "county": "",
    "city": "",
    "maxResults": 20,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/texas-trec-license-holder-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 '{
  "searchTerms": [
    "smith"
  ],
  "licenseNumbers": [],
  "licenseType": "Real Estate",
  "licenseStatus": "all",
  "county": "",
  "city": "",
  "maxResults": 20,
  "includeDetails": true
}' |
apify call automation-lab/texas-trec-license-holder-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Texas TREC License Holder Search Scraper",
        "description": "Search official Texas TREC public license-holder records by name, license number, type, status, county, sponsors, expiration, and profile URL.",
        "version": "0.1",
        "x-build-id": "WWDm2C9TgfdM9dtUV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~texas-trec-license-holder-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-texas-trec-license-holder-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/automation-lab~texas-trec-license-holder-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-texas-trec-license-holder-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/automation-lab~texas-trec-license-holder-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-texas-trec-license-holder-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",
                "properties": {
                    "searchTerms": {
                        "title": "Names or keywords",
                        "type": "array",
                        "description": "License holder names, broker/company names, DBA names, or '*' for a broad search. Use specific names for targeted lookups.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "licenseNumbers": {
                        "title": "License numbers",
                        "type": "array",
                        "description": "Optional exact TREC license numbers such as 406599-B or 123456-SA. These are searched in addition to names/keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "licenseType": {
                        "title": "License type",
                        "enum": [
                            "Real Estate",
                            "Inspector",
                            "Easement",
                            "Appraiser",
                            "Appraisal Management Company",
                            "Provider"
                        ],
                        "type": "string",
                        "description": "TREC license category to search.",
                        "default": "Real Estate"
                    },
                    "licenseStatus": {
                        "title": "License status",
                        "enum": [
                            "all",
                            "Active",
                            "Inactive",
                            "Expired",
                            "Expired less than 6 months"
                        ],
                        "type": "string",
                        "description": "Filter by TREC public status. Leave as all to include active and inactive records except upgraded records.",
                        "default": "all"
                    },
                    "county": {
                        "title": "County",
                        "type": "string",
                        "description": "Optional exact county filter as listed by TREC, for example Harris or Dallas. Leave empty for statewide search."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Optional exact city filter. City is available from detail records, so enabling it requires detail lookups."
                    },
                    "maxResults": {
                        "title": "Maximum license records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of license records to save to the dataset.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Fetch detail pages",
                        "type": "boolean",
                        "description": "Fetch TREC detail records for address, city, phone, opened date, sponsors, DBA/team names, and disciplinary action count. Recommended for compliance workflows.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```