# Czech Insolvency Register ISIR - Bankruptcy Check & Monitor (`pringlesbitch/czech-insolvency-register-isir`) Actor

Check Czech companies and individuals for insolvency in the official ISIR register. Lookups by company ID, personal ID or name, incremental monitoring of new events with watchlists and webhooks, case details. Normalized English output for KYC and compliance.

- **URL**: https://apify.com/pringlesbitch/czech-insolvency-register-isir.md
- **Developed by:** [Pringles Kamila](https://apify.com/pringlesbitch) (community)
- **Categories:** Automation, Lead generation, Integrations
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 subject lookups

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Czech Insolvency Register (ISIR) — Bankruptcy Check, Monitoring & Case Details

Query the **official Czech insolvency register (ISIR)** run by the Ministry of Justice — the
single authoritative source of all bankruptcy and insolvency proceedings in the Czech Republic
since 2008. This actor turns the registry's legacy SOAP services into a clean, normalized
**English-language JSON API**: instant insolvency checks by company ID, real-time monitoring
of new insolvency events, and full case state resolution.

Built for **KYC and compliance teams, factoring and trade-credit providers, debt collection
agencies, distressed-debt funds, credit bureaus and M&A due-diligence** workflows that need
reliable Czech insolvency data without dealing with Czech-only SOAP/XML interfaces.

### 1. What it does

| Mode | What you get | Typical use |
|---|---|---|
| `lookup` | Instant insolvency check for companies (IČO), individuals (personal ID) or names — including **negative results** (subject is clean) | KYC / onboarding, credit checks |
| `monitor` | Incremental feed of **new insolvency events** since your last run, with optional watchlist filtering and webhook notifications | Debtor monitoring, portfolio alerts |
| `proceeding` | Current state of specific insolvency cases by case number (e.g. `INS 12575/2022`) | Case tracking, collections |

Data comes live from both official ISIR web services (`ISIR_CUZK_WS2` for lookups,
`ISIR_PUBLIC_WS` replication log for monitoring). No API keys needed on the registry side,
data is legally public.

### 2. Quick start

**Insolvency check by company ID:**
```json
{ "mode": "lookup", "icos": ["25083325"] }
````

**Monitor a debtor watchlist daily** (run on a schedule — state persists between runs):

```json
{
  "mode": "monitor",
  "watchlistIcos": ["25083325", "00074358"],
  "watchlistBirthNumbers": ["820331/3316"],
  "webhookUrl": "https://your-app.example.com/isir-alerts"
}
```

**Resolve case details:**

```json
{ "mode": "proceeding", "caseNumbers": ["INS 12575/2022"] }
```

### 3. Output — normalized English schema

```json
{
  "record_type": "lookup_result",
  "has_insolvency": true,
  "case_number": "INS 12575/2022",
  "court": "Městský soud v Praze",
  "senate": 95,
  "debtor": {
    "name": "Sberbank CZ, a.s. v likvidaci",
    "ico": "25083325",
    "birth_number_masked": null,
    "type": "legal",
    "address": { "city": "Praha 5", "street": "U Trezorky", "zip": "158 00" }
  },
  "proceeding_state": "bankruptcy_liquidation",
  "proceeding_state_cs": "KONKURS",
  "insolvency_started_at": "2022-09-13",
  "source_url": "https://isir.justice.cz/isir/ueu/evidence_upadcu_detail.do?id=…",
  "scraped_at": "2026-07-11T12:26:35+00:00"
}
```

Monitor mode emits `record_type: "event"` records with the event ID, official event type
code, Czech label and an **English label for the ~40 most common event types** (insolvency
petition, bankruptcy order, debt relief approval, creditor claim filed, …), links to court
documents (PDF) when published, and the deep link into the registry.

Proceeding states are normalized to an English enum: `pending`, `moratorium`,
`insolvency_declared`, `bankruptcy_liquidation`, `debt_relief`, `reorganization`,
`resolved`, `final`, `closed` and more — raw Czech codes are always kept alongside.

**Privacy note:** Czech personal IDs (rodné číslo) are accepted as input but are **never
exposed in plain text** in the output — only masked (`820331/****`) plus a SHA-256 hash
for deterministic joining.

### 4. Real-time API & MCP (AI agents)

The actor supports **Standby mode**: `GET /lookup?ico=25083325` returns the insolvency
check as JSON in ~1 second. Once published, the actor is automatically available as an
**MCP tool** via `mcp.apify.com` — ideal for compliance copilots that need to
*"check a Czech company or person for insolvency"* as a single tool call.

### 5. Pricing (pay per event)

| Event | Price | Charged for |
|---|---|---|
| `subject-lookup` | **$0.015** | each checked subject in lookup mode (negative results included — a clean check is valuable) |
| `monitoring-event` | **$0.005** | each emitted event in monitor mode |
| `proceeding-detail` | **$0.03** | each resolved case in proceeding mode |
| `actor-start` | $0.0001 | each run |

1,000 KYC checks ≈ $15/month — a fraction of commercial registry data providers.
Cost protection: `maxItems`, `maxEvents` and your Apify spending limits are always honored.

#### Why this actor

Unlike simple ISIR search scrapers, this actor talks directly to the **official ministry
web services** (no fragile HTML scraping) and is the only one offering an **incremental
event feed**: run it on a schedule and get exactly the new insolvency events since your
last run — no duplicates, no gaps, with watchlists, webhooks, masked-PII output and a
real-time lookup API for AI agents. Lookup by IČO, personal ID, name **or case number**.

### 6. FAQ & notes

- **Is this legal?** Yes. ISIR is a public register established by Czech law (Act 182/2006
  Coll., Insolvency Act); the Ministry of Justice explicitly operates these web services
  for automated consumption.
- **How fresh is the data?** The registry log is written by courts continuously; monitor
  mode picks up events within minutes of publication. Lookup responses include the
  registry synchronization timestamp.
- **First monitor run:** starts from the *current end* of the registry log (no historical
  backfill by default — the log contains ~79 million events since 2008). Use `startFromId`
  to begin from a specific position.
- **Reliability:** monitor state is persisted in a named key-value store and survives
  restarts and failed runs without duplicates or gaps.
- **Search keywords:** Czech insolvency register API, ISIR API, Czech bankruptcy check,
  insolvency monitoring Czech Republic, debtor monitoring, KYC Czech Republic, insolvenční
  rejstřík, lustrace, credit risk Czechia.

**Works well with:** [CZ & SK Real Estate Aggregator](https://apify.com/store) — monitor
distressed real estate alongside insolvency proceedings for a complete distressed-asset
pipeline.

# Actor input Schema

## `mode` (type: `string`):

<b>lookup</b> — check subjects for insolvency (by IČO, personal ID or name). <b>monitor</b> — incrementally emit new insolvency events since the last run (state persists between runs; use with a schedule). <b>proceeding</b> — resolve current state of specific insolvency cases by case number.

## `icos` (type: `array`):

Czech company identification numbers to check (8 digits, leading zeros allowed). Lookup mode.

## `birthNumbers` (type: `array`):

Czech personal identification numbers, with or without slash. <b>Privacy:</b> personal IDs are never echoed to the output in plain text — only masked (YYMMDD/\*\*\*\*) plus a SHA-256 hash for joining.

## `names` (type: `array`):

Person surnames or company names to search for. Lookup mode. Name search can return multiple matches — combine with exactNameMatch.

## `exactNameMatch` (type: `boolean`):

Only return exact name matches (applies to name-based lookups).

## `ignoreDiacritics` (type: `boolean`):

Match names regardless of Czech diacritics (Novak = Novák).

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

Only return currently active insolvency proceedings (skip closed/historical ones).

## `caseNumbers` (type: `array`):

Insolvency case numbers to resolve, e.g. 'INS 12575/2022'. Proceeding mode.

## `watchlistIcos` (type: `array`):

Monitor mode: only emit events whose debtor matches one of these IČOs. Leave empty (with empty watchlist personal IDs) to emit all new events.

## `watchlistBirthNumbers` (type: `array`):

Monitor mode: only emit events whose debtor matches one of these personal IDs (with or without slash).

## `startFromId` (type: `integer`):

Monitor mode, first run only: start reading the registry log after this event ID. Leave empty to start from the current end of the log (recommended).

## `maxEvents` (type: `integer`):

Monitor mode: stop after emitting this many events (cost protection).

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

Lookup & proceeding modes: cap on processed subjects or case numbers (cost protection).

## `maxResultsPerSubject` (type: `integer`):

Cap on registry matches returned for a single subject (name searches can match many).

## `maxBatches` (type: `integer`):

Monitor mode: max registry log batches (1000 events each) scanned per run.

## `webhookUrl` (type: `string`):

Monitor mode: POST a JSON notification here when new events were emitted.

## `stateStoreName` (type: `string`):

Named key-value store holding the monitor position between runs. Change to run multiple independent monitors.

## `stateSaveInterval` (type: `integer`):

How often (in emitted events) to persist monitor state. 1 = safest (at most one duplicate on crash), higher = fewer store writes.

## Actor input object example

```json
{
  "mode": "lookup",
  "icos": [
    "25083325"
  ],
  "exactNameMatch": false,
  "ignoreDiacritics": true,
  "activeOnly": false,
  "maxEvents": 1000,
  "maxItems": 100,
  "maxResultsPerSubject": 50,
  "maxBatches": 100,
  "stateStoreName": "cz-isir-state",
  "stateSaveInterval": 1
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("pringlesbitch/czech-insolvency-register-isir").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 = { "icos": ["25083325"] }

# Run the Actor and wait for it to finish
run = client.actor("pringlesbitch/czech-insolvency-register-isir").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 '{
  "icos": [
    "25083325"
  ]
}' |
apify call pringlesbitch/czech-insolvency-register-isir --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=pringlesbitch/czech-insolvency-register-isir",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Czech Insolvency Register ISIR - Bankruptcy Check & Monitor",
        "description": "Check Czech companies and individuals for insolvency in the official ISIR register. Lookups by company ID, personal ID or name, incremental monitoring of new events with watchlists and webhooks, case details. Normalized English output for KYC and compliance.",
        "version": "0.1",
        "x-build-id": "gV9G9ORnZuCdpxSxo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/pringlesbitch~czech-insolvency-register-isir/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-pringlesbitch-czech-insolvency-register-isir",
                "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/pringlesbitch~czech-insolvency-register-isir/runs": {
            "post": {
                "operationId": "runs-sync-pringlesbitch-czech-insolvency-register-isir",
                "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/pringlesbitch~czech-insolvency-register-isir/run-sync": {
            "post": {
                "operationId": "run-sync-pringlesbitch-czech-insolvency-register-isir",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "lookup",
                            "monitor",
                            "proceeding"
                        ],
                        "type": "string",
                        "description": "<b>lookup</b> — check subjects for insolvency (by IČO, personal ID or name). <b>monitor</b> — incrementally emit new insolvency events since the last run (state persists between runs; use with a schedule). <b>proceeding</b> — resolve current state of specific insolvency cases by case number.",
                        "default": "lookup"
                    },
                    "icos": {
                        "title": "Company IDs (IČO)",
                        "type": "array",
                        "description": "Czech company identification numbers to check (8 digits, leading zeros allowed). Lookup mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "birthNumbers": {
                        "title": "Personal IDs (rodné číslo)",
                        "type": "array",
                        "description": "Czech personal identification numbers, with or without slash. <b>Privacy:</b> personal IDs are never echoed to the output in plain text — only masked (YYMMDD/****) plus a SHA-256 hash for joining.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "names": {
                        "title": "Names",
                        "type": "array",
                        "description": "Person surnames or company names to search for. Lookup mode. Name search can return multiple matches — combine with exactNameMatch.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "exactNameMatch": {
                        "title": "Exact name match",
                        "type": "boolean",
                        "description": "Only return exact name matches (applies to name-based lookups).",
                        "default": false
                    },
                    "ignoreDiacritics": {
                        "title": "Ignore diacritics",
                        "type": "boolean",
                        "description": "Match names regardless of Czech diacritics (Novak = Novák).",
                        "default": true
                    },
                    "activeOnly": {
                        "title": "Active proceedings only",
                        "type": "boolean",
                        "description": "Only return currently active insolvency proceedings (skip closed/historical ones).",
                        "default": false
                    },
                    "caseNumbers": {
                        "title": "Case numbers",
                        "type": "array",
                        "description": "Insolvency case numbers to resolve, e.g. 'INS 12575/2022'. Proceeding mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "watchlistIcos": {
                        "title": "Watchlist — company IDs",
                        "type": "array",
                        "description": "Monitor mode: only emit events whose debtor matches one of these IČOs. Leave empty (with empty watchlist personal IDs) to emit all new events.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "watchlistBirthNumbers": {
                        "title": "Watchlist — personal IDs",
                        "type": "array",
                        "description": "Monitor mode: only emit events whose debtor matches one of these personal IDs (with or without slash).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startFromId": {
                        "title": "Start from event ID",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Monitor mode, first run only: start reading the registry log after this event ID. Leave empty to start from the current end of the log (recommended)."
                    },
                    "maxEvents": {
                        "title": "Max events per run",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Monitor mode: stop after emitting this many events (cost protection).",
                        "default": 1000
                    },
                    "maxItems": {
                        "title": "Max subjects / cases per run",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Lookup & proceeding modes: cap on processed subjects or case numbers (cost protection).",
                        "default": 100
                    },
                    "maxResultsPerSubject": {
                        "title": "Max results per subject",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap on registry matches returned for a single subject (name searches can match many).",
                        "default": 50
                    },
                    "maxBatches": {
                        "title": "Max log batches per run",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Monitor mode: max registry log batches (1000 events each) scanned per run.",
                        "default": 100
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "Monitor mode: POST a JSON notification here when new events were emitted."
                    },
                    "stateStoreName": {
                        "title": "State store name",
                        "type": "string",
                        "description": "Named key-value store holding the monitor position between runs. Change to run multiple independent monitors.",
                        "default": "cz-isir-state"
                    },
                    "stateSaveInterval": {
                        "title": "State save interval",
                        "minimum": 1,
                        "type": "integer",
                        "description": "How often (in emitted events) to persist monitor state. 1 = safest (at most one duplicate on crash), higher = fewer store writes.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```