# Global Company Registry Lead Finder (`thescrapelab/global-company-registry-lead-finder`) Actor

Search public company registries across multiple countries and export normalized business records for lead generation, market research, compliance checks, and recurring company monitoring.

- **URL**: https://apify.com/thescrapelab/global-company-registry-lead-finder.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Categories:** AI, E-commerce, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.49 / 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Global Company Registry Lead Finder

Global Company Registry Lead Finder is an Apify company scraper that searches selected public company registry websites and exports matching business records as clean structured data. It works as a practical company registry scraper, business registry scraper, company lookup tool, and public company records monitor for teams that want repeatable company search results from public web pages.

### Company Registry Scraper for Public Business Records

This Actor searches selected public registry websites and returns normalized results that are ready for export from Apify. It is built for buyers who want a simple company data scraper that can help with business leads, new company leads, market research, and company registry monitor workflows without relying on private databases.

Version 1 supports selected public registries. More countries may be added over time.

### What This Actor Does

- Searches public company registry websites by keyword
- Extracts company names, company numbers, status, addresses, and source links where available
- Normalizes records across supported countries
- Marks records as new or changed across repeat runs
- Exports results to the Apify dataset

This makes it useful as a company search API workflow through Apify, a business registry scraper for public company records, and a company lookup tool for recurring lead generation or monitoring.

### Supported Countries

Version 1 currently supports these public registry sources:

- United Kingdom: Companies House
- United States: SEC EDGAR public filer data
- France: Annuaire des Entreprises / recherche-entreprises API
- Japan: National Tax Agency Corporate Number Publication Site
- Spain: OpenMercantil data derived from Spain's official BORME gazette
- Norway: Brønnøysund Register Centre Enhetsregisteret API
- Finland: Finnish PRH open data API
- Czech Republic: ARES public API
- Canada: Corporations Canada federal corporation search
- New Zealand: New Zealand Companies Register

The United States source covers SEC EDGAR filers such as public companies and other SEC-reporting entities. It is not a complete state-by-state registry of every US LLC or corporation.
The Spain source uses OpenMercantil data derived from Spain's official BORME gazette. It is useful for public gazette-backed company discovery, but it is not a complete Registro Mercantil extract.

### Who This Is For

- B2B sales teams
- Lead generation agencies
- Accountants
- Web design agencies
- Recruiters
- Market researchers
- Compliance teams
- Investors

### Use Cases

- Find new business leads
- Monitor company registry search results
- Build prospect lists
- Track companies matching a keyword
- Research companies in a market
- Export company registry data

### Input

The Actor keeps the input simple:

- `searchQueries`: one or more company names or business keywords you want to search for
- `countries`: one or more supported countries
- `maxResultsPerCountry`: how many matches to collect per country
- `includeInactive`: include dissolved, removed, cancelled, or inactive records when public pages expose them
- `onlyNew`: return only records not seen in earlier runs with the same company search history

Each search term is processed separately, and each output row keeps the specific `searchQuery` that produced it.

If no input is provided, the Actor runs a small smoke search for `AAPL` in `US` so the default run produces at least one SEC EDGAR record.

Common examples:

- `solar` in `GB` to find solar-related companies in the United Kingdom
- `AAPL` or `Apple` in `US` to find SEC EDGAR filer records
- `renault` in `FR` to find French enterprise records
- `Toyota` in `JP` to find Japanese corporate number records
- `telefonica` in `ES` to find Spanish BORME-derived records
- `equinor` in `NO` to find Norwegian organisation records
- `nokia` in `FI` to find Finnish PRH records
- `skoda` in `CZ` to find Czech ARES records
- `construction` in `GB` and `CA` to build a broader lead list
- `marketing` with `onlyNew=true` for a repeat-run monitoring workflow
- `restaurant` with `includeInactive=false` to focus on currently active public records

### Output

Each dataset item uses a normalized structure like this:

```json
{
  "companyName": "SOLAR LTD",
  "companyNumber": "11660911",
  "jurisdiction": "GB",
  "country": "United Kingdom",
  "registryName": "Companies House",
  "status": "Active",
  "companyType": "Private limited Company",
  "incorporationDate": "2018-11-05",
  "registeredAddress": "Latif House First Way, Wembley, London, Middlesex, United Kingdom, HA9 0JD",
  "industryCodes": ["35110 - Production of electricity"],
  "sourceUrl": "https://find-and-update.company-information.service.gov.uk/company/11660911",
  "searchQuery": "solar",
  "matchedKeyword": "solar",
  "isNew": true,
  "isChanged": false,
  "previousHash": null,
  "contentHash": "0a4a5a64a3a98dbb1dfd7eb2d1af0ee7e9ec61d5080aa27d48eaa62f4fe88975",
  "scrapedAt": "2026-05-13T14:00:00.000Z"
}
````

The Actor also saves a `RUN_SUMMARY` record in the key-value store. This makes the output more useful for recurring jobs, automations, and QA because you can quickly see:

- how many records were found
- how many were output after filters such as `onlyNew`
- how many were new, changed, or unchanged
- active vs inactive totals
- a country-by-country breakdown
- failed or skipped sources

You can export the dataset from Apify as JSON, CSV, or Excel-friendly formats after the run finishes.

### New Company Leads and Change Detection

The Actor stores seen records between runs and compares a stable content hash for each company or business record. That means repeat runs can help you spot:

- New company leads that were not seen before
- Changed records whose public registry details have changed
- Unchanged records that were already known

If you enable `onlyNew`, the dataset will contain only new records while the Actor still updates its persistent state in the background.

The Actor keeps its search history automatically so repeat runs can identify new or changed records.

### Python API Example

```python
from apify_client import ApifyClient

