# Company Registry & Registration Lookup: Officers, Status (`pvalyou/company-registry-lookup`) Actor

Look up a company in its official business register by name or registration number. Registration number, legal name, status, incorporation date, address, officers where published, licence cited on every record. 40+ jurisdictions. $0.005 a record, $0.003 on higher Apify plans.

- **URL**: https://apify.com/pvalyou/company-registry-lookup.md
- **Developed by:** [Pvalyou](https://apify.com/pvalyou) (community)
- **Categories:** Business, Developer tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 matched 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

[![Company Registry Lookup Actor](https://apify.com/actor-badge?actor=pvalyou/company-registry-lookup)](https://apify.com/pvalyou/company-registry-lookup)

**Verify any company against its official register, the business register of its country or state: confirm that it exists, is active and is registered under the name and number it gave you.** Send a **legal name or a registration number** and one register key, and you get **that register's own record**: registration id, legal name, entity status, registration and dissolution dates, registered address, and, where the register publishes them, officers and filings. Send a **region** instead and every register in it is searched at once, best matches first. **Try it now with the prefilled input:** `Nestle` across Europe and `C 10` in Malta.

For KYB and KYC onboarding teams, supplier due diligence, CRM cleaning and entity resolution: $0.005 per matched record, $0.15 per region search, no start fee, and less on Apify's Silver and Gold plans. Use it as your company registration number lookup and business register search where you would otherwise open OpenCorporates or the GLEIF LEI search by hand, one country at a time.

Each query is answered from the register and passed straight through to your run's dataset. Official registers only: no data brokers, no aggregator database, no scraped directories, and no copy of the answers kept on our side.

**What you get**

- ✅ **The register's record, with its provenance.** Every row carries the register it came from, the register's licence, the source URL and an `as_of` date, so an auditor can see where each fact originated.
- ✅ **One schema across 42 official registers plus GLEIF.** Companies House, INSEE Sirene, KBO/BCE, ACRA, the NTA Corporate Number site, Sunbiz, Zefix and the rest of the table below, all returning the same fields, so a Companies House lookup and a Sirene lookup parse with the same code.
- ✅ **Two priced events and nothing else.** $0.005 per matched record on a single-register query, $0.15 per region search, both lower on Apify's Silver and Gold plans. No start fee, no subscription, no minimum. A no-match costs nothing, and so does a register that did not answer.

This is not a certified extract. For legal proof order the extract from the register itself.

### 👥 Who uses a company registry lookup?

- 🏦 **KYC and KYB onboarding.** Before a merchant, borrower or counterparty goes live, confirm the legal name, registration number, status and registered address against the register, and keep the `source_url` and `source_as_of` in the case file.
- 📦 **Supplier due diligence.** Check that a vendor is registered and active in the country it claims, see its dissolution date if it has one, and read the officers where the register publishes them, before a contract or a payment run.
- 🗺️ **Sales territory cleaning.** Run a CRM export through the register of each country, drop dissolved and struck-off entities, fix legal names and fill registration ids, so territories and quotas are built on companies that exist.
- 📈 **Investment research.** Resolve a target across every register in a region in one query, find its LEI holders and their local numbers through GLEIF, and read registration dates and filing history from the source rather than from a commercial database.
- 🤖 **AI agents and pipelines.** Structured JSON with the source, licence and snapshot date on every record, callable from the Apify API, the MCP server and the Python and JavaScript clients. The Actor charges only for events, with no start fee, so it is eligible for agentic payment.

### ▶️ How to look up a company in an official register in 5 steps

1. Open this Actor in the Apify Console.
2. Under `queries`, add one row per lookup: a company name or registration number in `query`, and a register key or a region (`all`, `europe`, `americas`, `asia_pacific`, `us`) in `jurisdiction`. Leave `max_candidates` at 50 or lower it.
3. Click **Start**.
4. Download the results from the run's dataset as JSON, CSV or Excel, or read them through the Apify API.
5. Optionally, schedule the run to re-check a list, for example weekly, or add a webhook that fires when the run finishes.

### ⬇️ Input: a company name or a registration number, and where to look

One row per lookup. The prefilled input runs a Europe search for a name and a Malta lookup by number.

```json
{
  "queries": [
    {"query": "Nestle", "jurisdiction": "europe"},
    {"query": "C 10", "jurisdiction": "mt"}
  ],
  "max_candidates": 50
}
```

| Field | What it does |
|---|---|
| `queries[].query` | A company name or a registration number, at most 200 characters. Each register decides which one it received from its own number shape, so `0403.170.701` goes to Belgium as a number and `Nestle` goes everywhere as a name. Accents and legal-form suffixes (`Ltd`, `GmbH`, `S.A.`) are tolerated. |
| `queries[].jurisdiction` | A register key from the coverage table, or a region: `all`, `europe`, `americas`, `asia_pacific`, `us`. |
| `max_candidates` | Cap on the shortlist a query may return, across every register it searched. Default and maximum 50. |

A name sent to a register marked **number only** is not searched. It comes back as an uncharged error item that names the register and the number shape it expects. An empty query, a query over 200 characters or an unknown key is rejected before any paid step, also uncharged, and the run still ends normally.

### ⬆️ Output: one dataset item per register record

Every item carries `type`, the `query` and `jurisdiction` you sent, and `charged`, so the dataset is the complete record of what you paid for.

| `type` | Charged | Contents |
|---|---|---|
| `record` | on a single-register query, once when `status` is `matched` or `ambiguous` | the register's record, flattened |
| `search_summary` | once per region or all-registers search | `best_match`, counts, and the registers searched, unavailable and skipped |
| `error` | never | an `error` code and a message |

`status` on a record is one of `matched` (one entity, confidence attached), `ambiguous` (several plausible entities, see `candidates`) or `no_match` (the register answered and holds nothing by that name or number).

A real matched record, the second prefilled query (empty fields shortened):

```json
{
  "type": "record", "query": "C 10", "jurisdiction": "mt", "register": "mt", "searched_by": "number",
  "status": "matched", "charged": true, "charged_event": "registry_record", "confidence": 100,
  "registration_id": "C10", "legal_name": "BALLUT BLOCKS LIMITED", "english_name": null,
  "legal_form": "Limited Liability Company - Private Exempt Single Member",
  "entity_status": "active", "entity_status_raw": "Active",
  "registration_date": "1965-04-23", "dissolution_date": null,
  "country": "Malta", "country_code": "MLT", "state": null, "city": "NAXXAR",
  "street_name": null, "street_number": null, "building": "WIED FILEP", "postal_code": null, "po_box": null,
  "display_address": "WIED FILEP, NAXXAR, MALTA",
  "officers": [], "filings": [], "candidates": [],
  "source_register": "Malta (Malta Business Registry open data)", "source_name": "mbr_open_data_mt",
  "source_url": "https://openapi.baros.mbr.mt/api/v1/companies/C%2010",
  "source_as_of": "2026-09-08", "source_mode": "mirror_names_live_numbers",
  "source_licence": "CC BY 4.0", "source_attribution": "Malta Business Registry (MBR) open data",
  "via": null, "message": null
}
```

The real summary item of the first prefilled query, a Europe search for `Nestle` (16 registers answered, 17 records, 3 matched, 1 ambiguous with a shortlist, 13 with no match, 13 seconds on a warm instance and about 30 on a cold one):

```json
{
  "type": "search_summary", "query": "Nestle", "jurisdiction": "europe", "scope": "europe",
  "status": "ok", "charged": true, "charged_event": "registry_search",
  "best_match": {"register": "ch", "status": "matched", "legal_name": "Nestlé AG", "english_name": "Nestlé Ltd.",
                 "registration_id": "CHE-105.909.036", "confidence": 100, "entity_status": "active",
                 "display_address": "Zugerstrasse 8, 6330 Cham, Switzerland", "via": "gleif", "...": "..."},
  "n_records": 17, "n_matched": 3, "n_ambiguous": 1, "n_candidates": 28,
  "jurisdictions_searched": ["bg", "ch", "cy", "ee", "fi", "fr", "gb", "ie", "lei", "lt", "lv", "mt", "ro", "rs", "si", "sk"],
  "jurisdictions_unavailable": [],
  "jurisdictions_skipped": ["be", "cz", "no", "pl", "se"],
  "elapsed_s": 13.11
}
```

The other two matches in that search were the LEI record of NESTLÉ S.A. in Vevey and THE NESTLE COMPANY LIMITED in Ireland (closed, registered 1965). France answered `ambiguous` with a shortlist of French entities named NESTLE, each with its SIREN. `via: "gleif"` on the Swiss record means GLEIF supplied the local number and the Swiss register was then asked by number.

`jurisdictions_skipped` are the number-only registers a name cannot be sent to. `jurisdictions_unavailable` are registers that did not answer within the search deadline: they may well hold the company, and a single-register query gives them the full 60 seconds.

Officers carry `name`, `title` and flags (`is_director`, `is_shareholder`, `is_psc`, `is_executive`). Filings carry the register's own filing type, date and description. Both are lists, kept as JSON in CSV exports. Export the dataset as JSON, CSV, Excel or XML, or read it through the Apify API.

### 💰 How much does a company registry lookup cost?

| Event | Price | When it fires |
|---|---|---|
| `registry_record` | **$0.005** | once per record with status `matched` or `ambiguous`, on a single-register query |
| `registry_search` | **$0.15** | once per query whose jurisdiction is a region or `all`, whatever it finds |
| Actor start | **none** | this Actor has no start event |
| No match, register unavailable, number-only register given a name, invalid input | **free** | |

The prices in this table are what the Apify Free and Bronze plans pay. On Silver and Gold both events cost less, applied automatically, and Platinum and Diamond pay the Gold price.

Region search (`registry_search`):

| Plan | Price per region search |
|---|---|
| Free and Bronze | $0.15 |
| Silver | $0.12 |
| Gold | $0.10 |

Matched record (`registry_record`):

| Plan | Price per matched record |
|---|---|
| Free and Bronze | $0.005 |
| Silver | $0.004 |
| Gold | $0.003 |

There is no Actor start fee and no platform-usage surcharge: the two events above are the whole bill. Every worked example below is therefore the whole figure, with nothing to add per run. Each is at the Free and Bronze prices, with Silver and Gold in parentheses:

- Three registration numbers looked up in three registers, all three found: 3 x $0.005 = **$0.015** (Silver $0.012, Gold $0.009).
- One name in one register that comes back `ambiguous` with a shortlist of 12 candidates: **$0.005** (Silver $0.004, Gold $0.003), one record with the shortlist inside it.
- One name in one register, nothing found: **$0.00** on every plan.
- One Europe search, whatever the outcome: **$0.15** (Silver $0.12, Gold $0.10).
- The prefilled input (one Europe search and one Malta number that matches): $0.15 + $0.005 = **$0.155** (Silver $0.124, Gold $0.103).
- A CRM list of 1,000 UK companies checked by company number, 940 found: 940 x $0.005 = **$4.70** (Silver $3.76, Gold $2.82).

A region search is priced as one unit of work because it queries every register in the region in parallel, GLEIF first, and merges the answers into one ranked shortlist. If you already know the country, a single-register query is cheaper and gives that register the full deadline. Set a spending limit on the run if you want a hard cap: the Actor stops before the next query once the limit is reached and marks any record it could not charge.

You can try the Actor on the Apify free plan, which includes monthly platform usage credit and needs no credit card.

### 🗺️ Which business registers can you search?

42 official registers in 31 countries plus GLEIF, generated from the service on 2026-09-11. Every one answers from the register itself or from a scheduled copy of its open-data file, and says which. `Key` is the value to pass as `jurisdiction`.

| Key | Register | Search by | Number example | Mode | Refresh | Officers | Owners | Filings | Licence |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `ar` | Argentina (Registro Nacional de Sociedades) | name or number | `30-54668997-9` | mirror | monthly | no | no | no | CC BY 4.0 |
| `au` | Australia (ABN Lookup, Australian Business Register) | name or number | `51 824 753 556` | live | live | no | no | yes | public record |
| `be` | Belgium (Crossroads Bank for Enterprises, KBO/BCE) | number only | `0403.170.701` | live | live | yes | no | yes | public record |
| `br` | Brazil (Receita Federal CNPJ register via public APIs) | number only | `33.000.167/0001-01` | live | live | yes | yes | no | public record |
| `bg` | Bulgaria (Commercial Register, Registry Agency) | name or number | `831642181` | live | live | yes | yes | no | public record |
| `ca` (also `ca_federal`, `ca_on`, `ca_qc`) | Canada (Canada's Business Registries search: federal, Ontario, Quebec) | name or number | `1234567` | live | live | no | no | yes | Open Government Licence - Canada |
| `ca_bc` | Canada, British Columbia (OrgBook BC) | name or number | `BC0123456` | live | live | no | no | yes | Open Government Licence - British Columbia |
| `cy` | Cyprus (Department of Registrar of Companies open data) | name or number | `HE 12345` | live | live | yes | no | no | CC BY 4.0 |
| `cz` | Czech Republic (ARES economic entities) | number only | `45274649` | live | live | no | no | no | public record |
| `ee` | Estonia (e-Business Register open data) | name or number | `10238429` | live | daily | no | no | no | CC BY 4.0 |
| `fi` | Finland (PRH/YTJ Business Information System open data) | name or number | `0112038-9` | live | live | no | no | no | CC BY 4.0 |
| `fr` | France (Recherche d'entreprises, INSEE Sirene) | name or number | `552032534` | live | live | yes | no | no | Licence Ouverte 2.0 |
| `gr` | Greece (General Commercial Registry, G.E.MI.) | name or number | `1037501000` | live | live | yes | yes | no | ODC-BY-1.0 |
| `in` | India (Ministry of Corporate Affairs data from public web sources) | number only | `L22210MH1995PLC084781` | live | live | yes | no | yes | public record |
| `ie` | Ireland (Companies Registration Office open data) | name or number | `104547` | live | live | no | no | yes | CC BY 4.0 |
| `il` | Israel (Registrar of Companies) | name or number | `516943180` | mirror | daily | no | no | no | public record |
| `jp` | Japan (NTA Corporate Number Publication Site) | name or number | `1180301018771` | live | live | no | no | no | Public Data Terms of Use v1.0 (公共データ利用規約 第1.0版) |
| `lv` | Latvia (Register of Enterprises open data) | name or number | `40003245752` | live | live | no | no | no | CC0 |
| `lt` | Lithuania (Register of Legal Entities, Registru centras) | name or number | `301844044` | live | live | no | no | no | CC BY 4.0 |
| `mt` | Malta (Malta Business Registry open data) | name or number | `C 10` | mirror for names, live for numbers | daily | no | no | no | CC BY 4.0 |
| `lei` | Global (GLEIF Legal Entity Identifier register) | name or number | `HWUPKR0MPOU8FGXBT394` | live | live | no | no | no | CC0 |
| `no` | Norway (Bronnoysund Register Centre, Enhetsregisteret) | number only | `923609016` | live | live | no | no | no | NLOD 2.0 |
| `pe` | Peru (SUNAT RUC register, padron reducido) | name or number | `20100113610` | mirror | monthly | no | no | no | ODC-BY |
| `pl` | Poland (National Court Register, KRS open API) | number only | `0000012345` | live | live | yes | no | yes | public record |
| `ro` | Romania (ANAF by CUI, ONRC trade register mirror for names) | name or number | `14399840` | mirror for names, live for numbers | every 14 days | no | no | no | CC BY 4.0 (ONRC open data), public record (ANAF) |
| `rs` | Serbia (Business Registers Agency, APR) | name or number | `17162543` | mirror | monthly | no | no | no | Serbian Open Data Licence |
| `sg` | Singapore (ACRA entities, data.gov.sg) | name only |  | live | live | no | no | no | Singapore Open Data Licence |
| `sk` | Slovakia (Register of Legal Entities, RPO) | name or number | `31333532` | live | live | yes | no | no | CC BY 4.0 |
| `si` | Slovenia (AJPES Business Register, PRS) | name or number | `5043611` | mirror | twice a month | no | no | no | CC BY 4.0 |
| `se` | Sweden (Bolagsverket, Valuable Datasets API) | number only | `556703-7485` | live | live | no | no | no | CC0 1.0 |
| `ch` | Switzerland (Zefix central business name index) | name or number | `CHE-105.909.036` | live | live | no | no | yes | OGD Open use. Must provide the source (opendata.swiss terms\_by) |
| `gb` (also `UK`, `gb_sct`, `uk`) | United Kingdom (Companies House) | name or number | `00000006` | live | live | yes | no | yes | OGL v3 |
| `us_ak` | United States, Alaska (Division of Corporations, Business and Professional Licensing) | name or number | `1127D` | mirror | weekly | no | no | no | public record |
| `us_co` | United States, Colorado (Secretary of State business entities) | name or number | `19981033526` | live | live | yes | no | yes | public record |
| `us_ct` | United States, Connecticut (Business Registry) | name or number | `1234567` | live | live | yes | no | yes | public record |
| `us_dc` | United States, District of Columbia (DLCP corporate registration) | name or number | `924244` | live | live | yes | no | yes | public record |
| `us_fl` | United States, Florida (Division of Corporations, Sunbiz) | name or number | `P12000012345` | mirror | weekly | yes | no | no | public record |
| `us_ia` | United States, Iowa (active business entities open dataset) | name or number | `153725` | mirror | weekly | yes | no | no | public record |
| `us_ny` | United States, New York (Department of State active corporations) | name or number | `69033` | live | live | no | no | yes | public record |
| `us_or` | United States, Oregon (Secretary of State active businesses) | name or number | `8739914` | live | live | yes | no | yes | public record |
| `us_pa` | United States, Pennsylvania (Department of State current registered businesses) | name or number | `139000` | live | live | yes | no | yes | public record |
| `us_tx` | United States, Texas (Comptroller franchise tax account status) | name or number | `0806671479` | live | live | yes | no | yes | public record |
| `us_va` | United States, Virginia (State Corporation Commission) | name or number | `11763213` | mirror | monthly | yes | no | no | public record |

Regions you can search as one query: `all` (All registers (search)), `europe` (Europe (search)), `americas` (Americas (search)), `asia_pacific` (Asia Pacific (search)), `us` (United States (search)).

`lei` is GLEIF, the global Legal Entity Identifier register: a worldwide name check that answers for LEI holders only (roughly 2.5 million entities, mostly companies that trade financial instruments) and returns their local registration number and register. A region search asks GLEIF first and then queries the registers it points to by number, which works even on registers that only accept numbers.

**Mode** tells you where the answer comes from. `live` queries the register on every lookup. `mirror` answers from a scheduled copy of the register's own open-data file, refreshed on the cadence in the `Refresh` column, and each record's `source_as_of` carries the snapshot date of that copy. A register that publishes only a names file answers names from the mirror and numbers from the register itself. Registers are added on request, and the table is generated from the live service, so it is always what the Actor can do today.

### 🔎 How the lookup works

1. The query goes to the register you named, or to every register in the region in parallel. Each register decides from its own number shape whether it received a number or a name.
2. A number is looked up directly. A name is matched with accent folding, legal-form normalization and token comparison against the register's search or its mirrored open-data file, and scored: one clear winner is `matched`, several plausible entities are `ambiguous` with the candidates listed, capped at `max_candidates`.
3. On a region search GLEIF is asked first. Every LEI holder by that name comes with its local registration number and register, and those become number lookups at the matching registers.
4. Answers are merged into one list, best first, and the same entity reached by name and by number is kept once.
5. Every record is returned with its register, the register's licence and attribution, the source URL and `as_of`: the day of the query for a live register, the snapshot date for a mirrored one.
6. A register that did not answer inside the deadline is listed under `jurisdictions_unavailable`, never folded into "not found". Nothing is estimated or inferred: every field on a record is the register's own value, and `confidence` scores the name match only.

### ⏱️ How long does a lookup take?

A single-register query answers in 1 to 20 seconds, depending on the register. A region search runs its registers in parallel under a 40 second deadline and returns what has answered by then (the Europe search above took 13 seconds). Each query has a 60 second wall-clock limit inside the Actor, and a transport failure or an upstream 5xx is retried once before it becomes an error item. Queries run one after another, so a run of 100 single-register lookups typically finishes in a few minutes.

### 🔌 Company registry API, clients and integrations

Run the Actor from the Apify Console, from the [Apify API](https://docs.apify.com/api/v2), from the Python or JavaScript client, from the Apify MCP server, or from Make, Zapier and n8n through the Apify integrations. Schedule it to re-check a vendor list weekly, and set a webhook on run completion to pull the dataset into your own system.

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("pvalyou/company-registry-lookup").call(run_input={
    "queries": [
        {"query": "0403.170.701", "jurisdiction": "be"},
        {"query": "Nestle", "jurisdiction": "europe"},
    ],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["type"], item.get("register"), item.get("status"), item.get("legal_name"), item.get("charged"))
```

### 🔐 Data, licences and privacy

- **Official registers only.** Every register in the table is queried through its public search, its public API, or the open-data file the register itself publishes. GLEIF is the worldwide LEI cross-reference. No data brokers, no aggregator databases, no scraped directories.
- **Licence and attribution per record.** `source_licence` and `source_attribution` carry the register's terms (Open Government Licence, CC BY 4.0, Licence Ouverte 2.0, CC0, public record and others). Keep the attribution when you republish.
- **Pass-through, no retained copy.** Each query is answered from the register and passed through to your run. The results live in your own Apify dataset, under your account's retention settings. No copy of the answers is retained on our side and no index of people is built from them. Operational logs keep the query text, the register key, timing and the billing outcome, which is what running and billing the service needs.
- **Officers and owners only where the register publishes them.** The `Officers` and `Owners` columns in the table say which registers do. Identifiers a register masks stay masked, and dates of birth appear only where the register prints them.
- **Personal data.** Officer and owner names are personal data that registers publish under company-law publicity. Use them only where you have a lawful basis (for KYB and due diligence this is usually legitimate interest) and in line with the laws of your jurisdiction. A person who wants a record corrected should ask the register that published it, which is the only place a correction takes effect. Objections about this Actor's processing can be raised through the Issues tab on this page.
- **No access controls bypassed.** No CAPTCHA solving, no logins, no credentials of yours. Robots directives are respected, and a register that asks us to stop is removed from the table.

### 🔗 Works well with

One company, five other questions, each sold on its own: [Company Enrichment API](https://apify.com/pvalyou/company-record) for the firmographics, classification and funding of the same company, [Website Liveness Check](https://apify.com/pvalyou/website-liveness-check) for whether its site is live, parked or redirected, [Job Postings](https://apify.com/pvalyou/job-postings) for the open roles on its own job board, [Patent Lookup](https://apify.com/pvalyou/patent-lookup) for its patents by applicant, and [LinkedIn Person Enrichment](https://apify.com/pvalyou/linkedin-person-enrichment) for the career records of the officers you find here.

### ❓ FAQ

#### Is the data live or cached?

Both, and each record says which. `source_mode` is `live` when the register was queried at the moment of your lookup and `mirror` when the answer came from a scheduled copy of the register's own open-data file. `source_as_of` is the date the answer describes: the day of the query for a live register, the snapshot date for a mirror.

#### Can I use it as a company registry API?

Yes. Every Actor on Apify is callable through the REST API, the Python and JavaScript clients and the MCP server, and can be scheduled or wired to Make, Zapier and n8n. See the snippet above.

#### What does a no-match mean, and does it cost anything?

`no_match` means the register answered and holds nothing by that name or number. It is free. Before concluding the company does not exist, check `jurisdictions_skipped` (number-only registers that a name cannot be sent to) and `jurisdictions_unavailable` (registers that did not answer in time).

#### Why is a register listed as unavailable?

It did not answer inside the deadline. Registers go slow, go offline for maintenance, or rate-limit callers. An unavailable register is not a "no": retry it as a single-register query, which gives it the full 60 seconds, and nothing is charged for the unavailable answer.

#### Do you return officers, directors and beneficial owners?

Where the register publishes them, yes: the `Officers` and `Owners` columns in the coverage table say which. Officers carry name, title and role flags. Personal identifiers that a register masks stay masked.

#### Is it legal to use, and what about GDPR?

The records are public registry data published by the registers under the licences shown on each record. Keep the attribution when you republish. Officer names are personal data under laws such as the GDPR, so use them only where you have a legitimate reason and in line with the laws of your jurisdiction. The Data, licences and privacy section above describes what the Actor does and does not do with the data.

#### Is the record a certified extract?

No. This is not a certified extract. For legal proof order the extract from the register itself. The `source_url` on each record points to the register's own page or API for that entity, which is where to start.

#### Why did a name search return nothing for a country I expected?

Some registers publish numbers only, with no name search. They are marked `number only` in the table, they appear under `jurisdictions_skipped` on a region search, and a name sent to one directly comes back as an uncharged error item. Use GLEIF (`lei`) or a region search to find the number, then look it up by number.

#### Is there a free tier or a trial?

Every no-match and every unavailable register is free, and Apify's free plan credit covers the first paid lookups. There is no subscription: you pay per matched record or per region search and nothing else.

#### How fresh are mirrored registers?

The `Refresh` column gives the cadence, from daily to monthly depending on how often the register publishes its file, and `source_as_of` on each record gives the exact snapshot date, so you always know how old the answer is.

### 📏 Limits

- A query is at most 200 characters, and each query has a 60 second wall-clock deadline inside the Actor.
- A region search runs under a 40 second deadline and reports registers that missed it as unavailable.
- `max_candidates` is at most 50 per query, across every register searched.
- Queries run one after another. Exact duplicates (same text, same register) within one run are collapsed.
- The run's spending limit is honoured: the Actor stops before the next query once it is reached.

### 💬 Support and feedback

Found a register that answered wrong, or one you need that is not in the table? Open an issue on this Actor's page with the query, the register and what you expected. Issues are answered by the developer, and registers are added by request.

### 📝 Changelog

- **0.1 update (2026-09-11)** Region search lowered to $0.15, and both events are now cheaper on Apify's Silver and Gold plans: $0.12 and $0.10 per region search, $0.004 and $0.003 per matched record. README: status badge at the top, a five-step how-to, a price table per plan, and cost examples recomputed at the new prices.
- **0.1 (2026-09-08)** First public release: 40 official registers in 30 countries plus GLEIF, region searches (`all`, `europe`, `americas`, `asia_pacific`, `us`), two priced events, no start fee.

# Actor input Schema

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

One lookup per row: a company name or a registration number, and where to look. Pick one register to get its records ($0.005 per matched record), or a region or 'All registers' to search every register in it at once ($0.15 per search, best matches first, at most 50 candidates).

## `max_candidates` (type: `integer`):

How many shortlist candidates a query may return in total, across every register it searched. Ambiguous names come back as a ranked shortlist rather than a guess.

## Actor input object example

```json
{
  "queries": [
    {
      "query": "Nestle",
      "jurisdiction": "europe"
    },
    {
      "query": "C 10",
      "jurisdiction": "mt"
    }
  ],
  "max_candidates": 50
}
```

# Actor output Schema

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

Every item of the run with every field it carries: register records, error items and search summaries.

## `records` (type: `string`):

Every item of the run, shown as the record columns: register, status, confidence, legal name, registration number, entity status, dates, snapshot date, source URL, the licence the register publishes under, the attribution it requires, charged. A view picks the columns and never drops rows, so search summaries and error items are in this table too, with the record columns they do not carry left blank.

## `summaries` (type: `string`):

Every item of the run, shown as the search-summary columns: registers answered, matched, ambiguous and skipped, and the single best match with its name, number, status, licence and attribution. A view picks the columns and never drops rows, so record rows and error items are in this table too, with the summary columns left blank.

# 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": [
        {
            "query": "Nestle",
            "jurisdiction": "europe"
        },
        {
            "query": "C 10",
            "jurisdiction": "mt"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("pvalyou/company-registry-lookup").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": [
        {
            "query": "Nestle",
            "jurisdiction": "europe",
        },
        {
            "query": "C 10",
            "jurisdiction": "mt",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("pvalyou/company-registry-lookup").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 '{
  "queries": [
    {
      "query": "Nestle",
      "jurisdiction": "europe"
    },
    {
      "query": "C 10",
      "jurisdiction": "mt"
    }
  ]
}' |
apify call pvalyou/company-registry-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,pvalyou/company-registry-lookup"
        }
    }
}

```

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/nh5v7WU0pVumzApNq/builds/pFlnLprZBKNStm3am/openapi.json