# UPV Classificatiechecker — Producentenverantwoordelijkheid NL (`codeclouds/upv-classificatiechecker`) Actor

Bepaal op basis van een productomschrijving of GN/HS-code onder welke UPV-categorie (Uitgebreide Producentenverantwoordelijkheid) een product in Nederland valt: wettelijk, vrijwillig, of financieel.

- **URL**: https://apify.com/codeclouds/upv-classificatiechecker.md
- **Developed by:** [Dennis](https://apify.com/codeclouds) (community)
- **Categories:** Other
- **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

## UPV Classificatiechecker — Uitgebreide Producentenverantwoordelijkheid 🇳🇱

Check in seconds whether a product falls under one of the Dutch **UPV** (Uitgebreide Producentenverantwoordelijkheid / Extended Producer Responsibility) categories — textiles, packaging, batteries, mattresses, and 9 more — and whether that obligation is **legally mandatory, voluntary, or a financial-only contribution**.

### When should an AI agent use this?

- "Does a kindermatras (children's mattress) fall under a Dutch UPV category, and is it mandatory or voluntary?"
- "Check whether our winterjassen (winter coats) product line triggers a UPV textile obligation."
- "We sell 60,000 kg of packaging per year — does that cross the UPV packaging threshold?"
- "Which of these 20 products in our catalog are subject to a wettelijke (legal), vrijwillige (voluntary), or financiële (financial-only) UPV obligation?"
- "Is 'vochtige doekjes' (wet wipes) a full UPV responsibility scheme or just a financial contribution?"
- "Given a direct category code like 'batterijen' or 'vistuig', what UPV obligation applies?"

### Why this matters

UPV isn't one regulation — it's a growing family of product categories (textiles, packaging, single-use plastics, mattresses, fishing gear, flat glass — with shoes, diapers and furniture already announced for future inclusion). Even businesses that think they're outside UPV's scope can be caught by surprise through packaging or components. This Actor gives a fast first answer per product line, so you know when to dig deeper.

### What this Actor does

- Maps a free-text **product description** (or a direct category code) to 1 of **13 UPV categories**
- Distinguishes between **wettelijk** (legally mandatory), **vrijwillig** (voluntary sector covenant), and **financieel** (financial contribution only, e.g. under the Single-Use Plastics directive)
- Applies the **50,000 kg/year packaging threshold** when a quantity is supplied
- Supports **bulk classification** of an entire product catalog in one run
- Flags match confidence (`hoog`/`middel`/`laag`) — free-text matching against product descriptions is inherently approximate, and this Actor shows that honestly instead of pretending certainty
- 100% static rule engine — no scraping, no external API calls at runtime

### Input

| Field | Type | Description |
|---|---|---|
| `productomschrijving` | string | Free-text product description, e.g. `"kindermatras"` or `"partij winterjassen"` |
| `categorie` | string | Direct category code instead of free text, e.g. `"textiel"`, `"verpakkingen"`, `"batterijen"` — takes priority if both are given |
| `jaarlijkseHoeveelheidKg` | integer | Only relevant for the `verpakkingen` category: annual packaging weight in kg, for the 50,000 kg threshold check |
| `producten` | array | Bulk mode: a list of objects with the same fields above (plus an optional `label` per item) |
| `trackWijzigingen` | boolean | Compares each product's UPV status against the previous run (via this Actor's key-value store) and flags an actual status change. Default `false` |

### Output

