# GLEIF LEI Records Scraper (`fetch_cat/gleif-lei-records-scraper`) Actor

Search public GLEIF LEI records by legal name, exact LEI code, country, entity status, and registration status. Export clean compliance data.

- **URL**: https://apify.com/fetch\_cat/gleif-lei-records-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Business, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 lei record saveds

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 Records Scraper

Find and export Legal Entity Identifier (LEI) records from the public GLEIF dataset.

Use this actor to search companies by legal name, fetch exact LEI codes, filter by country or status, and export normalized compliance-ready records.

---

### What does GLEIF LEI Records Scraper do?

GLEIF LEI Records Scraper helps you collect public Legal Entity Identifier reference data at scale.

It returns structured records for legal entities, including names, LEIs, registration status, jurisdiction, addresses, renewal dates, Local Operating Unit details, and available financial identifiers.

You can run one quick lookup or a bulk search job.

Typical jobs include:

- 🔎 Search legal entity names such as `Apple`, `Microsoft`, or supplier names
- 🧾 Fetch exact 20-character LEI codes
- 🌍 Filter entities by legal address country
- ✅ Filter by registration and entity status
- 📦 Export clean records to JSON, CSV, Excel, Google Sheets, or your own API pipeline

---

### Who is it for?

This actor is useful for teams that need reliable public company-reference data.

- 🏦 KYC and AML teams validating counterparties
- 📊 B2B data vendors enriching company profiles
- 🧑‍💼 Sales operations teams cleaning lead and account lists
- 🛡️ Supplier-risk and procurement analysts checking legal entities
- 🧮 Finance teams mapping entities to LEI records
- 🧰 Developers building compliance or enrichment workflows

---

### Why use this actor?

GLEIF data is public, but many users need it in an automation-friendly format.

This actor provides:

- Bulk input handling
- Pagination controls
- Consistent field names
- Deduplication by LEI
- Optional raw source record retention
- Apify dataset export formats
- API and integration support
- Pay-per-result pricing

---

### What data can you extract?

| Field | Description |
|---|---|
| `lei` | Legal Entity Identifier |
| `legalName` | Registered legal name |
| `entityStatus` | Active or inactive entity status |
| `registrationStatus` | LEI registration status |
| `jurisdiction` | Legal jurisdiction code |
| `legalForm` | Legal form identifier |
| `legalAddress` | Registered legal address object |
| `headquartersAddress` | Headquarters address object |
| `initialRegistrationDate` | First registration date |
| `lastUpdateDate` | Last update timestamp |
| `nextRenewalDate` | Next renewal date |
| `managingLou` | Managing Local Operating Unit |
| `bic` | BIC codes where available |
| `isin` | ISIN values where available |
| `directParentLei` | Direct parent LEI when available |
| `ultimateParentLei` | Ultimate parent LEI when available |
| `sourceUrl` | Source record URL |
| `matchedInput` | Input term or LEI that found the record |
| `rawRecord` | Optional full source record |

---

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee charged when a run starts. Covers fixed startup cost. | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `item` | Charged per public GLEIF LEI record saved to the dataset. | $0.0575 / 1,000 | $0.05 / 1,000 | $0.039 / 1,000 | $0.03 / 1,000 | $0.02 / 1,000 | $0.014 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### Quick start

1. Open the actor on Apify.
2. Enter one or more legal names in **Legal names to search**.
3. Optionally add exact LEI codes.
4. Add filters such as country, registration status, or entity status.
5. Set **Maximum records**.
6. Click **Start**.
7. Download the dataset when the run finishes.

---

### Input options

#### Legal names to search

Use `searchTerms` for company names or partial legal names.

Examples:

- `Apple`
- `Microsoft`
- `Volkswagen`
- `Acme Holdings`

#### Exact LEI codes

Use `leiCodes` when you already know the LEI.

The actor fetches these directly and deduplicates them against search results.

#### Country filter

Use `country` with a two-letter country code.

Examples:

- `US`
- `GB`
- `DE`
- `FR`
- `IN`

#### Registration status

Use `registrationStatus` to focus on issued, lapsed, retired, or other record states.

#### Entity status

Use `entityStatus` to filter active or inactive legal entities.

---

### Example input

