# Oregon Contractor License Lookup Scraper (`automation-lab/oregon-contractor-license-lookup-scraper`) Actor

🔎 Search public Oregon CCB contractor records and export license numbers, business names, statuses, and addresses for verification, compliance, or leads.

- **URL**: https://apify.com/automation-lab/oregon-contractor-license-lookup-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **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/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

## Oregon Contractor License Lookup Scraper

Search the Oregon Construction Contractors Board (CCB) public license register and export structured contractor records in minutes.

Use this Actor to verify license status, discover Oregon contractors, monitor compliance lists, or enrich a CRM with official public CCB identifiers.

The scraper handles the CCB form session and pagination automatically. No Oregon account, GitHub token, or private credential is required.

### What does Oregon Contractor License Lookup Scraper do?

The Actor searches Oregon's public contractor license lookup using one or more terms.

It returns:

- CCB license number
- registered business name
- public license status
- public mailing address
- search term and result page
- source URL and extraction timestamp

Search by a company name, license number, trade keyword, city, ZIP code, or address fragment supported by the public search.

### Who is it for?

#### Contractor lead generation teams

Build targeted contractor lists for insurance, equipment, financing, software, and professional services outreach.

#### Compliance and procurement teams

Check whether vendors appear in the Oregon CCB register and retain timestamped verification evidence.

#### Property managers and homeowners

Look up contractors before procurement or renovation work.

#### Researchers and public-interest teams

Study contractor market coverage and license-status patterns using exportable records.

#### Developers and data teams

Feed official public contractor data into internal databases, dashboards, alerts, or enrichment pipelines.

### Why use this Actor?

Oregon CCB publishes active licenses through the state's official Open Data API and all-status searches through a stateful ASP.NET flow. This Actor selects the appropriate official route automatically.

This Actor:

- queries the official Open Data API for active-license searches
- preserves the anonymous website session for all-status searches
- submits required hidden form fields when using the website
- follows result redirects
- navigates API or website result pages
- normalizes table values
- applies an exact output limit
- charges only for records saved

You receive clean JSON, CSV, Excel, XML, RSS, or Parquet through Apify Dataset exports.

### What data can I extract?

| Field | Type | Description |
|---|---|---|
| `licenseNumber` | string | Oregon CCB license identifier |
| `businessName` | string | Public registered contractor name |
| `licenseStatus` | string | Status shown by Oregon CCB |
| `address` | string | Public address shown in search results |
| `searchTerm` | string | Input that produced the record |
| `resultPage` | number | Result page where it appeared |
| `sourceUrl` | URL | Oregon CCB public result source |
| `scrapedAt` | datetime | UTC extraction timestamp |

Optional or unavailable values are not invented.

### How to scrape Oregon contractor licenses

1. Open the Actor input page.
2. Enter one or more search terms.
3. Choose whether to request active licenses only.
4. Set the maximum number of records.
5. Click **Start**.
6. Preview the dataset.
7. Export it in your preferred format.

Start with a precise company name or license number when verifying one contractor.

Use broader terms such as a trade or city when building a prospect list.

### Input

