# KYB Company Verifier — Cross-Registry Business Verification API (`malonestar/kyb-company-verifier`) Actor

KYB/AML company verification API. Given a company name, fans out to France (INSEE/RNE), GLEIF LEI, and US state registries and returns, per registry: exists, normalized status, jurisdiction, identifiers (SIREN/LEI), officers, address, and a match-confidence score. Keyless.

- **URL**: https://apify.com/malonestar/kyb-company-verifier.md
- **Developed by:** [Kyle Maloney](https://apify.com/malonestar) (community)
- **Categories:** Lead generation, Developer tools, Agents
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## KYB Company Verifier — Cross-Registry Business Verification API

Verify whether a company **exists** and is **in good standing** across multiple
official business registries in one keyless call. Give it a company name and it
fans out — in parallel — to **France (INSEE/RNE)**, the **GLEIF LEI** database,
and **US state registries**, returning one normalized record per registry with:
does it exist, legal status, jurisdiction, identifiers (SIREN / LEI / state ID),
officers or registered agent, address, source link, and a **match-confidence
score** so you can auto-accept or route to manual review.

Built for **KYB / AML onboarding, merchant/vendor due diligence, and AI agents**
that need a grounded "is this a real company?" check.

### Who it's for
- **KYB / AML & compliance teams** grounding onboarding against primary sources.
- **Merchant & vendor onboarding / RevOps** auto-verifying business identity before approval.
- **Fintech / payments risk** screening applicants at signup.
- **AI agents & builders** that need a callable company-existence tool (see MCP note below).

### What it does
- Cross-registry fan-out from a single company name (parallel, keyless).
- Normalizes each hit to a stable schema with a status enum (`active` / `inactive` / `dissolved` / `unknown`).
- Scores name match (token similarity, legal-form aware) so `DANONE SA` == `Danone` == confidence `1`.
- Emits an explicit `exists: false` row when a registry returns no match — negative evidence is a first-class result.

### Supported registries
| Code | Source | Jurisdiction |
|------|--------|--------------|
| `FR-INSEE` | recherche-entreprises.api.gouv.fr (INSEE + RNE) | France |
| `GLEIF` | api.gleif.org LEI records | Global |
| `US-CO`,`US-CT`,`US-NY`,`US-OR`,`US-PA`,`US-DE` | State open-data registries | United States |

### Example input
```json
{
  "companyName": "Danone",
  "country": "FR",
  "maxPerRegistry": 3
}
````

Query everything (leave `country`/`registries` blank), or target specific
registries:

```json
{
  "companyName": "Acme Holdings LLC",
  "registries": ["GLEIF", "US-CO", "US-NY"],
  "maxPerRegistry": 5
}
```

### Output fields

Each dataset item is one registry result:

| Field | Description |
|-------|-------------|
| `input_name` | The name you queried (echoed for joins). |
| `registry` | `FR-INSEE`, `GLEIF`, or `US-<state>`. |
| `jurisdiction` | `FR`, `US-CO`, `GLOBAL`, etc. |
| `exists` | `true` if a match was found, else `false`. |
| `matched_name` | Registered legal name of the match. |
| `entity_id` | SIREN (FR), LEI (GLEIF), or state entity/filing number. |
| `status` | Normalized: `active` / `inactive` / `dissolved` / `unknown`. |
| `address` | Registered / head-office address. |
| `officers` | Directors, officers, or registered agent (joined). |
| `match_confidence` | Name similarity in `[0,1]` (`1` = exact; `0` for not-found). |
| `source_url` | Link to the official record for auditing. |
| `retrieved_at` | ISO-8601 UTC timestamp. |

### Use as an MCP tool

This actor is callable by AI agents (Claude, Cursor, etc.) via
[mcp.apify.com](https://mcp.apify.com). The clean, field-level input/output
descriptions make it a reliable **company-verification tool** an agent can chain
into a KYB/AML workflow: pass a `companyName`, read back `exists`, `status`,
`entity_id`, and `match_confidence` per registry.

### FAQ

**How do I verify a company exists by name?** Pass `companyName`; each registry
returns `exists` plus a `match_confidence` so you can threshold auto-accept.

**Is this a KYB / AML company verification API?** Yes — it grounds business
identity against official French, global (GLEIF), and US state registries.

**How do I get a company's SIREN or LEI from its name?** The `entity_id` field
returns the SIREN for French matches and the LEI for GLEIF matches.

**Does it tell me if a company is dissolved or inactive?** Yes — `status` is
normalized to `active` / `inactive` / `dissolved` / `unknown` across registries.

**Do I need an API key?** No. All sources are keyless open data / public APIs.

### Notes & limits

- A registry that errors is **skipped** (logged) rather than reported as `exists: false` — an outage is not proof of absence.
- Delaware exposes licensed businesses (not the corporate registry); treat `US-DE` as a licensing signal.
- Name matching is fuzzy; always gate automated decisions on `match_confidence`.

# Actor input Schema

## `companyName` (type: `string`):

Legal or trade name of the company to verify (e.g. "Danone", "Acme Holdings LLC"). Required. Legal-form tokens (LLC, SA, GmbH...) are ignored during matching.

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

Restrict to registries for one country: FR (France INSEE/RNE) or US (all supported US states). GLEIF (global) is always included. Leave blank to query every registry.

## `registries` (type: `array`):

Explicit registry codes to query. Supported: FR-INSEE, GLEIF, US-CO, US-CT, US-NY, US-OR, US-PA, US-DE. Overrides the country filter when set.

## `maxPerRegistry` (type: `integer`):

Maximum candidate records to return per registry, ranked by name-match confidence. 1 = best match only.

## Actor input object example

```json
{
  "companyName": "Danone",
  "registries": [],
  "maxPerRegistry": 5
}
```

# Actor output Schema

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

Normalized cross-registry verification records in the default dataset.

# 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 = {
    "companyName": "Danone"
};

// Run the Actor and wait for it to finish
const run = await client.actor("malonestar/kyb-company-verifier").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 = { "companyName": "Danone" }

# Run the Actor and wait for it to finish
run = client.actor("malonestar/kyb-company-verifier").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 '{
  "companyName": "Danone"
}' |
apify call malonestar/kyb-company-verifier --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "KYB Company Verifier — Cross-Registry Business Verification API",
        "description": "KYB/AML company verification API. Given a company name, fans out to France (INSEE/RNE), GLEIF LEI, and US state registries and returns, per registry: exists, normalized status, jurisdiction, identifiers (SIREN/LEI), officers, address, and a match-confidence score. Keyless.",
        "version": "1.0",
        "x-build-id": "0GssQwk3qfEOkzvUy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/malonestar~kyb-company-verifier/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-malonestar-kyb-company-verifier",
                "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/malonestar~kyb-company-verifier/runs": {
            "post": {
                "operationId": "runs-sync-malonestar-kyb-company-verifier",
                "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/malonestar~kyb-company-verifier/run-sync": {
            "post": {
                "operationId": "run-sync-malonestar-kyb-company-verifier",
                "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": [
                    "companyName"
                ],
                "properties": {
                    "companyName": {
                        "title": "Company name",
                        "type": "string",
                        "description": "Legal or trade name of the company to verify (e.g. \"Danone\", \"Acme Holdings LLC\"). Required. Legal-form tokens (LLC, SA, GmbH...) are ignored during matching."
                    },
                    "country": {
                        "title": "Country filter (optional)",
                        "type": "string",
                        "description": "Restrict to registries for one country: FR (France INSEE/RNE) or US (all supported US states). GLEIF (global) is always included. Leave blank to query every registry."
                    },
                    "registries": {
                        "title": "Registries (optional, overrides country)",
                        "type": "array",
                        "description": "Explicit registry codes to query. Supported: FR-INSEE, GLEIF, US-CO, US-CT, US-NY, US-OR, US-PA, US-DE. Overrides the country filter when set.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPerRegistry": {
                        "title": "Max matches per registry",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum candidate records to return per registry, ranked by name-match confidence. 1 = best match only.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```