# EU Dealer Counterparty Check — Verify Any European Company (`studio-amba/eu-dealer-counterparty-check`) Actor

Verify a European company before you sign a deal. Give a name and/or registration number plus a country, and it queries the matching official company registry across 11 EU countries and merges the result into one dossier: legal name, status, address, incorporation date, officers, red flags.

- **URL**: https://apify.com/studio-amba/eu-dealer-counterparty-check.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $40.00 / 1,000 counterparty checks

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

## EU Dealer Counterparty Check — Verify Any European Company

Before you sign a deal with a European company, check it. Give this actor a **company name and/or registration number** plus a **country** (or let it auto-detect from the number format), and it fans out to the right official company registry, merges whatever comes back into **one counterparty dossier**, and surfaces red flags — insolvency filings, dissolution, and status mismatches — instead of hiding them.

This is a meta-actor: it does not scrape any site directly. It runs our own country-specific registry scrapers (Northdata, Handelsregister and Bundesanzeiger for Germany, Pappers and Recherche Entreprises for France, Companies House for the UK, KRS for Poland, Registro Imprese for Italy, Registro Mercantil/BORME for Spain, Zefix for Switzerland, BRREG and Proff.no for Norway, Allabolag for Sweden, Firmy.cz for Czechia, KVK for the Netherlands) and merges their answers.

### What it does

- **One dossier, not eleven scrapers.** You give a company name or number and a country. The actor picks the matching registry (or registries — several countries get a primary source plus a secondary cross-check), runs them in parallel, and returns a single merged row.
- **Risk surfaced, not buried.** If any source — even a secondary one — flags insolvency, dissolution, or a "deleted" register status, that risk wins over another source's "active" claim. A counterparty check that hides the bad news is worse than useless.
- **Confidence is explicit.** Every dossier carries a `confidence` field: `high` means an exact registration-number match on an official state registry, `medium` means a name-only match on an official registry (or a number match on a directory), `low` means only a directory/aggregator site matched. You always know how much to trust the result.
- **Disambiguation for common names.** If you search by name only, the dossier includes `candidateCount` and up to 5 `otherCandidateNames` so you can tell "Boulangerie Guillaume" from the other three companies with a similar name.
- **Officers merged and deduplicated** across every source that exposed them (directors, board members, CEO).
- **Source links kept** for every registry that matched, so you can click through and verify manually.

### Countries covered

| Country | Primary source | Secondary / red-flag source | Registry type |
|---|---|---|---|
| Germany (DE) | Northdata | Handelsregister (status), Bundesanzeiger (insolvency filings) | Official register + gazette |
| France (FR) | Pappers | Recherche Entreprises (official gov cross-check) | Official register |
| United Kingdom (GB) | Companies House | — | Official register |
| Poland (PL) | KRS | — | Official register |
| Italy (IT) | Registro Imprese | — | Official register |
| Spain (ES) | Registro Mercantil (BORME) | — | Official gazette (recent filings only) |
| Switzerland (CH) | Zefix | — | Official register |
| Norway (NO) | BRREG | Proff.no (financials/board enrichment) | Official register + aggregator |
| Sweden (SE) | Allabolag.se | — | Aggregator (not Bolagsverket directly) |
| Czechia (CZ) | Firmy.cz | — | Business directory (no official CZ registry in our fleet yet) |
| Netherlands (NL) | KVK | — | Official register |

### How to scrape EU company registry data

1. Enter a **company name**, a **registration number**, or both. A number narrows the lookup to an exact match; a name alone runs a search and returns the best-ranked result.
2. Pick the **country** — or set it to `auto` and the actor will try to recognize a distinctive number format (Swiss UID, German HRB/HRA, UK company number, Polish KRS, Italian Partita IVA). Auto-detect deliberately refuses to guess on ambiguous plain-digit formats shared by multiple countries; set the country explicitly in that case.
3. Leave **enrich with red-flag sources** on (default) to also query the secondary source where one exists — Bundesanzeiger for Germany, Recherche Entreprises for France, Proff.no for Norway.
4. Run it. One row comes back: legal name, registration number, status, address, incorporation date, officers, and any red flags found.
5. Check `confidence` before you trust the match. `high` means it was pinned down by an exact registration number on an official state registry.

