# LEI Company Identity & Ownership (GLEIF, 2.7M+) (`foxlabs/lei-company-ownership`) Actor

Look up global legal entities from GLEIF by name, LEI or jurisdiction. Verified identity, addresses, status, cross-reference IDs (BIC, MIC, ISIN, OpenCorporates) and the corporate OWNERSHIP GRAPH — direct & ultimate parent and children. Public domain (CC0), no key.

- **URL**: https://apify.com/foxlabs/lei-company-ownership.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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

<p align="center"><a href="https://apify.com/foxlabs/lei-company-ownership"><img src="https://data.foxlabs.com.tr/img/lei-company-ownership-banner.svg" alt="LEI Company Identity & Ownership" width="100%" /></a></p>

## LEI Company Identity & Ownership (GLEIF, 2.7M+)

Need to **verify a legal entity and map who owns it** — across borders, from one authoritative source? This Actor turns the official **GLEIF** register (Global Legal Entity Identifier Foundation) into ready-to-use records: **~2.7 million legal entities** worldwide with a verified **LEI**, legal identity, addresses and status — plus the **corporate ownership graph** (direct & ultimate parent, direct children) and the **cross-reference join keys** that link an entity across banking, securities and other datasets.

Built on the official **GLEIF API**, **public domain (CC0)** — reuse and redistribute freely. **No API key, no login, no fragile HTML scraping** — so it doesn't break when a website changes. Most LEI actors stop at *name → LEI*; this one adds the **hierarchy** and the **join keys** that make it useful for real work.

- 🌐 **~2.7M legal entities** worldwide — one global identity source, not a national slice
- 🧬 **Ownership graph** — direct & ultimate parent + direct children, with counts and subsidiary/parent flags
- 🔗 **Cross-reference join keys** — BIC · MIC · OpenCorporates · S&P Global — to reconcile entities across datasets
- 🆓 **Public domain (CC0)** — reuse **and resell**, no key, no scraping

### Quick start (API)

Look up two companies with their full ownership hierarchy, in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~lei-company-ownership/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "names": ["Apple Inc", "Volkswagen AG"], "includeOwnership": true, "maxResults": 25 }'
````

Prefer no code? Open the **Input** tab, enter names / LEIs / a jurisdiction, and click **Start** — then download the results.

### What you get

One clean, flat record per legal entity:

| Field | Type | Description |
|---|---|---|
| `lei` | string | 20-character Legal Entity Identifier (ISO 17442) |
| `legalName` | string | Registered legal name |
| `otherNames` | array | Previous, trading & other names |
| `legalForm` | string | Entity Legal Form (ELF) code, e.g. `H1UM` |
| `category` / `subCategory` | string | GLEIF entity category (e.g. `GENERAL`, `FUND`, `BRANCH`) |
| `entityStatus` | string | Legal status — `ACTIVE` / `INACTIVE` |
| `registrationStatus` | string | LEI registration status — `ISSUED`, `LAPSED`, `RETIRED`… |
| `jurisdiction` | string | Registration jurisdiction — ISO country / subdivision (e.g. `US-CA`) |
| `registeredAs` | string | The entity's number in its local business registry |
| `legalAddress` / `headquartersAddress` | string | Full legal & headquarters addresses |
| `creationDate` / `lastUpdated` | string | Incorporation date & LEI record last-update (`YYYY-MM-DD`) |
| `crossReferences` | object | Join keys present for this entity — `{ bic, mic, openCorporatesId, spGlobal }` (absent keys are omitted) |
| `ownership` *(default on)* | object | `{ directParent, ultimateParent, directChildren[], directChildrenCount, isSubsidiary, isUltimateParent }`; each node is `{ lei, name }` |
| `source` / `license` / `sourceUrl` | string | Provenance — GLEIF, CC0, and the GLEIF record URL |
| `scrapedAt` | string | ISO timestamp of retrieval |