```json
{
  "searchTerms": ["Apple", "Microsoft"],
  "country": "US",
  "registrationStatus": "ISSUED",
  "entityStatus": "ACTIVE",
  "maxItems": 25,
  "pageSize": 50,
  "includeRawRecord": true
}
````

***

### Example output

```json
{
  "lei": "549300N1UWZ4871DND44",
  "legalName": "Apple Bank",
  "entityStatus": "ACTIVE",
  "registrationStatus": "ISSUED",
  "jurisdiction": "US-NY",
  "legalForm": "M0ER",
  "legalAddress": {
    "city": "New York",
    "country": "US",
    "fullAddress": "122 E 42nd St Fl 9, New York, US-NY, 10168, US"
  },
  "nextRenewalDate": "2026-10-11T19:37:39Z",
  "managingLou": "529900F6BNUR3RJ2WH29",
  "bic": ["APPAUS33XXX"],
  "isin": [],
  "sourceUrl": "https://api.gleif.org/api/v1/lei-records/549300N1UWZ4871DND44",
  "matchedInput": "Apple"
}
```

***

### Tips for better results

- Use official legal names when possible.
- Combine broad names with a country filter to reduce noise.
- Use exact LEI codes for verification workflows.
- Keep `includeRawRecord` enabled when you need audit trails.
- Start with a low `maxItems` value, review output, then scale up.

***

### Common use cases

#### KYC checks

Validate whether a counterparty has an active issued LEI record.

#### Supplier onboarding

Enrich supplier records with jurisdiction, address, and renewal status.

#### CRM enrichment

Attach LEI identifiers to account records for finance and compliance workflows.

#### Data vendor pipelines

Create recurring exports of entities by country and registration status.

***

### Integrations

Apify datasets can be connected to many downstream tools.

Useful workflows include:

- Send new LEI records to Google Sheets
- Export CSV files to S3 or Google Drive
- Trigger webhooks after a compliance enrichment run
- Call the actor from a CRM enrichment service
- Schedule recurring country/status exports

***

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('fetch_cat/gleif-lei-records-scraper').call({
  searchTerms: ['Apple'],
  country: 'US',
  registrationStatus: 'ISSUED',
  entityStatus: 'ACTIVE',
  maxItems: 25
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])

run = client.actor('fetch_cat/gleif-lei-records-scraper').call(run_input={
    'searchTerms': ['Apple'],
    'country': 'US',
    'registrationStatus': 'ISSUED',
    'entityStatus': 'ACTIVE',
    'maxItems': 25,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~gleif-lei-records-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["Apple"],"country":"US","maxItems":25}'
```

***

### MCP integration

