# Company Data Enrichment — Domain to Firmographics API (`nexgensignal/company-data-enrichment-api`) Actor

Domain-to-firmographics API: homepage company name, description and hosting hints, cross-matched to the public GLEIF LEI register for legal name, jurisdiction, entity status and registered head office. Keyless, pay per company; organisation data only, no officer or contact data.

- **URL**: https://apify.com/nexgensignal/company-data-enrichment-api.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, Developer tools, Other
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $67.00 / 1,000 company 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?

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Domain Firmographics API — LEI Company Enrichment

**Pay per company. Turn a domain into a firmographic profile — company name, description, hosting hints, and a cross-matched GLEIF Legal Entity Identifier with jurisdiction, entity status, and registered head office.**

Feed one domain or ten thousand and get back, for each, a clean firmographic record: the company's own homepage metadata plus a cross-enrichment against the public GLEIF Legal Entity Identifier (LEI) register. It is a keyless, code-friendly domain-to-firmographics endpoint that joins each company's public web presence to its official legal-entity reference data — with no personal, officer, or contact data anywhere in the output.

### What this is, in one paragraph

Most "company enrichment" tools stop at what a homepage says about itself. This actor goes one step further: for every domain it reads the company's public homepage (name, description, title, hosting and CMS hints), then matches the company by name against the **GLEIF LEI register** — the global, open, authoritative source of legal-entity identifiers — and attaches the entity's LEI, registered legal name, legal jurisdiction, entity and registration status, and registered head-office address. The result is a single flat record per domain that ties a company's marketing identity to its legal identity, keyed by domain so it joins straight into your CRM or data warehouse. No API key at either source, and no person-level data of any kind.

### Who buys this and for what job

- **Sales and RevOps teams** enriching inbound domains and lead lists with firmographics and a verifiable legal-entity identifier.
- **Compliance, KYB, and onboarding teams** who need to resolve a customer's domain to a registered legal entity, jurisdiction, and LEI before they act.
- **Data teams** building a company master table who want homepage firmographics and GLEIF reference data joined on domain in one pass.
- **Builders and AI agents** who need a keyless firmographics-plus-LEI endpoint callable from code.

The job it does: take a domain you already have and return both what the company says about itself and what the official register says about it — reliably, with provenance, and without an account or key at the source.

### The upgrade over a plain enrichment call

A homepage tells you a company's marketing name and pitch. It does not tell you the registered legal entity behind it, its jurisdiction, or a stable identifier you can carry across systems. This actor cross-enriches every domain against the GLEIF LEI register, so alongside the homepage firmographics you get the entity's **LEI** — a 20-character ISO 17442 identifier used across finance, procurement, and regulatory reporting — plus the registered legal name, legal jurisdiction, entity status (for example `ACTIVE`), registration status (for example `ISSUED`), and the registered head-office city, region, country, and postal code. That is the difference between "a website called Shopify" and "SHOPIFY INC., LEI 549300HGQ43STJLLP808, incorporated in Canada, head office in Ottawa, status ACTIVE." The register data is organisation-level only; no officers, directors, or contacts are ever fetched or returned.

### Pricing

Pay per event. You are billed a small fixed fee when a run starts, then one event per company record delivered; the record is delivered before it is charged. No subscription. Tiered by your Apify plan.

| Event | Free plan | Bronze | Silver | Gold / Platinum / Diamond |
|-------|-----------|--------|--------|---------------------------|
| Actor start | $0.00005 | $0.00005 | $0.00005 | $0.00005 |
| Company record | $0.10 | $0.09 | $0.08 | $0.067 |

About 10 enriched companies per dollar at the base record rate. A domain that resolves to neither a homepage nor an LEI still returns a record (with `success: false`) and counts as one processed company, exactly as an enrichment API would meter a lookup.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `domains` | array | *(required)* | One or more company domains (e.g. `stripe.com`). Full URLs are accepted and normalised. |
| `domain` | string | — | A single domain (alias for `domains`). |
| `includeLei` | boolean | true | Cross-enrich each company against the GLEIF LEI register. Turn off for homepage-only firmographics. |
| `maxRecords` | integer | *(all domains)* | Ceiling on records delivered and billed. Defaults to the number of domains supplied. |
| `proxyConfiguration` | object | Residential | Proxy for homepage and register requests. Residential is recommended for reliable homepage reads. |

### Output

One JSON object per domain. Real example from a run:

```json
{
  "record_id": "shopify.com",
  "domain": "shopify.com",
  "company_name": "Shopify",
  "website_title": "Shopify | Build or grow your business",
  "description": "Try Shopify free. Build or grow your business fast.",
  "homepage_status": 200,
  "homepage_reachable": true,
  "server": "cloudflare",
  "generator": null,
  "lei": "549300HGQ43STJLLP808",
  "legal_name": "SHOPIFY INC.",
  "legal_jurisdiction": "CA",
  "entity_status": "ACTIVE",
  "registration_status": "ISSUED",
  "hq_city": "OTTAWA",
  "hq_region": "CA-ON",
  "hq_country": "CA",
  "hq_postal_code": "K1Y 2P5",
  "lei_match": "exact_name",
  "has_lei": true,
  "success": true,
  "error": null,
  "source": "company homepage + GLEIF LEI register",
  "source_url": "https://shopify.com",
  "licence": "Firmographics from public homepage and GLEIF public LEI reference data.",
  "attribution": "Sources: the company's public homepage and GLEIF public LEI reference data (gleif.org).",
  "observed_at": "2026-08-25T00:00:00Z"
}
```

