# GLEIF LEI Bulk Lookup (`automation-lab/gleif-lei-bulk-lookup`) Actor

🔎 Bulk lookup company LEIs from official GLEIF data. Match names or LEI codes and export KYB-ready entity status, jurisdiction, and renewal fields.

- **URL**: https://apify.com/automation-lab/gleif-lei-bulk-lookup.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Bulk Lookup

Bulk lookup Legal Entity Identifiers (LEIs) from the official GLEIF API. Enter company names, legal names, or LEI codes and export normalized compliance-ready entity records.

### What does GLEIF LEI Bulk Lookup do?

GLEIF LEI Bulk Lookup turns a list of companies or LEI codes into structured Legal Entity Identifier records. It uses the public GLEIF JSON API directly, so runs are fast, lightweight, and do not need a browser, login, or proxy.

Use it when you need to enrich vendors, counterparties, customers, issuers, or portfolio companies with verified LEI metadata.

### Who is it for?

- 🏦 KYB and KYC operations teams checking legal entity status.
- 🛡️ Compliance analysts validating counterparties before onboarding.
- 📦 Procurement and vendor-risk teams enriching supplier lists.
- 💳 Fintech onboarding teams matching company names to LEIs.
- 📊 CRM and data teams adding LEI fields to account records.
- ⚖️ Legal and risk teams checking registration renewal and conformity.

### Why use it?

Manual GLEIF lookups are fine for one company. They are painful for a spreadsheet. This actor accepts bulk input, keeps the source query on every row, normalizes nested GLEIF data into exportable fields, and charges only for records it saves.

### What data can I extract?

| Field | Description |
| --- | --- |
| `query` | Original company name or LEI input. |
| `queryType` | `lei` for exact LEI lookups or `text` for full-text searches. |
| `rank` | Result rank within the query. |
| `lei` | Legal Entity Identifier. |
| `legalName` | Official legal name from GLEIF. |
| `otherNames` | Trading names, former names, or transliterations when available. |
| `jurisdiction` | Legal jurisdiction code. |
| `entityStatus` | Entity status such as `ACTIVE`. |
| `registrationStatus` | LEI registration status such as `ISSUED` or `LAPSED`. |
| `conformityFlag` | GLEIF conformity flag. |
| `registeredAs` | Local registry identifier. |
| `legalAddress` | Structured legal address object. |
| `headquartersAddress` | Structured headquarters address object. |
| `bic`, `mic`, `ocid`, `qcc`, `spglobal` | Additional identifiers when GLEIF provides them. |
| `gleifUrl` | Official GLEIF API URL for the record. |

### How much does it cost to look up LEIs in bulk?

The actor uses pay-per-event pricing:

- A small one-time start event per run.
- A per-record event for each LEI record written to the dataset.

Because the actor calls the official API directly and does not use proxies or browsers, costs are designed to stay low for recurring enrichment jobs.

### How to use it

1. Open the actor on Apify.
2. Paste company names or LEI codes into **Company names or LEIs**.
3. Set **Max results per name query**.
4. Optionally filter by country, active entities, or conforming records.
5. Run the actor.
6. Download the dataset as JSON, CSV, Excel, or connect it to your workflow.

### Input example

```json
{
  "queries": [
    "Apple Inc",
    "Microsoft Corporation",
    "529900T8BM49AURSDO55"
  ],
  "maxResultsPerQuery": 10,
  "onlyActive": true,
  "onlyConforming": false,
  "includeRelationships": true
}
````

### Output example

```json
{
  "query": "529900T8BM49AURSDO55",
  "queryType": "lei",
  "rank": 1,
  "lei": "529900T8BM49AURSDO55",
  "legalName": "Ubisecure Oy",
  "jurisdiction": "FI",
  "entityStatus": "ACTIVE",
  "registrationStatus": "ISSUED",
  "conformityFlag": "CONFORMING",
  "registeredAs": "1748721-4",
  "nextRenewalDate": "2027-06-28T18:34:06Z",
  "gleifUrl": "https://api.gleif.org/api/v1/lei-records/529900T8BM49AURSDO55"
}
```

### Company-name matching

For ordinary company names, the actor uses GLEIF full-text search. Each saved row includes the original query and result rank so you can review match quality in downstream systems.

### Exact LEI matching

For 20-character LEI-shaped inputs, the actor uses the exact LEI endpoint. Invalid or unknown LEIs return no rows instead of creating noisy placeholder records.

### Country filters

Use `countryCodes` to restrict results to ISO alpha-2 country codes. The actor checks the legal jurisdiction prefix plus legal and headquarters address country fields.

### Active and conforming filters

Use `onlyActive` for entity status checks and `onlyConforming` for GLEIF conformity screening. These filters are useful for compliance teams that only want immediately actionable records.

### Parent relationship links

Enable `includeRelationships` to add direct and ultimate parent relationship URLs where GLEIF exposes them. The actor records links instead of expanding nested parent data by default, keeping bulk runs fast and inexpensive.

### Tips for best results

- Use exact legal names when possible.
- Combine company name and country filter for common names.
- Set `maxResultsPerQuery` higher for ambiguous names and lower for clean internal master data.
- Keep `onlyActive` off during discovery if you need to find historical or lapsed records.
- Keep the `query` column in exports so reviewers can trace every row back to the source list.

### Integrations

Use this actor in:

- 🧾 Vendor onboarding workflows before supplier approval.
- 🏦 Customer due diligence and KYB queues.
- 📈 Portfolio monitoring dashboards.
- 🧹 CRM enrichment and account deduplication flows.
- 📤 Apify integrations that send dataset rows to Google Sheets, S3, BigQuery, or webhooks.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/gleif-lei-bulk-lookup').call({
  queries: ['Apple Inc', '529900T8BM49AURSDO55'],
  maxResultsPerQuery: 5,
  onlyActive: true
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/gleif-lei-bulk-lookup').call(run_input={
    'queries': ['Apple Inc', '529900T8BM49AURSDO55'],
    'maxResultsPerQuery': 5,
    'onlyActive': True,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~gleif-lei-bulk-lookup/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"queries":["Apple Inc","529900T8BM49AURSDO55"],"maxResultsPerQuery":5}'
```

