# GLEIF LEI Lookup (`maximedupre/gleif-lei-lookup`) Actor

Look up GLEIF LEI records by company name, LEI code, or country filters. Export legal entity data, registration dates, addresses, parent relationships, ISIN links, and deterministic KYB decision fields.

- **URL**: https://apify.com/maximedupre/gleif-lei-lookup.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 checked lei records

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 for legal entity data

GLEIF LEI Lookup searches the public [GLEIF](https://www.gleif.org/) Legal Entity Identifier data and saves clean company records you can export from Apify. Search by company name, exact 20-character LEI code, country filters, or a mix of targets, then get official registry facts, addresses, registration dates, parent relationship context, ISIN links, and deterministic KYB decision fields.

Use it when you need repeatable LEI lookup, vendor onboarding checks, counterparty screening, company enrichment, or a GLEIF data API workflow without maintaining your own LEI database. Each saved dataset row is one accepted GLEIF LEI entity record. Batch runs also write a `PORTFOLIO_SUMMARY` key-value output with totals, risk distribution, country exposure, priority queues, and watchlist health.

For a first run, keep the prefilled targets `Apple` and `HWUPKR0MPOU8FGXBT394`, keep `Max records` at `25`, and start the Actor. Once the row shape fits your workflow, add more company names, paste LEI codes, add country filters, or turn on the richer relationship and securities options.

### ✅ What this Actor does

- Looks up GLEIF LEI records by company name or exact LEI code.
- Exports filtered country datasets by ISO country code, entity status, and entity category.
- Saves one dataset row per accepted Legal Entity Identifier record.
- Returns official legal names, alternate names, entity status, jurisdiction, legal form, registration authority, addresses, registration dates, managing LOU, and source URLs.
- Adds parent basics, child counts, relationship edges, and reporting exceptions when relationship enrichment is enabled and GLEIF provides the data.
- Adds ISIN/security links when securities enrichment is enabled and available.
- Adds deterministic decision fields such as recommended action, risk score, risk band, identity confidence, ownership transparency, onboarding complexity, and renewal state.
- Supports watchlist snapshots so scheduled runs can flag first-seen, unchanged, and changed LEI records.
- Works with Apify dataset exports, API access, schedules, webhooks, and integrations.
- Charges only for saved LEI records.

This Actor focuses on public GLEIF data. It does not provide sanctions, PEP, adverse media, OFAC, SEC, OpenCorporates, Companies House, or legal advice.

### 📦 Data you can export

Each dataset item is one official GLEIF Legal Entity Identifier record. Fields can be `null` or empty when GLEIF does not expose that data or when your selected output detail keeps the row compact.

- `lei`, `matchedInputs`, `legalName`, and `otherNames`
- `entity` with status, category, subcategory, jurisdiction, legal form, registration authority, registered-as number, and BIC codes
- `registration` with LEI status, initial registration date, last update date, next renewal date, managing LOU, and registration-number match state
- `legalAddress` and `headquartersAddress`
- `parents` with direct parent, ultimate parent, child count, and ownership-opacity signal
- `relationships` with parent, child, or other relationship edges when collected
- `securities` with ISIN links when collected
- `decision` with policy profile, recommended action, risk score, risk band, risk factors, review flags, identity confidence, ownership transparency, onboarding complexity, and renewal state
- `watchlist` with change status and changed fields when a watchlist name is supplied
- `sourceUrl` linking back to the public GLEIF record

### 🎯 Common use cases

- Enrich a vendor or customer list with official LEI records.
- Check whether a known LEI code is active, issued, renewed, and tied to the expected legal entity.
- Build country-level legal entity exports for research or screening.
- Add GLEIF source URLs and registration facts to a CRM, warehouse, spreadsheet, or compliance review queue.
- Review parent ownership context before onboarding a counterparty.
- Track a fixed watchlist of entities with scheduled Apify runs.
- Feed source-backed LEI data into an internal KYB workflow through the Apify API.

### ▶️ How to run it

1. Open the Actor input.
2. Add company names or exact LEI codes in **Company names or LEI codes**.
3. Optional: add ISO country codes such as `US`, `GB`, or `DE` in **Countries**.
4. Set **Max records** to control runtime and cost. Use `0` only when you want every matching record.
5. Choose **Entity status**, **Entity category**, **Decision policy**, and **Output detail**.
6. Turn relationship, securities, or graph-ready relationship data on only when you need that extra context.
7. Optional: add a **Watchlist name** or **Registration number** for repeat monitoring and corroboration.
8. Start the Actor and open the dataset or `PORTFOLIO_SUMMARY` output.

You can export results as JSON, CSV, Excel, XML, RSS, or HTML. You can also call the Actor through the Apify API, schedule repeat runs, or send results to another system with webhooks.

### ⚙️ Input

Example input:

```json
{
  "queries": ["Apple", "HWUPKR0MPOU8FGXBT394"],
  "countries": ["US"],
  "maxRecords": 25,
  "entityStatus": "ACTIVE",
  "entityCategory": "GENERAL",
  "policyProfile": "balanced",
  "outputProfile": "standard",
  "includeRelationships": true,
  "includeSecurities": false,
  "includeGraphEdges": false,
  "watchlistName": "vendor-review",
  "registrationNumber": "C0806592"
}
````

#### 🎯 Targets and filters

Use `queries` for specific company names or exact LEI codes. Use `countries` for filtered exports. You can fill both in one run; the Actor deduplicates accepted LEI records before saving them.

Use `entityStatus` and `entityCategory` when you want GLEIF-backed filters. Leave them blank for broader matching.

#### 🧭 Decisions and output detail

Use `policyProfile` to choose how the deterministic decision fields weigh status, renewal, identity, and ownership evidence. Use `outputProfile` to control how much detail each row carries:

- `essential`: core LEI identity, statuses, dates, addresses, source URL, and compact decision scores.
- `decision`: adds decision evidence, registration-number corroboration, and watchlist changes.
- `standard`: adds alternate names, legal and registration labels, BIC codes, and parent basics.
- `full`: keeps requested relationship and ISIN/security arrays.

### 📄 Output example

```json
{
  "lei": "HWUPKR0MPOU8FGXBT394",
  "matchedInputs": ["Apple", "HWUPKR0MPOU8FGXBT394"],
  "legalName": "APPLE INC.",
  "otherNames": ["Apple Computer, Inc."],
  "entity": {
    "status": "ACTIVE",
    "category": "GENERAL",
    "subcategory": null,
    "jurisdiction": "US-CA",
    "legalForm": { "code": "XTIQ", "name": "Corporation" },
    "registeredAs": "C0806592",
    "registrationAuthority": { "id": "RA000598", "name": "California Secretary of State" },
    "bicCodes": []
  },
  "registration": {
    "status": "ISSUED",
    "initialRegistrationDate": "2012-06-06",
    "lastUpdateDate": "2026-01-15",
    "nextRenewalDate": "2027-01-15",
    "managingLou": "EVK05KS7XY1DEII3R011",
    "registrationNumberMatch": "matched"
  },
  "decision": {
    "policyProfile": "balanced",
    "recommendedAction": "approve",
    "riskScore": 18,
    "riskBand": "low",
    "identityConfidence": 98,
    "identityVerdict": "strong_match",
    "ownershipTransparency": "clear",
    "onboardingComplexity": "standard",
    "renewalState": "current"
  },
  "sourceUrl": "https://search.gleif.org/#/record/HWUPKR0MPOU8FGXBT394"
}
```

The actual dataset row also includes address, parent, relationship, securities, and watchlist fields from the approved output schema.

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged once for each accepted LEI record saved to the dataset. The current local pricing artifact sets `Checked LEI record` at `$0.0018` per saved record.

The portfolio summary, watchlist comparison fields, and optional enrichment fields are part of the saved LEI record. They are not separate charge events.

### ⚠️ Limits and caveats

- `Max records` controls the number of accepted LEI records saved across the run.
- `Max records` set to `0` means every matching record, subject to normal Actor runtime and source availability.
- Relationship and securities enrichment can add runtime on large exports.
- Some entities do not have parent, child, relationship, ISIN, BIC, or watchlist-change data in GLEIF.
- Decision fields are deterministic indicators from GLEIF facts. They are not legal, compliance, or financial advice.

### ❓ FAQ

#### Do I need a GLEIF API key?

No. The Actor uses public GLEIF data and does not ask you for GLEIF credentials, cookies, or a private source account.

#### Can I use it as a GLEIF data API?

Yes. Run the Actor through the Apify API, schedule it, export the dataset, or connect it to webhooks and integrations. The dataset rows are structured for downstream systems.

#### Does it screen sanctions or adverse media?

No. It only uses GLEIF LEI data. Use a separate screening source if you need sanctions, PEP, adverse media, or other risk lists.

#### Why are some fields empty?

GLEIF does not expose every relationship, security, address detail, or code label for every entity. The Actor keeps unavailable source data empty instead of inventing values.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~gleif-lei-lookup/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Pappers Sirene Scraper ↗](https://apify.com/maximedupre/pappers-sirene-scraper) - Search and enrich French company registry data with official identifiers, addresses, financials, dirigeants, and establishments.
- [LinkedIn Company Scraper ↗](https://apify.com/maximedupre/linkedin-company-scraper) - Export public LinkedIn company profile data for account research and CRM enrichment.
- [LinkedIn Company People Scraper ↗](https://apify.com/maximedupre/linkedin-company-people-scraper) - Extract visible people from LinkedIn company People pages using your own browser session.
- [Business Address Scraper ↗](https://apify.com/maximedupre/business-address-scraper) - Find physical business addresses shown on public company websites.
- [Harris County Court Records Scraper ↗](https://apify.com/maximedupre/harris-county-court-records-scraper) - Export public Harris County Probate and Civil case metadata, parties, attorneys, and filing events.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

Search specific entities by company name or exact 20-character LEI code.

## `countries` (type: `array`):

ISO 3166-1 alpha-2 country codes for filtered exports, such as US, GB, or DE.

## `maxRecords` (type: `integer`):

Maximum LEI records to return across searches and exports. Use 0 for every matching record.

## `entityStatus` (type: `string`):

Limit results by the legal entity's operating status in GLEIF.

## `entityCategory` (type: `string`):

Limit results by broad legal entity category when GLEIF provides it.

## `policyProfile` (type: `string`):

Choose the evidence weighting used for match confidence, status risk, and review flags.

## `outputProfile` (type: `string`):

Choose how much accepted source data, review context, and normalized detail each result includes.

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

Add parent, ultimate parent, child counts, and relationship signals when GLEIF provides them.

## `includeSecurities` (type: `boolean`):

Add GLEIF ISIN/security links for entities that have securities data.

## `includeGraphEdges` (type: `boolean`):

Add graph-ready relationship context inside each LEI row when relationship data is available.

## `watchlistName` (type: `string`):

Optional name for a repeatable monitoring list used to compare results across runs.

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

Optional local registration number to corroborate against GLEIF registration and authority data.

## Actor input object example

```json
{
  "queries": [
    "Apple",
    "HWUPKR0MPOU8FGXBT394"
  ],
  "countries": [
    "US"
  ],
  "maxRecords": 600,
  "entityStatus": "",
  "entityCategory": "",
  "policyProfile": "balanced",
  "outputProfile": "standard",
  "includeRelationships": true,
  "includeSecurities": false,
  "includeGraphEdges": false
}
```

# Actor output Schema

## `results` (type: `string`):

Successful GLEIF Legal Entity Identifier records with registry facts, relationships, securities, decision fields, and watchlist context.

## `portfolioSummary` (type: `string`):

Batch-level totals, risk distribution, country exposure, priority queues, and watchlist health.

# 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",
        "HWUPKR0MPOU8FGXBT394"
    ],
    "countries": [
        "US"
    ],
    "maxRecords": 600
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/gleif-lei-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",
        "HWUPKR0MPOU8FGXBT394",
    ],
    "countries": ["US"],
    "maxRecords": 600,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/gleif-lei-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",
    "HWUPKR0MPOU8FGXBT394"
  ],
  "countries": [
    "US"
  ],
  "maxRecords": 600
}' |
apify call maximedupre/gleif-lei-lookup --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GLEIF LEI Lookup",
        "description": "Look up GLEIF LEI records by company name, LEI code, or country filters. Export legal entity data, registration dates, addresses, parent relationships, ISIN links, and deterministic KYB decision fields.",
        "version": "0.0",
        "x-build-id": "pv0sL3ziCuQ42J9WI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~gleif-lei-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-gleif-lei-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/maximedupre~gleif-lei-lookup/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-gleif-lei-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/maximedupre~gleif-lei-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-gleif-lei-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",
                "properties": {
                    "queries": {
                        "title": "Company names or LEI codes",
                        "type": "array",
                        "description": "Search specific entities by company name or exact 20-character LEI code.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "ISO 3166-1 alpha-2 country codes for filtered exports, such as US, GB, or DE.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxRecords": {
                        "title": "Max records",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Maximum LEI records to return across searches and exports. Use 0 for every matching record.",
                        "default": 600
                    },
                    "entityStatus": {
                        "title": "Entity status",
                        "enum": [
                            "",
                            "ACTIVE",
                            "INACTIVE"
                        ],
                        "type": "string",
                        "description": "Limit results by the legal entity's operating status in GLEIF.",
                        "default": ""
                    },
                    "entityCategory": {
                        "title": "Entity category",
                        "enum": [
                            "",
                            "GENERAL",
                            "BRANCH",
                            "FUND",
                            "SOLE_PROPRIETOR"
                        ],
                        "type": "string",
                        "description": "Limit results by broad legal entity category when GLEIF provides it.",
                        "default": ""
                    },
                    "policyProfile": {
                        "title": "Decision policy",
                        "enum": [
                            "balanced",
                            "vendor_onboarding",
                            "banking",
                            "investment"
                        ],
                        "type": "string",
                        "description": "Choose the evidence weighting used for match confidence, status risk, and review flags.",
                        "default": "balanced"
                    },
                    "outputProfile": {
                        "title": "Output detail",
                        "enum": [
                            "essential",
                            "decision",
                            "standard",
                            "full"
                        ],
                        "type": "string",
                        "description": "Choose how much accepted source data, review context, and normalized detail each result includes.",
                        "default": "standard"
                    },
                    "includeRelationships": {
                        "title": "Include ownership relationships",
                        "type": "boolean",
                        "description": "Add parent, ultimate parent, child counts, and relationship signals when GLEIF provides them.",
                        "default": true
                    },
                    "includeSecurities": {
                        "title": "Include ISIN securities",
                        "type": "boolean",
                        "description": "Add GLEIF ISIN/security links for entities that have securities data.",
                        "default": false
                    },
                    "includeGraphEdges": {
                        "title": "Add graph-ready relationship data",
                        "type": "boolean",
                        "description": "Add graph-ready relationship context inside each LEI row when relationship data is available.",
                        "default": false
                    },
                    "watchlistName": {
                        "title": "Watchlist name",
                        "type": "string",
                        "description": "Optional name for a repeatable monitoring list used to compare results across runs."
                    },
                    "registrationNumber": {
                        "title": "Registration number",
                        "type": "string",
                        "description": "Optional local registration number to corroborate against GLEIF registration and authority data."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