```json
{
  "searchTerms": ["construction", "plumbing"],
  "activeOnly": true,
  "maxItems": 100,
  "maxPagesPerSearch": 25
}
````

#### `searchTerms`

A list of business names, CCB numbers, trade terms, cities, ZIP codes, or address fragments.

Duplicate and blank terms are removed.

#### `activeOnly`

Set to `true` to request active records from the source. Set to `false` to include all statuses returned by CCB.

#### `maxItems`

Maximum records saved across all search terms. Allowed range: 1 to 10,000.

#### `maxPagesPerSearch`

A safety limit for broad terms. Oregon CCB normally displays about 20 records per page.

### Output example

```json
{
  "licenseNumber": "257762",
  "businessName": "MT HOOD CONSTRUCTION & HANDYMAN SERVICES",
  "licenseStatus": "Active",
  "address": "PO BOX 534 BRIGHTWOOD OR 97011",
  "searchTerm": "construction",
  "resultPage": 1,
  "sourceUrl": "https://search.ccb.state.or.us/search/list_results.aspx",
  "scrapedAt": "2026-07-12T04:30:00.000Z"
}
```

Records from overlapping searches can describe the same license. Deduplicate downstream by `licenseNumber` when combining broad searches.

### How much does it cost to look up Oregon contractor licenses?

The Actor uses pay-per-event pricing:

- a small charge when the run starts
- a per-item charge for each dataset record saved

Apify plan tiers receive volume-adjusted item prices. The Console shows the exact run estimate before execution.

HTTP-only extraction keeps compute use low. Set a conservative `maxItems` during evaluation.

### Search strategies

#### Verify one contractor

Search an exact CCB number and set `maxItems` to 5.

#### Build a trade list

Search terms such as `roofing`, `plumbing`, or `excavation` and request active records.

#### Build a local list

Search a city or ZIP fragment, then filter and deduplicate the exported dataset.

#### Monitor status

Schedule exact license-number searches and compare `licenseStatus` between datasets.

### Tips for accurate results

- Use exact CCB numbers for verification.
- Try legal and trading business names separately.
- Keep multiple terms in one run for efficient batching.
- Deduplicate overlapping broad queries by `licenseNumber`.
- Store `scrapedAt` when creating audit evidence.
- Confirm critical decisions on the official source page.

### Scheduling and monitoring

Apify schedules can run this Actor hourly, daily, weekly, or monthly.

A monitoring workflow can:

1. search a fixed list of license numbers
2. save a dated dataset
3. compare status with the prior run
4. send changed rows to a webhook
5. notify procurement or compliance staff

Use Apify webhooks with Slack, email automation, or your own API endpoint.

### Integrations

Use `licenseNumber` as the stable key in these end-to-end workflows:

1. **Dataset → Google Sheets compliance queue:** schedule a daily active-license search, export the dataset to a Sheet, and let reviewers add approval and follow-up columns without re-keying contractor details.
2. **Scheduled run → webhook status alert:** search a fixed list of CCB numbers, compare each run with the previous dataset, and send changed or missing licenses through an Apify webhook to Slack, Zapier, Make, or an incident endpoint.
3. **Dataset → CRM lead pipeline:** sync active rows to Airtable, HubSpot, or Salesforce by `licenseNumber`, then route newly found contractors to territory owners while preserving the Oregon CCB source link.

For warehouse analysis, load dated datasets into Snowflake, BigQuery, or PostgreSQL and track status changes over time.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/oregon-contractor-license-lookup-scraper').call({
  searchTerms: ['roofing'],
  activeOnly: true,
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/oregon-contractor-license-lookup-scraper').call(run_input={
    'searchTerms': ['257762'],
    'activeOnly': False,
    'maxItems': 5,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~oregon-contractor-license-lookup-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["construction"],"activeOnly":true,"maxItems":100}'
```

Fetch run results from the dataset endpoint returned by the run API.

### Use with Apify MCP

The scoped MCP endpoint is:

`https://mcp.apify.com/?tools=automation-lab/oregon-contractor-license-lookup-scraper`

Add it to Claude Code:

```bash
claude mcp add --transport http apify-oregon-ccb \
  'https://mcp.apify.com/?tools=automation-lab/oregon-contractor-license-lookup-scraper'
```

For Claude Desktop, Cursor, or VS Code, add this HTTP server to the client's MCP JSON configuration (set `APIFY_TOKEN` in the client environment or complete the prompted Apify authentication):

```json
{
  "mcpServers": {
    "apify-oregon-ccb": {
      "type": "http",
      "url": "https://mcp.apify.com/?tools=automation-lab/oregon-contractor-license-lookup-scraper"
    }
  }
}
```

Example prompts to ask Claude through MCP:

- “Find 50 active Oregon roofing contractors and group them by city.”
- “Check Oregon CCB license 257762 and summarize the record with its source URL.”
- “Export active contractors matching plumbing to CSV and flag duplicate license numbers.”

### Reliability

The scraper uses official public HTTP sources rather than a browser.

Active-only searches use Oregon's Open Data API, avoiding dependence on the slower interactive search form. All-status searches validate the website response, preserve cookies, submit ASP.NET hidden fields, follow the result redirect, and post pagination events.

If a broad term has no rows, the Actor moves to the next term without failing the whole run.

### Limitations

- Data is limited to what Oregon CCB publicly displays.
- Source labels and page structure may change.
- Search is controlled by the state website's matching behavior.
- Broad terms can return thousands of records.
- One contractor may match several input terms.
- Result rows do not represent private complaint or payment data.
- Temporary state-site maintenance can interrupt a run.