For bulk counterparty screening, run the actor once per company via the Apify API and collect the results — the merge logic and PPE pricing are per-check, so cost scales linearly with the number of companies checked.

### Input options

| Field | Type | Description |
|---|---|---|
| `companyName` | string | Company name to search. Required if no registration number is given. |
| `registrationNumber` | string | Official registry number (SIREN, Companies House number, KRS, HRB/HRA, Partita IVA, CIF/NIF, UID, org.nr, KVK, IČO). Narrows to an exact match. |
| `country` | select | `auto`, `DE`, `FR`, `GB`, `PL`, `IT`, `ES`, `CH`, `NO`, `SE`, `CZ`, `NL`. Default `DE`. |
| `enrichRedFlags` | boolean | Also query the secondary source for insolvency/cross-check signals, where one exists. Default `true`. |
| `maxResults` | integer | How many candidates the underlying registry search fetches before picking the best match. Default `10`. |
| `timeoutPerSourceSecs` | integer | How long to wait for each registry child-actor before treating it as failed. Default `120`. |
| `proxyConfiguration` | proxy | Passed through to the underlying registry scrapers that need a country-scoped residential proxy. |

### Output fields

| Field | Example | Description |
|---|---|---|
| `legalName` | `"Siemens AG"` | Merged legal name from the highest-trust source that had it |
| `registrationNumber` | `"HRB 6684"` | Official registry number |
| `matchedByRegistrationNumber` | `true` | Whether the match was anchored on an exact number, not a name guess |
| `status` | `"active"` | `active`, `dissolved`, `insolvent`, or `unknown` |
| `address` / `city` / `postalCode` | | Registered office |
| `incorporationDate` | `"1966-08-01"` | |
| `legalForm` | `"Aktiengesellschaft"` | |
| `officers` | `[{"name":"...", "role":"..."}]` | Deduplicated across all matching sources |
| `redFlags` | `["Bundesanzeiger filing suggests insolvency..."]` | Empty array when nothing was found |
| `confidence` | `"high"` | See "What it does" above |
| `candidateCount` / `otherCandidateNames` | `3` / `["Siemens Healthineers AG", ...]` | Disambiguation aid for name-only searches |
| `sourcesUsed` / `sourcesFailed` | `["northdata","handelsregister"]` / `["bundesanzeiger"]` | Which child-actors contributed |
| `sourceUrls` | `{"northdata":"https://..."}` | Click-through links for manual verification |
| `scrapedAt` | ISO timestamp | |

### Example output