### Use with MCP and AI agents

You can connect this actor to AI tools through Apify MCP. Use a scoped MCP URL such as:

`https://mcp.apify.com/?tools=automation-lab/gleif-lei-bulk-lookup`

Example prompts:

- "Look up LEI records for these counterparties and summarize which ones are active."
- "Find conforming LEI records for this supplier list and flag lapsed registrations."
- "Enrich these company names with LEI, jurisdiction, and next renewal date."

### Data source

The source is the Global Legal Entity Identifier Foundation (GLEIF) public API. GLEIF provides official LEI reference data and relationship links. This actor is not affiliated with or endorsed by GLEIF.

### Legality and compliance

This actor retrieves public business registry metadata from a public API. You are responsible for using the output in accordance with your compliance program, local regulations, and data governance rules.

### FAQ and troubleshooting

#### Why did a company name return many rows?

GLEIF full-text search can match legal names, addresses, and related fields. Use country filters, exact legal names, or exact LEI codes for tighter matching.

#### Why did an LEI return no row?

The LEI may be invalid, unknown to GLEIF, or mistyped. Exact LEI inputs use the `/lei-records/{lei}` endpoint and do not emit placeholder rows for 404 responses.

#### Why are parent fields empty?

Not every record has direct or ultimate parent relationship links. Enable `includeRelationships` to include available URLs.

### Related Apify actors

- https://apify.com/automation-lab/company-website-finder
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/domain-to-company-name

### Changelog

- 0.1.0 — Initial version with bulk name/LEI lookup, normalized output, filters, and optional relationship links.

### Support

If you need additional fields from the GLEIF API, share an example LEI and the field you need. The actor is designed to be extended without changing the core bulk workflow.

### Field quick reference

- `query` is included as a stable export column for spreadsheet and database workflows.
- `queryType` is included as a stable export column for spreadsheet and database workflows.
- `rank` is included as a stable export column for spreadsheet and database workflows.
- `lei` is included as a stable export column for spreadsheet and database workflows.
- `legalName` is included as a stable export column for spreadsheet and database workflows.
- `otherNames` is included as a stable export column for spreadsheet and database workflows.
- `jurisdiction` is included as a stable export column for spreadsheet and database workflows.
- `entityCategory` is included as a stable export column for spreadsheet and database workflows.
- `entityStatus` is included as a stable export column for spreadsheet and database workflows.
- `registrationStatus` is included as a stable export column for spreadsheet and database workflows.
- `conformityFlag` is included as a stable export column for spreadsheet and database workflows.
- `legalFormId` is included as a stable export column for spreadsheet and database workflows.
- `registeredAtId` is included as a stable export column for spreadsheet and database workflows.
- `registeredAs` is included as a stable export column for spreadsheet and database workflows.
- `managingLou` is included as a stable export column for spreadsheet and database workflows.
- `initialRegistrationDate` is included as a stable export column for spreadsheet and database workflows.
- `lastUpdateDate` is included as a stable export column for spreadsheet and database workflows.
- `nextRenewalDate` is included as a stable export column for spreadsheet and database workflows.
- `legalAddress` is included as a stable export column for spreadsheet and database workflows.
- `headquartersAddress` is included as a stable export column for spreadsheet and database workflows.
- `bic` is included as a stable export column for spreadsheet and database workflows.
- `mic` is included as a stable export column for spreadsheet and database workflows.
- `ocid` is included as a stable export column for spreadsheet and database workflows.
- `qcc` is included as a stable export column for spreadsheet and database workflows.
- `spglobal` is included as a stable export column for spreadsheet and database workflows.
- `directParentLeiUrl` is included as a stable export column for spreadsheet and database workflows.
- `directParentRelationshipUrl` is included as a stable export column for spreadsheet and database workflows.
- `ultimateParentLeiUrl` is included as a stable export column for spreadsheet and database workflows.
- `ultimateParentRelationshipUrl` is included as a stable export column for spreadsheet and database workflows.
- `gleifUrl` is included as a stable export column for spreadsheet and database workflows.
- `fetchedAt` is included as a stable export column for spreadsheet and database workflows.