Use `maxPagesPerSearch` to bound unusually broad queries.

### Troubleshooting

#### Why did my search return zero records?

Check spelling, try part of the legal business name, remove punctuation, or search the CCB number.

#### Why do I see duplicate licenses?

Overlapping search terms can return the same contractor. Deduplicate by `licenseNumber`.

#### Why did the run stop before all source results?

Increase `maxItems` or `maxPagesPerSearch`. Either limit may intentionally stop pagination.

#### Why did a normally working run fail?

The Oregon state site may be under maintenance. Review the Actor log and retry later.

### Data freshness

Each run queries the live public Oregon CCB search application.

`scrapedAt` records when the row was extracted, not when the agency last updated the underlying license.

For recurring compliance checks, schedule fresh runs rather than relying on an old export.

### Responsible use and legality

This Actor accesses public government license records without bypassing authentication.

Users are responsible for complying with applicable laws, source terms, marketing rules, privacy requirements, and internal policies.

Do not treat automated output as legal advice. Confirm high-impact licensing or procurement decisions with Oregon CCB.

### Related scrapers

Explore other Automation Labs actors for complementary public-business workflows:

- [Washington Contractor License Lookup Scraper](https://apify.com/automation-lab/washington-contractor-license-lookup-scraper)
- [Florida DBPR License Verification](https://apify.com/automation-lab/florida-dbpr-license-verification)
- [Michigan Professional License Lookup](https://apify.com/automation-lab/michigan-lara-professional-license-lookup)

Combine state-specific exports using stable license and source fields.

### FAQ

#### Does the Actor require an Oregon account?

No. It uses the public CCB search surface.

#### Can I search inactive licenses?

Yes. Set `activeOnly` to `false` to request all source statuses.

#### Can I search multiple businesses at once?

Yes. Add multiple values to `searchTerms`; the global `maxItems` applies across them.

#### Can I export to Excel or CSV?

Yes. Use the Dataset export controls or API.

#### Does this replace official verification?

No. It automates collection of public records. Confirm critical decisions with the official agency.

#### Can I run it on a schedule?

Yes. Use Apify schedules and webhooks to build recurring monitoring workflows.

### Support

For reproducible support, include:

- the run URL
- non-sensitive input
- the search term involved
- the relevant log excerpt
- expected and actual result counts

Do not include private credentials or unrelated personal data.

# Actor input Schema

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

Business names, CCB license numbers, or address keywords to search.

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

Return only records currently marked active by Oregon CCB.

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

Stop after this many unique search-result records.

## `maxPagesPerSearch` (type: `integer`):

Safety limit for broad searches (20 records per page).

## Actor input object example

```json
{
  "searchTerms": [
    "construction"
  ],
  "activeOnly": true,
  "maxItems": 20,
  "maxPagesPerSearch": 2
}
```

# 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": [
        "construction"
    ],
    "activeOnly": true,
    "maxItems": 20,
    "maxPagesPerSearch": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/oregon-contractor-license-lookup-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": ["construction"],
    "activeOnly": True,
    "maxItems": 20,
    "maxPagesPerSearch": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/oregon-contractor-license-lookup-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": [
    "construction"
  ],
  "activeOnly": true,
  "maxItems": 20,
  "maxPagesPerSearch": 2
}' |
apify call automation-lab/oregon-contractor-license-lookup-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Oregon Contractor License Lookup Scraper",
        "description": "🔎 Search public Oregon CCB contractor records and export license numbers, business names, statuses, and addresses for verification, compliance, or leads.",
        "version": "0.1",
        "x-build-id": "7FdA5YWs0LIQxq33J"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~oregon-contractor-license-lookup-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-oregon-contractor-license-lookup-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~oregon-contractor-license-lookup-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-oregon-contractor-license-lookup-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~oregon-contractor-license-lookup-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-oregon-contractor-license-lookup-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": "Search terms",
                        "type": "array",
                        "description": "Business names, CCB license numbers, or address keywords to search.",
                        "default": [
                            "construction"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "activeOnly": {
                        "title": "Active licenses only",
                        "type": "boolean",
                        "description": "Return only records currently marked active by Oregon CCB.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Maximum license records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many unique search-result records.",
                        "default": 100
                    },
                    "maxPagesPerSearch": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Safety limit for broad searches (20 records per page).",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```