#### Sample output

Real record for **Apple Inc.** (`names: ["Apple Inc"]`, ownership on) — a top-level parent with eight reported subsidiaries:

```json
{
  "lei": "HWUPKR0MPOU8FGXBT394",
  "legalName": "Apple Inc.",
  "otherNames": ["Apple Computer, Inc."],
  "legalForm": "H1UM",
  "category": "GENERAL",
  "subCategory": null,
  "entityStatus": "ACTIVE",
  "registrationStatus": "ISSUED",
  "jurisdiction": "US-CA",
  "registeredAs": "806592",
  "legalAddress": "C/O C T Corporation System, 330 N. Brand Blvd, Suite 700, Glendale, US-CA, 91203, US",
  "headquartersAddress": "One Apple Park Way, Cupertino, US-CA, 95014, US",
  "creationDate": "1977-01-03",
  "lastUpdated": "2026-03-03",
  "crossReferences": {
    "bic": ["APLEUS66XXX"],
    "spGlobal": ["24937"]
  },
  "source": "GLEIF — Global Legal Entity Identifier Foundation",
  "license": "CC0 1.0 (public domain) — Source: GLEIF",
  "sourceUrl": "https://search.gleif.org/#/record/HWUPKR0MPOU8FGXBT394",
  "scrapedAt": "2026-07-05T09:00:00.000Z",
  "ownership": {
    "directParent": null,
    "ultimateParent": null,
    "directChildren": [
      { "lei": "2549008YU9EOMHFUA249", "name": "APPLE OPERATIONS INDIA PRIVATE LIMITED" },
      { "lei": "5493004QI6E3PJNCEB09", "name": "APPLE CHILE COMERCIAL LIMITADA" },
      { "lei": "549300YX4S1LLSMK2627", "name": "APPLE ENERGY LLC" },
      { "lei": "5493006LHHR4CLPX4Q79", "name": "BRAEBURN CAPITAL, INC." },
      { "lei": "549300G81RQKP7XW2N18", "name": "APPLE OPERATIONS INTERNATIONAL LIMITED" },
      { "lei": "549300UJWEUFNYXPJ620", "name": "APPLE COMPUTER BRASIL LTDA." },
      { "lei": "549300MF6CNUB2URPE58", "name": "APPLE OPERATIONS MEXICO SA DE CV" },
      { "lei": "5493004SYPRAVRVNK561", "name": "APPLE CANADA INC." }
    ],
    "directChildrenCount": 8,
    "isSubsidiary": false,
    "isUltimateParent": true
  }
}
```

Absent cross-reference keys (here `mic`, `openCorporatesId`) are simply omitted; unreported parents are `null` — never guessed.

### Example inputs (copy & paste)

```jsonc
// 1) Look up specific companies by name, with the ownership graph
{ "names": ["Apple Inc", "Volkswagen AG", "Nestlé S.A."], "includeOwnership": true }

// 2) Exact LEI lookup for KYC — identity only, faster
{ "leis": ["HWUPKR0MPOU8FGXBT394", "549300G81RQKP7XW2N18"], "includeOwnership": false }

// 3) Browse every active legal entity registered in a jurisdiction
{ "jurisdiction": "US-CA", "status": "ACTIVE", "maxResults": 5000 }

// 4) Whole-country sweep, every status, identity only (fast at scale)
{ "jurisdiction": "DE", "status": "any", "includeOwnership": false, "maxResults": 20000 }

// 5) Fast KYC by name — identity only, no ownership graph
{ "names": ["Stripe Inc", "Revolut Ltd"], "includeOwnership": false }

// 6) Audit lapsed / retired entities in a jurisdiction
{ "jurisdiction": "GB", "status": "INACTIVE", "maxResults": 2000 }

// 7) Mixed batch — names + exact LEIs in one run, with ownership
{ "names": ["Nestlé S.A."], "leis": ["HWUPKR0MPOU8FGXBT394"], "includeOwnership": true }
```

