# GLEIF LEI Lookup Scraper (`automation-lab/gleif-lei-lookup-scraper`) Actor

Search official GLEIF Legal Entity Identifier records by company name or LEI for KYC, AML, onboarding, and counterparty enrichment.

- **URL**: https://apify.com/automation-lab/gleif-lei-lookup-scraper.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 Lookup Scraper

Extract official Legal Entity Identifier (LEI) records from the Global Legal Entity Identifier Foundation (GLEIF) API by company name or exact LEI code.

Use this actor for KYC, AML screening support, vendor onboarding, counterparty enrichment, company master-data cleanup, and compliance evidence collection.

### What does GLEIF LEI Lookup Scraper do?

GLEIF LEI Lookup Scraper searches the official GLEIF LEI database and returns structured records for legal entities.

It can:

- 🔎 Search legal entities by company or fund name
- 🆔 Fetch exact 20-character LEI records
- 🌍 Filter name searches by legal-address country
- ✅ Filter by GLEIF registration status such as `ISSUED` or `LAPSED`
- 🏢 Return legal and headquarters addresses
- 📅 Return renewal, registration, and last-update dates
- 🔗 Optionally enrich each record with direct and ultimate parent LEI summaries
- 🧾 Include the raw official JSON record when you need audit trails

### Who is it for?

This actor is designed for teams that need repeatable official LEI data without building their own pagination and normalization pipeline.

- 🏦 Compliance teams checking counterparties and vendors
- 🧮 Fintech operations teams enriching company master data
- 🛡️ AML and KYC analysts validating legal names and statuses
- 📊 Data teams joining LEI records into warehouses or CRMs
- ⚖️ Legal and risk teams reviewing entity registration evidence
- 🤝 Procurement teams onboarding suppliers and corporate customers

### Why use this actor?

GLEIF publishes a strong public API, but production workflows still need input validation, pagination, normalized output, retry handling, and dataset exports.

This actor wraps that official API into an Apify workflow that can be scheduled, integrated, exported, and monitored.

### Data source

The actor uses the official GLEIF JSON:API endpoint:

`https://api.gleif.org/api/v1/lei-records`

No browser, login, cookies, or proxy is required for the default workflow.

### How much does it cost to look up GLEIF LEI records?

The actor uses pay-per-event pricing.

Typical costs are:

- A small run-start event
- A per-record event for each dataset item produced

The final Store price is visible on the Apify actor page before you start a run.

### Input options

The most common inputs are company names and exact LEI codes.

