# Global Company Verification: Registry & Ownership Lookup (`scrapemint/global-company-verification`) Actor

Verify legal entities in any country against the official global LEI registry: registered name, addresses, status, local registry number, and parent company ownership. Search by company name or LEI code. Keyless, no browser. Pay per verified company, no-match searches free.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Global Company Verification: Registry & Ownership Lookup

Check that a company legally exists, in any country, against GLEIF - the official global Legal Entity Identifier registry used by banks and regulators worldwide. Around 2.5 million legal entities, one authoritative record each.

Give it company names or LEI codes, get back the official registered identity: exact legal name, registered and headquarters address, entity status, the local business registry number, and who owns the company.

### What you get

One row per verified entity:

| Field | Description |
| --- | --- |
| `lei` | The entity's 20-character Legal Entity Identifier |
| `legalName`, `otherNames` | Official registered name and trading names |
| `entityStatus` | ACTIVE, INACTIVE (merged, dissolved...) |
| `jurisdiction`, `legalFormId` | Where and in what legal form it is registered |
| `localRegistryId`, `registrationAuthority` | The entity's number in its national business registry |
| `legalAddress...`, `hqAddress...` | Registered and headquarters addresses |
| `directParentName`, `directParentLei` | Who owns it (accounting consolidation) |
| `ultimateParentName`, `ultimateParentLei` | The top of the ownership chain |
| `leiRegistrationStatus`, `leiNextRenewal` | How fresh the record is |

### Typical uses

- **Supplier and vendor onboarding**: does this entity exist, where is it registered, and under which registry number?
- **Invoice fraud checks**: the name and address on the invoice should match the registry record.
- **Sales intelligence**: resolve an enterprise prospect to its legal entity and ultimate parent group.
- **KYC pre-screening**: pull the official identity before the expensive full check.
- **Corporate research**: map ownership chains across borders.

Pairs naturally with sanctions and watchlist screening: verify the entity, then screen it.

### Honest coverage note

LEIs are mandatory for entities active in financial markets: banks, funds, insurers, listed companies, bond issuers, and most mid-size and large corporates that trade or borrow. A small local business that never touched a financial market may legitimately have no LEI. A no-match result means "not in the LEI system", not "does not exist" - and it costs you nothing.

### Pricing

You pay per verified company row (`company_found`). Searches with no match are free. The first 2 rows of every run are free.

### Input example

```json
{
    "queries": ["Volkswagen AG", "Safaricom", "HWUPKR0MPOU8FGXBT394"],
    "country": "",
    "activeOnly": true,
    "includeParents": true,
    "maxResultsPerQuery": 3
}
````

### Notes

- Data comes from GLEIF's public API. No API key, no login, no browser.
- Parent relationships are as reported to GLEIF; a missing parent usually means the entity is itself the top of its chain, or reports an exception (natural persons, no consolidation).
- GLEIF rate-limits per IP; the actor paces itself, retries once on a limit, and stops cleanly with partial data if the limit persists (finished rows are kept).

# Actor input Schema

## `queries` (type: `array`):

Company names are searched full-text; 20-character LEI codes are fetched directly.

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

Two-letter code (US, DE, KE...) to limit name searches to entities legally registered in one country.

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

Skip merged, retired, and otherwise inactive entities in name searches.

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

How many registry matches to return for each company name.

## `includeParents` (type: `boolean`):

Look up each entity's direct and ultimate parent from the ownership relationship records. Adds two API calls per entity.

## `maxRows` (type: `integer`):

Cap on verified company rows across all queries. Controls total cost.

## Actor input object example

```json
{
  "queries": [
    "Apple Inc",
    "Safaricom",
    "Volkswagen AG"
  ],
  "activeOnly": false,
  "maxResultsPerQuery": 5,
  "includeParents": true,
  "maxRows": 100
}
```

# 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 = {
    "queries": [
        "Apple Inc",
        "Safaricom",
        "Volkswagen AG"
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Global Company Verification: Registry & Ownership Lookup",
        "description": "Verify legal entities in any country against the official global LEI registry: registered name, addresses, status, local registry number, and parent company ownership. Search by company name or LEI code. Keyless, no browser. Pay per verified company, no-match searches free.",
        "version": "0.1",
        "x-build-id": "7GqN46bXCm4N4uOld"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~global-company-verification/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-global-company-verification",
                "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/scrapemint~global-company-verification/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-global-company-verification",
                "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/scrapemint~global-company-verification/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-global-company-verification",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Company names or LEI codes (one per line)",
                        "type": "array",
                        "description": "Company names are searched full-text; 20-character LEI codes are fetched directly.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country (optional)",
                        "type": "string",
                        "description": "Two-letter code (US, DE, KE...) to limit name searches to entities legally registered in one country."
                    },
                    "activeOnly": {
                        "title": "Active entities only",
                        "type": "boolean",
                        "description": "Skip merged, retired, and otherwise inactive entities in name searches.",
                        "default": false
                    },
                    "maxResultsPerQuery": {
                        "title": "Max matches per name search",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many registry matches to return for each company name.",
                        "default": 5
                    },
                    "includeParents": {
                        "title": "Include parent companies",
                        "type": "boolean",
                        "description": "Look up each entity's direct and ultimate parent from the ownership relationship records. Adds two API calls per entity.",
                        "default": true
                    },
                    "maxRows": {
                        "title": "Max rows per run",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on verified company rows across all queries. Controls total cost.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
