# GLEIF LEI Legal Entity Registry Scraper — Company Data API (`compute-edge/gleif-lei-entities-scraper`) Actor

Extract legal entity data from the Global Legal Entity Identifier (LEI) Registry maintained by GLEIF. Access 3.3M+ companies worldwide with jurisdiction, registration status, and corporate structure data for KYC compliance, B2B intelligence, and regulatory reporting.

- **URL**: https://apify.com/compute-edge/gleif-lei-entities-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## GLEIF LEI Legal Entity Registry Scraper

Extract structured company data from the **Global Legal Entity Identifier (LEI) Registry** maintained by the Global Legal Entity Identifier Foundation (GLEIF) — the authoritative, globally consolidated registry of 3.3M+ legal entities worldwide. This Actor provides clean JSON output of company names, jurisdictions, legal forms, registration dates, and corporate structure data essential for KYC compliance, B2B lead intelligence, and regulatory reporting.

The LEI Registry is the backbone of global financial regulation and know-your-customer (KYC) processes. Every regulated financial institution, investment fund, and public company maintains an LEI code. Unlike decentralized business directories, the LEI Registry is maintained under international governance (ISO 17442) and is the single source of truth for corporate identity verification.

### Key Features

- **Complete LEI Registry access** — 3.3M+ registered legal entities with verified registration data
- **Flexible search filtering** — Filter by entity name, country (ISO 2-letter code), entity status, or registration status
- **No authentication required** — Free public API, no API keys or credentials needed
- **Comprehensive entity data** — Legal name, jurisdiction, corporate structure, registration dates, headquarters location, and managing LOU
- **Pagination support** — Efficiently retrieve large result sets in configurable batches
- **Clean JSON output** — Structured entity records ready for KYC automation, compliance pipelines, or B2B enrichment
- **Optional chaining** — All fields include null-safe extraction (empty string if missing)

### Output Data Fields

| Field | Type | Description |
|-------|------|-------------|
| `lei` | string | Global Legal Entity Identifier code (unique worldwide identifier) |
| `legalName` | string | Official registered name of the legal entity |
| `legalForm` | string | Legal form ID (e.g., corporation, partnership, trust, LLC) |
| `jurisdiction` | string | Jurisdiction/country code where entity is registered |
| `category` | string | Entity category (e.g., FUND, BRANCH, SUBSIDIARY) |
| `entityStatus` | string | Current entity status (ACTIVE, INACTIVE, DISSOLVED, etc.) |
| `city` | string | City of registered address |
| `region` | string | Region/state of registered address |
| `country` | string | Country code of registered address (ISO 2-letter) |
| `postalCode` | string | Postal/ZIP code of registered address |
| `addressLine` | string | Street address lines (joined with commas if multiple) |
| `hqCity` | string | City of headquarters address (if different from registered) |
| `hqCountry` | string | Country code of headquarters address |
| `registrationStatus` | string | LEI registration status (ISSUED, LAPSED, MERGED, RETIRED, DUPLICATE) |
| `initialRegistrationDate` | string | Date entity was first registered (ISO 8601) |
| `lastUpdateDate` | string | Most recent update to registration data (ISO 8601) |
| `nextRenewalDate` | string | Date when LEI will require renewal |
| `managingLou` | string | Local Operating Unit code managing this LEI |
| `registeredAs` | string | Category of how entity is registered |
| `bic` | string | Bank Identifier Codes associated with entity (if any) |

### How to Scrape GLEIF LEI Data

#### Basic Usage (All Entities, Default Limit 1,000)

1. Navigate to the **GLEIF LEI Entities Scraper** Actor on Apify Store.
2. Click **Start** to open the configuration form.
3. Leave all filters blank to retrieve the first 1,000 entities (default).
4. Click **Start** to run the Actor.
5. Download results as JSON, CSV, or Excel from the **Dataset** tab.

#### Advanced: Search by Company Name

1. In the **Legal Entity Name Filter** field, enter a partial name (e.g., "Apple", "Microsoft", "Tesla").
2. Set **Max Results** to desired count (e.g., 100 to get top 100 matches).
3. Click **Start**.

#### Advanced: Search by Country

1. In the **Country Code Filter** field, enter a 2-letter ISO country code:
   - `US` = United States
   - `GB` = United Kingdom
   - `DE` = Germany
   - `JP` = Japan
   - `FR` = France
2. Set **Max Results** to desired count.
3. Click **Start**.

#### Advanced: Filter by Registration Status