```json
{
  "queries": ["Apple", "Stripe"],
  "leiCodes": ["549300MGN03W4U2NK749"],
  "maxResultsPerQuery": 25,
  "registrationStatuses": ["ISSUED"],
  "includeRelationships": false
}
````

### Company name searches

Use `queries` when you know a company name but not its LEI.

The actor calls GLEIF name search and follows pagination until `maxResultsPerQuery` is reached.

Broad names can return many records, so keep the cap conservative for first runs.

### Exact LEI lookups

Use `leiCodes` when you already have identifiers.

Exact LEI mode fetches `/lei-records/{lei}` for each supplied code.

Invalid or missing LEIs are skipped with a warning instead of stopping the whole run.

### Filters

You can filter company-name searches with:

- `countryCodes` — legal-address countries such as `US`, `GB`, `IE`, `DE`
- `registrationStatuses` — values such as `ISSUED`, `LAPSED`, `RETIRED`, or `MERGED`

Filters apply to name searches. Exact LEI lookups fetch the requested identifiers directly.

### Relationship enrichment

Set `includeRelationships` to `true` to fetch parent summaries.

The actor adds:

- `directParentLei`
- `directParentName`
- `ultimateParentLei`
- `ultimateParentName`

This option makes extra GLEIF API requests, so it is disabled by default.

### Output data

Each dataset item is one official GLEIF LEI record normalized for analysis.

| Field | Description |
| --- | --- |
| `input` | Company name or LEI code that produced the record |
| `queryType` | `name` or `lei` |
| `lei` | Legal Entity Identifier |
| `legalName` | Official legal name |
| `entityStatus` | Entity status, for example `ACTIVE` |
| `registrationStatus` | GLEIF registration status, for example `ISSUED` |
| `jurisdiction` | Entity jurisdiction code |
| `country` | Legal-address country |
| `legalAddress` | Structured legal address |
| `headquartersAddress` | Structured headquarters address |
| `registeredAs` | Local registry identifier when available |
| `lastUpdateDate` | Last GLEIF registration update |
| `nextRenewalDate` | Next renewal date |
| `managingLou` | Managing Local Operating Unit |
| `sourceUrl` | Official GLEIF API record URL |

### Example output

```json
{
  "input": "Apple",
  "queryType": "name",
  "lei": "549300MGN03W4U2NK749",
  "legalName": "APPLE OPERATIONS LIMITED",
  "entityStatus": "ACTIVE",
  "registrationStatus": "ISSUED",
  "jurisdiction": "IE",
  "country": "IE",
  "nextRenewalDate": "2027-03-08T17:20:49Z",
  "sourceUrl": "https://api.gleif.org/api/v1/lei-records/549300MGN03W4U2NK749"
}
```

### How to run

1. Open the actor on Apify.
2. Add company names to `queries` or LEI codes to `leiCodes`.
3. Set `maxResultsPerQuery` for name searches.
4. Add optional country/status filters.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, XML, or via API.

### Tips for better results

- Use exact legal names when possible.
- Add country filters for common names.
- Use `ISSUED` to focus on active registration records.
- Use exact `leiCodes` for deterministic enrichment jobs.
- Keep `rawOutput` off unless you need full audit payloads.
- Enable relationship enrichment only when parent LEI data is needed.

### Integrations

The actor fits common data workflows:

- Enrich a CRM account list with LEI identifiers
- Validate vendor legal names before onboarding
- Join LEI status into a compliance warehouse
- Monitor renewal dates for counterparties
- Feed legal entity data into KYC review queues
- Append official source URLs to analyst workpapers

### API usage

#### 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-lookup-scraper').call({
  queries: ['Apple'],
  maxResultsPerQuery: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/gleif-lei-lookup-scraper').call(run_input={
    'queries': ['Apple'],
    'maxResultsPerQuery': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

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

### MCP usage

Use the Apify MCP server with Claude tools:

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

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/gleif-lei-lookup-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/gleif-lei-lookup-scraper"
    }
  }
}
```

Example prompts:

- "Look up the LEI records for Apple and summarize active entities."
- "Fetch this LEI and tell me the next renewal date."
- "Find issued LEI records for Stripe in the US and return legal names."

### Scheduling

You can schedule recurring runs to monitor:

- Vendor LEI renewal dates
- Counterparty status changes
- New entities matching a legal-name pattern
- Compliance watchlist enrichment batches

### Limits and reliability

The actor is intentionally polite to the official API.

It uses:

- Bounded pagination
- Conservative default result caps
- Bounded retries for 429 and 5xx responses
- Optional request delay controls
- No proxy by default

### Legality

GLEIF LEI records are public official data.

Use the actor responsibly and comply with your organization’s privacy, compliance, and data-retention policies.

Do not treat LEI status as the only KYC or AML decision factor; it is one useful official data point.

### FAQ

#### Is this official GLEIF data?

Yes. The actor requests the public official GLEIF JSON:API and normalizes each returned LEI record into an Apify dataset.

### Troubleshooting

#### I got too many records for a company name

Lower `maxResultsPerQuery`, add a `countryCodes` filter, or use exact LEI codes.

#### I cannot find a company

Try the exact legal name, remove country filters, or search by known LEI code.

#### Relationship fields are empty

Some entities do not have reported parent records. Enable `includeRelationships` only when you need those fields.

### Related scrapers

Other automation-lab actors that can complement this workflow:

- `https://apify.com/automation-lab/company-funding-tracker`
- `https://apify.com/automation-lab/financial-statements-scraper`
- `https://apify.com/automation-lab/sec-form-nport-mutual-fund-holdings-scraper`
- `https://apify.com/automation-lab/whois-lookup`
- `https://apify.com/automation-lab/website-contact-finder`

### Changelog

- `0.1.0` — Initial GLEIF LEI lookup, filters, exact LEI mode, optional parent enrichment, and raw output support.

# Actor input Schema

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

Company, fund, counterparty, vendor, or legal entity names to search in the official GLEIF LEI database.

## `leiCodes` (type: `array`):

Optional exact 20-character LEI identifiers to fetch directly.

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

Safety cap for broad company-name searches. Exact LEI lookups are not affected.

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

Optional ISO 3166-1 alpha-2 country codes, for example US, GB, IE, DE. Leave empty to search globally.

## `registrationStatuses` (type: `array`):

Optional GLEIF registration status filter. ISSUED is the common active-record value.

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

