# Company LEI Lookup API (GLEIF Data) (`sourcing-data-studio/lei-lookup-api`) Actor

Unofficial LEI lookup API: find companies in the public Global LEI Index (GLEIF) by name or LEI code and get the legal name, status, jurisdiction, registration number and registered address.

- **URL**: https://apify.com/sourcing-data-studio/lei-lookup-api.md
- **Developed by:** [Sourcing Data Studio](https://apify.com/sourcing-data-studio) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 lei records

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

Verify that a supplier or buyer is a registered legal entity before you sign or pay. Company LEI Lookup API (GLEIF Data) searches the Global LEI Index by company name, including English names of Chinese companies, or by LEI code, and returns legal name, LEI status, company status, jurisdiction, registration number and registered address. Mostly larger companies hold an LEI. You pay per record saved: $0.003 per LEI record on the Free tier, so a typical query (one company name, up to 10 matching records) costs $0.03.

Unofficial: not affiliated with or endorsed by GLEIF.

Source: Global Legal Entity Identifier Foundation (GLEIF), LEI data under CC0 1.0. See the [CC0 1.0 text](https://creativecommons.org/publicdomain/zero/1.0/).

Importers use this LEI lookup API for supplier verification. Check that a larger supplier or buyer is a registered legal entity, look up the LEI code of a company before a contract, a credit check or a customs form, or check company LEI codes for a whole list at once. It works as an LEI search for a single name, as a legal entity identifier lookup and as a company registration check for larger companies. The data comes from the public GLEIF API, returned as clean rows that you can use in a spreadsheet, a database or an AI agent.

### What does Company LEI Lookup API (GLEIF Data) do?

- Searches the Global LEI Index by company name. A name is matched against legal names, other names and transliterated names, so a Chinese company is usually found by its English name too.
- Does an LEI code lookup: give known 20-character codes and get the matching records. Spaces and dashes in a code are ignored.
- Can limit a name search to one country with a two-letter code such as CN, DE or AE.
- Keeps the **Maximum results per company name** you set, from 1 to 50, so a broad name does not fill the run.
- Removes duplicates. The same LEI found twice is saved and charged once.
- Charges one event per saved record. Failed requests, duplicates and names with no record are never charged.
- Writes a run summary to the key-value store: totals, your feedback, one status for every name and code you entered (found, no record, left out, failed, blocked or not looked up), and a count of what was held back to protect private persons.
- Works from Apify Console, the Apify API, n8n, Make and AI agents through the Apify MCP server.

### Output example

These rows come from a real run.

```json
[
  {
    "lei": "213800WR1OWEFQFT2F37",
    "legalName": "HUAWEI TECHNOLOGIES SRL",
    "otherNames": [],
    "entityStatus": "ACTIVE",
    "registrationStatus": "ISSUED",
    "jurisdiction": "RO",
    "legalForm": "XHN1",
    "category": "GENERAL",
    "registrationAuthorityId": "RA000497",
    "registrationNumber": "20567140",
    "legalAddress": {
      "lines": [
        "NR. 201, STRADA BARBU VACARESCU",
        "ETAJ 14, 15, 16, 23, 24 SI 25",
        "București Sectorul 2"
      ],
      "city": "BUCUREșTI",
      "region": "RO-B",
      "country": "RO",
      "postalCode": "020271"
    },
    "headquartersAddress": {
      "lines": [
        "NR. 201, STRADA BARBU VACARESCU",
        "ETAJ 14, 15, 16, 23, 24 SI 25",
        "București Sectorul 2"
      ],
      "city": "BUCUREșTI",
      "region": "RO-B",
      "country": "RO",
      "postalCode": "020271"
    },
    "entityCreationDate": "2007-01-15T00:00:00Z",
    "initialRegistrationDate": "2026-07-14T00:00:00Z",
    "lastUpdateDate": "2026-07-14T12:26:14Z",
    "nextRenewalDate": "2027-07-14T00:00:00Z",
    "managingLou": "213800WAVVOPS85N2205",
    "searchQuery": "Huawei",
    "source": "GLEIF",
    "retrievedAt": "2026-10-05T15:03:44.350Z"
  },
  {
    "lei": "2138009CFZKTZYV4QV61",
    "legalName": "HUAWEI (CHILE) S.A.",
    "otherNames": [],
    "entityStatus": "ACTIVE",
    "registrationStatus": "ISSUED",
    "jurisdiction": "CL",
    "legalForm": "OA6N",
    "category": "GENERAL",
    "registrationAuthorityId": "RA000787",
    "registrationNumber": "99535120-K",
    "legalAddress": {
      "lines": [
        "ROSARIO NORTE 532",
        "17 LAS CONDES"
      ],
      "city": "SANTIAGO",
      "region": "CL-RM",
      "country": "CL",
      "postalCode": "7561185"
    },
    "headquartersAddress": {
      "lines": [
        "ROSARIO NORTE 532",
        "17 LAS CONDES"
      ],
      "city": "SANTIAGO",
      "region": "CL-RM",
      "country": "CL",
      "postalCode": "7561185"
    },
    "entityCreationDate": "2019-09-04T00:00:00Z",
    "initialRegistrationDate": "2019-09-18T00:00:00Z",
    "lastUpdateDate": "2026-08-13T16:06:31Z",
    "nextRenewalDate": "2027-09-18T00:00:00Z",
    "managingLou": "213800WAVVOPS85N2205",
    "searchQuery": "Huawei",
    "source": "GLEIF",
    "retrievedAt": "2026-10-05T15:03:44.350Z"
  },
  {
    "lei": "213800CUYLHCD3Y53406",
    "legalName": "HUAWEI DEL PERU SAC",
    "otherNames": [],
    "entityStatus": "ACTIVE",
    "registrationStatus": "ISSUED",
    "jurisdiction": "PE",
    "legalForm": "CHX6",
    "category": "GENERAL",
    "registrationAuthorityId": "RA000689",
    "registrationNumber": "20507646728",
    "legalAddress": {
      "lines": [
        "415 CAL. LAS BEGONIAS",
        "SAN ISIDRO"
      ],
      "city": "LIMA",
      "region": "PE-LIM",
      "country": "PE",
      "postalCode": "15046"
    },
    "headquartersAddress": {
      "lines": [
        "415 CAL. LAS BEGONIAS",
        "SAN ISIDRO"
      ],
      "city": "LIMA",
      "region": "PE-LIM",
      "country": "PE",
      "postalCode": "15046"
    },
    "entityCreationDate": "2003-11-14T00:00:00Z",
    "initialRegistrationDate": "2026-07-10T00:00:00Z",
    "lastUpdateDate": "2026-07-10T11:26:36Z",
    "nextRenewalDate": "2027-07-10T00:00:00Z",
    "managingLou": "213800WAVVOPS85N2205",
    "searchQuery": "Huawei",
    "source": "GLEIF",
    "retrievedAt": "2026-10-05T15:03:44.350Z"
  }
]
```

### What data can you get with Company LEI Lookup API (GLEIF Data)?

| Field | Type | Description |
|---|---|---|
| `lei` | string | The 20-character Legal Entity Identifier (LEI) of the company. |
| `legalName` | string | Legal name of the entity as registered with GLEIF. |
| `otherNames` | array | Other names of the entity, including transliterated names (for example English names of Chinese companies). Empty list when there are none. |
| `entityStatus` | string, optional | Status of the legal entity, for example ACTIVE or INACTIVE. Null when GLEIF gives no status. |
| `registrationStatus` | string | Status of the LEI itself, for example ISSUED, LAPSED, RETIRED or DUPLICATE. ISSUED means the code is current. LAPSED means the yearly renewal is overdue. |
| `jurisdiction` | string, optional | Legal jurisdiction of the entity as a country or region code, for example CN, DE or US-DE. |
| `legalForm` | string, optional | Legal form of the entity: the free text GLEIF holds, otherwise the ISO 20275 legal form code. Null when unknown. |
| `category` | string | Entity category: GENERAL, BRANCH, FUND, RESIDENT_GOVERNMENT_ENTITY or INTERNATIONAL_ORGANIZATION. Records that the category, the legal form or the legal name marks as a sole proprietor, a personal trust, an estate or a personal pension account are left out; a private person that an LEI issuer filed as an ordinary company or fund without such a marker can remain. |
| `registrationAuthorityId` | string, optional | GLEIF code of the business register where the entity is registered, for example RA000497. |
| `registrationNumber` | string, optional | Registration number of the entity in that business register. |
| `legalAddress` | object | Registered (legal) address of the entity. |
| `headquartersAddress` | object | Headquarters address of the entity. Same shape as the legal address. |
| `entityCreationDate` | string, optional | ISO 8601 time the legal entity was created, as given by GLEIF (usually midnight UTC). |
| `initialRegistrationDate` | string, optional | ISO 8601 time the LEI was first registered. |
| `lastUpdateDate` | string, optional | ISO 8601 time the LEI record was last updated at GLEIF. |
| `nextRenewalDate` | string, optional | ISO 8601 time by which the LEI must be renewed next. |
| `managingLou` | string, optional | LEI of the Local Operating Unit that manages this record. |
| `searchQuery` | string, optional | Company name that found the record. Null when the record was found by LEI code. |
| `source` | string | Data source. Always GLEIF. |
| `retrievedAt` | string | ISO 8601 time when the record was retrieved. |

How to read the two status fields:

- `registrationStatus` is the status of the LEI code. `ISSUED` means the code is current. `LAPSED` means the yearly renewal is overdue. `RETIRED` means the code is no longer in use. `DUPLICATE` means GLEIF holds another LEI for the same company.
- `entityStatus` is the status of the company itself, for example `ACTIVE` or `INACTIVE`. It is null when GLEIF gives none.
- Lapsed, retired and duplicate records are kept in the results, so you can see the status. Check both fields before you rely on a record.

### How to use Company LEI Lookup API (GLEIF Data)

1. Click **Try for free** on this page.
2. Enter one or more **Company names**, or paste **LEI codes**. You need at least one of the two.
3. Optionally set a **Country filter** and the **Maximum results per company name**.
4. Set **Maximum records**. The run stops as soon as that many records are saved.
5. Click **Start**. Results appear in the **Output** tab while the run is going.
6. Download the results as JSON, CSV or Excel, or read them through the API.

### Input examples

#### Check company names

```json
{
  "searchQueries": [
    "Haier",
    "Midea"
  ],
  "maxResultsPerQuery": 5,
  "maxItems": 10
}
```

#### Verify lei codes

```json
{
  "leis": [
    "213800WR1OWEFQFT2F37",
    "2138009CFZKTZYV4QV61"
  ],
  "maxItems": 10
}
```

#### Names in one country

```json
{
  "searchQueries": [
    "Emirates",
    "Gulf Trading"
  ],
  "country": "AE",
  "maxResultsPerQuery": 10,
  "maxItems": 50,
  "feedback": "Example: please add parent company links."
}
```

### How much does Company LEI Lookup API (GLEIF Data) cost?

| Event | You pay for | Free | Bronze | Silver | Gold |
|---|---|---|---|---|---|
| LEI record | One legal entity record saved to the dataset. Failed requests, duplicates and names with no record are never charged. | $0.003 | $0.003 | $0.0027 | $0.0024 |

Prices are per event. Your tier follows your Apify subscription plan.

On the Free tier, $0.003 per LEI record means:

- 100 LEI records cost $0.30.
- 1,000 LEI records cost $3.00.
- A typical query (one company name, up to 10 matching records) is 10 LEI records and costs $0.03.

Apify also charges a tiny start fee per run (apify-actor-start, $0.00005 per GB of memory). Failed requests, duplicates and names with no record are never charged. To cap your spending, set **Maximum cost per run** in the run options; the run stops cleanly when that budget is used.

### Use Company LEI Lookup API (GLEIF Data) from the API, n8n, Make or an AI agent

#### Apify API

Run the Actor and get the records in one call:

**curl**

```bash
curl -X POST "https://api.apify.com/v2/acts/sourcing-data-studio~lei-lookup-api/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["Haier","Midea"],"maxResultsPerQuery":5,"maxItems":10}'
```

**JavaScript** (Node.js, `npm install apify-client`)

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

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

const input = {
    "searchQueries": [
        "Haier",
        "Midea"
    ],
    "maxResultsPerQuery": 5,
    "maxItems": 10
};

const run = await client.actor('sourcing-data-studio/lei-lookup-api').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python** (`pip install "apify-client>=3"`, Python 3.11 or later)

```python
import os

from apify_client import ApifyClient

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

run_input = {
    "searchQueries": [
        "Haier",
        "Midea"
    ],
    "maxResultsPerQuery": 5,
    "maxItems": 10
}

run = client.actor("sourcing-data-studio/lei-lookup-api").call(run_input=run_input)

for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)
```

That call returns the saved records and nothing else. An input without a row can mean that GLEIF holds no record for it, that the record was left out, that the request failed or that the run stopped before it got there. To see which, start the run and read its `RUN_SUMMARY` record. The first call below returns the run object, with its `id`, its `status` and its `statusMessage`, the one-line result of the run. The second call reads `RUN_SUMMARY` from the key-value store of that run:

```bash
curl -X POST "https://api.apify.com/v2/acts/sourcing-data-studio~lei-lookup-api/runs?waitForFinish=60" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"leis":["213800WR1OWEFQFT2F37","ZZZZZZZZZZZZZZZZZZ00"],"maxItems":10}'

curl "https://api.apify.com/v2/actor-runs/RUN_ID/key-value-store/records/RUN_SUMMARY" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

Replace `RUN_ID` with the `id` from the first answer. If `status` is still `RUNNING` after 60 seconds, ask for the run again at `https://api.apify.com/v2/actor-runs/RUN_ID` until its `status` is `SUCCEEDED` or `FAILED`. The saved records are in the dataset named by `defaultDatasetId`. The same `RUN_SUMMARY` record is also at `https://api.apify.com/v2/key-value-stores/STORE_ID/records/RUN_SUMMARY`, where `STORE_ID` is the `defaultKeyValueStoreId` of the run.

`RUN_SUMMARY` has the same one-line result in `message`, and a `listings` part with one entry for every company name (`name:...`) and every LEI code (`lei:...`) you entered. For the call above, the relevant parts read:

```json
{
  "status": "SUCCEEDED",
  "message": "Saved 1 LEI record.",
  "listings": {
    "lei:213800WR1OWEFQFT2F37": { "status": "ok", "items": 1 },
    "lei:ZZZZZZZZZZZZZZZZZZ00": { "status": "no-match", "items": 0 }
  }
}
```

The `status` of a listing is `ok`, `no-match`, `excluded`, `failed`, `blocked` or `stopped`. The FAQ below says what each one means. Check the listing before you read a missing row as "no record or withheld": that is what `no-match` and `excluded` mean. For `failed`, `blocked` and `stopped` the input was not answered, so run it again. A name search can also carry `matches`, the number of records GLEIF holds for that name, which can be more than `items`, the number saved.

#### n8n and Make

Use an HTTP request module with the same URL, method POST and a JSON body like the input examples above. Store your Apify API token as a credential, never in the workflow itself.

#### AI agents through the Apify MCP server

Connect your agent to the Apify MCP server and call `sourcing-data-studio/lei-lookup-api` with the same input. Agents can use the **Feedback for the developer** field to report missing fields or problems.

### For AI agents

- Minimal input: `{"searchQueries":["Huawei"],"maxItems":10}`. At the Free price of $0.003 per record, 10 records cost $0.03 plus the platform's start fee.
- Read these fields first: `lei`, `legalName`, `registrationStatus`, `entityStatus` and `jurisdiction`.
- Outcomes are in the status message of the run (one line) and in the `RUN_SUMMARY` record of the run's key-value store, with one status per input: `ok`, `no-match`, `excluded`, `failed`, `blocked` or `stopped`. Check the status before you read a missing row as "no record".
- Do not use it to prove that a company is trustworthy, to find a company that has no LEI (most small firms have none) or to look up a private person: it returns LEI records of legal entities only.
- It is callable through the Apify MCP server as the tool `sourcing-data-studio/lei-lookup-api` and through the Apify API.

### Limits

- At most 1,000 records per run, 100 company names and 1,000 LEI codes. For more, run the Actor several times.
- A name search returns the first page only: up to 50 records per name. A broad name such as a group brand can match more companies than that.
- The name match is a text match, not a fuzzy match. A misspelled name can return nothing. Try a shorter or alternative spelling.
- The Actor sends one request at a time and at most 30 requests per minute, to stay polite to the source. A name search takes a few seconds.
- Records are de-duplicated within a run, not across runs.
- If the source refuses a request (HTTP 401, 403 or 407), the Actor does not try again and does not look for another way in: the name or code gets the status `blocked`. After HTTP 429 (too many requests) it waits as long as the source asks, at most 60 seconds (at least 10 seconds when the source does not say), and tries again from the same address, up to **Retries per request** times. If the source asks for a longer wait, or says that its allowance is used up, the request ends as `blocked` at once. The Actor never takes another address or another proxy to get around a refusal.
- If three requests in a row fail or are refused, the run stops instead of sending the rest to a source that is down or does not want them. A request that the source rejects (HTTP 400 or 404) does not count for this. The names and codes that were not looked up have the status `stopped` in the run summary.
- Records of private persons are not returned: sole proprietors, personal trusts, estates of deceased persons and personal pension accounts. See the FAQ.
- The data is as current as the Global LEI Index. Check `lastUpdateDate` and `nextRenewalDate` in each record.

### FAQ

#### Which data does Company LEI Lookup API (GLEIF Data) collect?

Only public legal entity data from the Global LEI Index: names, status, jurisdiction, legal form, registration number, registered and headquarters address, and registration dates. It does not log in and needs no key.

#### Which data is NOT collected?

- No contact fields. The Actor copies only the fields in the table above, so phone numbers, email addresses and contact persons are never read or output.
- No sole proprietor records. A sole proprietor is a private person who trades in their own name. A record is left out when GLEIF's entity category says sole proprietor, when its legal form says so (for example the German "eingetragener Kaufmann" or the Indian "Sole Proprietorship"), or when its legal name ends in "e.K." or names a proprietor ("Prop."). Any category the Actor does not know is left out too.
- No personal trusts, estates or personal pension accounts. The Global LEI Index holds many records such as "(name) Revocable Living Trust", "(name) Family Trust", "(name) Discretionary Settlement", "Estate of (name), deceased" or "(name) SIPP". They are named after a private person and are often registered at a home address. A record is left out when its legal name or legal form carries such a marker. Trust companies, investment trusts and funds are kept.
- No care-of or attention lines. An address line is dropped when it repeats GLEIF's mail-routing field or carries a marker such as "c/o", "care of", "attn", "s/o" or a personal title such as "Mr" or "Shri". The whole line goes, also when it names a company ("c/o Example Ltd"), because the Actor does not guess. The rest of the address is kept.
- No ownership or parent company data.

Nothing is held back silently. The run summary (key `RUN_SUMMARY`) has a `withheld` block: the number of sole proprietor, personal trust and estate records that were left out, the number of address lines that were dropped, the reason for each, and the LEI codes of the saved records that lost an address line. If you need the full address of such a company, look up its LEI code on the GLEIF website.

What these rules cannot do: they work on markers. A private person whom an LEI issuer filed as an ordinary company, with a company-like name and legal form, can remain in the results. So can an address line that names a person without any marker, and a trust whose name has no marker, such as "(name) Trust" filed as a fund. If you find such a record, tell us in the **Feedback for the developer** field.

#### My supplier has no LEI. Is that a warning sign?

No. Most companies are not required to have an LEI, and many small factories and traders do not have one. The status `no-match` only means GLEIF holds no record for that name or code. It says nothing about whether the company is trustworthy. A record that exists shows that the company is registered, not that it is reliable or that its goods are good.

#### My supplier gave me an LEI, but the Actor returns nothing for it. Why?

Look at the run summary (key `RUN_SUMMARY` in the **Storage** tab). Every name and LEI code you entered is listed there with a status:

| Status | Meaning |
|---|---|
| `ok` | Looked up, and at least one record was saved for it (or was already saved earlier in the run). |
| `no-match` | Looked up. GLEIF holds no record for this name or code. |
| `excluded` | GLEIF holds a record, so the LEI code is real, but it is a record of a private person (a sole proprietor, or a personal trust, estate or pension account) and this Actor does not return those. Nothing is saved or charged. Check the code on the GLEIF website. |
| `failed` | The request failed after all retries, or the record that came back for an LEI code was incomplete. Nothing is charged. Run it again later. |
| `blocked` | The source refused the request (HTTP 401, 403, 407 or 429). A refusal (401, 403, 407) is never retried, and a rate limit (429) is retried from the same address only. Nothing is charged. Run it again later. |
| `stopped` | Not looked up, or found but not saved, because the run ended first: **Maximum records** or your maximum cost per run was reached, the run timed out, or three requests in a row failed or were refused. |

An LEI code with the status `excluded` is in most cases a valid code of a sole proprietor, which is common for small exporters. For company names it is different: sole proprietor records are not searched at all, so a sole proprietor's name usually ends as `no-match`. About 4 in 100 LEI records are filed as sole proprietors (130,065 of 3,457,357 in GLEIF's data of 9 October 2026).

#### Why did my run return 0 records?

No record matched your names or codes, the filters were too narrow, or the records were left out as records of private persons (sole proprietors, personal trusts and estates). The final status message and the run summary say which. Nothing is charged in any of these cases.

A name search keeps only records whose legal name or other names contain at least one distinctive word of the name you typed. Characters that the source reads as search operators (`,` `!` `*` `<` `>` `=` and `..`) are removed from a name before it is sent, so a typo cannot return unrelated companies.

#### Why do I get several companies for one name?

Large groups register many subsidiaries, and each has its own LEI. Use `searchQuery`, `legalName`, `jurisdiction` and the address to pick the entity you mean, or set a **Country filter**.

#### Can I schedule Company LEI Lookup API (GLEIF Data)?

Yes. Save your input as a task and add a schedule in Apify Console, for example a monthly check of your supplier list.

### Feedback

Tell us what to add next in the **Feedback for the developer** input field, or open an issue in the **Issues** tab. Feedback is saved with the run summary.

# Changelog

This Actor's version history is a separate document: https://apify.com/sourcing-data-studio/lei-lookup-api/changelog.md

# Actor input Schema

## `searchQueries` (type: `array`):

Company names to look up, one per entry, for example Huawei or Siemens Aktiengesellschaft. Each name is matched against legal names, other names and transliterated names, so a Chinese company is usually found by its English name too. Sole proprietor records are not searched. Optional when you give LEI codes; at least one of company names or LEI codes is required. Up to 100 names.

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

Optional. LEI codes (20 letters and digits, for example 213800WR1OWEFQFT2F37) for an exact lookup of known companies. Use this to verify a supplier or buyer who gave you an LEI. Spaces and dashes are ignored. A code with no record, or with a record of a private person such as a sole proprietor or a personal trust (which this Actor does not return), saves nothing and is never charged; the run summary says which of the two it was. Up to 1000 codes.

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

Optional. Two-letter ISO 3166-1 country code (for example CN, DE, AE, GB) that keeps only companies whose legal address is in that country. Applies to company name searches. Leave empty to search all countries.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of records returned for each company name, from 1 to 50. A name like Huawei matches many group companies, so a lower number keeps the cost down. Does not apply to LEI codes, which return at most one record each.

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

Maximum number of LEI records to save and pay for in this run, across all company names and LEI codes. The run stops as soon as this many records are saved. Duplicates (the same LEI found twice) are saved and charged once.

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

Optional. The GLEIF API is open and needs no proxy, so the default sends requests directly. Only change this if you have a reason to route requests through a proxy. The Actor keeps one proxy session for the whole run. It takes another address only when the connection through the proxy fails, never after the source refuses a request (HTTP 401, 403, 407 or 429).

## `maxRequestRetries` (type: `integer`):

How many times a failed request is retried with exponential backoff. A rate-limited request (HTTP 429) is retried from the same address after the wait the source asks for, and not at all when the source asks for more than 60 seconds or says its allowance is used up. A refused request (HTTP 401, 403 or 407) is never retried. Failed requests are never charged. If three requests in a row fail after their retries, the run stops.

## `debugLog` (type: `boolean`):

Print detailed debug messages to the run log.

## `feedback` (type: `string`):

Optional. Tell us which field or data source you need next, or what went wrong. It is saved with the run summary. Do not include personal data. AI agents may also use this field to report problems.

## Actor input object example

```json
{
  "searchQueries": [
    "Huawei"
  ],
  "maxResultsPerQuery": 10,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxRequestRetries": 3,
  "debugLog": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (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 = {
    "searchQueries": [
        "Huawei"
    ],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("sourcing-data-studio/lei-lookup-api").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 = {
    "searchQueries": ["Huawei"],
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("sourcing-data-studio/lei-lookup-api").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 '{
  "searchQueries": [
    "Huawei"
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call sourcing-data-studio/lei-lookup-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sourcing-data-studio/lei-lookup-api"
        }
    }
}
```

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/JyYqewNrr9sj1DdSZ/builds/1op1G4rYLFZnb4Ypb/openapi.json