### Input & filters

- **Company names** (`names`) — legal entity names to look up, e.g. `Apple Inc`, `Volkswagen AG`. Returns the matching LEI records.
- **LEI codes** (`leis`) — exact 20-character LEIs for precise lookup (batched).
- **Jurisdiction** (`jurisdiction`) — browse every entity in a country (`DE`, `US`) or ISO subdivision (`US-CA`).
- **Status** (`status`) — filter a browse by `ACTIVE`, `INACTIVE`, or `any`.
- **Include ownership graph** (`includeOwnership`) — attach direct & ultimate parent and direct children. **On by default** — this is what sets it apart from a plain LEI lookup; turn off for a faster identity-only run.
- **Max results** (`maxResults`) — 1 to **50,000**.

Provide at least one of `names`, `leis`, or `jurisdiction`.

### Use cases

- **KYC / KYB & due diligence.** Onboarding a counterparty? Pass its `names` or `leis` → verified legal identity, jurisdiction, status, local registry number, **and** the parent/subsidiary chain your compliance file needs — from one authoritative source, in one call.
- **Corporate-structure mapping.** Reconstruct a group's tree: look up the head entity with ownership on to get `directChildren`, then walk each child's LEI to map subsidiaries across jurisdictions.
- **Entity resolution & enrichment.** The LEI plus `bic` / `mic` / `openCorporatesId` / `spGlobal` are clean **join keys** — reconcile the same company across your CRM, banking data, securities data and OpenCorporates without fuzzy name-matching.
- **Counterparty & supply-chain risk.** Resolve the exact legal entity behind a supplier or client and surface its ultimate parent, so exposure rolls up to the real controlling group.
- **Sanctions & adverse-media scoping.** Pin down the precise entity (not a name string) and its parents/children before screening, so a hit on one node can be traced through the ownership graph.
- **Securities & reference-data ops.** Enrich holdings and trade records with a stable global identifier plus BIC/MIC/S\&P cross-references for reconciliation and reporting.

### Performance & throughput

The Actor queries the **live GLEIF API** — no bulk download, no proxies, no keys. It paginates results (100 records/page) and enriches with **8 parallel workers**. Identity-only runs (`includeOwnership: false`) move quickly. Turning **ownership on** adds up to three relationship look-ups per entity (direct-parent, ultimate-parent, direct-children), so large ownership runs take proportionally longer — leave it off when you only need identity. A jurisdiction browse pages through GLEIF until it reaches `maxResults` or exhausts the jurisdiction. Throughput is otherwise bounded only by your Apify plan.

### Integrations