Fetch direct and ultimate parent LEI summaries for every output record. This makes extra GLEIF API requests.

## `rawOutput` (type: `boolean`):

Attach the original JSON:API record to each dataset item for audit/debug workflows.

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

Polite delay used between paginated GLEIF API requests and optional relationship lookups.

## Actor input object example

```json
{
  "queries": [
    "Apple",
    "Stripe"
  ],
  "leiCodes": [
    "549300MGN03W4U2NK749"
  ],
  "maxResultsPerQuery": 20,
  "countryCodes": [],
  "registrationStatuses": [
    "ISSUED"
  ],
  "includeRelationships": false,
  "rawOutput": false,
  "requestDelayMs": 150
}
```

# 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",
        "Stripe"
    ],
    "leiCodes": [
        "549300MGN03W4U2NK749"
    ],
    "maxResultsPerQuery": 20,
    "countryCodes": [],
    "registrationStatuses": [
        "ISSUED"
    ],
    "includeRelationships": false,
    "rawOutput": false,
    "requestDelayMs": 150
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/gleif-lei-lookup-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "queries": [
        "Apple",
        "Stripe",
    ],
    "leiCodes": ["549300MGN03W4U2NK749"],
    "maxResultsPerQuery": 20,
    "countryCodes": [],
    "registrationStatuses": ["ISSUED"],
    "includeRelationships": False,
    "rawOutput": False,
    "requestDelayMs": 150,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/gleif-lei-lookup-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "queries": [
    "Apple",
    "Stripe"
  ],
  "leiCodes": [
    "549300MGN03W4U2NK749"
  ],
  "maxResultsPerQuery": 20,
  "countryCodes": [],
  "registrationStatuses": [
    "ISSUED"
  ],
  "includeRelationships": false,
  "rawOutput": false,
  "requestDelayMs": 150
}' |
apify call automation-lab/gleif-lei-lookup-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GLEIF LEI Lookup Scraper",
        "description": "Search official GLEIF Legal Entity Identifier records by company name or LEI for KYC, AML, onboarding, and counterparty enrichment.",
        "version": "0.1",
        "x-build-id": "bPNIH8eleh1E3sHAE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~gleif-lei-lookup-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-gleif-lei-lookup-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~gleif-lei-lookup-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-gleif-lei-lookup-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~gleif-lei-lookup-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-gleif-lei-lookup-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "queries": {
                        "title": "Company names",
                        "type": "array",
                        "description": "Company, fund, counterparty, vendor, or legal entity names to search in the official GLEIF LEI database.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "leiCodes": {
                        "title": "Exact LEI codes",
                        "type": "array",
                        "description": "Optional exact 20-character LEI identifiers to fetch directly.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum results per company name",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Safety cap for broad company-name searches. Exact LEI lookups are not affected.",
                        "default": 50
                    },
                    "countryCodes": {
                        "title": "Legal address country codes",
                        "type": "array",
                        "description": "Optional ISO 3166-1 alpha-2 country codes, for example US, GB, IE, DE. Leave empty to search globally.",
                        "items": {
                            "type": "string",
                            "minLength": 2,
                            "maxLength": 2
                        }
                    },
                    "registrationStatuses": {
                        "title": "Registration statuses",
                        "type": "array",
                        "description": "Optional GLEIF registration status filter. ISSUED is the common active-record value.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "ISSUED",
                                "LAPSED",
                                "PENDING_ARCHIVAL",
                                "PENDING_TRANSFER",
                                "RETIRED",
                                "DUPLICATE",
                                "ANNULLED",
                                "CANCELLED",
                                "MERGED"
                            ],
                            "enumTitles": [
                                "Issued",
                                "Lapsed",
                                "Pending archival",
                                "Pending transfer",
                                "Retired",
                                "Duplicate",
                                "Annulled",
                                "Cancelled",
                                "Merged"
                            ]
                        }
                    },
                    "includeRelationships": {
                        "title": "Include parent relationships",
                        "type": "boolean",
                        "description": "Fetch direct and ultimate parent LEI summaries for every output record. This makes extra GLEIF API requests.",
                        "default": false
                    },
                    "rawOutput": {
                        "title": "Include raw GLEIF record",
                        "type": "boolean",
                        "description": "Attach the original JSON:API record to each dataset item for audit/debug workflows.",
                        "default": false
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Polite delay used between paginated GLEIF API requests and optional relationship lookups.",
                        "default": 150
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```