# GLEIF LEI Lookup & Corporate Ownership for AI Agents (`haketa/gleif-lei`) Actor

Look up Legal Entity Identifiers (LEI) and corporate ownership from GLEIF for AI agents & LLMs. Get the LEI code, legal name, address, status, legal form, jurisdiction and parent/child relationships. MCP-callable KYB, compliance & entity-resolution tool.

- **URL**: https://apify.com/haketa/gleif-lei.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** AI, Agents, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## GLEIF LEI Lookup & Corporate Ownership Scraper — LEI codes, legal entity data & parent/child tree

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-orange.svg)](https://apify.com/haketa/gleif-lei)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://apify.com/haketa/gleif-lei)
[![Data Format](https://img.shields.io/badge/Data-JSON%20%7C%20CSV%20%7C%20Excel-blue.svg)](https://apify.com/haketa/gleif-lei)
[![MCP Ready](https://img.shields.io/badge/MCP-Ready-purple.svg)](https://apify.com/haketa/gleif-lei)
[![Pagination](https://img.shields.io/badge/Pagination-1%2C000%2B%20Unlocked-brightgreen.svg)](https://apify.com/haketa/gleif-lei)

**Look up Legal Entity Identifiers (LEI) and corporate ownership from the official [GLEIF](https://www.gleif.org/) database — no login, no coding.** This high-throughput **GLEIF scraper** lets you **scrape GLEIF** by company name, full text, country or LEI code and returns clean, structured records: LEI code, legal name, entity status, legal form, jurisdiction, legal & headquarters address, business-registry ID, BIC/SWIFT codes, registration dates and the full **direct & ultimate parent / child ownership tree**. It answers the "which company is this, and who owns it?" question that every KYB, due-diligence and entity-resolution workflow needs.

One record per entity, export to **JSON, CSV, Excel, or API** — ready for a spreadsheet, a database, an LLM context window or an AI-agent tool response.

> **Built for** compliance and KYB/AML teams, risk and onboarding analysts, fintech and payments engineers, corporate-intelligence researchers, and AI agents that need authoritative, ownership-aware legal-entity data. Fully unlocked for **1,000+ results pagination** with support for both batch extraction and warm **Standby mode / MCP** agent tool calls.

***

### ⚡ At a glance

| Metric / Feature | Specification |
|---|---|
| **Target Database** | [Global Legal Entity Identifier Foundation (GLEIF)](https://www.gleif.org/) |
| **Catalog Coverage** | Over 2.5 million active Legal Entity Identifiers worldwide across 200+ jurisdictions |
| **Extraction Protocol** | Direct official JSON API integration (`api.gleif.org`) — keyless & high-speed |
| **Ownership Tree** | Direct parent, ultimate parent (LEI + Legal Name), and total subsidiary child count |
| **Pagination Scale** | **1,000+ records unlocked** — pages sequentially in 200-item chunks |
| **Execution Modes** | Batch dataset generation & warm **Standby Mode** for instant MCP / HTTP responses |
| **Throughput / Speed** | ~100 entities in 15–25 seconds; ~1,000 entities in 2–3 minutes |
| **Recommended Memory** | 512 MB – 1024 MB (pure HTTP, zero browser overhead) |
| **Output Formats** | JSON, CSV, Excel (XLSX), XML, HTML |
| **Deduplication** | 100% unique records deduplicated by 20-character ISO 17442 LEI code |

***

### 🔎 Why scrape GLEIF?

The **Global Legal Entity Identifier Foundation (GLEIF)** maintains the single global source of truth for the **Legal Entity Identifier** — the 20-character **ISO 17442** code that uniquely identifies a legally distinct organization anywhere in the world. Over 2.5 million entities are registered, from global banks and listed corporations to funds, subsidiaries and small companies. The data is published under **CC0** and backed by local registration authorities, making it the most authoritative, machine-readable company-identity source available for free.

The real value of **GLEIF data** is not just the LEI — it is the **relationship graph**. GLEIF records who the **direct parent** and **ultimate parent** of an entity are, and how many subsidiaries it controls. That ownership tree is exactly what analysts need for Know-Your-Business (KYB), anti-money-laundering (AML), beneficial-ownership and counterparty-risk checks, and it is precisely the part most free tools skip.

Collecting this by hand from the GLEIF website is slow and painful: you search one name at a time, click into each record, copy the address and status, then chase parent and child links across separate pages. A **GLEIF scraper** turns that into a single run that returns hundreds or thousands of enriched, de-duplicated entities at once.

#### Manual Verification vs. Automated GLEIF Extraction

| Factor | Manual GLEIF Lookup | GLEIF LEI Scraper |
|---|---|---|
| **Speed** | 2–3 minutes per entity | ~100 entities in 20 seconds |
| **Scale** | 15–20 companies per day | 1,000+ companies per run |
| **Ownership Tree** | Manual navigation through multiple tabs | Direct & ultimate parents linked automatically |
| **Subsidiary Count** | Must count child records manually | Exact `childrenCount` provided in JSON |
| **Cross-References** | Scattered across different panels | BIC/SWIFT, RA ID, and local registry numbers extracted |
| **Automation** | None (manual repetitive searches) | Programmatic REST API, Webhooks & MCP tools |

#### High-Value Reasons to Extract GLEIF Data

- **KYB & Client Onboarding:** Verify corporate entities in real time and retrieve authoritative legal names, registered addresses, and jurisdiction codes.
- **AML & Beneficial Ownership Mapping:** Trace corporate ownership chains from operating subsidiaries up to ultimate holding companies to satisfy regulatory scrutiny.
- **Global Entity Resolution:** Disambiguate similar or localized company names into a single immutable 20-character ISO standard identifier.
- **Supplier & Counterparty Due Diligence:** Screen suppliers for inactive or lapsed LEI registration statuses before executing high-value contracts.
- **Payment Operations & Routing:** Match institutional counterparties to validated **BIC/SWIFT** codes and national corporate register IDs.
- **AI Agent Context & Tool Calling:** Supply LLMs (Claude, GPT, Gemini) with grounded legal entity records via Model Context Protocol (MCP).

***

### ✨ Key Features & Capabilities

- ✅ **Flexible Search Modes:** Search by company name using broad **full-text** search (matches addresses and aliases) or precise **legal name** matching.
- ✅ **Jurisdiction & Country Filters:** Filter by ISO 2-letter country codes with 40+ presets or supply custom jurisdiction identifiers.
- ✅ **Active Status Filtering:** Restrict datasets to currently issued and active LEI registrations, filtering out lapsed or dissolved entities.
- ✅ **Direct LEI List Resolution:** Paste an array of 20-character LEI codes to look up exact entities in bulk with zero search ambiguity.
- ✅ **1,000+ Deep Pagination Unlocked:** Pages through the official GLEIF catalog in 200-record chunks without arbitrary ceiling limits.
- ✅ **Complete Ownership Trees:** Concurrent asynchronous enrichment resolves direct parent LEI/Name, ultimate parent LEI/Name, and subsidiary child counts.
- ✅ **Comprehensive Identity Metadata:** Captures entity category, legal form (ELF codes), headquarters and legal addresses, and registration dates.
- ✅ **BIC/SWIFT & Registry Identifiers:** Links entities to global financial SWIFT codes and domestic registration authority identifiers (e.g., HRB, Companies House).
- ✅ **Dual Execution Architecture:** Supports standard asynchronous batch runs and zero-cold-start **Standby Mode** for instant agent tool-calling.

***

### 🎯 Primary Use Cases

#### 1. Compliance, AML & KYB Teams

Automate institutional client verification during onboarding. Determine corporate structure, verify active legal standing, and identify parent entities across cross-border holding structures.

#### 2. Fintech & B2B Payments Engineers

Enrich domestic and international payment transactions by validating counterparty identities, resolving routing BIC/SWIFT numbers, and standardizing database entity keys.

#### 3. Corporate Intelligence & Forensic Investigators

Map complex corporate hierarchies, uncover cross-border shell structures, and investigate multi-tiered business conglomerates.

#### 4. Supply Chain Risk Managers

Monitor vendor portfolios against GLEIF renewal dates. Flag suppliers with lapsed LEI registrations indicating potential insolvency or regulatory delinquency.

#### 5. AI Agents & Autonomous Workflows

Equip autonomous agents with an authoritative corporate fact-checking tool. Using MCP or Standby HTTP, agents can query entity ownership and jurisdiction on the fly.

***

### 📥 Input Parameters

Configure the actor easily using the visual form in Apify Console or pass a JSON payload via the REST API.

| Field | Type | Default | Description |
|---|---|---|---|
| `query` | String | `"Deutsche Bank"` | Company or organization name to look up. Leave empty to retrieve a diverse worldwide sample of landmark entities. |
| `searchField` | Select | `"fulltext"` | Matching mode: `"fulltext"` (broad match across name and address) or `"legalName"` (strict legal name matching). |
| `country` | Select | `""` | ISO 2-letter country code (e.g. `"US"`, `"DE"`, `"GB"`). Leave empty for worldwide results. |
| `countryCode` | String | `null` | Optional 2-letter ISO code for countries not listed in the preset dropdown. Overrides `country`. |
| `activeOnly` | Boolean | `false` | When true, returns only entities with active, currently issued LEI registrations. |
| `includeOwnership` | Boolean | `true` | Enriches every entity with direct parent, ultimate parent, and subsidiary counts via concurrent API lookups. |
| `leis` | Array | `[]` | Optional list of exact 20-character LEI codes to resolve directly without text searching. |
| `maxItems` | Integer | `100` | Maximum number of legal entities to return. Set to `0` for unlimited extraction (1,000+ items unlocked). |
| `proxyConfiguration` | Object | `{"useApifyProxy": false}` | Proxy settings. Not required for GLEIF as the API is keyless and public. |

#### Input Examples

##### Example 1: Standard Name Search with Ownership (Prefill)

```json
{
  "query": "Deutsche Bank",
  "searchField": "fulltext",
  "includeOwnership": true,
  "maxItems": 100
}
```

##### Example 2: Deep 1,000+ Country-Level Extraction (Germany Active Banks)

```json
{
  "query": "Bank",
  "country": "DE",
  "activeOnly": true,
  "includeOwnership": false,
  "maxItems": 1000
}
```

##### Example 3: Bulk Direct LEI Code Resolution

```json
{
  "leis": [
    "7LTWFZYICNSX8D621K86",
    "HWUPKR0MPOU8FGXBT394",
    "213800YHAR3DBH4BPS22"
  ],
  "includeOwnership": true
}
```

***

### 📤 Output Dataset & Field Coverage

The actor outputs clean, flat JSON objects where each record corresponds to a verified Legal Entity Identifier.

#### Field Specification & Coverage Indicators

##### 🏢 Legal Entity Identity

| Field | Type | Coverage | Description |
|---|---|---|---|
| `lei` | String | 🟢 High (100%) | 20-character ISO 17442 Legal Entity Identifier. |
| `legalName` | String | 🟢 High (100%) | Official registered legal name in native UTF-8. |
| `entityStatus` | String | 🟢 High (100%) | Operational status: `"ACTIVE"` or `"INACTIVE"`. |
| `registrationStatus` | String | 🟢 High (100%) | Registration lifecycle: `"ISSUED"`, `"LAPSED"`, `"RETIRED"`, etc. |
| `legalForm` | String | 🟢 High (~98%) | Entity Legal Form (ELF) code (e.g. `"6QQB"`, `"9999"`). |
| `category` | String | 🟢 High (100%) | Classification: `"GENERAL"`, `"FUND"`, `"BRANCH"`, etc. |
| `jurisdiction` | String | 🟢 High (100%) | Legal jurisdiction of incorporation (e.g. `"DE"`, `"US-DE"`). |

##### 📍 Registered & Headquarters Addresses

| Field | Type | Coverage | Description |
|---|---|---|---|
| `legalAddress` | String | 🟢 High (100%) | Complete street address of legal registration. |
| `legalCity` | String | 🟢 High (100%) | Registered legal city. |
| `legalCountry` | String | 🟢 High (100%) | ISO 2-letter country code for legal address. |
| `hqAddress` | String | 🟢 High (~96%) | Physical headquarters street address. |
| `hqCountry` | String | 🟢 High (~96%) | ISO 2-letter country code for headquarters. |

##### 🌳 Corporate Ownership Tree

| Field | Type | Coverage | Description |
|---|---|---|---|
| `directParentLei` | String | 🟡 Conditional (~15%) | LEI of immediate corporate parent. `null` for standalone entities. |
| `directParentName` | String | 🟡 Conditional (~15%) | Legal name of immediate corporate parent. |
| `ultimateParentLei` | String | 🟡 Conditional (~12%) | LEI of ultimate corporate parent holding company. |
| `ultimateParentName` | String | 🟡 Conditional (~12%) | Legal name of ultimate corporate parent holding company. |
| `childrenCount` | String | 🟢 High (100%) | Number of direct operating subsidiaries reported to GLEIF. |

##### 🏛️ Regulatory & Banking References

| Field | Type | Coverage | Description |
|---|---|---|---|
| `registeredAs` | String | 🟡 Conditional (~82%) | Domestic commercial register ID (e.g. HRB number). |
| `registrationAuthorityId` | String | 🟡 Conditional (~83%) | RA identifier code from GLEIF authority master. |
| `bic` | Array | 🟡 Conditional (~8%) | Associated SWIFT / BIC codes for financial entities. |
| `initialRegistrationDate`| String | 🟢 High (100%) | First LEI assignment date (`YYYY-MM-DD`). |
| `lastUpdateDate` | String | 🟢 High (100%) | Most recent GLEIF record modification date. |
| `nextRenewalDate` | String | 🟢 High (100%) | Annual renewal deadline. |
| `gleifUrl` | String | 🟢 High (100%) | Direct URL to web record on search.gleif.org. |
| `scrapedAt` | String | 🟢 High (100%) | ISO 8601 extraction timestamp. |

#### Sample Output Record (Subsidiary Entity)

```json
{
  "lei": "213800YHAR3DBH4BPS22",
  "legalName": "Акционерное общество «Altyn Bank»",
  "entityStatus": "ACTIVE",
  "registrationStatus": "ISSUED",
  "legalForm": "9999",
  "category": "GENERAL",
  "jurisdiction": "KZ",
  "legalAddress": "109B Abay Ave, Almaty, A05A1B9, KZ",
  "legalCity": "Almaty",
  "legalCountry": "KZ",
  "hqAddress": "109B Abay Ave, Almaty, KZ-75, A05A1B9, KZ",
  "hqCountry": "KZ",
  "initialRegistrationDate": "2014-01-31",
  "lastUpdateDate": "2025-11-24",
  "nextRenewalDate": "2026-12-21",
  "registeredAs": "980740000057",
  "registrationAuthorityId": "RA000918",
  "bic": ["ATYNKZKAXXX"],
  "ultimateParentLei": null,
  "ultimateParentName": null,
  "directParentLei": "300300C1030211000384",
  "directParentName": "中信银行股份有限公司",
  "childrenCount": "0",
  "gleifUrl": "https://search.gleif.org/#/record/213800YHAR3DBH4BPS22",
  "scrapedAt": "2026-11-10T16:15:00.000Z"
}
```

***

### 🔁 Pagination, Scale & Performance

- **1,000+ Deep Pagination:** Results are requested in standard batches of 200 items per page (`page[size]=200`). Sequential pagination continues seamlessly until reaching the requested `maxItems` target.
- **Concurrent Ownership Lookups:** When `includeOwnership` is enabled, the actor batches parent and child network requests with a concurrency factor of 8, completing 100 entity enrichments in under 30 seconds.
- **Memory Right-Sized:** Operates purely via lightweight HTTP requests with zero browser emulation, consuming under 100 MB RAM and costing fractions of a cent per run.
- **Zero Duplicates:** In-memory set checks prevent duplicate records from being saved even when multi-term default queries return overlapping entities.

***

### 💻 Programmatic Integration & AI Agent Tool Calling

#### Node.js (Apify SDK)

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

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

const run = await client.actor('haketa/gleif-lei').call({
    query: 'Siemens',
    searchField: 'legalName',
    includeOwnership: true,
    maxItems: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Resolved ${items.length} Siemens legal entities with corporate parents.`);
```

#### Python (Apify Client)

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.getenv('APIFY_TOKEN'))

run = client.actor('haketa/gleif-lei').call(run_input={
    'query': 'BlackRock',
    'activeOnly': True,
    'includeOwnership': True,
    'maxItems': 100,
})

for entity in client.dataset(run['defaultDatasetId']).list_items().items:
    parent = entity.get('directParentName') or 'Independent / Top Level'
    print(f"{entity['legalName']} ({entity['lei']}) -> Parent: {parent}")
```

#### Direct cURL Request

```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~gleif-lei/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "Deutsche Bank",
    "searchField": "fulltext",
    "includeOwnership": true,
    "maxItems": 100
  }'
```

***

### ⚡ Standby Mode & Instant Zero-Cold-Start API

Beyond traditional batch runs, this actor supports **Apify Standby Mode**, allowing it to run as an always-warm HTTP API server. When deployed in Standby mode, the actor stays active and responds to incoming HTTP requests in milliseconds without container boot delays:

#### Standby Query Parameters

Send standard HTTP GET requests to your Standby container endpoint:

| Query Parameter | Example Value | Description |
|---|---|---|
| `query` or `name` | `Deutsche Bank` | Entity or company name to search |
| `searchField` | `legalName` | Matching mode (`fulltext` or `legalName`) |
| `country` | `DE` | ISO 2-letter jurisdiction code |
| `lei` or `leis` | `7LTWFZYICNSX8D621K86` | Direct LEI identifier code(s) |
| `activeOnly` | `true` | Restrict to currently active registrations |
| `includeOwnership`| `true` | Fetch direct and ultimate parent entities |
| `maxItems` | `10` | Maximum records returned in payload |

#### Standby HTTP Example

```bash
curl -X GET "https://gleif-lei.apify.actor?query=Siemens&includeOwnership=true&maxItems=5" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

```json
{
  "ok": true,
  "count": 5,
  "results": [
    {
      "lei": "5299002DRAEQ03248U86",
      "legalName": "SIEMENS AKTIENGESELLSCHAFT",
      "entityStatus": "ACTIVE",
      "jurisdiction": "DE",
      "directParentName": null,
      "ultimateParentName": null,
      "childrenCount": "194"
    }
  ]
}
```

***

### 🏛️ Supported Registries & Legal Forms

GLEIF integrates with domestic business registers globally. Captured records link directly to local authority identifiers:

- **Germany:** Commercial Register (Handelsregister HRB / HRA via RA000242).
- **United Kingdom:** Companies House (RA000585).
- **United States:** Delaware Division of Corporations, California Secretary of State, SEC CIK.
- **France:** SIRENE / INPI (RA000193).
- **Singapore:** ACRA (Accounting and Corporate Regulatory Authority via RA000511).
- **Switzerland:** Central Business Name Index (ZEFIX via RA000569).

***

### 💡 Practical Pro-Tips

- **Exact Legal Name vs. Broad Search:** Use `searchField: "legalName"` when you know the exact company name (e.g., "Apple Inc.") to avoid capturing unrelated companies located on Apple Street.
- **Speed Optimization:** When pulling bulk registries (> 500 records) where only status and address are needed, set `includeOwnership: false` to complete runs in seconds.
- **Screening Lapsed Registrations:** Filter by `registrationStatus != "ISSUED"` to quickly identify companies that have failed to complete their annual regulatory renewal.
- **Connecting to LLMs via MCP:** Add `https://mcp.apify.com/?actor=haketa/gleif-lei` to your Claude Desktop or Cursor MCP configuration to give your AI assistants instant KYB intelligence.

***

### ❓ Frequently Asked Questions (FAQ)

##### Do I need a GLEIF account or API token?

No. GLEIF data is open, public, and governed by CC0 licensing. No accounts, API tokens, or payment details are required.

##### Why are parent fields null for many companies?

In GLEIF, standalone independent companies have no reporting parent entity. Parent fields only populate when an entity belongs to a corporate group and reports its direct or ultimate holding company.

##### Can I lookup companies by their 20-character LEI directly?

Yes. Provide one or more codes in the `leis` input array to bypass text search and look up exact matching records.

##### How frequently is GLEIF data refreshed?

This actor queries the live GLEIF API directly on every run, delivering real-time registration and ownership statuses.

***

### 📋 Changelog

#### v1.2 (2026-11)

- **Unlocked 1,000+ Deep Pagination:** Removed pagination clamps during default/sample runs so explicit requests above 100 items return full datasets.
- **Dynamic Term Allocation:** Worldwide sample runs dynamically paginate through terms to satisfy requested `maxItems`.
- **Fast Standby & MCP Response:** Streamlined parameter parsing and sub-second response times for LLM tool-calling.
- **Optimized Prefill Execution:** Default sample runs execute cleanly in under 30 seconds.

#### v1.1 (2026-07)

- **Concurrent Ownership Resolution:** Added batch parallel enrichment for direct parent, ultimate parent, and child counts.
- **Standby Mode Support:** Added warm HTTP API server for zero-cold-start agent integration.

#### v1.0 (2026-07)

- Initial release featuring full-text and legal name search, ISO country filtering, LEI code resolution, and multi-format exports.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/gleif-lei/changelog.md

# Actor input Schema

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

Type a company or organization name to look up, e.g. "Apple", "Deutsche Bank". Leave empty to get a ready-made sample of well-known entities worldwide.

## `searchField` (type: `string`):

How your search term is matched. "Legal name" is precise (name only); "Full text" is broader and also matches addresses.

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

Only return entities registered in this country. Leave on "Any country" to search worldwide.

## `countryCode` (type: `string`):

Optional. For a country not in the list above, enter its 2-letter ISO code here (e.g. GR, CZ, HU). Overrides the Country dropdown when set.

## `activeOnly` (type: `boolean`):

Keep only entities with an active, currently issued LEI registration.

## `includeOwnership` (type: `boolean`):

Add each entity's direct & ultimate parent company and its number of subsidiaries — the corporate ownership tree. Highly valuable for KYB and research.

## `leis` (type: `array`):

Optional. Already have LEI codes? Paste them here to look them up directly, e.g. 7LTWFZYICNSX8D621K86. Most users can leave this empty and just search by name.

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

Maximum number of entities to return. Set 0 for no limit.

## `proxyConfiguration` (type: `object`):

Apify Proxy settings. A proxy is not required for this Actor and is off by default.

## Actor input object example

```json
{
  "query": "Deutsche Bank",
  "searchField": "fulltext",
  "country": "",
  "activeOnly": false,
  "includeOwnership": true,
  "leis": [],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Legal Entity Identifier (20 chars)

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

Registered legal name

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

ACTIVE / INACTIVE

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

ISSUED / LAPSED / ...

## `legalForm` (type: `string`):

Legal form code (ELF)

## `category` (type: `string`):

Entity category

## `jurisdiction` (type: `string`):

Registration jurisdiction

## `legalAddress` (type: `string`):

Full legal address

## `legalCity` (type: `string`):

Legal address city

## `legalCountry` (type: `string`):

Legal address country

## `hqAddress` (type: `string`):

Headquarters address

## `hqCountry` (type: `string`):

Headquarters country

## `initialRegistrationDate` (type: `string`):

Initial registration date

## `lastUpdateDate` (type: `string`):

Last update date

## `nextRenewalDate` (type: `string`):

Next renewal date

## `registeredAs` (type: `string`):

Local business-registry number (e.g. commercial register no.), present when available

## `registrationAuthorityId` (type: `string`):

GLEIF registration authority (RA) code of the local business registry

## `ultimateParentLei` (type: `string`):

Ultimate parent LEI

## `ultimateParentName` (type: `string`):

Ultimate parent name

## `directParentLei` (type: `string`):

Direct parent LEI

## `directParentName` (type: `string`):

Direct parent name

## `childrenCount` (type: `string`):

Number of direct children

## `gleifUrl` (type: `string`):

GLEIF record URL

## `scrapedAt` (type: `string`):

Extraction timestamp

# 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 = {
    "query": "Deutsche Bank",
    "leis": [],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/gleif-lei").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 = {
    "query": "Deutsche Bank",
    "leis": [],
    "maxItems": 100,
}

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

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

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

```

## CLI example

```bash
echo '{
  "query": "Deutsche Bank",
  "leis": [],
  "maxItems": 100
}' |
apify call haketa/gleif-lei --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/gleif-lei"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/6vFU81NOgeesl1h2Y/builds/qxSAHRzgqFjyd7qqg/openapi.json