# Belgium CBE Company Registry Scraper (`automation-lab/belgium-cbe-company-registry-scraper`) Actor

Extract official Belgian CBE/KBO company records by enterprise number for B2B enrichment, KYB, legal-status checks, activities and officers.

- **URL**: https://apify.com/automation-lab/belgium-cbe-company-registry-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.05 / 1,000 item extracteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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/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

## Belgium CBE / KBO Company Registry Scraper

Extract structured company records from Belgium's official Crossroads Bank for Enterprises (CBE/KBO) public registry.

Turn known Belgian enterprise numbers into clean records for sales research, KYB checks, compliance workflows, and company-data enrichment.

### What does it do?

This actor visits the public CBE/KBO record page for each supplied Belgian enterprise number.

It returns one normalized company record per resolved enterprise.

The actor uses the official public registry page, not a third-party directory.

Every row keeps its official source URL and a retrieval timestamp.

### Who is it for?

- 🇧🇪 Belgian B2B sales teams enriching account lists.
- 🛡️ KYB and compliance teams verifying legal identity details.
- 📊 Data teams joining CBE facts to internal CRM records.
- 🏢 Researchers checking corporate status and legal form.
- 🔗 Automation builders who need repeatable registry lookups.

### Why use this CBE scraper?

A registry web page is useful for one manual lookup, but it is difficult to reuse in a spreadsheet or workflow.

This actor makes repeatable lookups exportable through an Apify dataset.

It preserves nested officers and NACE-BEL activity information when requested.

It also normalizes enterprise-number punctuation, so `0403227515` and `0403.227.515` work the same way.

### Official data source

The source is the public CBE/KBO search service operated by the Belgian FPS Economy.

Source domain: `https://kbopub.economie.fgov.be`.

Only public record pages are requested.

Use the source URL in every output row to review the original record.

### Data you receive

| Field | Description |
| --- | --- |
| `enterpriseNumber` | Ten-digit Belgian enterprise number |
| `status` | Public registry status |
| `legalState` | Public legal situation |
| `names` | Registered names shown by CBE/KBO |
| `registeredAddress` | Registered-office address when present |
| `entityType` | Entity classification |
| `legalForm` | Legal form |
| `establishmentCount` | Listed establishment-unit count |
| `officers` | Listed function holders, role and date |
| `activities` | Visible NACE-BEL activity codes |
| `sourceUrl` | Official CBE/KBO record URL |
| `retrievedAt` | ISO timestamp of extraction |

### How much does it cost to scrape Belgian CBE company records?

This actor uses pay-per-event pricing: a small one-time start event plus one event for each company record saved.

Per-record pricing is tiered by Apify subscription plan. The current published price is shown on the actor page before you run it.

You are charged only for records emitted to the dataset; unresolved enterprise numbers do not produce item events.

### Quick start

1. Add one or more Belgian enterprise numbers.
2. Keep the default maximum low for an inexpensive first run.
3. Run the actor.
4. Export the default dataset as JSON, CSV, Excel, or through the API.
5. Use `sourceUrl` when a reviewer needs to check an original record.

### Input: enterprise numbers

Enter ten-digit Belgian enterprise numbers in **Enterprise numbers**.

Punctuation is optional.

For example, both `0403227515` and `0403.227.515` resolve to the same official record.

Invalid or unavailable numbers are skipped without creating misleading partial data.

### Input: official record URLs

Advanced users can supply official `kbopub.economie.fgov.be` record URLs.

This is useful when a prior workflow already stores an official record link.

Only official CBE/KBO URLs are accepted.

Use enterprise numbers for the simplest and most stable workflow.

### Input: optional detail fields

**Include officers** controls extraction of the visible function-holder table.

**Include NACE-BEL activities** controls extraction of visible activity codes and descriptions.

Disable either option when you need a smaller, identity-focused payload.

`maxItems` limits the number of company rows emitted in one run.

### Output example

```json
{
  "enterpriseNumber": "0403227515",
  "status": "Active",
  "names": ["KBC Group", "KBC Groupe", "KBC Groep"],
  "legalForm": "Public limited company",
  "activities": [{"source":"VAT","code":"64.190"}],
  "sourceUrl": "https://kbopub.economie.fgov.be/...",
  "retrievedAt": "2026-07-11T00:00:00.000Z"
}
````

Fields unavailable in a public record may be omitted.

### NACE-BEL activities

NACE-BEL codes classify economic activities in Belgium.

Activity rows include the visible source category, code, and description.

The registry may display activity versions differently over time.

Treat output as a current public-record snapshot, not historical legal advice.

### Officers and roles

When enabled, `officers` contains visible function holders.

Each object contains the displayed role, name, and available since-date.

A person can appear more than once if the registry lists multiple roles.

Do not infer ownership, authority, or beneficial ownership from this field alone.

### Tips for data quality

Start with one known number to validate your downstream mapping.

Keep source URLs when importing to a CRM or compliance tool.

Deduplicate by `enterpriseNumber`, not company display name.

Use the latest retrieval timestamp when records are refreshed.

### Integrations

- 🔄 Send dataset rows to Make or Zapier after a run.
- 🧩 Join `enterpriseNumber` to a CRM account table.
- 📥 Export CSV for a sales-operations enrichment batch.
- 🔎 Use the source URL in a reviewer queue.
- 🗃️ Store snapshots in a warehouse for change monitoring.

### API usage: Node.js

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/belgium-cbe-company-registry-scraper')
  .call({ enterpriseNumbers: ['0403227515'] });
const items = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.items);
```

