# Japan Construction & Real Estate License Registry Stats (`jpmarketdata/japan-construction-license-checker`) Actor

Official MLIT registry stats for any Japanese prefecture in one call: exact counts of licensed construction companies (all 29 trades) or real-estate brokers, exact national vs prefectural license split, city mix and renewal-based broker age. From $0.02 per area — no subscription. 建設業・宅建業の許認可統計。

- **URL**: https://apify.com/jpmarketdata/japan-construction-license-checker.md
- **Developed by:** [h ichi](https://apify.com/jpmarketdata) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 area registry analyzeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Japan Construction & Real Estate License Registry Stats

**How many licensed construction companies are there in Osaka? How many of them do demolition? What share are nationally licensed? How old are the real-estate brokerages in Fukuoka?** One call answers it — with the *exact* population count, not an estimate.

This Actor queries Japan's official MLIT registry of licensed businesses ([建設業者・宅建業者等企業情報検索システム](https://etsuran2.mlit.go.jp/TAKKEN/)), the legally authoritative source for:

- **建設業許可業者 / licensed construction companies** — ~480,000 nationwide, every one of them licensed in 1 or more of 29 regulated trades
- **宅地建物取引業者 / licensed real-estate brokers** — the only public list of who may legally broker property in Japan

There is **no official API and no bulk download** for this registry, and the search UI is Japanese-only, session-based and Shift_JIS encoded. This Actor turns it into one clean, English-labelled JSON record per prefecture.

### What you get per prefecture (one record)

| Field | Meaning |
|---|---|
| `totalLicensedCompanies` | **Exact registry count** for the prefecture — the size of the market |
| `byBusinessType` | Exact count for each of the **29 construction trades** (civil engineering, building, electrical, plumbing, demolition…) — the industrial structure of the area |
| `topBusinessTypes` | The five largest trades, ranked |
| `ministerLicensedCount` / `ministerLicenseRatio` | **Exact count** (not an estimate) of companies holding a **national (minister) license** = they operate in more than one prefecture. The single best proxy for how consolidated the local market is — e.g. 2,746 of Tokyo's 44,827 construction licensees (6.1%) vs 24 of Kochi's 2,907 (0.8%) |
| `cityDistribution` | Top 10 municipalities by number of licensees |
| `generalLicensedCount` / `specificLicensedCount` | 一般 vs 特定 license mix (optional) |
| `licenseRenewalDistribution`, `medianRenewalCount`, `newEntrantsShare` | *Real estate only:* Japanese broker licenses are renewed every 5 years and the renewal number is printed in every license number — so this is a **business-age profile of the local brokerage market**, including the share of brand-new entrants |

Optionally, every sampled company as its own record (name, license authority, license number, office, address, city).

**Privacy:** the registry displays each company's representative (a natural person). This Actor parses that column away and **never outputs personal names**.

### Pricing — from $0.02 per area, no subscription

| Event | Price | When |
|---|---|---|
| Area registry summary | **$0.02** | Per prefecture (× registry) analyzed |
| Individual company | **$0.002** | Only if you enable **Include individual companies** |

A default run (1 prefecture, summary + all 29 trade counts) costs **$0.02**. Areas that return zero companies are never charged.

### Input

| Field | Example | Notes |
|---|---|---|
| `registry` | `"construction"` | `construction` (建設業許可業者) or `realestate` (宅地建物取引業者) |
| `prefectures` | `["13"]`, `["Tokyo","Kochi"]`, `["東京都"]` | English names, Japanese names or JIS codes — all accepted. Matched on head-office location. $0.02 each |
| `businessTypes` | `["Electrical works","解体"]` | Construction only. Codes 1–29, English or Japanese names. Empty = all 29 trades |
| `breakdownByBusinessType` | `true` | Construction only. Adds the per-trade counts (~30s) |
| `includeIndividualCompanies` | `false` | Enable to also get each sampled company as a record |
| `maxCompaniesPerArea` | `150` | Sample size per prefecture (50–600) |
| `licenseTypeBreakdown` | `false` | Construction only. Adds general/specific license counts |

#### Exact vs sampled — which is which

Most of this Actor's numbers are **population counts, not estimates**: the registry returns a total for any query in a single request, so each one costs one request rather than a full crawl.

| Field | Basis |
|---|---|
| `totalLicensedCompanies` | **Exact** — registry count for the prefecture |
| `byBusinessType` (29 trades) | **Exact** — one registry count per trade |
| `ministerLicensedCount`, `prefecturalLicensedCount`, `ministerLicenseRatio` | **Exact** — dedicated national-license query (`ministerLicenseSource: "exact"`) |
| `generalLicensedCount` / `specificLicensedCount` | **Exact** (optional) |
| `cityDistribution` | Sampled |
| `licenseRenewalDistribution`, `medianRenewalCount`, `newEntrantsShare` | Sampled |

Sampled fields are always listed in `estimatedFrom.sampledFields` together with `sampledCompanies` and `sampledPages`, so you never have to guess.

The registry's default sort groups nationally licensed companies at the top, so sampling the first page only would badly skew a sample. This Actor sorts by **company name** and jumps to **evenly spaced pages across the whole result set** (e.g. pages 1 / 449 / 897 of 897).

### Output example (abridged; totals and license split are real measured values, per-trade counts are illustrative)

```json
{
  "type": "registry_summary",
  "registry": "construction",
  "prefecture": "Tokyo",
  "prefectureNameJa": "東京都",
  "prefectureCode": "13",
  "totalLicensedCompanies": 44827,
  "resultPages": 897,
  "sampledCompanies": 150,
  "sampledPages": [1, 449, 897],
  "byBusinessType": [
    {"code": "1", "name": "Civil engineering works", "nameJa": "土木一式", "companies": 6120},
    {"code": "2", "name": "Building construction", "nameJa": "建築一式", "companies": 14980},
    {"code": "8", "name": "Electrical works", "nameJa": "電気", "companies": 7340},
    {"code": "29", "name": "Demolition", "nameJa": "解体", "companies": 3980}
  ],
  "topBusinessTypes": [{"code": "2", "name": "Building construction", "companies": 14980}],
  "ministerLicensedCount": 2746,
  "prefecturalLicensedCount": 42081,
  "ministerLicenseRatio": 0.0613,
  "ministerLicenseSource": "exact",
  "cityDistribution": [{"city": "世田谷区", "companies": 11}, {"city": "大田区", "companies": 9}],
  "estimatedFrom": {"sampledCompanies": 150, "sampledPages": [1, 449, 897], "sampledFields": ["cityDistribution"]},
  "checkedAt": "2026-07-25T09:00:00+00:00"
}
````

Real-estate runs add instead:

```json
{
  "licenseRenewalDistribution": [{"renewalCount": 1, "companies": 34}, {"renewalCount": 16, "companies": 8}],
  "medianRenewalCount": 4,
  "newEntrantsShare": 0.2267
}
```

### Use cases

- **B2B lead scoping & territory planning** — building materials, tools, heavy equipment and rental firms sizing a prefecture before hiring a rep
- **Insurance & guarantee products** — the licensee population and its trade mix is the addressable market for construction liability and workers' cover
- **Construction SaaS / PropTech go-to-market** — TAM per prefecture, split by trade and by minister vs prefectural license
- **Supply-chain & subcontractor due diligence** — verify that a trade is actually licensed in the area, and how deep the local pool is
- **Market research & policy** — 47-prefecture comparison of construction density, consolidation and brokerage churn (run one call per prefecture)

### Notes & limits

- Companies are matched on their **head-office** location, so a Tokyo-headquartered firm working in Chiba counts under Tokyo
- One company is usually licensed for several trades, so `byBusinessType` counts overlap and sum to far more than `totalLicensedCompanies` — read them as "how many licensees can legally do X", not as a partition
- 一般 (general) and 特定 (specific) licenses can both be held by one company, so those two counts may overlap
- The registry is refreshed roughly monthly by MLIT — treat it as a monthly-fresh source, not a daily feed
- Renewal-count → years-in-business is an **approximation** (the cycle was 3 years before 1996); use the distribution, not a hard age
- Read-only, throttled to ≥1 request/second out of respect for a government system. No login, no personal data, nothing stored between runs
- Keep it to a few prefectures per run; a full per-trade breakdown is ~34 requests (~40 s) per prefecture, a real-estate area 5 requests (~6 s)

***

### 日本語ガイド

**国土交通省「建設業者・宅建業者等企業情報検索システム」の許認可データを、1コールで都道府県単位の市場統計にして返す Actor です。**

- **概要**: 指定した都道府県の **建設業許可業者数(29業種すべての内訳つき)** または **宅地建物取引業者数** を、システムが返す**実数**で取得します。あわせて、**大臣許可・大臣免許の業者数と比率も推定ではなく実数**(専用クエリ1回で取得。例: 東京の建設業は 44,827 社中 2,746 社 = 6.1%、高知は 2,907 社中 24 社 = 0.8%)、市区町村別の分布、一般/特定の内訳(オプション)、宅建業では**免許証番号の更新回数分布**(5年更新のため業歴の指標。新規参入=更新回数1の比率も算出)を返します。公式APIも一括ダウンロードも存在しないデータです。
- **使い方**: `registry` で建設業(`construction`)か宅建業(`realestate`)を選び、`prefectures` に都道府県を指定します(**JISコード `13` / 日本語 `東京都` / 英語 `Tokyo` のいずれでも可**)。業種を絞るときは `businessTypes` にコード(1〜29)・日本語名(電気、解体)・英語名を指定してください。個別業者の一覧が必要な場合のみ `includeIndividualCompanies` を ON にします。
- **料金**: 都道府県サマリー1件 **$0.02**、個別業者レコードは **$0.002/件**(既定は OFF なので、既定実行は $0.02 固定)。0件の地域には課金されません。サブスクリプション不要です。
- **実数とサンプルの区別**: 件数(総数・業種別・**大臣許可/知事許可の内訳**・一般/特定)はすべて**全数の実数**です(`ministerLicenseSource: "exact"`)。標本から算出するのは **市区町村分布** と **宅建の更新回数分布** のみで、対象フィールド名・標本ページ・標本数は `estimatedFrom.sampledFields` に明記されます。標本は商号順に並べた検索結果を**全ページ範囲へ等間隔にジャンプして層化サンプリング**します(先頭ページだけを見ると大臣許可業者に偏るための対策)。
- **個人情報**: 検索結果に表示される**代表者名は出力しません**(取得後に破棄)。商号・許可番号・所在地など法人情報のみを返します。

# Actor input Schema

## `registry` (type: `string`):

Which official MLIT registry to analyze. 'construction' = licensed construction companies (建設業許可業者, 29 trades). 'realestate' = licensed real-estate brokers (宅地建物取引業者).

## `prefectures` (type: `array`):

One or more prefectures. Accepts English names (Tokyo, Osaka, Kochi), Japanese names (東京都, 大阪府) or JIS codes (13, 27, 39). Companies are matched on their head-office location. Each prefecture costs $0.02.

## `businessTypes` (type: `array`):

Construction registry only. Limit the per-trade breakdown to specific trades. Accepts codes (1-29), English names (Building construction, Electrical works, Demolition) or Japanese names (建築一式, 電気, 解体). Leave empty to get the breakdown for all 29 trades.

## `breakdownByBusinessType` (type: `boolean`):

Construction registry only. Adds the exact number of licensed companies for each of the 29 trades (one extra request per trade, ~30s). Turn off for the fastest possible run.

## `includeIndividualCompanies` (type: `boolean`):

Off by default: a run costs a flat $0.02 per prefecture summary. Enable to also get every sampled company (name, license authority & number, office, address, city) at +$0.002 per company. Representative names are never collected.

## `maxCompaniesPerArea` (type: `integer`):

How many companies to sample per prefecture (50 per result page, spread evenly over the whole alphabetically sorted result set). More companies = more accurate license-split, city and renewal statistics, and more records when 'Include individual companies' is on.

## `licenseTypeBreakdown` (type: `boolean`):

Construction registry only. Adds the number of general (一般建設業) and specific (特定建設業) licensees for the prefecture (2 extra requests). A company may hold both, so the two counts can overlap.

## Actor input object example

```json
{
  "registry": "construction",
  "prefectures": [
    "13"
  ],
  "businessTypes": [],
  "breakdownByBusinessType": true,
  "includeIndividualCompanies": false,
  "maxCompaniesPerArea": 150,
  "licenseTypeBreakdown": false
}
```

# 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 = {
    "prefectures": [
        "13"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpmarketdata/japan-construction-license-checker").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 = { "prefectures": ["13"] }

# Run the Actor and wait for it to finish
run = client.actor("jpmarketdata/japan-construction-license-checker").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 '{
  "prefectures": [
    "13"
  ]
}' |
apify call jpmarketdata/japan-construction-license-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=jpmarketdata/japan-construction-license-checker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Japan Construction & Real Estate License Registry Stats",
        "description": "Official MLIT registry stats for any Japanese prefecture in one call: exact counts of licensed construction companies (all 29 trades) or real-estate brokers, exact national vs prefectural license split, city mix and renewal-based broker age. From $0.02 per area — no subscription. 建設業・宅建業の許認可統計。",
        "version": "0.1",
        "x-build-id": "VBwJWRmgxcOWJtKgL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jpmarketdata~japan-construction-license-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jpmarketdata-japan-construction-license-checker",
                "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/jpmarketdata~japan-construction-license-checker/runs": {
            "post": {
                "operationId": "runs-sync-jpmarketdata-japan-construction-license-checker",
                "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/jpmarketdata~japan-construction-license-checker/run-sync": {
            "post": {
                "operationId": "run-sync-jpmarketdata-japan-construction-license-checker",
                "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": [
                    "prefectures"
                ],
                "properties": {
                    "registry": {
                        "title": "Registry",
                        "enum": [
                            "construction",
                            "realestate"
                        ],
                        "type": "string",
                        "description": "Which official MLIT registry to analyze. 'construction' = licensed construction companies (建設業許可業者, 29 trades). 'realestate' = licensed real-estate brokers (宅地建物取引業者).",
                        "default": "construction"
                    },
                    "prefectures": {
                        "title": "Prefectures",
                        "type": "array",
                        "description": "One or more prefectures. Accepts English names (Tokyo, Osaka, Kochi), Japanese names (東京都, 大阪府) or JIS codes (13, 27, 39). Companies are matched on their head-office location. Each prefecture costs $0.02.",
                        "default": [
                            "13"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "businessTypes": {
                        "title": "Construction business types (optional)",
                        "type": "array",
                        "description": "Construction registry only. Limit the per-trade breakdown to specific trades. Accepts codes (1-29), English names (Building construction, Electrical works, Demolition) or Japanese names (建築一式, 電気, 解体). Leave empty to get the breakdown for all 29 trades.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "breakdownByBusinessType": {
                        "title": "Break down by business type",
                        "type": "boolean",
                        "description": "Construction registry only. Adds the exact number of licensed companies for each of the 29 trades (one extra request per trade, ~30s). Turn off for the fastest possible run.",
                        "default": true
                    },
                    "includeIndividualCompanies": {
                        "title": "Include individual companies",
                        "type": "boolean",
                        "description": "Off by default: a run costs a flat $0.02 per prefecture summary. Enable to also get every sampled company (name, license authority & number, office, address, city) at +$0.002 per company. Representative names are never collected.",
                        "default": false
                    },
                    "maxCompaniesPerArea": {
                        "title": "Max companies sampled per area",
                        "minimum": 50,
                        "maximum": 600,
                        "type": "integer",
                        "description": "How many companies to sample per prefecture (50 per result page, spread evenly over the whole alphabetically sorted result set). More companies = more accurate license-split, city and renewal statistics, and more records when 'Include individual companies' is on.",
                        "default": 150
                    },
                    "licenseTypeBreakdown": {
                        "title": "General / specific license breakdown",
                        "type": "boolean",
                        "description": "Construction registry only. Adds the number of general (一般建設業) and specific (特定建設業) licensees for the prefecture (2 extra requests). A company may hold both, so the two counts can overlap.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
