# GLEIF Legal Entity Scraper (`crawlerbros/gleif-scraper`) Actor

Scrape GLEIF (Global Legal Entity Identifier Foundation), the global standard for identifying legal entities in financial transactions. Covers 2M+ entities worldwide with standardized company data including LEI codes, addresses, registration status, and corporate hierarchy.

- **URL**: https://apify.com/crawlerbros/gleif-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Legal Entity Scraper

Extract standardized company data from **GLEIF** (Global Legal Entity Identifier Foundation) — the global registry for Legal Entity Identifiers (LEI codes) covering **2 million+ legal entities** worldwide engaged in financial transactions.

### What You Get

- **Entity search** — find companies by name with standardized legal name, jurisdiction, address, and registration status
- **By LEI** — full structured data for any company using its 20-character LEI code
- **Corporate hierarchy** — direct children (subsidiaries), direct parent, or ultimate parent of any entity
- **Managing organizations** — list all Local Operating Units (LOUs) that issue LEI codes worldwide

### Data Source

All data is sourced from the **official GLEIF API** (`api.gleif.org`) — the authoritative global registry for LEI codes mandated by the G20. The API is completely free with no authentication required. Data is used by regulators, banks, and financial institutions worldwide.

---

### Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | Select | What to fetch: `searchEntities`, `byLEI`, `relationships`, `managingOrganizations` |
| `query` | Text | Search keyword for entity name (mode=searchEntities) |
| `lei` | Text | 20-character LEI code (mode=byLEI or relationships) |
| `country` | Select | Filter by ISO 3166-1 alpha-2 country code (US, GB, DE, FR, JP, etc.) |
| `status` | Select | Filter by registration status: ACTIVE, INACTIVE, LAPSED, MERGED, etc. |
| `relationshipType` | Select | `direct-children`, `direct-parent`, or `ultimate-parent` |
| `maxItems` | Integer | Maximum records to return (1–500, default 20) |

---

### Modes

#### `searchEntities` — Search legal entities by name
Full-text search across 2M+ registered entities worldwide.