**JavaScript** (`apify-client`):

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('foxlabs/lei-company-ownership').call({
  names: ['Apple Inc', 'Volkswagen AG'], includeOwnership: true, maxResults: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python** (`apify-client`):

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("foxlabs/lei-company-ownership").call(run_input={
    "names": ["Apple Inc", "Volkswagen AG"], "includeOwnership": True, "maxResults": 50,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["lei"], item["legalName"])
```

Also works with **Make / n8n / Zapier** (Apify app → run this Actor, map the input), scheduled runs, webhooks, and the **Apify MCP server** for AI agents.

### Data quality (honest)

The LEI system is standardised, so **core identity is dense**: `lei`, `legalName`, `entityStatus`, `registrationStatus`, `jurisdiction` and the `legalAddress` are present for essentially every record — they're mandatory to hold an LEI. `legalForm`, `registeredAs`, `creationDate` and `headquartersAddress` are usually present.

**Cross-references and ownership are richer for corporates than for random small entities.** Large banks and listed firms typically carry `bic` / `mic` / `spGlobal` and reported parent/child relationships; many private or standalone entities carry none — the `crossReferences` object simply omits the absent keys, and `directParent` / `ultimateParent` come back `null`. GLEIF's Level-2 relationships exist **where entities disclosed them** (accounting-consolidation parents), so some private groups have gaps. Nothing is fabricated — a missing value is `null` or an omitted key, never a guess.

### Pricing

**Pay per result** — you're billed per entity returned; the ownership graph is included in that price when enabled. There's an Apify **free tier** to evaluate the full feature set before you scale. No proxies, no third-party API costs (GLEIF is a free public API).

### FAQ

**What is an LEI?** A 20-character ISO 17442 code that uniquely identifies a legal entity worldwide — the global standard behind KYC, securities reporting and corporate hierarchies.

**Can I use this data commercially / resell it?** Yes. GLEIF data is **public domain (CC0)** — commercial reuse and redistribution are permitted with no attribution required. Records still carry a `Source: GLEIF` credit as good practice.

**How fresh is the data?** GLEIF publishes a daily "golden copy" and each run queries the **live GLEIF API**, so you get the current record at run time.

**Do I need an API key or a GLEIF account?** No. No key, no login, no scraping.

**Can I look up specific companies?** Yes — put legal names in `names`, or exact 20-character codes in `leis` for precise lookup.

**What's in the ownership graph?** `directParent`, `ultimateParent`, a `directChildren[]` list (each `{ lei, name }`), a `directChildrenCount`, and `isSubsidiary` / `isUltimateParent` flags — GLEIF's Level-2 relationship data.

**Why are `directParent` / `ultimateParent` `null`?** Because the entity is a top-level parent, has filed a reporting exception, or hasn't disclosed a parent to GLEIF. It's a legitimate state, not a scrape miss.

**Does it include revenue, employees or contact emails?** No. This is **legal-entity identity and hierarchy**, not financials or contacts — those live in national company registries and filings. It excels at identity, ownership and cross-referencing.

**What are the cross-reference IDs for?** `bic` (SWIFT/BIC), `mic` (market identifier), `openCorporatesId` and `spGlobal` are **join keys** to link the entity to banking, securities and other datasets.

**What export formats are available?** JSON, CSV, Excel, or via the Apify API/integrations.

**How many entities can I get in one run?** Up to **50,000** via `maxResults`.

### Troubleshooting

- **"Provide `names`, `leis`, or a `jurisdiction`"** → the run had no lookup input; set at least one of the three.
- **Few / no results for a name** → GLEIF matches on the registered legal name (exact/close, not fuzzy). Use the entity's exact registered name, or look it up by `leis` for a guaranteed hit.
- **Ownership fields missing** → confirm **Include ownership graph** is on (it's the default). Remember `null` parents and an empty `directChildren` are legitimate for standalone entities.
- **Ownership run is slow** → each entity does up to three extra relationship calls. Set `includeOwnership: false` for a fast identity-only pull.

### Notes, limits & legal (honest)

- **Ownership is what entities *reported* to GLEIF.** Level-2 parent/child relationships exist where they were disclosed; some private groups have gaps. `directParent` / `ultimateParent` are `null` when none is reported (a top entity legitimately has no parent).
- **Identity, not financials.** No revenue, employees or contact details — the LEI record is legal identity, hierarchy and cross-references.
- **Ownership adds API calls** per entity; turn it off for a faster identity-only run.
- **Licence & attribution.** GLEIF data is CC0 (public domain); attribution isn't required, but records carry `Source: GLEIF` as good practice.
- **Not affiliated** with GLEIF; this Actor redistributes its public open data via the official API.

### Support

Questions, a field you'd like added, or a custom build? Open the **Issues** tab on this Actor, or email **info@foxlabs.com.tr**. We reply fast.

*If this Actor saves you time, a ⭐ review really helps.*

### Changelog

#### 0.2 — 2026-07-05

- Reworked docs: API quick-start, sample output, integrations, FAQ & troubleshooting.

#### 0.1

- Initial release. Name / LEI / jurisdiction lookup over GLEIF's ~2.7M entities with verified identity, addresses, cross-reference IDs (BIC/MIC/OpenCorporates/S\&P Global) and the direct/ultimate parent + children ownership graph. Public domain, no key.

***

Part of the **[foXLabs data platform](https://data.foxlabs.com.tr/)** — official public-data company, contact, ownership, jobs, charity, location & AI-search intelligence scrapers. Browse the full suite at **[data.foxlabs.com.tr](https://data.foxlabs.com.tr/)**.

# Actor input Schema

## `names` (type: `array`):

Legal entity names to look up — e.g. "Apple Inc", "Volkswagen AG". Returns matching LEI records.

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

Exact 20-character LEI codes for precise lookup (e.g. "HWUPKR0MPOU8FGXBT394").

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

Browse all entities in a jurisdiction — a country ISO code like "DE", "US", or an ISO subdivision like "US-CA". Combine with Status.

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

Filter browsed entities by legal status.

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

Attach each entity's direct & ultimate parent and direct children (the corporate hierarchy). On by default — this is what sets it apart from a plain LEI lookup. Adds a few calls per entity.

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

Maximum number of entities to return (1–50000).

## Actor input object example

```json
{
  "names": [
    "Apple Inc"
  ],
  "leis": [],
  "status": "ACTIVE",
  "includeOwnership": true,
  "maxResults": 200
}
```

# 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 = {
    "names": [
        "Apple Inc"
    ],
    "leis": [],
    "maxResults": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/lei-company-ownership").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 = {
    "names": ["Apple Inc"],
    "leis": [],
    "maxResults": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/lei-company-ownership").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 '{
  "names": [
    "Apple Inc"
  ],
  "leis": [],
  "maxResults": 200
}' |
apify call foxlabs/lei-company-ownership --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LEI Company Identity & Ownership (GLEIF, 2.7M+)",
        "description": "Look up global legal entities from GLEIF by name, LEI or jurisdiction. Verified identity, addresses, status, cross-reference IDs (BIC, MIC, ISIN, OpenCorporates) and the corporate OWNERSHIP GRAPH — direct & ultimate parent and children. Public domain (CC0), no key.",
        "version": "0.1",
        "x-build-id": "qi0iZrLXb407R6vAo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/foxlabs~lei-company-ownership/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-foxlabs-lei-company-ownership",
                "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/foxlabs~lei-company-ownership/runs": {
            "post": {
                "operationId": "runs-sync-foxlabs-lei-company-ownership",
                "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/foxlabs~lei-company-ownership/run-sync": {
            "post": {
                "operationId": "run-sync-foxlabs-lei-company-ownership",
                "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": {
                    "names": {
                        "title": "Company names",
                        "type": "array",
                        "description": "Legal entity names to look up — e.g. \"Apple Inc\", \"Volkswagen AG\". Returns matching LEI records.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "leis": {
                        "title": "LEI codes",
                        "type": "array",
                        "description": "Exact 20-character LEI codes for precise lookup (e.g. \"HWUPKR0MPOU8FGXBT394\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jurisdiction": {
                        "title": "Jurisdiction (browse)",
                        "type": "string",
                        "description": "Browse all entities in a jurisdiction — a country ISO code like \"DE\", \"US\", or an ISO subdivision like \"US-CA\". Combine with Status."
                    },
                    "status": {
                        "title": "Entity status",
                        "enum": [
                            "any",
                            "ACTIVE",
                            "INACTIVE"
                        ],
                        "type": "string",
                        "description": "Filter browsed entities by legal status.",
                        "default": "ACTIVE"
                    },
                    "includeOwnership": {
                        "title": "Include ownership graph",
                        "type": "boolean",
                        "description": "Attach each entity's direct & ultimate parent and direct children (the corporate hierarchy). On by default — this is what sets it apart from a plain LEI lookup. Adds a few calls per entity.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of entities to return (1–50000).",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```