APIFY_TOKEN = "YOUR_APIFY_TOKEN"
ACTOR_ID = "YOUR_USERNAME/global-company-registry-lead-finder"

client = ApifyClient(APIFY_TOKEN)

run_input = {
    "searchQueries": ["solar", "construction"],
    "countries": ["GB"],
    "maxResultsPerCountry": 50,
    "includeInactive": False,
    "onlyNew": False,
}

run = client.actor(ACTOR_ID).call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Limitations

- This Actor searches public registry websites.
- It does not use private databases.
- It does not access pages requiring sign-in, payment, challenge pages, or special permission.
- Some registry websites may change layout or limit access.
- Supported countries are limited in version 1.
- Some fields may be missing because registry websites expose different information.

### Compliance Note

Users are responsible for using the exported data lawfully and in line with applicable rules, restrictions, and internal compliance requirements.

### FAQ

#### Does it support all countries?

No. Version 1 supports selected public registries in the United Kingdom, United States, France, Japan, Spain, Norway, Finland, Czech Republic, Canada, and New Zealand.

#### Does it use registry APIs?

No. This Actor uses public web pages only.

#### Can it find new companies?

It can help identify new matching records compared with earlier runs of the same search.

#### Can it monitor repeat searches?

Yes. Persistent state lets the Actor compare repeat runs and mark records as new or changed.

#### Can I export CSV, JSON, or Excel from Apify?

Yes. Once the run finishes, you can export the Apify dataset in the formats supported by Apify.

#### Why are some fields missing?

Registry websites do not all expose the same public fields, so some records may have `null` values for fields that are not publicly shown.

#### What does the run summary tell me?

The `RUN_SUMMARY` record shows totals, new vs changed vs unchanged counts, output counts after filtering, active vs inactive counts, and a country breakdown so repeat runs are easier to review.

### Business Registry Scraper for Repeatable Company Lookup

If you need a company registry scraper, business registry scraper, or company data scraper that helps surface public company records and new company leads from selected registries, this Actor gives you a simple commercial workflow through Apify.

Run the Actor with a keyword and country to start building a public company registry lead list.

# Actor input Schema

## `searchQueries` (type: `array`):

Enter one or more company names, ticker symbols, or business keywords such as AAPL, solar, construction, restaurant, AI, or marketing.

## `countries` (type: `array`):

Choose one or more supported countries. The default smoke run uses United States SEC EDGAR data so it returns at least one record quickly.

## `maxResultsPerCountry` (type: `integer`):

Maximum number of company records to collect per country.

## `includeInactive` (type: `boolean`):

Include dissolved, cancelled, removed, or other inactive records when the public registry shows them.

## `onlyNew` (type: `boolean`):

Return only records that were not seen in earlier runs of the same company search.

## Actor input object example

```json
{
  "searchQueries": [
    "AAPL"
  ],
  "countries": [
    "US"
  ],
  "maxResultsPerCountry": 50,
  "includeInactive": false,
  "onlyNew": false
}
```

# Actor output Schema

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

No description

## `resultsCsv` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

## `debugReport` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("thescrapelab/global-company-registry-lead-finder").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("thescrapelab/global-company-registry-lead-finder").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 '{}' |
apify call thescrapelab/global-company-registry-lead-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Global Company Registry Lead Finder",
        "description": "Search public company registries across multiple countries and export normalized business records for lead generation, market research, compliance checks, and recurring company monitoring.",
        "version": "0.1",
        "x-build-id": "3LCvi1u354rmrWLP7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thescrapelab~global-company-registry-lead-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thescrapelab-global-company-registry-lead-finder",
                "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/thescrapelab~global-company-registry-lead-finder/runs": {
            "post": {
                "operationId": "runs-sync-thescrapelab-global-company-registry-lead-finder",
                "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/thescrapelab~global-company-registry-lead-finder/run-sync": {
            "post": {
                "operationId": "run-sync-thescrapelab-global-company-registry-lead-finder",
                "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": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Company search",
                        "minItems": 1,
                        "maxItems": 25,
                        "type": "array",
                        "description": "Enter one or more company names, ticker symbols, or business keywords such as AAPL, solar, construction, restaurant, AI, or marketing.",
                        "items": {
                            "type": "string",
                            "minLength": 2,
                            "maxLength": 100
                        },
                        "default": [
                            "AAPL"
                        ]
                    },
                    "countries": {
                        "title": "Countries to search",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Choose one or more supported countries. The default smoke run uses United States SEC EDGAR data so it returns at least one record quickly.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "GB",
                                "US",
                                "FR",
                                "JP",
                                "ES",
                                "NO",
                                "FI",
                                "CZ",
                                "CA",
                                "NZ"
                            ],
                            "enumTitles": [
                                "United Kingdom",
                                "United States",
                                "France",
                                "Japan",
                                "Spain",
                                "Norway",
                                "Finland",
                                "Czech Republic",
                                "Canada",
                                "New Zealand"
                            ]
                        },
                        "default": [
                            "US"
                        ]
                    },
                    "maxResultsPerCountry": {
                        "title": "Matches per country",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of company records to collect per country.",
                        "default": 50
                    },
                    "includeInactive": {
                        "title": "Include inactive companies",
                        "type": "boolean",
                        "description": "Include dissolved, cancelled, removed, or other inactive records when the public registry shows them.",
                        "default": false
                    },
                    "onlyNew": {
                        "title": "Only show new companies",
                        "type": "boolean",
                        "description": "Return only records that were not seen in earlier runs of the same company search.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
