# NIS2 SBI Sector Mapper — Cyberbeveiligingswet Checker (`codeclouds/nis2-sbi-sector-mapper`) Actor

Check of een organisatie onder de Nederlandse Cyberbeveiligingswet (NIS2) valt op basis van SBI-code en bedrijfsgrootte, inclusief essentieel/belangrijk-classificatie.

- **URL**: https://apify.com/codeclouds/nis2-sbi-sector-mapper.md
- **Developed by:** [Dennis](https://apify.com/codeclouds) (community)
- **Categories:** Other, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 classificatie-resultaats

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 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

## NIS2 SBI Sector Mapper — Cyberbeveiligingswet Checker 🇳🇱

Check in seconds whether your organization falls under the Dutch **Cyberbeveiligingswet** (the Dutch implementation of the EU **NIS2 Directive**), which enters into force on **15 August 2026 with no transition period**. Input a SBI code (or sector name) plus company size, and get back whether you're an essential entity, important entity, or out of scope — with the reasoning shown.

### When should an AI agent use this?

- "Does a SBI code 62.01 company with 300 employees fall under NIS2/the Cyberbeveiligingswet?"
- "Is my client an essential or important entity under the Dutch NIS2 law, given their SBI code and headcount?"
- "Check this list of 50 client organizations to see which ones need to worry about the 15 August 2026 Cyberbeveiligingswet deadline."
- "What sector does SBI code 6201 map to under NIS2 Annex I/II, and how confident is that mapping?"
- "Given a sector name like 'drinkwater' and a company's turnover/balance sheet total, is it in scope of NIS2?"
- "Why would this organization be classified as 'buiten scope' for NIS2 — is that just because its SBI code isn't in the rule set?"

### What this Actor does

- Maps a Dutch **SBI code** (or a free-text sector name) to the official NIS2 Annex I ("essential") and Annex II ("important") sectors
- Applies the legal size thresholds (employees / annual turnover / balance sheet total) to determine **essentieel / belangrijk / buiten scope**
- Supports **bulk classification** of many organizations in one run (e.g. an entire client portfolio for an accountant or compliance consultant)
- Flags match confidence (`hoog`/`middel`/`laag`) whenever an SBI division is broader than the legal sector definition, so you know when to double-check manually instead of trusting a false-confident answer
- 100% static rule engine — no scraping, no external API calls at runtime, so results are fast, cheap, and never break due to a source website changing

### Why this matters now

Every year, thousands of Dutch companies discover — often too late — that a new EU directive applies to them. The Cyberbeveiligingswet is a hard, near-term deadline (15 August 2026, no grace period) affecting **18 sectors**, from energy and healthcare to digital infrastructure and chemical manufacturing. Non-compliance carries real supervisory and liability risk. This Actor gives a fast first answer so you know whether to investigate further.

### Input

| Field | Type | Description |
|---|---|---|
| `sbiCode` | string | Main SBI code, e.g. `"62.01"` or `"6201"` (any punctuation is stripped automatically) |
| `sbiCodes` | array of strings | Optional side-activity SBI codes, in addition to `sbiCode`. Every code is classified individually and the results are merged into one outcome using the highest severity (essentieel > belangrijk > buiten_scope > onbekend) |
| `sector` | string | Free-text sector name (e.g. `"energie"`, `"drinkwater"`) — used only if no SBI code is given/recognized |
| `medewerkers` | integer | Number of employees (FTE) |
| `jaaromzetEur` | integer | Annual turnover in EUR |
| `balanstotaalEur` | integer | Balance sheet total in EUR |
| `organisaties` | array | Bulk mode: a list of objects with the same fields above (plus an optional `label` per item), to classify many organizations in one run |

Every field is optional, but without at least a `sbiCode`/`sector` and one size field, the result is `onbekend` (undetermined) rather than a guess.

### Output

One flat JSON object per organization:

```json
{
  "input": { "sbiCode": "62.01", "medewerkers": 300 },
  "sbiDivisieCode": "62",
  "matches": [
    {
      "code": "62",
      "sbiSectie": "K",
      "codeTitel": "Computerprogrammering, consultancy en aanverwante activiteiten",
      "categorie": "I",
      "nis2SectorNaam": "ICT-dienstbeheer (business-to-business)",
      "matchZekerheid": "middel",
      "toelichting": "Managed service providers/MSSP's vallen hieronder, maar niet elke software-consultant — handmatig verifiëren."
    }
  ],
  "grootteklasse": "groot",
  "status": "essentieel",
  "toelichting": "Grote organisatie in een Bijlage I-sector (ICT-dienstbeheer (business-to-business)) — waarschijnlijk een essentiële entiteit.",
  "disclaimer": "Dit is een indicatieve classificatie ... GEEN juridisch bindend advies.",
  "regelsetVersie": "2026-07-12",
  "laatstGecontroleerd": "2026-07-12"
}
````

- **`status`**: `essentieel`, `belangrijk`, `buiten_scope`, or `onbekend` (missing input to decide)
- **`matches`**: can contain more than one entry when an SBI division spans multiple legal sector definitions — the ambiguity is shown, not hidden
- **`matchZekerheid`**: `hoog` means the SBI division maps almost 1:1 to the legal sector; `middel`/`laag` means the division is broader and manual review is recommended
- **`regelsetVersie`** / **`laatstGecontroleerd`**: version and last-checked date of the underlying SBI↔NIS2 rule set, for audit trails
- **`codeMatches`**: only present when `sbiCodes` (side activities) is used — the per-code matches/status before merging into the final `status`/`matches`

### Use cases

- **Accountants & compliance consultants**: bulk-classify an entire client portfolio in one run to flag who needs NIS2 attention before 15 August 2026
- **KvK-enrichment / compliance platforms**: plug this in as a classification step on top of an existing SBI-code lookup
- **MKB self-check**: a single company checking its own SBI code before consulting a lawyer
- **AI agents**: structured JSON output, ideal as an MCP tool for compliance-assistant workflows

### Pricing

This Actor uses Apify's Pay-Per-Event (PPE) pricing model.

- **Actor Start:** $0.00005 (Apify default)
- **classificatie-resultaat:** $0.003 per classified organization

### Legal

- Based on the Cyberbeveiligingswet (Dutch NIS2 implementation, in force 15 August 2026) and the NIS2 Directive Annex I/II sector lists, cross-referenced against the official CBS SBI2025 classification (live-verified via the CBS SBI Typeermodule API).
- **This is an indicative classification, not legal advice.** The SBI-to-NIS2 mapping is a best-effort interpretation by the developer — SBI codes do not map 1:1 onto the legal sector definitions in every case (see `matchZekerheid` per result). Always verify with the official law text, the NCSC, or a legal/compliance advisor before making compliance decisions.
- No personal data is processed — only organization-level classification data (SBI code, sector, size).

### FAQ

**Q: Does a "hoog" matchZekerheid mean I'm definitely in scope?**
A: It means the SBI division is a strong match for the legal sector description — still not a legal guarantee, but the most reliable tier this Actor produces.

**Q: What if my SBI code isn't in the rule set at all?**
A: You get `buiten_scope` — most likely you're not covered, but this rule set is not exhaustive of every edge case in the law. If your company is close to a covered sector, double-check manually.

**Q: Can I check hundreds of companies at once?**
A: Yes — use the `organisaties` bulk input field with one object per company.

**Q: Why no live database lookup by KvK number?**
A: This Actor deliberately stays a pure, static rule engine (no external calls) — it's your input that determines the SBI code. Pair it with a KvK/SBI-lookup actor or your own CRM export if you need that step.

### Related Actors

- **[NL & EU Government Tenders Scraper](https://apify.com/codeclouds/nl-eu-tenders-scraper)** — public procurement leads, another compliance-adjacent Dutch/EU data source by the same developer.
- **[UPV Classificatiechecker](../upv-classificatiechecker)** — the sibling Dutch regulatory-classification checker, built on the same shared rule-engine, but for UPV/Uitgebreide Producentenverantwoordelijkheid (Extended Producer Responsibility) instead of NIS2/Cyberbeveiligingswet.

### Keywords

nis2, cyberbeveiligingswet, sbi-code, compliance, cybersecurity, nederland, mkb, essentiële entiteit, belangrijke entiteit, kvk

### Changelog

#### 0.1.1

- Added optional `sbiCodes` input field for side/secondary activities: every code is classified
  individually and merged into one outcome (highest severity wins). No pricing change.
- Added `regelsetVersie`/`laatstGecontroleerd` output fields for auditability of the underlying rule set.
  No pricing change.
- Invalid input now fails the run with a readable Dutch error message naming the exact field/item
  (including the 1-based item number for `organisaties` bulk input) instead of a raw stack trace.

#### 2026-07-12 - Internal refactor (no behavior change)

- Matching logic and field names (`code`/`codeTitel`/`categorie`/`toelichting`) moved to the shared `shared-rule-engine` package, now that a second classification actor (UPV) uses the same pattern. Classification results are unchanged; only the JSON field names in `matches[]` were renamed for consistency across actors.

#### 0.1.0 - Initial release

- SBI-code and free-text sector classification against the NIS2 Annex I/II rule set.
- Essentieel/belangrijk/buiten\_scope determination based on legal size thresholds.
- Bulk classification via the `organisaties` input field.
- Match-confidence flagging (`hoog`/`middel`/`laag`) for transparency where SBI divisions are broader than the legal sector definition.

# Actor input Schema

## `sbiCode` (type: `string`):

SBI-code van de organisatie (bv. "62.01" of "6201"). Wordt gebruikt om de NIS2-sector te bepalen. Laat leeg om in plaats daarvan 'sector' te gebruiken.

## `sbiCodes` (type: `array`):

Optioneel: extra SBI-codes naast 'sbiCode', bv. de nevenactiviteiten uit een KvK-uittreksel. Elke code wordt afzonderlijk tegen de regelset gematcht; de uiteindelijke status is de hoogste severity over alle codes (essentieel > belangrijk > buiten\_scope > onbekend).

## `sector` (type: `string`):

Alternatief voor SBI-code: een vrije zoekterm voor de sector, bv. "energie" of "drinkwater". Wordt alleen gebruikt als er geen (herkende) SBI-code is opgegeven.

## `medewerkers` (type: `integer`):

Aantal medewerkers (FTE) van de organisatie, bv. 50. Nodig om essentieel/belangrijk/buiten-scope te bepalen.

## `jaaromzetEur` (type: `integer`):

Jaaromzet in euro's, bv. 12000000.

## `balanstotaalEur` (type: `integer`):

Balanstotaal in euro's, bv. 6000000.

## `organisaties` (type: `array`):

Optioneel: classificeer meerdere organisaties in één run. Elk item heeft dezelfde velden als hierboven (sbiCode, sector, medewerkers, jaaromzetEur, balanstotaalEur, en optioneel een eigen 'label' om het item te herkennen in de output). Als dit veld gevuld is, worden de losse velden hierboven genegeerd. Bv. \[{"label": "Bedrijf A", "sbiCode": "62.01", "medewerkers": 50, "jaaromzetEur": 12000000}].

## Actor input object example

```json
{
  "sbiCodes": [],
  "medewerkers": 50,
  "jaaromzetEur": 12000000,
  "balanstotaalEur": 6000000,
  "organisaties": [
    {
      "label": "Bedrijf A",
      "sbiCode": "62.01",
      "medewerkers": 50,
      "jaaromzetEur": 12000000
    }
  ]
}
```

# 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 = {
    "sbiCodes": [],
    "medewerkers": 50,
    "jaaromzetEur": 12000000,
    "balanstotaalEur": 6000000,
    "organisaties": [
        {
            "label": "Bedrijf A",
            "sbiCode": "62.01",
            "medewerkers": 50,
            "jaaromzetEur": 12000000
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("codeclouds/nis2-sbi-sector-mapper").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 = {
    "sbiCodes": [],
    "medewerkers": 50,
    "jaaromzetEur": 12000000,
    "balanstotaalEur": 6000000,
    "organisaties": [{
            "label": "Bedrijf A",
            "sbiCode": "62.01",
            "medewerkers": 50,
            "jaaromzetEur": 12000000,
        }],
}

# Run the Actor and wait for it to finish
run = client.actor("codeclouds/nis2-sbi-sector-mapper").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 '{
  "sbiCodes": [],
  "medewerkers": 50,
  "jaaromzetEur": 12000000,
  "balanstotaalEur": 6000000,
  "organisaties": [
    {
      "label": "Bedrijf A",
      "sbiCode": "62.01",
      "medewerkers": 50,
      "jaaromzetEur": 12000000
    }
  ]
}' |
apify call codeclouds/nis2-sbi-sector-mapper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=codeclouds/nis2-sbi-sector-mapper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NIS2 SBI Sector Mapper — Cyberbeveiligingswet Checker",
        "description": "Check of een organisatie onder de Nederlandse Cyberbeveiligingswet (NIS2) valt op basis van SBI-code en bedrijfsgrootte, inclusief essentieel/belangrijk-classificatie.",
        "version": "0.1",
        "x-build-id": "KV9Jo0ZuunACbIDGD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/codeclouds~nis2-sbi-sector-mapper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-codeclouds-nis2-sbi-sector-mapper",
                "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/codeclouds~nis2-sbi-sector-mapper/runs": {
            "post": {
                "operationId": "runs-sync-codeclouds-nis2-sbi-sector-mapper",
                "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/codeclouds~nis2-sbi-sector-mapper/run-sync": {
            "post": {
                "operationId": "run-sync-codeclouds-nis2-sbi-sector-mapper",
                "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": {
                    "sbiCode": {
                        "title": "SBI-code",
                        "type": "string",
                        "description": "SBI-code van de organisatie (bv. \"62.01\" of \"6201\"). Wordt gebruikt om de NIS2-sector te bepalen. Laat leeg om in plaats daarvan 'sector' te gebruiken."
                    },
                    "sbiCodes": {
                        "title": "Extra SBI-codes (nevenactiviteiten)",
                        "type": "array",
                        "description": "Optioneel: extra SBI-codes naast 'sbiCode', bv. de nevenactiviteiten uit een KvK-uittreksel. Elke code wordt afzonderlijk tegen de regelset gematcht; de uiteindelijke status is de hoogste severity over alle codes (essentieel > belangrijk > buiten_scope > onbekend).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sector": {
                        "title": "Sector (vrije tekst)",
                        "type": "string",
                        "description": "Alternatief voor SBI-code: een vrije zoekterm voor de sector, bv. \"energie\" of \"drinkwater\". Wordt alleen gebruikt als er geen (herkende) SBI-code is opgegeven."
                    },
                    "medewerkers": {
                        "title": "Aantal medewerkers",
                        "type": "integer",
                        "description": "Aantal medewerkers (FTE) van de organisatie, bv. 50. Nodig om essentieel/belangrijk/buiten-scope te bepalen."
                    },
                    "jaaromzetEur": {
                        "title": "Jaaromzet (EUR)",
                        "type": "integer",
                        "description": "Jaaromzet in euro's, bv. 12000000."
                    },
                    "balanstotaalEur": {
                        "title": "Balanstotaal (EUR)",
                        "type": "integer",
                        "description": "Balanstotaal in euro's, bv. 6000000."
                    },
                    "organisaties": {
                        "title": "Bulk: lijst van organisaties",
                        "type": "array",
                        "description": "Optioneel: classificeer meerdere organisaties in één run. Elk item heeft dezelfde velden als hierboven (sbiCode, sector, medewerkers, jaaromzetEur, balanstotaalEur, en optioneel een eigen 'label' om het item te herkennen in de output). Als dit veld gevuld is, worden de losse velden hierboven genegeerd. Bv. [{\"label\": \"Bedrijf A\", \"sbiCode\": \"62.01\", \"medewerkers\": 50, \"jaaromzetEur\": 12000000}]."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```