# 🏛️ GLEIF LEI Entity Resolution — Bulk Reference + Fuzzy Match (`nexgendata/gleif-lei-entity-resolution`) Actor

Resolve company names, addresses, or LEIs to official GLEIF Legal Entity Identifiers with corporate hierarchy traversal (parent + child LEIs), jurisdiction filter, and fuzzy match scoring. Built for bank KYC, derivatives back-office, hedge-fund counterparty risk, and M\&A due diligence.

- **URL**: https://apify.com/nexgendata/gleif-lei-entity-resolution.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 entity resolveds

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

## 🏛️ GLEIF LEI Entity Resolution — Bulk Reference + Fuzzy Match

**Stop paying Bloomberg, Refinitiv, or Dun & Bradstreet for entity reference data that already lives, for free, in the official GLEIF Level-1 + Level-2 datasets.** This actor resolves a company name, address, or 20-character LEI to the canonical [Global Legal Entity Identifier Foundation](https://www.gleif.org) record — with parent + child corporate hierarchy, jurisdiction, registration status, fuzzy-match scoring, and the official source URL on every row.

The GLEIF system is the only globally-recognized, regulator-mandated entity identifier for financial counterparties (ISO 17442). If your KYC, OFAC screening, derivatives reporting, or counterparty risk workflow doesn't anchor on LEIs, you're flying blind. This actor turns the public GLEIF data feed into a clean, deterministic, hierarchy-aware lookup that drops directly into your operations pipeline.

---

### ✅ What you get

| Field | Description |
|---|---|
| `LEI` | The official 20-character ISO 17442 Legal Entity Identifier |
| `legal_name` | Registered legal name (in registration language) |
| `legal_form` | ELF code (e.g. `H1UM` = Inc., `XTIQ` = LTD, `8888` = unknown) |
| `country` | ISO 3166-1 alpha-2 country code from the legal address |
| `address` | `{legal, headquarters}` — flat string per address type |
| `registration_status` | Entity status (ACTIVE, INACTIVE, NULL) |
| `registration_workflow_status` | GLEIF workflow status (ISSUED, LAPSED, PENDING_VALIDATION, …) |
| `parent_LEI` | Direct parent LEI (GLEIF Level-2 relationship feed) |
| `ultimate_parent_LEI` | Ultimate corporate parent LEI |
| `child_LEIs` | Array of direct-children LEIs (capped at 200 per entity) |
| `last_update_date` | Most recent GLEIF reference-data refresh for this entity |
| `initial_registration_date` | When this LEI was first issued |
| `next_renewal_date` | When this LEI is next due for revalidation |
| `jurisdiction` | ISO 3166-2 jurisdiction code (e.g. `US-CA`, `GB`, `LU`) |
| `managing_lou` | The Local Operating Unit (LOU) that maintains the record |
| `bic_codes` | Linked SWIFT/BIC codes (for banks / financial institutions) |
| `fuzzy_match_score` | 0..1 token-aware match score (only set for `lookup_type='name'`) |
| `source.api` | Canonical GLEIF API URL for this LEI (audit trail) |
| `source.gleif_search` | Human-readable search.gleif.org record URL |

Every row is one billable `entity-resolved` event.

---

### 🎯 Use cases

#### Bank KYC / customer-onboarding ops
Resolve a new counterparty name to its canonical LEI in seconds, then traverse the corporate hierarchy to identify the ultimate beneficial parent — the standard first step of every CDD / EDD workflow under FATF, BSA, and AMLD6.

#### Derivatives back-office (EMIR / Dodd-Frank Title VII / MiFIR)
Every OTC swap reported to a Trade Repository must reference both counterparties' LEIs. Use this actor to bulk-resolve a name list (e.g. an end-of-day reconciliation file) and auto-flag entries where the LEI is `LAPSED`, has rotated, or has changed parent — all of which break TR matching.

#### Hedge-fund counterparty-risk monitoring
Pull the full child hierarchy of every prime broker, ISDA-counterparty, or fund administrator on your books. Schedule a weekly refresh and diff against your last snapshot to detect entity-group reorganizations before they hit your credit limits.

#### M&A due diligence / sell-side advisory
Map a target's full legal-entity tree — direct parent → ultimate parent → all direct-children → grandchildren — by chaining LEI lookups. The GLEIF Level-2 dataset is the only globally-consistent source for this; commercial alternatives (Bureau van Dijk Orbis, D&B Family Tree) charge five figures per seat per year for the same data.

---

### 📥 Sample input

```json
{
  "query": "Apple Inc",
  "lookup_type": "name",
  "max_results": 3,
  "include_hierarchy": true
}
````

You can also pass a 20-character LEI directly:

```json
{
  "query": "HWUPKR0MPOU8FGXBT394",
  "lookup_type": "lei",
  "include_hierarchy": true
}
```

Or search by city / country / address fragment:

```json
{
  "query": "Cupertino",
  "lookup_type": "address",
  "max_results": 25,
  "include_hierarchy": false
}
```

***

### 📤 Sample output (one row)

```json
{
  "LEI": "HWUPKR0MPOU8FGXBT394",
  "legal_name": "Apple Inc.",
  "legal_form": "H1UM",
  "country": "US",
  "address": {
    "legal": "C/O C T Corporation System, 330 N. Brand Blvd, Suite 700, Glendale, US-CA, 91203, US",
    "headquarters": "One Apple Park Way, Cupertino, US-CA, 95014, US"
  },
  "registration_status": "ACTIVE",
  "registration_workflow_status": "ISSUED",
  "parent_LEI": null,
  "ultimate_parent_LEI": null,
  "child_LEIs": [
    "2549008YU9EOMHFUA249",
    "549300ZRBV4SY8GTOY54",
    "529900PM64WH8AF1E917"
  ],
  "last_update_date": "2026-03-03T16:34:33Z",
  "initial_registration_date": "2012-06-06T15:53:00Z",
  "next_renewal_date": "2027-03-08T17:27:20Z",
  "jurisdiction": "US-CA",
  "category": "GENERAL",
  "managing_lou": "5493001KJTIIGC8Y1R12",
  "bic_codes": ["APLEUS66XXX"],
  "fuzzy_match_score": 0.9474,
  "source": {
    "api": "https://api.gleif.org/api/v1/lei-records/HWUPKR0MPOU8FGXBT394",
    "gleif_search": "https://search.gleif.org/#/record/HWUPKR0MPOU8FGXBT394"
  }
}
```

***

### 🚀 How to use

#### Apify Python client

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("nexgendata/gleif-lei-entity-resolution").call(run_input={
    "query": "JP Morgan Chase",
    "lookup_type": "name",
    "max_results": 10,
    "include_hierarchy": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["LEI"], item["legal_name"], "->",
          "parent:", item["parent_LEI"],
          "children:", len(item["child_LEIs"]))
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/nexgendata~gleif-lei-entity-resolution/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query":"Goldman Sachs","lookup_type":"name","max_results":5,"include_hierarchy":true}'
```

#### MCP / agent integration

This actor exposes a deterministic schema and a single high-leverage tool (`resolve_entity`) — wire it into any MCP-compatible agent (Claude Desktop, Cursor, your in-house RAG stack) and your assistant can answer "who is the ultimate parent of Acme Bank's London branch?" without you handing it a Bloomberg session.

***

### ⚖️ Legal & data source notes

- **Data source:** [GLEIF Level-1 + Level-2 public API](https://api.gleif.org/api/v1/lei-records) and the [GLEIF Concatenated File](https://www.gleif.org/en/lei-data/gleif-concatenated-file/download-the-concatenated-file). GLEIF reference data is published under [CC0 1.0 Universal](https://www.gleif.org/en/about/governance/gleif-statement-on-the-use-of-open-data) — no licensing fee, no per-record charge, no attribution requirement (though we surface the canonical source URL on every row regardless).
- **Polite-bot identification:** every request carries `User-Agent: NexGenData GLEIF Actor hello@thenextgennexus.com`. Concurrency is capped at 6 in-flight requests, well under GLEIF's documented soft-limit comfort threshold.
- **No PII:** GLEIF reference data is by design free of natural-person PII. The actor passes through legal-entity attributes only; no individual / director / beneficial-owner names are included.
- **Hierarchy caveats:** GLEIF Level-2 (parent-child) relationships rely on each entity self-reporting its parent. About 35% of LEIs currently have a documented parent-reporting exception (e.g. "no consolidating parent", "non-public information"). When that's the case, `parent_LEI` / `ultimate_parent_LEI` come back `null` — that's the GLEIF ground-truth, not a scrape failure.

***

### ❓ FAQ

**Q: How is this different from the free [search.gleif.org](https://search.gleif.org) website?**
A: search.gleif.org is the single-record human UI. This actor returns structured JSON, ranks fuzzy name matches, traverses parent + child hierarchy in one call, and integrates directly with your data pipeline / Excel / MCP agent. It's the GLEIF API, productized for ops.

**Q: How fresh is the data?**
A: Real-time. Every request hits the live GLEIF API; the `meta.goldenCopy.publishDate` field on each response identifies the most recent GLEIF golden-copy snapshot (refreshed multiple times per day).

**Q: What if my counterparty doesn't have a LEI yet?**
A: For US/EU regulated entities, almost every legal entity above shell-company thresholds is now LEI-issued (post-EMIR and Dodd-Frank Title VII rollout). For exotic jurisdictions or pre-issuance, the actor returns 0 rows and exits cleanly — no crash, no charge for the empty result beyond `apify-actor-start`.

**Q: How accurate is the fuzzy name match score?**
A: The score is the maximum of (a) raw character-sequence similarity and (b) token-sort similarity, both computed by Python's stdlib `difflib.SequenceMatcher`. In practice, scores ≥ 0.85 are reliable matches; 0.70-0.85 should be reviewed; below 0.70 indicates the name is ambiguous and you should refine the query.

**Q: Why is `child_LEIs` capped at 200 per entity?**
A: A handful of mega-holding-companies (JPMorgan, BlackRock, Berkshire) have thousands of direct children. The 200-cap keeps the payload predictable and the run cost bounded. For exhaustive sweep, set `include_hierarchy: false` and chain a follow-up run on the child LEIs you care about.

***

### 🔗 Related actors

**Reference-data + KYC cluster** — every one of these is a public actor in the NexGenData fleet and pairs naturally with this LEI resolver:

- [**Company Enrichment Tool**](https://apify.com/nexgendata/company-enrichment-tool) — once you have the LEI, enrich the company with employee count, tech stack, social profiles, and contact info.
- [**B2B Leads Finder**](https://apify.com/nexgendata/b2b-leads-finder) — flip the workflow: start from a target persona / industry, get contacts, then resolve their parent entities to LEIs here for compliance.
- [**SEC Form 13F Tracker Pro**](https://apify.com/nexgendata/sec-form-13f-tracker-pro) — pair institutional-investor LEI resolution with 13F equity holdings for a complete counterparty-exposure view.

***

### 🏷️ About NexGenData

NexGenData operates 260+ public Apify actors covering business reference data, financial filings, real estate, IP, lead generation, and MCP servers for AI agents. All actors are PAY-PER-EVENT priced, work directly with the Apify Console, n8n, Make, Zapier, and the MCP ecosystem. Questions or custom-data requests? Email `hello@thenextgennexus.com`.

# Actor input Schema

## `query` (type: `string`):

What to resolve. For lookup\_type='name': a company / entity legal name (fuzzy-matched against GLEIF's legalName + otherNames fields). For lookup\_type='lei': a 20-character ISO 17442 LEI. For lookup\_type='address': a city, country (ISO 2-letter code), or address-line fragment.

## `lookup_type` (type: `string`):

How to interpret the query. 'name' = fuzzy entity-name search ranked by a 0..1 match score; 'lei' = direct LEI lookup; 'address' = address / city / country search via GLEIF's address filters.

## `max_results` (type: `integer`):

Maximum number of LEI records to return. Each resolved record is one billable 'entity-resolved' event. Range 1-100. For name searches, results are ranked by fuzzy-match score before this cap is applied.

## `include_hierarchy` (type: `boolean`):

If true, also fetch each entity's direct parent LEI, ultimate parent LEI, and direct-children LEIs (capped at 200 per entity). Adds 3 extra GLEIF API calls per resolved record. Recommended for KYC and counterparty-risk workflows.

## Actor input object example

```json
{
  "query": "Apple Inc",
  "lookup_type": "name",
  "max_results": 10,
  "include_hierarchy": true
}
```

# 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 = {
    "query": "Apple Inc",
    "lookup_type": "name",
    "max_results": 10,
    "include_hierarchy": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/gleif-lei-entity-resolution").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 = {
    "query": "Apple Inc",
    "lookup_type": "name",
    "max_results": 10,
    "include_hierarchy": True,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/gleif-lei-entity-resolution").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 '{
  "query": "Apple Inc",
  "lookup_type": "name",
  "max_results": 10,
  "include_hierarchy": true
}' |
apify call nexgendata/gleif-lei-entity-resolution --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/gleif-lei-entity-resolution",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🏛️ GLEIF LEI Entity Resolution — Bulk Reference + Fuzzy Match",
        "description": "Resolve company names, addresses, or LEIs to official GLEIF Legal Entity Identifiers with corporate hierarchy traversal (parent + child LEIs), jurisdiction filter, and fuzzy match scoring. Built for bank KYC, derivatives back-office, hedge-fund counterparty risk, and M&A due diligence.",
        "version": "0.0",
        "x-build-id": "cIRypDCPxiSLq8t0l"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~gleif-lei-entity-resolution/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-gleif-lei-entity-resolution",
                "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/nexgendata~gleif-lei-entity-resolution/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-gleif-lei-entity-resolution",
                "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/nexgendata~gleif-lei-entity-resolution/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-gleif-lei-entity-resolution",
                "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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Query",
                        "type": "string",
                        "description": "What to resolve. For lookup_type='name': a company / entity legal name (fuzzy-matched against GLEIF's legalName + otherNames fields). For lookup_type='lei': a 20-character ISO 17442 LEI. For lookup_type='address': a city, country (ISO 2-letter code), or address-line fragment."
                    },
                    "lookup_type": {
                        "title": "Lookup type",
                        "enum": [
                            "name",
                            "lei",
                            "address"
                        ],
                        "type": "string",
                        "description": "How to interpret the query. 'name' = fuzzy entity-name search ranked by a 0..1 match score; 'lei' = direct LEI lookup; 'address' = address / city / country search via GLEIF's address filters.",
                        "default": "name"
                    },
                    "max_results": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of LEI records to return. Each resolved record is one billable 'entity-resolved' event. Range 1-100. For name searches, results are ranked by fuzzy-match score before this cap is applied.",
                        "default": 10
                    },
                    "include_hierarchy": {
                        "title": "Include corporate hierarchy",
                        "type": "boolean",
                        "description": "If true, also fetch each entity's direct parent LEI, ultimate parent LEI, and direct-children LEIs (capped at 200 per entity). Adds 3 extra GLEIF API calls per resolved record. Recommended for KYC and counterparty-risk workflows.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