Use this actor from MCP-compatible tools through Apify MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=fetch_cat/gleif-lei-records-scraper
```

Claude Code setup:

```bash
claude mcp add apify-gleif-lei-records "https://mcp.apify.com/?tools=fetch_cat/gleif-lei-records-scraper"
```

Claude Desktop JSON configuration:

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

Example prompts:

- "Find active US LEI records for Apple and summarize renewal dates."
- "Look up this LEI and return the legal address."
- "Export active issued LEI records for Microsoft-related entities."

***

### Scheduling

You can schedule recurring runs in Apify.

Examples:

- Daily checks for a watchlist of LEI codes
- Weekly supplier list enrichment
- Monthly country-level export refreshes

***

### Data quality notes

The output reflects public GLEIF reference data at run time.

Some optional identifiers, parent relationships, or financial codes may be missing for some entities.

Always review `registrationStatus`, `entityStatus`, and `nextRenewalDate` for compliance decisions.

***

### Limits

The actor is designed for public reference-data extraction.

Very large jobs should use sensible `maxItems` and `pageSize` settings.

If a search term is broad, the actor may return many legally distinct entities with similar names.

***

### Legality

This actor collects publicly available LEI reference data.

You are responsible for using the data in accordance with applicable laws, internal compliance policies, and the terms of the source data provider.

Do not use the output as the only basis for a regulated decision without appropriate review.

***

### FAQ

#### Why did I get multiple companies for one name?

Legal names are often shared across subsidiaries, jurisdictions, and similarly named entities. Add a country or status filter to narrow the results.

#### Why are some parent LEI fields empty?

Not every public record exposes parent relationship values in the same way. Keep `rawRecord` enabled if you need to inspect all relationship metadata.

#### Why did my run return zero items?

Check spelling, remove overly strict filters, or try an exact LEI code if you have one.

#### Can I export to CSV or Excel?

Yes. Open the run dataset and choose CSV, Excel, JSON, XML, or RSS export.

***

### Related scrapers

Other actors from the same developer that may help with company and compliance workflows:

- https://apify.com/fetch\_cat/sec-edgar-company-filings-scraper
- https://apify.com/fetch\_cat/github-profile-scraper
- https://apify.com/fetch\_cat/github-repository-search-scraper

***

### Support

If you need a field that is present in public GLEIF records but not normalized in the dataset, open an issue on the actor page.

Include your input, run ID, and a short description of the field you need.

# Actor input Schema

## `searchTerms` (type: `array`):

Company or legal entity names to search in GLEIF LEI records. Partial names are accepted.

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

Optional exact 20-character LEI codes to fetch directly.

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

Optional ISO 3166-1 alpha-2 country code, such as US, GB, DE, or IN.

## `registrationStatus` (type: `string`):

Optional GLEIF registration status filter.

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

Optional legal entity status filter.

## `maxItems` (type: `integer`):

Maximum number of unique LEI records to save across all searches and LEI codes.

## `pageSize` (type: `integer`):

Number of records to request per API page. Higher values reduce requests for bulk jobs.

## `includeRawRecord` (type: `boolean`):

Include the full source API object for auditability and advanced enrichment workflows.

## Actor input object example

```json
{
  "searchTerms": [
    "Apple",
    "Microsoft"
  ],
  "leiCodes": [
    "HWUPKR0MPOU8FGXBT394"
  ],
  "country": "US",
  "registrationStatus": "ISSUED",
  "entityStatus": "ACTIVE",
  "maxItems": 10,
  "pageSize": 10,
  "includeRawRecord": true
}
```

# 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 = {
    "searchTerms": [
        "Apple",
        "Microsoft"
    ],
    "leiCodes": [
        "HWUPKR0MPOU8FGXBT394"
    ],
    "country": "US",
    "registrationStatus": "ISSUED",
    "entityStatus": "ACTIVE",
    "maxItems": 10,
    "pageSize": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/gleif-lei-records-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 = {
    "searchTerms": [
        "Apple",
        "Microsoft",
    ],
    "leiCodes": ["HWUPKR0MPOU8FGXBT394"],
    "country": "US",
    "registrationStatus": "ISSUED",
    "entityStatus": "ACTIVE",
    "maxItems": 10,
    "pageSize": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/gleif-lei-records-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 '{
  "searchTerms": [
    "Apple",
    "Microsoft"
  ],
  "leiCodes": [
    "HWUPKR0MPOU8FGXBT394"
  ],
  "country": "US",
  "registrationStatus": "ISSUED",
  "entityStatus": "ACTIVE",
  "maxItems": 10,
  "pageSize": 10
}' |
apify call fetch_cat/gleif-lei-records-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GLEIF LEI Records Scraper",
        "description": "Search public GLEIF LEI records by legal name, exact LEI code, country, entity status, and registration status. Export clean compliance data.",
        "version": "0.1",
        "x-build-id": "ULk6aGiei5EB02pbo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~gleif-lei-records-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-gleif-lei-records-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/fetch_cat~gleif-lei-records-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-gleif-lei-records-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/fetch_cat~gleif-lei-records-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-gleif-lei-records-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": {
                    "searchTerms": {
                        "title": "Legal names to search",
                        "type": "array",
                        "description": "Company or legal entity names to search in GLEIF LEI records. Partial names are accepted.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "leiCodes": {
                        "title": "Exact LEI codes",
                        "type": "array",
                        "description": "Optional exact 20-character LEI codes to fetch directly.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Legal address country",
                        "minLength": 2,
                        "maxLength": 2,
                        "type": "string",
                        "description": "Optional ISO 3166-1 alpha-2 country code, such as US, GB, DE, or IN."
                    },
                    "registrationStatus": {
                        "title": "Registration status",
                        "enum": [
                            "ISSUED",
                            "LAPSED",
                            "DUPLICATE",
                            "RETIRED",
                            "ANNULLED",
                            "CANCELLED",
                            "PENDING_ARCHIVAL",
                            "PENDING_TRANSFER"
                        ],
                        "type": "string",
                        "description": "Optional GLEIF registration status filter."
                    },
                    "entityStatus": {
                        "title": "Entity status",
                        "enum": [
                            "ACTIVE",
                            "INACTIVE"
                        ],
                        "type": "string",
                        "description": "Optional legal entity status filter."
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of unique LEI records to save across all searches and LEI codes.",
                        "default": 50
                    },
                    "pageSize": {
                        "title": "GLEIF API page size",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Number of records to request per API page. Higher values reduce requests for bulk jobs.",
                        "default": 100
                    },
                    "includeRawRecord": {
                        "title": "Include raw GLEIF record",
                        "type": "boolean",
                        "description": "Include the full source API object for auditability and advanced enrichment workflows.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
