# Company KYB Lookup - LEI, EU & SEC EDGAR Verify, No API Key (`themineworks/company-identity-resolver`) Actor

Verify any company in one call: returns GLEIF LEI number, EU jurisdiction flag, and SEC EDGAR CIK for US-listed firms. Built for KYB, vendor onboarding & counterparty due diligence. No API key, structured JSON. Use it as an MCP server in Claude, ChatGPT & AI agents.

- **URL**: https://apify.com/themineworks/company-identity-resolver.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** MCP servers, Developer tools, Business
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 company resolveds

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

## Company Identity Resolver — GLEIF LEI + EU-Jurisdiction Flag + SEC EDGAR Cross-Reference

> **On EU VAT:** This actor does **not** perform a live VIES VAT-number validation. It returns an `is_eu_registered` jurisdiction flag derived from the GLEIF headquarters country code. See [How does EU VAT status work](#frequently-asked-questions) below for details.

Resolve a company name into verified legal identity data from three authoritative public registries in a single API call. No API key required. Ideal for KYB (Know Your Business) automation, vendor onboarding, and counterparty due diligence workflows.

---

### What This Actor Does

When you need to verify a company, you typically have to query three separate registries, reconcile inconsistent name formats, and write custom parsing logic for each source. This actor handles all of that:

1. **GLEIF (Global LEI Index)** — Queries `api.gleif.org` for the company's Legal Entity Identifier (LEI), its registration status (ISSUED, LAPSED, PENDING), and its headquarters country. The LEI is the gold standard for legal entity identification in financial services, required for MiFID II, EMIR, and Dodd-Frank reporting.

2. **EU VAT Status (derived from GLEIF country)** — Using the headquarters country returned by GLEIF, the actor flags whether the entity is registered in an EU member state (`is_eu_registered: true/false`). This is a reliable proxy for EU VAT jurisdiction coverage without needing a VIES scrape, and it lets you immediately route entities into EU-specific compliance workflows.

3. **SEC EDGAR** — Queries `efts.sec.gov` for US-listed companies that have filed 10-K annual reports since 2015. Returns the company's CIK (Central Index Key), filing name as registered with the SEC, and the date of the most recent filing. CIK is the persistent identifier for any company in the US public disclosure system.

The result is a single clean record per company with all three data points merged — or clear `null` values where a company does not appear in a given registry.

---

### Why Compliance, Fintech, and Procurement Teams Need This

**Vendor onboarding** is a manual bottleneck. An analyst querying GLEIF, then EDGAR, then cross-checking country codes against an EU list, for a list of 200 counterparties, takes hours. This actor processes a list in minutes, outputs structured JSON, and integrates directly into downstream pipelines via Apify datasets or webhooks.

**Counterparty due diligence** in financial services requires LEI verification before executing trades, issuing credit, or signing service agreements in regulated markets. The GLEIF LEI check is the foundation.

**KYB automation** for fintech platforms and neobanks requires continuous monitoring of entity status. A lapsed LEI is a compliance red flag. This actor can be scheduled to re-verify your counterparty list on a rolling basis.

**Procurement and supply chain teams** need to verify that new suppliers are registered legal entities, not shell companies. The `resolved: false` flag immediately surfaces companies that appear in none of the three registries.

---

### Source Registries

| Registry | Endpoint | Coverage |
|---|---|---|
| GLEIF Global LEI Index | `api.gleif.org/api/v1/lei-records` | 2.1M+ entities worldwide |
| EU-Jurisdiction Flag (not VIES) | Derived from GLEIF country code | 27 EU member states |
| SEC EDGAR Full-Text Search | `efts.sec.gov/LATEST/search-index` | All US public companies with 10-K filings |

---

### Output Fields

Each resolved company produces one record:

| Field | Type | Description |
|---|---|---|
| `query_name` | string | The company name you submitted |
| `lei` | string or null | 20-character LEI code from GLEIF |
| `lei_status` | string or null | ISSUED, LAPSED, PENDING_TRANSFER, etc. |
| `legal_name` | string or null | Official registered legal name from GLEIF |
| `country` | string or null | ISO 2-letter HQ country code |
| `entity_status` | string or null | ACTIVE, INACTIVE, etc. |
| `is_eu_registered` | boolean or null | True if country is an EU member state |
| `edgar_cik` | string or null | SEC EDGAR Central Index Key |
| `edgar_name` | string or null | Name as filed with SEC |
| `edgar_last_filing` | string or null | Date of most recent 10-K filing |
| `resolved` | boolean | True if found in at least one registry |
| `scraped_at` | ISO timestamp | Run time |

---

### Pricing

- **First 25 companies free** — the free tier is per-account and tracked across runs using a named key-value store. No time limit on when you use your 25 free resolutions.
- **$10 per 1,000 companies** after the free tier ($0.01 per company). No subscription, no minimum spend.

---

### Use Cases

- **Vendor onboarding portals** — submit new supplier names and get LEI + EDGAR status in the intake form response
- **Counterparty verification pipelines** — batch-verify trading counterparties before deal execution
- **KYB automation** — build or augment a KYB flow without paying for a third-party KYB API
- **Compliance dashboards** — schedule periodic re-checks on your monitored entity list; alert on `lei_status` changes
- **M&A due diligence** — quickly resolve a target's subsidiaries across jurisdictions
- **Data enrichment** — append LEI and EDGAR CIK to any CRM or ERP export

---

### Frequently Asked Questions

**What happens when a company is not found in any registry?**
The record is still written to the dataset with all registry fields set to `null` and `resolved: false`. This is intentional — it tells you the lookup ran but came back empty, so you can flag that company for manual review rather than silently dropping it.

**How does EU VAT status work if you're not calling VIES directly?**
The `is_eu_registered` field is derived from the GLEIF headquarters country code. If GLEIF returns a country in the 27-member EU set (AT, BE, BG, CY, CZ, DE, DK, EE, ES, FI, FR, GR, HR, HU, IE, IT, LT, LU, LV, MT, NL, PL, PT, RO, SE, SI, SK), the flag is `true`. This is not a live VAT number validation — it is a jurisdiction flag. If you need exact VAT number lookup, the GLEIF `lei` you get here is the correct starting point for a secondary VIES API call.

**Does `countryCode` affect EDGAR lookups?**
No. The `countryCode` hint is passed only to GLEIF to narrow the entity search. EDGAR is always searched by company name regardless of country, since the SEC filing history is the definitive source for US companies and many multinationals file in both registries.

**What does a lapsed LEI mean?**
An LEI with status `LAPSED` means the registrant did not renew their annual LEI registration. Under MiFID II and EMIR, a lapsed LEI can prevent a counterparty from participating in regulated trades. It does not mean the company is dissolved — just that their LEI renewal is overdue. You should treat a lapsed LEI as a yellow flag requiring follow-up.

**How does this compare to paid KYB APIs like Dun & Bradstreet, Bureau van Dijk, or Comply Advantage?**
Paid KYB APIs offer broader coverage including private companies, adverse media screening, PEP/sanctions lists, and UBO (Ultimate Beneficial Owner) chains. This actor covers the publicly available regulatory layer — LEI registration and US securities filings — which is sufficient for a first-pass counterparty screen and is free for the first 25 queries. For regulated financial institutions that require full UBO chains and sanctions screening, use this actor as a fast enrichment step before sending candidates to a paid KYB API.

**Can I use this for real-time onboarding flows?**
Yes. The actor runs in under 5 seconds for a single company (with EDGAR enabled) and under 60 seconds for batches of 50. You can trigger it via the Apify API from your onboarding backend, wait for the run to complete, and pull the dataset record to populate your form or CRM.

**What if a company name returns multiple GLEIF matches?**
The actor takes the first result returned by GLEIF's relevance ranking for the given name and country hint. If you need to review all candidates, you can submit the company with different `countryCode` values or inspect the raw GLEIF API directly using the LEI returned.

---

### Technical Notes

- Rate limiting: the actor sleeps 300ms between companies and 200ms between GLEIF and EDGAR calls within a company to stay within GLEIF's fair-use rate limits.
- The actor uses ESM (`"type": "module"`) and requires Node 18+.
- All HTTP calls include a `User-Agent` header identifying the actor per GLEIF and SEC usage guidelines.
- The `_type: "summary"` record at the end of the dataset is a metadata row — filter it out if you are processing dataset records programmatically.


### Use in Claude, ChatGPT & any MCP agent

This actor is also a **Model Context Protocol (MCP) server tool** — call it directly from Claude, ChatGPT, Cursor, Windsurf, or any MCP-compatible AI agent. The agent only pays for results delivered (same pay-per-result model).

- Per-actor MCP endpoint: `https://mcp.apify.com/?tools=themineworks/company-identity-resolver`
- Full Mine Works MCP server (all tools): `https://the-mine-works-mcp.hatchable.site/api/mcp`

```js
// Call this actor as a tool via apify-client (Node)
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('themineworks/company-identity-resolver').call({ /* input from the table above */ });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
````

# Actor input Schema

## `companies` (type: `array`):

List of company names to resolve. E.g. \["Apple Inc", "Volkswagen AG", "Tata Motors"]

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

Optional: hint the country for faster LEI matching (e.g. US, DE, GB).

## `includeEDGAR` (type: `boolean`):

Look up SEC EDGAR filing status for potential US-listed companies.

## Actor input object example

```json
{
  "companies": [
    "Apple Inc",
    "Volkswagen AG"
  ],
  "includeEDGAR": true
}
```

# Actor output Schema

## `results` (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 = {
    "companies": [
        "Apple Inc",
        "Volkswagen AG"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/company-identity-resolver").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 = { "companies": [
        "Apple Inc",
        "Volkswagen AG",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("themineworks/company-identity-resolver").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 '{
  "companies": [
    "Apple Inc",
    "Volkswagen AG"
  ]
}' |
apify call themineworks/company-identity-resolver --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Company KYB Lookup - LEI, EU & SEC EDGAR Verify, No API Key",
        "description": "Verify any company in one call: returns GLEIF LEI number, EU jurisdiction flag, and SEC EDGAR CIK for US-listed firms. Built for KYB, vendor onboarding & counterparty due diligence. No API key, structured JSON. Use it as an MCP server in Claude, ChatGPT & AI agents.",
        "version": "0.1",
        "x-build-id": "VidPcV1rNPJNuib64"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/themineworks~company-identity-resolver/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-themineworks-company-identity-resolver",
                "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/themineworks~company-identity-resolver/runs": {
            "post": {
                "operationId": "runs-sync-themineworks-company-identity-resolver",
                "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/themineworks~company-identity-resolver/run-sync": {
            "post": {
                "operationId": "run-sync-themineworks-company-identity-resolver",
                "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": {
                    "companies": {
                        "title": "Company names",
                        "type": "array",
                        "description": "List of company names to resolve. E.g. [\"Apple Inc\", \"Volkswagen AG\", \"Tata Motors\"]"
                    },
                    "countryCode": {
                        "title": "Country hint (ISO 2-letter)",
                        "type": "string",
                        "description": "Optional: hint the country for faster LEI matching (e.g. US, DE, GB)."
                    },
                    "includeEDGAR": {
                        "title": "Include SEC EDGAR lookup",
                        "type": "boolean",
                        "description": "Look up SEC EDGAR filing status for potential US-listed companies.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