# Actor input Schema

## `queries` (type: `array`):

Enter company names, legal names, or 20-character LEI codes. LEI-shaped inputs use the exact-record endpoint; names use GLEIF full-text search.

## `maxResultsPerQuery` (type: `integer`):

Maximum GLEIF records returned for each company-name search. Exact LEI lookups always return at most one record.

## `countryCodes` (type: `array`):

Optional ISO 3166-1 alpha-2 country codes. Filters by jurisdiction and legal/headquarters address country.

## `onlyActive` (type: `boolean`):

Keep only records where the GLEIF entity status is ACTIVE.

## `onlyConforming` (type: `boolean`):

Keep only records where the GLEIF conformity flag is CONFORMING.

## `includeRelationships` (type: `boolean`):

Add GLEIF API links for direct and ultimate parent records/relationships when GLEIF exposes them. This keeps the default run lightweight while enabling ownership workflows.

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

Polite delay between GLEIF API requests. Increase this for very large batches if needed.

## Actor input object example

```json
{
  "queries": [
    "Apple Inc",
    "529900T8BM49AURSDO55",
    "Microsoft Corporation"
  ],
  "maxResultsPerQuery": 10,
  "countryCodes": [],
  "onlyActive": false,
  "onlyConforming": false,
  "includeRelationships": false,
  "requestDelayMs": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "queries": [
        "Apple Inc",
        "529900T8BM49AURSDO55",
        "Microsoft Corporation"
    ],
    "maxResultsPerQuery": 10,
    "countryCodes": [],
    "onlyActive": false,
    "onlyConforming": false,
    "includeRelationships": false,
    "requestDelayMs": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/gleif-lei-bulk-lookup").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 = {
    "queries": [
        "Apple Inc",
        "529900T8BM49AURSDO55",
        "Microsoft Corporation",
    ],
    "maxResultsPerQuery": 10,
    "countryCodes": [],
    "onlyActive": False,
    "onlyConforming": False,
    "includeRelationships": False,
    "requestDelayMs": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/gleif-lei-bulk-lookup").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 '{
  "queries": [
    "Apple Inc",
    "529900T8BM49AURSDO55",
    "Microsoft Corporation"
  ],
  "maxResultsPerQuery": 10,
  "countryCodes": [],
  "onlyActive": false,
  "onlyConforming": false,
  "includeRelationships": false,
  "requestDelayMs": 20
}' |
apify call automation-lab/gleif-lei-bulk-lookup --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GLEIF LEI Bulk Lookup",
        "description": "🔎 Bulk lookup company LEIs from official GLEIF data. Match names or LEI codes and export KYB-ready entity status, jurisdiction, and renewal fields.",
        "version": "0.1",
        "x-build-id": "Bd5lIk1iIpTePaELK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~gleif-lei-bulk-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-gleif-lei-bulk-lookup",
                "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/automation-lab~gleif-lei-bulk-lookup/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-gleif-lei-bulk-lookup",
                "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/automation-lab~gleif-lei-bulk-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-gleif-lei-bulk-lookup",
                "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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Company names or LEIs",
                        "type": "array",
                        "description": "Enter company names, legal names, or 20-character LEI codes. LEI-shaped inputs use the exact-record endpoint; names use GLEIF full-text search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per name query",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum GLEIF records returned for each company-name search. Exact LEI lookups always return at most one record.",
                        "default": 10
                    },
                    "countryCodes": {
                        "title": "Country filter",
                        "type": "array",
                        "description": "Optional ISO 3166-1 alpha-2 country codes. Filters by jurisdiction and legal/headquarters address country.",
                        "items": {
                            "type": "string",
                            "minLength": 2,
                            "maxLength": 2
                        }
                    },
                    "onlyActive": {
                        "title": "Only active entities",
                        "type": "boolean",
                        "description": "Keep only records where the GLEIF entity status is ACTIVE.",
                        "default": false
                    },
                    "onlyConforming": {
                        "title": "Only conforming records",
                        "type": "boolean",
                        "description": "Keep only records where the GLEIF conformity flag is CONFORMING.",
                        "default": false
                    },
                    "includeRelationships": {
                        "title": "Include parent relationship links",
                        "type": "boolean",
                        "description": "Add GLEIF API links for direct and ultimate parent records/relationships when GLEIF exposes them. This keeps the default run lightweight while enabling ownership workflows.",
                        "default": false
                    },
                    "requestDelayMs": {
                        "title": "Delay between API requests (ms)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Polite delay between GLEIF API requests. Increase this for very large batches if needed.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