```json
{
  "matchedQuery": "Siemens",
  "country": "DE",
  "legalName": "Siemens Aktiengesellschaft",
  "registrationNumber": "Amtsgericht Muenchen HRB 6684",
  "matchedByRegistrationNumber": false,
  "status": "active",
  "address": "Werner-von-Siemens-Strasse 1, Muenchen, Deutschland",
  "city": "Muenchen",
  "postalCode": "80333",
  "incorporationDate": "1966-08-01",
  "legalForm": null,
  "officers": [{ "name": "Roland Busch", "role": "Vorstandsvorsitzender" }],
  "redFlags": [],
  "confidence": "medium",
  "candidateCount": 15,
  "otherCandidateNames": ["Siemens Healthineers AG", "Siemens Mobility GmbH"],
  "sourcesUsed": ["northdata", "handelsregister", "bundesanzeiger"],
  "sourcesFailed": [],
  "sourceUrls": {
    "northdata": "https://www.northdata.de/Siemens%20Aktiengesellschaft/Amtsgericht%20Muenchen%20HRB%206684"
  },
  "scrapedAt": "2026-07-18T09:00:00.000Z"
}
````

### Cost estimate

Priced at $0.05 per check (pay-per-event: charged on the single dataset item the run produces). One check verifies one company across every source configured for its country. There is no per-item cost beyond the check itself — running with `enrichRedFlags` on does not cost extra, it is included in the $0.05.

### Limitations

- **Not every country has an equally strong source.** Spain's Registro Mercantil source only reads the last 30 days of BORME gazette filings — a hit is a real corporate act, but a miss proves nothing about the company's actual status. Czechia's Firmy.cz is a Yellow-Pages-style directory, not the official ARES/OR registry — treat CZ results as `low` confidence.
- **Officer/board data is inconsistent across countries.** Some registries (Companies House, KRS, Proff.no) expose named officers; others (Zefix, KVK) do not publish this data in a scrapeable form.
- **Name searches can be ambiguous.** A common name like "Boulangerie" or "Bau GmbH" returns many candidates. Use `registrationNumber` whenever you have it — it is the only way to get `confidence: "high"`.
- **Auto-detect is intentionally conservative.** It only recognizes number formats that are distinctive to one country. A bare 8- or 9-digit number is shared across several countries' formats and will not auto-resolve — set `country` explicitly.
- **Each underlying registry scraper can itself fail** (rate limits, site changes, anti-bot). The dossier's `sourcesUsed`/`sourcesFailed` fields tell you exactly which sources actually answered for this run.

### Related scrapers

Each registry behind this actor is also available standalone if you need raw, unmerged data at scale: `northdata-scraper`, `handelsregister-scraper`, `bundesanzeiger-scraper`, `pappers-scraper`, `recherche-entreprises-scraper`, `companies-house-scraper`, `krs-scraper`, `registro-imprese-scraper`, `registro-mercantil-scraper`, `zefix-scraper`, `brreg-scraper`, `proff-no-scraper`, `allabolag-se-scraper`, `firmy-cz-scraper`, `kvk-scraper`.

# Actor input Schema

## `companyName` (type: `string`):

Name of the company to check. Required if no registration number is given. Example: 'Siemens AG', 'Boulangerie Guillaume'.

## `registrationNumber` (type: `string`):

Official registry number if you have it: SIREN/SIRET (FR), Companies House number (UK), KRS or NIP (PL), HRB/HRA register number (DE), Codice Fiscale / Partita IVA (IT), CIF/NIF (ES), UID (CH), organisasjonsnummer (NO), org.nr (SE), KVK number (NL), IČO (CZ). A number narrows the lookup to an exact match instead of a name search.

## `country` (type: `string`):

Country whose registry to check. Pick 'Auto-detect' to let the actor guess from the registration number format (only works for formats with a distinctive pattern: CH UID, DE HRB/HRA number, PL KRS number). If auto-detect can't determine the country, the run fails with a clear message asking you to set this field.

## `enrichRedFlags` (type: `boolean`):

Run an extra secondary source where available to surface insolvency/filing red flags: Bundesanzeiger for Germany (insolvency & capital-market filings), Proff.no for Norway (financials/board cross-check), Recherche Entreprises for France (official gov cross-check). Adds one extra child-actor call and a few seconds. On by default.

## `maxResults` (type: `integer`):

How many matches the underlying registry search fetches before the best match is picked. Higher values help disambiguate a common company name but cost more child-actor compute. The dossier itself is always a single merged result.

## `timeoutPerSourceSecs` (type: `integer`):

How long to wait for each underlying registry child-actor before treating it as failed.

## `proxyConfiguration` (type: `object`):

Only set this to FORCE a specific proxy on every underlying registry child-actor. Leave empty (default) so each child-actor uses its own country-tuned proxy default instead — several registries need a specific country's RESIDENTIAL proxy, and a generic override here replaces that with a slower or less reliable choice.

## Actor input object example

```json
{
  "companyName": "Siemens AG",
  "country": "DE",
  "enrichRedFlags": true,
  "maxResults": 10,
  "timeoutPerSourceSecs": 120
}
```

# 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 = {
    "companyName": "Siemens",
    "country": "DE",
    "maxResults": 10,
    "timeoutPerSourceSecs": 120
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/eu-dealer-counterparty-check").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 = {
    "companyName": "Siemens",
    "country": "DE",
    "maxResults": 10,
    "timeoutPerSourceSecs": 120,
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/eu-dealer-counterparty-check").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 '{
  "companyName": "Siemens",
  "country": "DE",
  "maxResults": 10,
  "timeoutPerSourceSecs": 120
}' |
apify call studio-amba/eu-dealer-counterparty-check --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=studio-amba/eu-dealer-counterparty-check",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EU Dealer Counterparty Check — Verify Any European Company",
        "description": "Verify a European company before you sign a deal. Give a name and/or registration number plus a country, and it queries the matching official company registry across 11 EU countries and merges the result into one dossier: legal name, status, address, incorporation date, officers, red flags.",
        "version": "0.1",
        "x-build-id": "O0IHzNgRIidoX67LG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~eu-dealer-counterparty-check/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-eu-dealer-counterparty-check",
                "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/studio-amba~eu-dealer-counterparty-check/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-eu-dealer-counterparty-check",
                "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/studio-amba~eu-dealer-counterparty-check/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-eu-dealer-counterparty-check",
                "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": [
                    "country"
                ],
                "properties": {
                    "companyName": {
                        "title": "Company name",
                        "type": "string",
                        "description": "Name of the company to check. Required if no registration number is given. Example: 'Siemens AG', 'Boulangerie Guillaume'."
                    },
                    "registrationNumber": {
                        "title": "Registration number (optional)",
                        "type": "string",
                        "description": "Official registry number if you have it: SIREN/SIRET (FR), Companies House number (UK), KRS or NIP (PL), HRB/HRA register number (DE), Codice Fiscale / Partita IVA (IT), CIF/NIF (ES), UID (CH), organisasjonsnummer (NO), org.nr (SE), KVK number (NL), IČO (CZ). A number narrows the lookup to an exact match instead of a name search."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "auto",
                            "DE",
                            "FR",
                            "GB",
                            "PL",
                            "IT",
                            "ES",
                            "CH",
                            "NO",
                            "SE",
                            "CZ",
                            "NL"
                        ],
                        "type": "string",
                        "description": "Country whose registry to check. Pick 'Auto-detect' to let the actor guess from the registration number format (only works for formats with a distinctive pattern: CH UID, DE HRB/HRA number, PL KRS number). If auto-detect can't determine the country, the run fails with a clear message asking you to set this field.",
                        "default": "DE"
                    },
                    "enrichRedFlags": {
                        "title": "Enrich with red-flag sources",
                        "type": "boolean",
                        "description": "Run an extra secondary source where available to surface insolvency/filing red flags: Bundesanzeiger for Germany (insolvency & capital-market filings), Proff.no for Norway (financials/board cross-check), Recherche Entreprises for France (official gov cross-check). Adds one extra child-actor call and a few seconds. On by default.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max candidate matches to scan",
                        "type": "integer",
                        "description": "How many matches the underlying registry search fetches before the best match is picked. Higher values help disambiguate a common company name but cost more child-actor compute. The dossier itself is always a single merged result.",
                        "default": 10
                    },
                    "timeoutPerSourceSecs": {
                        "title": "Per-source timeout (seconds)",
                        "type": "integer",
                        "description": "How long to wait for each underlying registry child-actor before treating it as failed.",
                        "default": 120
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration (advanced — leave empty)",
                        "type": "object",
                        "description": "Only set this to FORCE a specific proxy on every underlying registry child-actor. Leave empty (default) so each child-actor uses its own country-tuned proxy default instead — several registries need a specific country's RESIDENTIAL proxy, and a generic override here replaces that with a slower or less reliable choice."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