An unbilled `RUN_RECEIPT` records the GLEIF door check, how many domains went in, how many records were delivered, and how many matched an LEI.

### Field reference

Each record carries `record_id` and `domain` (the normalised domain), homepage firmographics (`company_name`, `website_title`, `description`, `homepage_status`, `homepage_reachable`, and coarse hosting/CMS hints `server` and `generator`), and — when matched — GLEIF register fields (`lei`, `legal_name`, `legal_jurisdiction`, `entity_status`, `registration_status`, and the registered head office `hq_city` / `hq_region` / `hq_country` / `hq_postal_code`). `lei_match` records how the entity was matched (`exact_name`, `fuzzy`, or `none`), `has_lei` and `success` are booleans your pipeline can branch on, and `error` explains any miss. Provenance travels on every record: `source`, `source_url`, `licence`, `attribution`, `disclaimer`, and `observed_at`.

### How a run works

For each domain the actor normalises it (stripping scheme, `www`, and any path), fetches the company's public homepage, and extracts the firmographic fields. If `includeLei` is on, it first confirms the GLEIF register is reachable and permits access, then matches the extracted company name against the register — an exact legal-name match first, then a fuzzy completion resolved back to an exact record. Any email address or phone-like sequence found in the homepage description is removed before the record is written, so no contact detail is ever emitted. The record is delivered, and the platform bills one company-record event for it. Domains that resolve to neither a homepage nor an LEI are still delivered with `success: false`, so every input is accounted for.

### Working with the data

Because every record is keyed by `domain`, the output joins cleanly into any company table you keep. Use `has_lei` to split matched from unmatched companies, `legal_jurisdiction` and `hq_country` to segment by geography, and `entity_status` to flag inactive or lapsed entities. The `lei` field is a stable cross-system key you can carry into finance, procurement, and regulatory tooling. Feed a whole domain list and get a firmographics-plus-LEI column set back in a single run.

### Use with AI agents

Point Claude, an OpenAI Agents SDK tool, an n8n or Make flow, or any MCP-aware client at this actor and hand it a list of domains. Because the output is flat JSON keyed by `domain`, an agent can enrich a lead list with firmographics and legal-entity identifiers in one call and use `success` and `has_lei` to route the misses to a human. A typical prompt: *enrich my list of company domains with firmographics and their GLEIF LEI, and flag any without a registered entity.*

### Honest limitations and caveats

- **LEI matching is name-based.** The register is matched on the company name read from the homepage; common or generic names can match a different legal entity with the same name. `lei_match` and `legal_name` are returned so you can verify each match against the primary register before relying on it.
- **Not every company has an LEI.** LEIs are widely held by entities active in financial markets and regulated sectors, but many small or private companies have none; those return `has_lei: false`, which is a real signal, not an error.
- **Public sources only.** Homepage fields come from each site's own public homepage; register fields come from GLEIF's public Level 1 reference data. Availability varies by domain.
- **Organisation data only — no person data.** Only company-level and registered-office fields are returned. No officer, director, founder, or contact-person data is collected or emitted, and any contact detail found in homepage text is stripped before output.
- **Values are reproduced verbatim.** Register fields are not relabelled or re-derived; homepage fields are extracted, not editorialised.

***

*Firmographics are assembled from each company's own public homepage and the public GLEIF Level 1 LEI reference data (Global Legal Entity Identifier Foundation). Register values are reproduced verbatim. Entity and registered-office data only; no officer, director, or contact-person data of any kind.*

# Actor input Schema

## `domains` (type: `array`):

One or more company domains (e.g. stripe.com). Full URLs are accepted and normalised to the bare domain.

## `domain` (type: `string`):

A single domain (alias for domains).

## `includeLei` (type: `boolean`):

Match each company against the public GLEIF Legal Entity Identifier register for its LEI, legal name, jurisdiction, entity/registration status, and registered head-office address.

## `maxRecords` (type: `integer`):

Ceiling on records delivered and billed. Defaults to the number of domains supplied. You are billed only for records delivered.

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

Proxy used for homepage and register requests. Residential is recommended for reliable homepage reads.

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "shopify.com"
  ],
  "includeLei": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Delivered records.

# 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 = {
    "domains": [
        "stripe.com",
        "shopify.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/company-data-enrichment-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 = {
    "domains": [
        "stripe.com",
        "shopify.com",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/company-data-enrichment-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 '{
  "domains": [
    "stripe.com",
    "shopify.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call nexgensignal/company-data-enrichment-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/company-data-enrichment-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/Pm3CJt1MIAubf45bt/builds/nLpWbTkerdqCkCYed/openapi.json