# CRBR Beneficial Owners Scraper (`automation-lab/crbr-beneficial-owners-scraper`) Actor

Search Poland's CRBR public beneficial ownership register by company name, NIP, KRS, or beneficiary details for KYB/AML workflows.

- **URL**: https://apify.com/automation-lab/crbr-beneficial-owners-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

from $0.02 / 1,000 item extracteds

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

## 🇵🇱 CRBR Beneficial Owners Scraper

Extract structured beneficial ownership data from Poland's public Central Register of Beneficial Owners (CRBR). Search by company name, NIP, KRS, or beneficiary details and export compliance-ready KYB/AML records from the official source.

### What does CRBR Beneficial Owners Scraper do?

CRBR Beneficial Owners Scraper automates searches on Poland's official CRBR public register and saves normalized rows to an Apify dataset.

It helps you answer questions such as:

- Who are the beneficial owners of a Polish company?
- What NIP and KRS identifiers are tied to a CRBR result?
- Which citizenship and residence country values are public for a UBO?
- What control or ownership rights are listed in CRBR?
- What CRBR request ID and timestamp prove the data source?

### Who is it for?

This actor is built for teams that need repeatable Polish company ownership checks.

- 🏦 **AML and KYC teams** screening Polish business customers.
- 🧾 **KYB onboarding teams** enriching company files with UBO data.
- ⚖️ **Compliance analysts** collecting official-source evidence.
- 💳 **Credit-risk teams** reviewing ownership and control structures.
- 🕵️ **Investigators and journalists** researching Polish corporate networks.
- 🧩 **Data teams** building registry pipelines across multiple jurisdictions.

### Why use this actor?

Manual CRBR searches are fine for one company. They are slow and inconsistent when you have many Polish entities to check.

This actor gives you:

- Structured JSON and tabular exports.
- Batch input for many company identifiers.
- Per-record source metadata.
- Output fields designed for compliance workflows.
- Runs on Apify with API, schedules, webhooks, and integrations.

### Official source

The actor uses the public CRBR web application at:

`https://crbr.podatki.gov.pl/adcrbr/#/wyszukaj`

The output includes `sourceUrl`, CRBR request IDs when returned by the service, and the actor's `scrapedAt` timestamp.

### What data can you extract?

| Field | Description |
| --- | --- |
| `companyName` | Full legal name from CRBR |
| `nip` | Polish tax identifier |
| `krs` | Polish court register identifier |
| `legalForm` | Legal form description |
| `companyAddress` | Registered address assembled from CRBR fields |
| `beneficiaryFullName` | Beneficial owner's public full name |
| `beneficiaryPesel` | PESEL when public in CRBR response |
| `beneficiaryCitizenships` | Public citizenship values |
| `beneficiaryResidenceCountry` | Public residence country |
| `controlType` | CRBR control/rights descriptor when available |
| `ownershipPercentage` | Ownership percentage when CRBR provides a numeric value |
| `rightsSummary` | Human-readable summary of rights/control fields |
| `requestId` | CRBR request identifier |
| `presentationStart` | CRBR presentation date from |
| `presentationEnd` | CRBR presentation date to |
| `scrapedAt` | Actor extraction timestamp |

### How much does it cost to scrape CRBR beneficial owners?

This actor uses Apify pay-per-event pricing.

- A small start event is charged once per run.
- A result event is charged for each saved CRBR company-beneficiary record.
- You can keep costs predictable with `maxResults`.

The exact live price is shown on the Apify Store page before you run the actor.

### Input options

The main input is `searches`, an array of CRBR search requests.

Each search has:

- `mode` — `companyName`, `nip`, `krs`, or `beneficiary`.
- `query` — company name, NIP, KRS, or beneficiary name.
- `pesel` — optional for exact beneficiary searches.
- `birthDate` — optional for beneficiary name searches when needed.
- `firstName` and `lastName` — optional overrides for beneficiary searches.

### Example input: company name