### API usage: Python

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/belgium-cbe-company-registry-scraper").call(
    run_input={"enterpriseNumbers": ["0403227515"]}
)
print(client.dataset(run["defaultDatasetId"]).list_items().items)
```

### API usage: cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~belgium-cbe-company-registry-scraper/runs?token=$APIFY_TOKEN" \
  -H 'content-type: application/json' \
  -d '{"enterpriseNumbers":["0403227515"]}'
```

### MCP

Use this actor through Apify MCP in Claude Desktop or Claude Code.

Add the server with `claude mcp add --transport http apify https://mcp.apify.com/?tools=automation-lab/belgium-cbe-company-registry-scraper`.

Claude Desktop JSON configuration:

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com/?tools=automation-lab/belgium-cbe-company-registry-scraper"}}}
```

Example prompt: “Look up Belgian enterprise number 0403227515 and return its legal form and NACE-BEL activities.”

Example prompt: “Enrich these Belgian enterprise numbers and give me a CSV-ready table.”

### Reliability and limits

The actor makes sequential official-page requests with a short delay.

This conservative approach is designed to be respectful of the public registry.

A registry page that does not contain a company record is skipped.

The actor does not guess identity details from partial search results.

### Legality and responsible use

CBE/KBO public-record access is subject to the source service's terms and applicable law.

You are responsible for your purpose, retention, and downstream use of data.

Do not use personal information for unlawful profiling or unsolicited outreach.

Check your compliance requirements before processing personal data.

### Troubleshooting

**Why did a number return no row?** Confirm it has ten digits and that an official public record is available.

**Why is a field missing?** The official record may not display that detail, or the optional detail toggle may be off.

**Why are officers repeated?** One person can hold multiple registry-listed functions.

**Why do names differ?** CBE/KBO may show multiple language variants of a registered name.

### Related scrapers

For other business-data workflows, browse actors from [Automation Lab](https://apify.com/automation-lab/).

Use this actor when the authoritative source is Belgium's CBE/KBO registry.

Use a country-specific registry actor for a different jurisdiction.

### FAQ

**Can I search by company name?** Version 0.1 focuses on reliable enterprise-number enrichment.

**Can I monitor changes?** Run recurring lookups and compare snapshots by enterprise number and retrieval time.

**Does it provide beneficial ownership?** No. It returns only visible public CBE/KBO record content.

**Can I export to CSV?** Yes. Apify datasets support CSV export after the run.

### Support

Include an enterprise number, run ID, and source URL when reporting an issue.

Do not include credentials or non-public personal data in support requests.

The source record can change independently of this actor.

Feedback on additional validated lookup modes is welcome.

# Actor input Schema

## `enterpriseNumbers` (type: `array`):

Belgian 10-digit enterprise/VAT numbers. Dots and spaces are accepted.

## `recordUrls` (type: `array`):

Optional official kbopub.economie.fgov.be record URLs.

## `maxItems` (type: `integer`):

Maximum company records to emit.

## `includeOfficers` (type: `boolean`):

Extract listed directors and other function holders.

## `includeActivities` (type: `boolean`):

Extract visible NACE-BEL activity codes and descriptions.

## Actor input object example

```json
{
  "enterpriseNumbers": [
    "0403227515"
  ],
  "recordUrls": [],
  "maxItems": 10,
  "includeOfficers": true,
  "includeActivities": true
}
```

# Actor output Schema

## `companies` (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 = {
    "enterpriseNumbers": [
        "0403227515"
    ],
    "recordUrls": [],
    "maxItems": 10,
    "includeOfficers": true,
    "includeActivities": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/belgium-cbe-company-registry-scraper").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 = {
    "enterpriseNumbers": ["0403227515"],
    "recordUrls": [],
    "maxItems": 10,
    "includeOfficers": True,
    "includeActivities": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/belgium-cbe-company-registry-scraper").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 '{
  "enterpriseNumbers": [
    "0403227515"
  ],
  "recordUrls": [],
  "maxItems": 10,
  "includeOfficers": true,
  "includeActivities": true
}' |
apify call automation-lab/belgium-cbe-company-registry-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/belgium-cbe-company-registry-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Belgium CBE Company Registry Scraper",
        "description": "Extract official Belgian CBE/KBO company records by enterprise number for B2B enrichment, KYB, legal-status checks, activities and officers.",
        "version": "0.1",
        "x-build-id": "bTFYr76nYTUorxfWg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~belgium-cbe-company-registry-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-belgium-cbe-company-registry-scraper",
                "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/automation-lab~belgium-cbe-company-registry-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-belgium-cbe-company-registry-scraper",
                "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/automation-lab~belgium-cbe-company-registry-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-belgium-cbe-company-registry-scraper",
                "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",
                "properties": {
                    "enterpriseNumbers": {
                        "title": "🏢 Enterprise numbers",
                        "type": "array",
                        "description": "Belgian 10-digit enterprise/VAT numbers. Dots and spaces are accepted.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "recordUrls": {
                        "title": "Official CBE record URLs",
                        "type": "array",
                        "description": "Optional official kbopub.economie.fgov.be record URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum companies",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum company records to emit.",
                        "default": 10
                    },
                    "includeOfficers": {
                        "title": "Include officers",
                        "type": "boolean",
                        "description": "Extract listed directors and other function holders.",
                        "default": true
                    },
                    "includeActivities": {
                        "title": "Include NACE-BEL activities",
                        "type": "boolean",
                        "description": "Extract visible NACE-BEL activity codes and descriptions.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```