```json
{
  "mode": "searchEntities",
  "query": "Apple",
  "country": "US",
  "status": "ACTIVE",
  "maxItems": 10
}
````

#### `byLEI` — Get entity by LEI code

Returns complete data for a specific legal entity using its unique 20-character identifier.

```json
{
  "mode": "byLEI",
  "lei": "7LTWFZYICNSX8D621K86"
}
```

#### `relationships` — Corporate hierarchy

Retrieve parent or subsidiary entities in the corporate ownership structure.

```json
{
  "mode": "relationships",
  "lei": "7LTWFZYICNSX8D621K86",
  "relationshipType": "direct-children",
  "maxItems": 50
}
```

#### `managingOrganizations` — List LEI-issuing organizations (LOUs)

Returns the organizations authorized to issue LEI codes globally.

```json
{
  "mode": "managingOrganizations",
  "maxItems": 30
}
```

***

### Output Fields

#### Legal Entities

| Field | Description |
|-------|-------------|
| `lei` | 20-character Legal Entity Identifier (unique global ID) |
| `legalName` | Official registered legal name |
| `otherNames` | Alternative or historical names (up to 5) |
| `jurisdiction` | Legal jurisdiction (e.g., US-DE for Delaware) |
| `country` | Country of legal address (ISO 3166-1 alpha-2) |
| `city` | City of legal address |
| `postalCode` | Postal/ZIP code |
| `region` | State/region code |
| `addressLines` | Street address lines |
| `hqCountry` | HQ country (if different from legal address) |
| `hqCity` | HQ city (if different from legal address) |
| `status` | Entity status (ACTIVE, INACTIVE, LAPSED, etc.) |
| `legalForm` | Legal form identifier or description |
| `category` | Entity category (GENERAL, FUND, BRANCH, etc.) |
| `registeredAs` | Registration number in the local registry |
| `registeredAt` | Registry where entity is registered |
| `registrationDate` | Initial LEI registration date (ISO 8601) |
| `lastUpdateDate` | Last data update date (ISO 8601) |
| `nextRenewalDate` | LEI renewal due date (ISO 8601) |
| `registrationStatus` | LEI registration status (ISSUED, etc.) |
| `managingLouLei` | LEI of the organization that manages this LEI |
| `parentLei` | LEI of associated parent entity (if known) |
| `gleifUrl` | Direct GLEIF entity page URL |

#### Managing Organizations (LOUs)

| Field | Description |
|-------|-------------|
| `louLei` | LEI code of the managing organization |
| `name` | Organization name |
| `status` | Status (ACTIVE, etc.) |
| `country` | Country of operation |
| `gleifUrl` | GLEIF page URL |

***

### Example Output Record

```json
{
  "lei": "7LTWFZYICNSX8D621K86",
  "legalName": "Apple Inc.",
  "otherNames": ["Apple Computer Inc."],
  "jurisdiction": "US-DE",
  "country": "US",
  "city": "Cupertino",
  "postalCode": "95014",
  "region": "US-CA",
  "addressLines": ["One Apple Park Way"],
  "status": "ACTIVE",
  "legalForm": "8888",
  "category": "GENERAL",
  "registeredAs": "CA-0671809",
  "registeredAt": "RA000665",
  "registrationDate": "2012-06-06T15:53:00.000Z",
  "lastUpdateDate": "2024-11-25T00:00:00.000Z",
  "nextRenewalDate": "2025-11-25T00:00:00.000Z",
  "registrationStatus": "ISSUED",
  "managingLouLei": "EVK05KS7XY1DEII3R011",
  "gleifUrl": "https://www.gleif.org/lei/7LTWFZYICNSX8D621K86",
  "recordType": "legalEntity",
  "scrapedAt": "2025-05-25T10:30:00+00:00"
}
```

***

### Use Cases

- **Financial compliance** — Verify counterparty identities using the global standard LEI code (required under MiFID II, EMIR, Dodd-Frank)
- **KYC/AML** — Enrich customer entity records with standardized global identifiers
- **Corporate research** — Map subsidiary structures and ownership hierarchies across jurisdictions
- **Data standardization** — Convert local company registrations to globally unique LEI identifiers
- **RegTech** — Build regulatory reporting pipelines with standardized entity data
- **Due diligence** — Verify entity registration status, jurisdiction, and renewal dates

***

### About LEI Codes

A Legal Entity Identifier (LEI) is a 20-character alphanumeric code that uniquely identifies a legal entity worldwide. LEI codes are:

- **Mandated** by regulators in the EU, US, UK, and 60+ other jurisdictions for financial transactions
- **Standardized** under ISO 17442, maintained by GLEIF
- **Free to look up** — the public registry is open to everyone
- **Used in** securities trading, derivatives reporting, banking, and insurance

***

### FAQ

**Q: What is an LEI code?**
A Legal Entity Identifier (LEI) is a unique 20-character global ID for any company, fund, or entity involved in financial transactions. It's similar to a company registration number but globally standardized.

**Q: How many entities are in the GLEIF registry?**
Over 2 million legal entities across 200+ jurisdictions are registered in the GLEIF Global LEI Index.

**Q: Is authentication required?**
No. The GLEIF API is completely free and open with no API key, registration, or authentication required.

**Q: What does the entity status mean?**

- **ACTIVE** — LEI is current and in good standing
- **LAPSED** — LEI renewal is overdue (data may be outdated)
- **INACTIVE** — Entity no longer exists or has been deregistered
- **MERGED** — Entity has merged into another
- **RETIRED** — LEI has been retired

**Q: Can I look up subsidiaries of a company?**
Yes — use `mode=relationships` with `relationshipType=direct-children` to get a list of direct subsidiaries. Use `ultimate-parent` to find the top-level parent company.

**Q: How current is the data?**
GLEIF data is updated continuously as entities renew or modify their LEI registrations. The `lastUpdateDate` field shows when each record was last updated.

# Actor input Schema

## `mode` (type: `string`):

What to fetch from GLEIF.

## `query` (type: `string`):

Full-text search for legal entity name or keyword (mode=searchEntities).

## `lei` (type: `string`):

20-character Legal Entity Identifier code (e.g. 7LTWFZYICNSX8D621K86).

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

Filter entities by country code (mode=searchEntities). Examples: US, GB, DE, FR, JP, CN, CA, AU.

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

Filter by LEI registration status (mode=searchEntities). ISSUED = active LEI in good standing.

## `relationshipType` (type: `string`):

Type of corporate relationship to retrieve.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "searchEntities",
  "query": "Apple",
  "country": "",
  "status": "",
  "relationshipType": "direct-children",
  "maxItems": 5
}
```