```json
{
  "searches": [
    { "mode": "companyName", "query": "ORLEN" }
  ],
  "maxResults": 50
}
````

### Example input: NIP and KRS

```json
{
  "searches": [
    { "mode": "nip", "query": "7742894628" },
    { "mode": "krs", "query": "0000252883" }
  ],
  "maxResults": 100
}
```

### Example input: beneficiary

```json
{
  "searches": [
    {
      "mode": "beneficiary",
      "query": "MAŁGORZATA GOŁUCHOWSKA",
      "pesel": "73110202448"
    }
  ],
  "maxResults": 20
}
```

### Output example

```json
{
  "recordType": "beneficial_owner",
  "searchType": "companyName",
  "sourceQuery": "ORLEN",
  "companyName": "ORLEN ADMINISTRACJA SP. Z O.O.",
  "nip": "7742894628",
  "krs": "0000252883",
  "legalForm": "Spółka z ograniczoną odpowiedzialnością",
  "beneficiaryFullName": "MAŁGORZATA DANUTA GOŁUCHOWSKA",
  "beneficiaryCitizenships": ["PL - POLSKA"],
  "beneficiaryResidenceCountry": "PL - POLSKA",
  "controlTypeCode": "3",
  "rightsSummary": "charakter 3",
  "sourceUrl": "https://crbr.podatki.gov.pl/adcrbr/#/wyszukaj",
  "scrapedAt": "2026-07-06T03:27:12.395Z"
}
```

### How to run

1. Open the actor on Apify.
2. Add one or more CRBR searches.
3. Set `maxResults` to control cost and run size.
4. Start the actor.
5. Export the dataset as JSON, CSV, Excel, or via API.

### Tips for better results

- Use NIP or KRS for exact company checks.
- Use company names for discovery or portfolio screening.
- Keep `maxResults` low for exploratory runs.
- Use `includeRaw` only when you need source fragments for debugging or audit review.
- Beneficiary name searches can require PESEL or birth-date context depending on CRBR validation.

### Integrations

You can connect this CRBR scraper to:

- AML onboarding queues.
- Customer due-diligence case tools.
- Credit-risk enrichment jobs.
- Data warehouses via Apify dataset exports.
- Webhooks that trigger downstream review when a record is found.
- Scheduled monitoring of Polish company portfolios.

### 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/crbr-beneficial-owners-scraper').call({
  searches: [{ mode: 'companyName', query: 'ORLEN' }],
  maxResults: 50,
});

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/crbr-beneficial-owners-scraper').call(run_input={
    'searches': [{'mode': 'companyName', 'query': 'ORLEN'}],
    'maxResults': 50,
})
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~crbr-beneficial-owners-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searches":[{"mode":"companyName","query":"ORLEN"}],"maxResults":50}'
```

### MCP usage

Use this actor from Claude Desktop or Claude Code through Apify MCP:

`https://mcp.apify.com/?tools=automation-lab/crbr-beneficial-owners-scraper`

Claude Code setup:

```bash
claude mcp add apify-crbr https://mcp.apify.com/?tools=automation-lab/crbr-beneficial-owners-scraper
```

Claude Desktop JSON setup:

```json
{
  "mcpServers": {
    "apify-crbr": {
      "url": "https://mcp.apify.com/?tools=automation-lab/crbr-beneficial-owners-scraper"
    }
  }
}
```

Example prompts:

- "Check CRBR beneficial owners for this list of Polish NIP numbers."
- "Find CRBR ownership records for companies matching ORLEN and summarize the owners."
- "Export Polish UBO data to CSV for my KYB review."

### Scheduling and monitoring

For recurring compliance checks, create an Apify schedule with your portfolio input. You can send webhook notifications to Slack, email, or your internal queue when the run finishes.

### Data quality notes

The actor returns what the official CRBR public service returns for the submitted query and date range. Empty results can mean no match, a too-broad or too-specific query, or source-side validation constraints.

### Error handling

The actor retries transient CRBR request failures. If a single search still fails, it logs the failed query and continues with the next search so one bad identifier does not stop the whole batch.

### Legality

CRBR is a public register, but you are responsible for using extracted personal and company data lawfully. Make sure your processing has an appropriate compliance, AML, KYB, journalistic, research, or other legal basis.

### FAQ

#### Is this an official CRBR API?

No. This actor automates the public CRBR web application's publicly reachable search endpoints and preserves official-source metadata returned by CRBR.

#### Can I use the data for AML checks?

The actor is designed for KYB and AML workflows, but your legal/compliance team should decide how CRBR data is processed, retained, and combined with other sources.

### Troubleshooting

#### Why did a beneficiary search return no rows?

CRBR beneficiary search validation can require PESEL or birth-date context. Try an exact company search by NIP or KRS when you know the target company.

#### Why are some ownership percentages empty?

CRBR may describe control rights without a numeric ownership percentage. The actor preserves available rights text in `rightsSummary`.

### Related scrapers

Other automation-lab actors that fit the same compliance workflow:

- https://apify.com/automation-lab/open-sanctions-scraper
- https://apify.com/automation-lab/ofac-sanctions-scraper
- https://apify.com/automation-lab/companies-house-scraper
- https://apify.com/automation-lab/gleif-lei-scraper

### Changelog

- `0.1` — Initial CRBR company and beneficiary search implementation.

### Support

If you need another CRBR output field or an integration pattern, open an issue on the Apify actor page with your input and expected output.

# Actor input Schema

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

List of company or beneficiary searches to run against the CRBR public register.

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

Maximum company-beneficiary relationship records to save.

## `dateFrom` (type: `string`):

Optional CRBR presentation date from in YYYY-MM-DD format. Defaults to today.

## `dateTo` (type: `string`):

Optional CRBR presentation date to in YYYY-MM-DD format. Defaults to dateFrom/today.

## `includeRaw` (type: `boolean`):

Add raw source fragments to each row for audit/debug workflows. Leave disabled for normal exports.

## Actor input object example

```json
{
  "searches": [
    {
      "mode": "companyName",
      "query": "ORLEN"
    }
  ],
  "maxResults": 20,
  "includeRaw": false
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searches": [
        {
            "mode": "companyName",
            "query": "ORLEN"
        }
    ],
    "maxResults": 20,
    "includeRaw": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/crbr-beneficial-owners-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 = {
    "searches": [{
            "mode": "companyName",
            "query": "ORLEN",
        }],
    "maxResults": 20,
    "includeRaw": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/crbr-beneficial-owners-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 '{
  "searches": [
    {
      "mode": "companyName",
      "query": "ORLEN"
    }
  ],
  "maxResults": 20,
  "includeRaw": false
}' |
apify call automation-lab/crbr-beneficial-owners-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CRBR Beneficial Owners Scraper",
        "description": "Search Poland's CRBR public beneficial ownership register by company name, NIP, KRS, or beneficiary details for KYB/AML workflows.",
        "version": "0.1",
        "x-build-id": "eOoOo92HFDfA6CfPj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~crbr-beneficial-owners-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-crbr-beneficial-owners-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~crbr-beneficial-owners-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-crbr-beneficial-owners-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~crbr-beneficial-owners-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-crbr-beneficial-owners-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": [
                    "searches"
                ],
                "properties": {
                    "searches": {
                        "title": "🔎 CRBR searches",
                        "type": "array",
                        "description": "List of company or beneficiary searches to run against the CRBR public register.",
                        "items": {
                            "type": "object",
                            "required": [
                                "mode",
                                "query"
                            ],
                            "properties": {
                                "mode": {
                                    "title": "Search mode",
                                    "type": "string",
                                    "enum": [
                                        "companyName",
                                        "nip",
                                        "krs",
                                        "beneficiary"
                                    ],
                                    "enumTitles": [
                                        "Company name",
                                        "NIP tax ID",
                                        "KRS registry number",
                                        "Beneficiary person"
                                    ],
                                    "description": "Choose how the query should be sent to CRBR."
                                },
                                "query": {
                                    "title": "Query",
                                    "type": "string",
                                    "description": "Company name, NIP, KRS, or beneficiary full name."
                                },
                                "firstName": {
                                    "title": "Beneficiary first name",
                                    "type": "string",
                                    "description": "Optional first name override for beneficiary searches."
                                },
                                "lastName": {
                                    "title": "Beneficiary last name",
                                    "type": "string",
                                    "description": "Optional last name override for beneficiary searches."
                                },
                                "pesel": {
                                    "title": "Beneficiary PESEL",
                                    "type": "string",
                                    "description": "Optional PESEL for exact beneficiary searches."
                                },
                                "birthDate": {
                                    "title": "Beneficiary birth date",
                                    "type": "string",
                                    "description": "Optional birth date in YYYY-MM-DD format."
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum company-beneficiary relationship records to save.",
                        "default": 20
                    },
                    "dateFrom": {
                        "title": "CRBR presentation date from",
                        "type": "string",
                        "description": "Optional CRBR presentation date from in YYYY-MM-DD format. Defaults to today."
                    },
                    "dateTo": {
                        "title": "CRBR presentation date to",
                        "type": "string",
                        "description": "Optional CRBR presentation date to in YYYY-MM-DD format. Defaults to dateFrom/today."
                    },
                    "includeRaw": {
                        "title": "Include raw CRBR fragments",
                        "type": "boolean",
                        "description": "Add raw source fragments to each row for audit/debug workflows. Leave disabled for normal exports.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