```json
{
  "input": { "productomschrijving": "partij winterjassen en truien voor de webshop" },
  "matches": [
    {
      "code": "textiel",
      "codeTitel": "Textiel (consumentenkleding, bedrijfskleding, huishoudtextiel)",
      "productgroepNaam": "Textiel",
      "categorie": "wettelijk",
      "matchZekerheid": "hoog",
      "toelichting": "Van kracht sinds 1 juli 2023. ...",
      "volgendeStap": {
        "uitvoeringsorganisatie": "Stichting UPV Textiel",
        "registratieUrl": "https://www.stichtingupvtextiel.nl/aanmelden/",
        "aanmeldtermijn": null,
        "opmerking": "Jaarlijkse rapportageplicht vanaf augustus 2026 aangekondigd — verifieer de exacte datum bij Stichting UPV Textiel."
      }
    }
  ],
  "status": "wettelijk_verplicht",
  "toelichting": "Match met wettelijke UPV-categorie(ën): Textiel. ...",
  "disclaimer": "Dit is een indicatieve classificatie ... GEEN juridisch bindend advies.",
  "regelsetLaatstGeverifieerd": "2026-07-12",
  "wijzigingsAlert": null
}
````

- **`status`**: `wettelijk_verplicht`, `vrijwillig_van_toepassing`, `financiele_bijdrage_verplicht`, `onder_drempel`, `buiten_scope`, or `onbekend`
- **`regelsetLaatstGeverifieerd`**: the date the underlying UPV rule set was last checked against
  ilent.nl/afvalcirculair.nl. UPV is a growing family of categories (shoes, diapers, and furniture have been
  announced) — this field tells you how fresh the classification logic is, so you know when to double-check.
- **`matches`**: can contain more than one category if a product spans multiple UPV categories
- **`volgendeStap`** (per match): the executing organization and registration URL, live-verified on 2026-07-16
  per category. `uitvoeringsorganisatie`/`registratieUrl` are `null` when no reliable current source was
  found (never a guess) — `opmerking` explains why, and flags categories where the organizational setup was
  itself unsettled/in transition at verification time (notably the three financial-only SUP categories).
- **`wijzigingsAlert`**: `null` unless `trackWijzigingen` is enabled and a real status change vs. the previous
  run was detected — see below
- If nothing matches your free-text description, the response suggests the exact category codes you can try directly instead

#### Change tracking (`trackWijzigingen`, optional, separately charged)

With `trackWijzigingen: true`, each product's UPV `status` is compared against the previous run (stored in
this Actor's key-value store) and, when it actually changed, `wijzigingsAlert` is filled:

```json
{ "wijzigingsAlert": { "vorigeStatus": "onder_drempel", "huidigeStatus": "wettelijk_verplicht" } }
```

Products are identified across runs via the optional `label` field (recommended for scheduled/bulk runs) —
without a `label`, the actor falls back to a key derived from `categorie`+`productomschrijving`, so changing
that text without a `label` is treated as a *different* product, not a status change of the same one. Charged
as `wijzigings-alert`, only when a status change is actually detected (never on the first run for a product).

**Bulk runs (more than 1 product) also get one summary record** at the end (`catalogus-samenvatting` event, $0.015 flat per run):

```json
{
  "type": "catalogusSamenvatting",
  "aantalProducten": 20,
  "perStatus": { "wettelijk_verplicht": 12, "vrijwillig_van_toepassing": 2, "financiele_bijdrage_verplicht": 1, "onder_drempel": 1, "buiten_scope": 4, "onbekend": 0 },
  "uniekeProductgroepen": ["Textiel", "Verpakkingen", "Batterijen"],
  "aantalMetLageMatchZekerheid": 3
}
```

### The 13 UPV categories covered

**Wettelijk (mandatory):** autobanden, auto's, batterijen, elektrische/elektronische apparatuur, textiel, verpakkingen, vistuig
**Vrijwillig (voluntary):** papier en karton, vlakglas, consumentenmatrassen
**Financieel (financial contribution only):** vochtige doekjes, ballonnen, tabaksfilters

### Use cases

- **Webshop owners & importers**: check your product catalog for UPV obligations before you start selling
- **Compliance consultants**: bulk-classify a client's full product range in one run
- **Sourcing/procurement teams**: flag which new product lines will trigger a new UPV registration
- **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.006 per classified product (increased from $0.003 — every match now
  includes actionable `volgendeStap` info: the executing organization and registration URL, not just a bare
  category label)
- **catalogus-samenvatting:** $0.015 flat, only charged once per run with 2+ producten
- **wijzigings-alert:** $0.01 extra, only with `trackWijzigingen` enabled and an actual status change
  detected vs. the previous run

### Legal

- Based on official Dutch sources (ilent.nl, afvalcirculair.nl / Rijkswaterstaat), cross-referenced 2026-07-12.
- **This is an indicative classification, not legal advice.** Free-text matching against product descriptions is inherently approximate — see `matchZekerheid` per result. Always verify with ilent.nl or a compliance advisor before making registration decisions.
- No personal data is processed — only product-level classification data.

### FAQ

**Q: My product description didn't match anything — does that mean I'm not covered?**
A: Probably, but the rule set isn't exhaustive and free-text matching has limits. Try a direct `categorie` code (the response lists all 13 codes when nothing matches) or check ilent.nl yourself.

**Q: Are shoes covered under Textiel?**
A: Some secondary sources mention shoes joining UPV Textiel from 2026, but this Actor's rule set does NOT assume that — it's not confirmed on the official ILT page at the time of writing. Verify separately if this applies to you.

**Q: What's the difference between "wettelijk", "vrijwillig" and "financieel"?**
A: "Wettelijk" means a full legal producer-responsibility scheme applies (registration, reporting, financing waste management). "Vrijwillig" means there's a sector covenant but no legal obligation. "Financieel" means only a financial contribution is required (typically under the EU Single-Use Plastics directive), not a full responsibility scheme.

### Related Actors

- **[NIS2 SBI Sector Mapper](../nis2-sbi-sector-mapper)** — the sibling Dutch regulatory-classification checker, built on the same shared rule-engine, but for NIS2/Cyberbeveiligingswet instead of UPV/Uitgebreide Producentenverantwoordelijkheid. Run both Actors against the same company/product data for a combined view of your Dutch regulatory exposure (UPV producer responsibility + NIS2 cybersecurity duties) — there is no integrated call between them, this is a manual two-Actor workflow.

### Keywords

upv, uitgebreide producentenverantwoordelijkheid, extended producer responsibility, textiel, verpakkingen, compliance, circulaire economie, netherlands, mkb

### Changelog

#### 0.4.0 - Next-step info & change tracking

- Every match now includes `volgendeStap`: the executing organization and registration URL per UPV category,
  live-verified 2026-07-16 (`null` fields where no reliable current source was found — never a guess, with an
  `opmerking` explaining the gap). `classificatie-resultaat` increased from $0.003 to $0.006 to reflect this
  added actionable value.
- Added `trackWijzigingen` (opt-in) — compares each product's status against the previous run via a named
  key-value store, exposed as `wijzigingsAlert`. New `wijzigings-alert` event ($0.01), only charged on an
  actually detected status change. Products are identified via `label`, or a fallback key derived from
  `categorie`+`productomschrijving`.

#### 0.3.2

- Store description no longer promises GN/HS-code input support — there is no official GN/HS-code table for
  UPV categories, only free-text `productomschrijving` and direct `categorie` codes are supported. Text
  correction only, no pricing change.
- Related Actors section now explicitly points out the NIS2 SBI Sector Mapper cross-reference is a manual
  two-Actor workflow (no integrated call). No pricing change.

#### 0.3.1 - Bugfix

- `classificatie-resultaat` is no longer charged when the result status is `onbekend` (empty/meaningless
  request) — the customer received nothing to classify, so they aren't billed for it.

#### 0.3.0

- Added a `catalogus-samenvatting` record at the end of bulk runs (2+ producten): counts per status, unique
  matched productgroepen and how many results include at least one low-`matchZekerheid` match worth a manual
  review. New charged event ($0.015 flat per run), confirmed by the user (2026-07-14).

#### 0.2.0

- Added `regelsetLaatstGeverifieerd` to every result — the date the UPV rule set itself was last checked
  against ilent.nl/afvalcirculair.nl, for transparency as the category list grows. No pricing change.

#### 0.1.0 - Initial release

- Free-text and direct-code classification against 13 UPV categories (wettelijk/vrijwillig/financieel).
- 50,000 kg/year packaging threshold check.
- Bulk classification via the `producten` input field.
- Match-confidence flagging (`hoog`/`middel`/`laag`) for transparency.
- Built on the shared `shared-rule-engine` package (also used by the NIS2 SBI Sector Mapper).

# Actor input Schema

## `productomschrijving` (type: `string`):

Vrije tekst, bv. "kindermatras" of "partij winterjassen". Wordt gematcht tegen de UPV-regelset. Laat leeg om in plaats daarvan een directe 'categorie'-code te gebruiken.

## `categorie` (type: `string`):

Directe categorie-code i.p.v. vrije tekst, bv. "textiel", "verpakkingen", "batterijen". Heeft voorrang boven productomschrijving als beide zijn ingevuld.

## `jaarlijkseHoeveelheidKg` (type: `integer`):

Alleen relevant voor de categorie 'verpakkingen': jaarlijkse hoeveelheid verpakkingsmateriaal in kg, bv. 60000, voor de 50.000kg-drempelcheck.

## `producten` (type: `array`):

Optioneel: classificeer meerdere producten in één run. Elk item heeft dezelfde velden als hierboven (productomschrijving, categorie, jaarlijkseHoeveelheidKg, en optioneel een eigen 'label'). Als dit veld gevuld is, worden de losse velden hierboven genegeerd. Bv. \[{"label": "Product A", "productomschrijving": "kindermatras"}].

## `trackWijzigingen` (type: `boolean`):

Vergelijkt de UPV-status van elk product met de vorige run (via de key-value store van deze actor) en markeert een daadwerkelijke statuswijziging. Producten worden herkend via 'label' (aanbevolen bij bulk/scheduled runs) of anders via categorie+productomschrijving. Nieuw event wijzigings-alert ($0,01), alleen bij een daadwerkelijk gedetecteerde statuswijziging.

## Actor input object example

```json
{
  "jaarlijkseHoeveelheidKg": 60000,
  "producten": [
    {
      "label": "Product A",
      "productomschrijving": "kindermatras"
    }
  ],
  "trackWijzigingen": 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 = {
    "jaarlijkseHoeveelheidKg": 60000,
    "producten": [
        {
            "label": "Product A",
            "productomschrijving": "kindermatras"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("codeclouds/upv-classificatiechecker").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 = {
    "jaarlijkseHoeveelheidKg": 60000,
    "producten": [{
            "label": "Product A",
            "productomschrijving": "kindermatras",
        }],
}

# Run the Actor and wait for it to finish
run = client.actor("codeclouds/upv-classificatiechecker").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 '{
  "jaarlijkseHoeveelheidKg": 60000,
  "producten": [
    {
      "label": "Product A",
      "productomschrijving": "kindermatras"
    }
  ]
}' |
apify call codeclouds/upv-classificatiechecker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UPV Classificatiechecker — Producentenverantwoordelijkheid NL",
        "description": "Bepaal op basis van een productomschrijving of GN/HS-code onder welke UPV-categorie (Uitgebreide Producentenverantwoordelijkheid) een product in Nederland valt: wettelijk, vrijwillig, of financieel.",
        "version": "0.1",
        "x-build-id": "UNGjvzuG891ccQ9Ok"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/codeclouds~upv-classificatiechecker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-codeclouds-upv-classificatiechecker",
                "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~upv-classificatiechecker/runs": {
            "post": {
                "operationId": "runs-sync-codeclouds-upv-classificatiechecker",
                "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~upv-classificatiechecker/run-sync": {
            "post": {
                "operationId": "run-sync-codeclouds-upv-classificatiechecker",
                "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": {
                    "productomschrijving": {
                        "title": "Productomschrijving",
                        "type": "string",
                        "description": "Vrije tekst, bv. \"kindermatras\" of \"partij winterjassen\". Wordt gematcht tegen de UPV-regelset. Laat leeg om in plaats daarvan een directe 'categorie'-code te gebruiken."
                    },
                    "categorie": {
                        "title": "Categorie-code (direct)",
                        "type": "string",
                        "description": "Directe categorie-code i.p.v. vrije tekst, bv. \"textiel\", \"verpakkingen\", \"batterijen\". Heeft voorrang boven productomschrijving als beide zijn ingevuld."
                    },
                    "jaarlijkseHoeveelheidKg": {
                        "title": "Jaarlijkse hoeveelheid (kg)",
                        "type": "integer",
                        "description": "Alleen relevant voor de categorie 'verpakkingen': jaarlijkse hoeveelheid verpakkingsmateriaal in kg, bv. 60000, voor de 50.000kg-drempelcheck."
                    },
                    "producten": {
                        "title": "Bulk: lijst van producten",
                        "type": "array",
                        "description": "Optioneel: classificeer meerdere producten in één run. Elk item heeft dezelfde velden als hierboven (productomschrijving, categorie, jaarlijkseHoeveelheidKg, en optioneel een eigen 'label'). Als dit veld gevuld is, worden de losse velden hierboven genegeerd. Bv. [{\"label\": \"Product A\", \"productomschrijving\": \"kindermatras\"}]."
                    },
                    "trackWijzigingen": {
                        "title": "Wijzigingen bijhouden tussen runs",
                        "type": "boolean",
                        "description": "Vergelijkt de UPV-status van elk product met de vorige run (via de key-value store van deze actor) en markeert een daadwerkelijke statuswijziging. Producten worden herkend via 'label' (aanbevolen bij bulk/scheduled runs) of anders via categorie+productomschrijving. Nieuw event wijzigings-alert ($0,01), alleen bij een daadwerkelijk gedetecteerde statuswijziging.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```