# Actor output Schema

## `entities` (type: `string`):

Dataset containing all scraped GLEIF legal entity records.

# 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 = {
    "mode": "searchEntities",
    "query": "Apple",
    "country": "",
    "status": "",
    "relationshipType": "direct-children",
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/gleif-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 = {
    "mode": "searchEntities",
    "query": "Apple",
    "country": "",
    "status": "",
    "relationshipType": "direct-children",
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/gleif-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 '{
  "mode": "searchEntities",
  "query": "Apple",
  "country": "",
  "status": "",
  "relationshipType": "direct-children",
  "maxItems": 5
}' |
apify call crawlerbros/gleif-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GLEIF Legal Entity Scraper",
        "description": "Scrape GLEIF (Global Legal Entity Identifier Foundation), the global standard for identifying legal entities in financial transactions. Covers 2M+ entities worldwide with standardized company data including LEI codes, addresses, registration status, and corporate hierarchy.",
        "version": "1.0",
        "x-build-id": "3JSTU5Q0FfVA2gHgB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~gleif-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-gleif-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/crawlerbros~gleif-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-gleif-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/crawlerbros~gleif-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-gleif-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchEntities",
                            "byLEI",
                            "relationships",
                            "managingOrganizations"
                        ],
                        "type": "string",
                        "description": "What to fetch from GLEIF.",
                        "default": "searchEntities"
                    },
                    "query": {
                        "title": "Search query (mode=searchEntities)",
                        "type": "string",
                        "description": "Full-text search for legal entity name or keyword (mode=searchEntities).",
                        "default": "Apple"
                    },
                    "lei": {
                        "title": "LEI code (mode=byLEI or relationships)",
                        "type": "string",
                        "description": "20-character Legal Entity Identifier code (e.g. 7LTWFZYICNSX8D621K86)."
                    },
                    "country": {
                        "title": "Country filter (ISO 3166-1 alpha-2)",
                        "enum": [
                            "",
                            "US",
                            "GB",
                            "DE",
                            "FR",
                            "JP",
                            "CN",
                            "CA",
                            "AU",
                            "CH",
                            "NL",
                            "SE",
                            "NO",
                            "DK",
                            "FI",
                            "IE",
                            "ES",
                            "IT",
                            "BE",
                            "AT",
                            "SG",
                            "HK",
                            "IN",
                            "BR",
                            "MX",
                            "ZA",
                            "KR",
                            "TW",
                            "NZ",
                            "PL",
                            "CZ",
                            "HU",
                            "RO",
                            "SK",
                            "PT",
                            "GR",
                            "RU",
                            "UA",
                            "TR",
                            "SA",
                            "AE",
                            "IL",
                            "AR",
                            "CL",
                            "CO",
                            "PE"
                        ],
                        "type": "string",
                        "description": "Filter entities by country code (mode=searchEntities). Examples: US, GB, DE, FR, JP, CN, CA, AU.",
                        "default": ""
                    },
                    "status": {
                        "title": "Registration status filter",
                        "enum": [
                            "",
                            "ISSUED",
                            "LAPSED",
                            "PENDING_TRANSFER",
                            "PENDING_ARCHIVAL",
                            "ANNULLED",
                            "DUPLICATE",
                            "MERGED",
                            "RETIRED"
                        ],
                        "type": "string",
                        "description": "Filter by LEI registration status (mode=searchEntities). ISSUED = active LEI in good standing.",
                        "default": ""
                    },
                    "relationshipType": {
                        "title": "Relationship type (mode=relationships)",
                        "enum": [
                            "direct-children",
                            "direct-parent",
                            "ultimate-parent"
                        ],
                        "type": "string",
                        "description": "Type of corporate relationship to retrieve.",
                        "default": "direct-children"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