1. In the **Registration Status Filter** field, enter one of:
   - `ISSUED` = Currently active LEI
   - `LAPSED` = Registration expired (not renewed)
   - `MERGED` = Entity merged into another
   - `RETIRED` = Voluntarily retired
   - `DUPLICATE` = Superseded by another LEI
2. Click **Start**.

#### Advanced: Search for Active Entities Only

1. In the **Entity Status Filter** field, enter `ACTIVE`.
2. Leave other filters blank to search all countries.
3. Set **Max Results** to desired count.
4. Click **Start**.

### Input Examples

#### Example 1: Search for All US Companies (First 500)

```json
{
    "country": "US",
    "maxResults": 500
}
````

#### Example 2: Search for a Specific Company Across All Jurisdictions

```json
{
    "legalName": "Apple",
    "maxResults": 100
}
```

#### Example 3: Find Only Active German Entities

```json
{
    "country": "DE",
    "status": "ACTIVE",
    "maxResults": 1000
}
```

#### Example 4: Retrieve All Data (Unlimited, Up to API Cap of 100,000)

```json
{
    "maxResults": 0
}
```

### Output Examples

#### Single Record Output

```json
{
    "lei": "5493001KJTIIGC8Y1R12",
    "legalName": "Apple Inc.",
    "legalForm": "ETIZ",
    "jurisdiction": "US",
    "category": "FUND",
    "entityStatus": "ACTIVE",
    "city": "Cupertino",
    "region": "CA",
    "country": "US",
    "postalCode": "95014",
    "addressLine": "1 Apple Park Way",
    "hqCity": "Cupertino",
    "hqCountry": "US",
    "registrationStatus": "ISSUED",
    "initialRegistrationDate": "2012-06-06",
    "lastUpdateDate": "2024-12-15",
    "nextRenewalDate": "2026-06-06",
    "managingLou": "5299001KKTIIGC8Y1000",
    "registeredAs": "BRANCH",
    "bic": ""
}
```

#### Bulk Export CSV (First 3 rows)

```
lei,legalName,legalForm,jurisdiction,category,entityStatus,city,region,country,postalCode,addressLine,hqCity,hqCountry,registrationStatus,initialRegistrationDate,lastUpdateDate,nextRenewalDate,managingLou,registeredAs,bic
5493001KJTIIGC8Y1R12,Apple Inc.,ETIZ,US,FUND,ACTIVE,Cupertino,CA,US,95014,1 Apple Park Way,Cupertino,US,ISSUED,2012-06-06,2024-12-15,2026-06-06,5299001KKTIIGC8Y1000,BRANCH,
5493001KJTIIGC8Y2R34,Microsoft Corporation,CTPR,US,FUND,ACTIVE,Redmond,WA,US,98052,One Microsoft Way,Redmond,US,ISSUED,2011-03-04,2024-11-20,2025-03-04,5299001KKTIIGC8Y2000,BRANCH,
```

### Pricing

This Actor fetches data from the free GLEIF public API using paginated requests.

- **Cost per run**: Minimal (API calls only, no browser automation required)
- **Actor start event**: Default platform rate
- **Per-result pricing**: $0.003/result

Typical run time is 5-30 seconds depending on filter complexity and result count.

### Use Cases

- **KYC Compliance Automation** — Auto-verify counterparty legal entity data against the authoritative LEI Registry during onboarding
- **B2B Lead Enrichment** — Append verified registration data, jurisdiction, and entity status to prospect lists for more accurate targeting
- **Financial Regulatory Reporting** — Gather LEI codes and corporate structure data for EMIR, MiFID II, and other regulatory filings
- **Counterparty Due Diligence** — Build comprehensive entity profiles including registration status, merger history, and managing LOU
- **Corporate Hierarchy Mapping** — Extract subsidiary and parent company relationships using headquarters vs. registered address data
- **Duplicate Entity Detection** — Identify merged, retired, or duplicate LEI codes to clean up CRM and financial systems
- **Fraud Prevention** — Cross-reference suspicious entities against GLEIF's lapsed/retired/merged status categories
- **RAG Pipeline Ingestion** — Clean structured output ready for LLM-based due diligence automation

### Legal & Compliance

- **Data Source**: GLEIF (Global Legal Entity Identifier Foundation) public API
- **License**: LEI Data Use Agreement governs redistribution (see [GLEIF terms](https://www.gleif.org/en/about-lei/use-of-lei-data))
- **Public Data**: All LEI data is publicly accessible and intended for general use
- **No Personal Data**: LEI Registry contains business entity information only, not personal data
- **Commercial Use**: Permitted under LEI Data Use Agreement for business intelligence, compliance, and automation

### FAQ

#### What is a LEI?

A Legal Entity Identifier (LEI) is a 20-character alphanumeric identifier issued by GLEIF to uniquely identify a legal entity. It's mandated under international regulatory frameworks (ISO 17442) and is the global standard for corporate identity verification.

#### How often is the GLEIF Registry updated?

The LEI Registry is updated in real-time as entities renew or update their registration data. The GLEIF API provides the most current data available.

#### Can I search by multiple filters at once?

Yes. For example, you can filter by country = "US" AND status = "ACTIVE" simultaneously.

#### What is the maximum number of results I can retrieve?

The GLEIF API supports up to 100,000 results per query. Set `maxResults` to 0 for unlimited retrieval (capped at 100,000).

#### Why is some address data missing?

Some entities may not have headquarters address data distinct from their registered address. The Actor returns empty strings for unavailable fields rather than null values.

#### Can I use this data for credit risk assessment?

Yes, but LEI data provides identity and registration status only. Combine with financial databases (D\&B, SEC EDGAR, etc.) for credit risk assessment.

#### How many entities are in the GLEIF Registry?

As of 2024, over 3.3M legal entities are registered in the LEI Registry, spanning all countries and major industries.

### Support

For issues, questions, or feature requests, contact the Apify support team via the Actor page.

***

**Disclaimer**: This Actor scrapes the publicly accessible GLEIF LEI Registry. Users are responsible for compliance with GLEIF's Data Use Agreement and applicable data protection laws (GDPR, CCPA, etc.). Apify does not warrant the accuracy or completeness of LEI data — refer to GLEIF's official documentation for authoritative information.

# Actor input Schema

## `legalName` (type: `string`):

Filter by legal entity name (partial match). Examples: 'Apple', 'Microsoft', 'Tesla Inc'. Leave blank to retrieve all entities.

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

Filter by country (2-letter ISO code). Examples: 'US', 'GB', 'DE', 'JP'. Leave blank to search all countries.

## `status` (type: `string`):

Filter by entity status. Values: 'ACTIVE', 'INACTIVE'. Leave blank for all statuses.

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

Filter by LEI registration status. Values: 'ISSUED', 'LAPSED', 'MERGED', 'RETIRED', 'DUPLICATE'. Leave blank for all statuses.

## `maxResults` (type: `integer`):

Maximum number of entity records to return. Set to 0 for unlimited (up to 100,000 API limit).

## Actor input object example

```json
{
  "legalName": "",
  "country": "",
  "status": "",
  "registrationStatus": "",
  "maxResults": 1000
}
```

# Actor output Schema

## `dataset` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/gleif-lei-entities-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/gleif-lei-entities-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 '{}' |
apify call compute-edge/gleif-lei-entities-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GLEIF LEI Legal Entity Registry Scraper — Company Data API",
        "description": "Extract legal entity data from the Global Legal Entity Identifier (LEI) Registry maintained by GLEIF. Access 3.3M+ companies worldwide with jurisdiction, registration status, and corporate structure data for KYC compliance, B2B intelligence, and regulatory reporting.",
        "version": "0.1",
        "x-build-id": "WAGO4uvwyKTmhTLCI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~gleif-lei-entities-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-gleif-lei-entities-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/compute-edge~gleif-lei-entities-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-gleif-lei-entities-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/compute-edge~gleif-lei-entities-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-gleif-lei-entities-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": {
                    "legalName": {
                        "title": "Legal Entity Name Filter",
                        "type": "string",
                        "description": "Filter by legal entity name (partial match). Examples: 'Apple', 'Microsoft', 'Tesla Inc'. Leave blank to retrieve all entities.",
                        "default": ""
                    },
                    "country": {
                        "title": "Country Code Filter",
                        "type": "string",
                        "description": "Filter by country (2-letter ISO code). Examples: 'US', 'GB', 'DE', 'JP'. Leave blank to search all countries.",
                        "default": ""
                    },
                    "status": {
                        "title": "Entity Status Filter",
                        "type": "string",
                        "description": "Filter by entity status. Values: 'ACTIVE', 'INACTIVE'. Leave blank for all statuses.",
                        "default": ""
                    },
                    "registrationStatus": {
                        "title": "Registration Status Filter",
                        "type": "string",
                        "description": "Filter by LEI registration status. Values: 'ISSUED', 'LAPSED', 'MERGED', 'RETIRED', 'DUPLICATE'. Leave blank for all statuses.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of entity records to return. Set to 0 for unlimited (up to 100,000 API limit).",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
