# German Trade Register Scraper - Handelsregister.de (`actorpilot/german-trade-register-scraper`) Actor

Extract company data from the official German Trade Register (Handelsregister) — representatives, address, share capital, register number & more.

- **URL**: https://apify.com/actorpilot/german-trade-register-scraper.md
- **Developed by:** [S. Klein](https://apify.com/actorpilot) (community)
- **Categories:** Automation, Lead generation, Other
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## German Trade Register Scraper - Handelsregister.de Company Data Extractor

Manually verifying 100 German companies on Handelsregister.de takes hours of copy-paste work. This Actor does it in minutes — batch-lookup by company name or register number and get structured JSON ready for your CRM, compliance workflow, or due diligence report.

**No expensive data provider contract needed.** Official Handelsregister data without Creditreform, Bisnode, or Dun & Bradstreet.

Try it free - click **Try for free** above.

---

### What does German Trade Register Scraper do?

This Actor queries the official German Handelsregister and returns structured company data for due diligence, compliance, sales research, and CRM enrichment.

In one run you can:

- Verify German company details
- Enrich CRM records with official register data
- Check company status such as active, deleted, or insolvency-related
- Extract directors, legal form, register court, address, and EUID
- Run direct register-number lookups for higher precision

---

### Why use German Trade Register Scraper?

| Your need | How this Actor helps |
|---|---|
| Due diligence | Verify directors, legal form, and register court quickly |
| B2B lead enrichment | Batch-process company names and return structured JSON |
| Compliance checks | Confirm official register status |
| Market research | Collect founding dates, share capital, and business purpose |
| API integration | Clean output for CRM, BI, and internal systems |
| CRM batch enrichment | Process hundreds of company names in one run and get structured JSON directly into HubSpot or Salesforce |

#### What data do you get?

- Company name and former names
- Legal form
- Register type, register number, and court
- Registered office city and postal address
- Business purpose
- Share capital
- Directors, board members, and representation authority
- Prokura holders
- Founding date and last update date
- EUID
- Available register document types
- Company status

---

### Who uses this Actor

- **KYC and AML Teams** verifying counterparties before onboarding
- **Sales Development Representatives** enriching CRM records with official company data before outreach
- **Compliance Officers** confirming legal form, register status, and authorised representatives
- **M&A and Private Equity Analysts** running first-pass due diligence on German acquisition targets
- **CRM Administrators** batch-enriching HubSpot, Salesforce, or Pipedrive contacts with verified business data
- **Legal Teams** confirming Prokura holders and representation authority

vs. commercial alternatives: Creditreform subscriptions start at €200+/month. This Actor costs under €1 per 100 lookups.

---

### How to use German Trade Register Scraper

1. Click **Try for free**
2. Enter company names in `companyNames`
3. Optionally add direct register lookups in `registerLookups`
4. Set `multiMatchStrategy`
5. Start the run
6. Download results as JSON, CSV, or Excel

---

### Input

You can combine name-based and register-number-based lookup in the same run.

#### Name search - `companyNames`

Type: `string[]`

Use exact registered company names including the legal form.

- Good: `"Volkswagen Aktiengesellschaft"`, `"SAP SE"`
- Bad: `"VW"`, `"Volkswagen AG"`

#### Register lookup - `registerLookups`

Type: `object[]`

| Field | Type | Required | Description |
|---|---|---|---|
| `registerType` | string | Yes | One of: `HRB`, `HRA`, `GnR`, `VR`, `PR` |
| `registerNumber` | string | Yes | Numeric part only, for example `"755"` |
| `court` | string | No | Amtsgericht name, for example `"Berlin (Charlottenburg)"` |

#### Additional settings

| Field | Type | Default | Description |
|---|---|---|---|
| `multiMatchStrategy` | string | `"first"` | `"first"`, `"all"`, or `"error"` |
| `requestDelayMs` | integer | `1200` | Delay between requests in milliseconds. Do not set below 1000 |
| `maxRetries` | integer | `3` | Retry attempts on failure |

Example input:

```json
{
  "companyNames": [
    "SAP SE",
    "Siemens Aktiengesellschaft",
    "Volkswagen Aktiengesellschaft"
  ],
  "registerLookups": [
    { "registerType": "HRB", "registerNumber": "755", "court": "Berlin (Charlottenburg)" }
  ],
  "multiMatchStrategy": "first",
  "requestDelayMs": 1200,
  "maxRetries": 3
}
````

***

### Output

Each company produces one dataset item.

Example output:

```json
{
  "company_name": "Volkswagen Aktiengesellschaft",
  "legal_form": "Aktiengesellschaft",
  "status": "active",
  "register_type": "HRB",
  "register_number": "100484",
  "register_court": "Braunschweig",
  "registered_office": "Wolfsburg",
  "address": "Berliner Ring 2, 38440 Wolfsburg",
  "business_purpose": "Herstellung und Vertrieb von Kraftfahrzeugen...",
  "share_capital": "2643604915.08 EUR",
  "representatives": [
    { "name": "Blume, Oliver", "role": "Vorstand", "authority": "Gesamtvertretung" }
  ],
  "founding_date": "1937-05-28",
  "last_updated": "2024-11-12",
  "euid": "DE*R1102*HRB100484",
  "documents_available": ["AD", "DK", "SI", "UT"],
  "query": "Volkswagen Aktiengesellschaft",
  "error": null
}
```

Key output fields:

- `company_name`, `former_names`
- `legal_form`, `status`
- `register_type`, `register_number`, `register_court`
- `registered_office`, `address`
- `business_purpose`, `share_capital`
- `representatives`, `prokura`
- `founding_date`, `last_updated`
- `euid`, `documents_available`
- `query`, `match_count`, `error`

***

### Use with AI agents via Apify MCP

This Actor can be used from Claude, Codex, Cursor, VS Code, Windsurf, Zed, and other MCP-compatible tools through Apify's Actors MCP server.

Important: this Actor is not its own remote MCP server. You connect Apify's Actors MCP server once, then ask your assistant to use the Handelsregister actor.

#### MCP setup

Add this MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server"],
      "env": {
        "APIFY_TOKEN": "your_apify_api_token_here"
      }
    }
  }
}
```

#### Copy-paste prompt for AI tools

If your assistant can configure MCP for you, paste this:

```text
Please set up Apify's Actors MCP server in my MCP configuration.

Use this package:
- command: npx
- args: -y @apify/actors-mcp-server

Set my APIFY_TOKEN in the MCP environment.

After setup, use the Apify actor "german-trade-register-scraper" and help me query German company register data from chat.
```

#### Example prompts after setup

- Use the `german-trade-register-scraper` actor to look up `SAP SE` and summarize the company details.
- Run the actor for these 20 company names and return a table with legal form, register court, and status.
- Check whether this German company is currently active and list the authorized representatives.
- Use direct register lookup for `HRB 755 Berlin (Charlottenburg)` and extract the official register details.

#### Client notes

- Claude, Codex, Cursor, VS Code, Windsurf, and Zed can generally use the stdio MCP config above directly.
- n8n, LangChain, OpenAI Agents SDK, Gemini, and custom applications can use the same Apify actor capability, but the exact MCP connection pattern depends on the environment around your MCP client.

***

### How much does it cost to scrape Handelsregister?

| Run size | Estimated cost |
|---|---|
| 10 companies | ~$0.05-$0.10 |
| 100 companies | ~$0.30-$0.80 |
| 500 companies | ~$1.50-$3.00 |

New Apify accounts receive $5 in free monthly credits.

***

### Error handling

Failed lookups do not stop the full run.

| Error | Cause |
|---|---|
| `candidate_only` | Name was found but ambiguous |
| `not_found` | No result for the query |
| `timeout` | Detail request timed out after retries |
| `fatal: <message>` | Unexpected runtime error |

Tip: if you get `candidate_only`, switch to a direct register-number lookup using the returned register details.

***

### Tips

- Always use exact registered company names including the legal form.
- Prefer `registerLookups` when precision matters.
- Increase `maxRetries` for companies that sometimes time out.
- Use `multiMatchStrategy: "all"` if you want every possible register hit.
- Use a slightly higher `requestDelayMs` for large batch jobs.

***

### FAQ

**Is this an official government tool?**
No. It is an independent Actor built on publicly accessible Handelsregister data.

**Is it legal to use?**
Handelsregister data is public business transparency data. You remain responsible for complying with applicable rules and Apify terms.

**Why is throughput limited?**
The source register has practical request limits, so the Actor spaces requests to remain reliable.

**Does it download company PDFs?**
No. It returns metadata and document availability, not the underlying PDFs.

**Do you support custom integrations?**
Yes. Contact us through the Apify platform if you need a custom workflow.

**How current is the data?**
The Actor reads directly from Handelsregister.de which is updated in near real time when companies file changes. The `last_updated` field in the output shows the date of the most recent register entry.

**Can I use this for KYC or AML workflows?**
Yes. The Actor returns official register data including directors, legal form, register court, and EUID. You are responsible for determining whether this data meets your specific compliance requirements.

**What is the difference between HRB and HRA?**
HRB (Handelsregister Abteilung B) covers limited liability companies (GmbH, AG, SE). HRA (Abteilung A) covers partnerships (OHG, KG). Use `registerType` to filter.

# Actor input Schema

## `companyNames` (type: `array`):

Enter German company names — one per line. Always use the exact registered name including legal form: 'Siemens Aktiengesellschaft' not 'Siemens AG', 'Volkswagen Aktiengesellschaft' not 'VW'. If the name is ambiguous or abbreviated, only basic register data is returned (no address, directors, or business purpose) — the output row will contain a candidate\_only error.

## `registerLookups` (type: `array`):

Direct register number lookups — more reliable than name search. Each entry needs 'registerType', 'registerNumber', and 'court'. Important: enter only the number in 'registerNumber' — not the prefix. Correct: '755'. Wrong: 'HRB 755'. Find the register number on handelsregister.de or in any official company document (Impressum, Geschäftsbericht).

## `multiMatchStrategy` (type: `string`):

Controls what happens when a name search returns more than one result. Example: 'Bauer GmbH' may match dozens of companies. 'Best match only' returns the most likely one. 'All matches' returns every result as a separate dataset row.

## `requestDelayMs` (type: `integer`):

Minimum wait time between HTTP requests in milliseconds. handelsregister.de allows approximately 60 requests per hour — do not go below 1000 ms or your IP may be blocked.

## `maxRetries` (type: `integer`):

How many times to retry a failed request before writing an error to the output. A company that cannot be reached after all retries will appear in the dataset with an error message — the run continues for all other companies.

## Actor input object example

```json
{
  "companyNames": [
    "SAP SE"
  ],
  "registerLookups": [
    {
      "registerType": "HRB",
      "registerNumber": "755",
      "court": "Berlin (Charlottenburg)"
    },
    {
      "registerType": "HRB",
      "registerNumber": "100484",
      "court": "Braunschweig"
    }
  ],
  "multiMatchStrategy": "first",
  "requestDelayMs": 1200,
  "maxRetries": 3
}
```

# 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 = {
    "registerLookups": [
        {
            "registerType": "HRB",
            "registerNumber": "755",
            "court": "Berlin (Charlottenburg)"
        },
        {
            "registerType": "HRB",
            "registerNumber": "100484",
            "court": "Braunschweig"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("actorpilot/german-trade-register-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "registerLookups": [
        {
            "registerType": "HRB",
            "registerNumber": "755",
            "court": "Berlin (Charlottenburg)",
        },
        {
            "registerType": "HRB",
            "registerNumber": "100484",
            "court": "Braunschweig",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("actorpilot/german-trade-register-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "registerLookups": [
    {
      "registerType": "HRB",
      "registerNumber": "755",
      "court": "Berlin (Charlottenburg)"
    },
    {
      "registerType": "HRB",
      "registerNumber": "100484",
      "court": "Braunschweig"
    }
  ]
}' |
apify call actorpilot/german-trade-register-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=actorpilot/german-trade-register-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "German Trade Register Scraper - Handelsregister.de",
        "description": "Extract company data from the official German Trade Register (Handelsregister) — representatives, address, share capital, register number & more.",
        "version": "1.0",
        "x-build-id": "DOgiWuId3pS5Sr0rq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/actorpilot~german-trade-register-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-actorpilot-german-trade-register-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/actorpilot~german-trade-register-scraper/runs": {
            "post": {
                "operationId": "runs-sync-actorpilot-german-trade-register-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/actorpilot~german-trade-register-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-actorpilot-german-trade-register-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "companyNames": {
                        "title": "Company names",
                        "type": "array",
                        "description": "Enter German company names — one per line. Always use the exact registered name including legal form: 'Siemens Aktiengesellschaft' not 'Siemens AG', 'Volkswagen Aktiengesellschaft' not 'VW'. If the name is ambiguous or abbreviated, only basic register data is returned (no address, directors, or business purpose) — the output row will contain a candidate_only error.",
                        "items": {
                            "type": "string",
                            "minLength": 2
                        },
                        "default": [
                            "SAP SE"
                        ]
                    },
                    "registerLookups": {
                        "title": "Register number lookups",
                        "type": "array",
                        "description": "Direct register number lookups — more reliable than name search. Each entry needs 'registerType', 'registerNumber', and 'court'. Important: enter only the number in 'registerNumber' — not the prefix. Correct: '755'. Wrong: 'HRB 755'. Find the register number on handelsregister.de or in any official company document (Impressum, Geschäftsbericht).",
                        "items": {
                            "type": "object",
                            "properties": {
                                "registerType": {
                                    "title": "Register type",
                                    "description": "Type of register: HRB (GmbH/AG), HRA (sole traders/partnerships), GnR (cooperatives), VR (associations), PR (partnerships).",
                                    "type": "string",
                                    "enum": [
                                        "HRB",
                                        "HRA",
                                        "GnR",
                                        "VR",
                                        "PR"
                                    ]
                                },
                                "registerNumber": {
                                    "title": "Register number",
                                    "description": "The numeric part only — no prefix. Example: '755' (not 'HRB 755'), '100484' (not 'HRB 100484').",
                                    "type": "string"
                                },
                                "court": {
                                    "title": "Court (Registergericht)",
                                    "description": "The Amtsgericht holding the register, e.g. 'Berlin (Charlottenburg)' or 'München'. Leave empty to search all courts.",
                                    "type": "string"
                                }
                            },
                            "required": [
                                "registerType",
                                "registerNumber"
                            ]
                        }
                    },
                    "multiMatchStrategy": {
                        "title": "When a name matches multiple companies",
                        "enum": [
                            "first",
                            "all",
                            "error"
                        ],
                        "type": "string",
                        "description": "Controls what happens when a name search returns more than one result. Example: 'Bauer GmbH' may match dozens of companies. 'Best match only' returns the most likely one. 'All matches' returns every result as a separate dataset row.",
                        "default": "first"
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 1000,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Minimum wait time between HTTP requests in milliseconds. handelsregister.de allows approximately 60 requests per hour — do not go below 1000 ms or your IP may be blocked.",
                        "default": 1200
                    },
                    "maxRetries": {
                        "title": "Max retries on errors",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many times to retry a failed request before writing an error to the output. A company that cannot be reached after all retries will appear in the dataset with an error message — the run continues for all other companies.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
