# crdc.be Belgium Number Provider Lookup (`mostafa-ennadi/crdc-be-belgium-number-provider-lookup`) Actor

Fast Belgian mobile operator lookup powered by crdc.be. Verify Belgian phone numbers, normalize formats, and detect operators such as Proximus, Orange, Base, Telenet, VOO, and more. Clean JSON output and ready for bulk checks.

- **URL**: https://apify.com/mostafa-ennadi/crdc-be-belgium-number-provider-lookup.md
- **Developed by:** [mostafa ennadi](https://apify.com/mostafa-ennadi) (community)
- **Categories:** Automation, Integrations, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 result returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## crdc.be Belgium Number Provider Lookup

**English / Français**

Fast Belgian number provider lookup powered by **crdc.be** through a backend API workflow.  
Look up Belgian phone numbers, normalize supported formats, and return the detected provider in clean JSON output.

Recherche rapide du fournisseur/opérateur d’un numéro belge via **crdc.be** avec un workflow basé sur une API backend.  
Vérifiez des numéros belges, normalisez les formats pris en charge et récupérez l’opérateur détecté dans une sortie JSON propre.

---

### English

#### Overview

This Actor checks Belgian phone numbers through a backend lookup API connected to **crdc.be**.  
It is designed for simple bulk processing in Apify without exposing the backend URL or API key to users.

The Actor sends each number to the backend, stores one result per number in the dataset, and generates a final summary in the Actor output.

#### What this Actor does

- Checks Belgian phone numbers using a **crdc.be-powered backend**
- Accepts multiple Belgian number formats
- Normalizes numbers to Belgian local format when possible
- Returns structured output for each processed number
- Supports bulk processing with a configurable safety limit
- Produces a final run summary

#### Supported input formats

Examples of accepted formats:

- `0493189190`
- `493189190`
- `32493189190`
- `+32493189190`
- `0032493189190`

#### Typical use cases

- Belgian telecom operator verification
- Phone number enrichment
- Lead validation
- Internal telecom checks
- Bulk provider lookup for Belgian numbers

#### How it works

1. The Actor reads the input list of numbers.
2. It removes empty values and duplicate entries.
3. It sends each number to the backend lookup API.
4. It stores one dataset item per processed number.
5. It writes a final summary to the Actor output.

#### Input

##### Example input

```json
{
  "numbers": [
    "0493189190",
    "+32493189190",
    "32493189190"
  ],
  "timeoutSec": 25,
  "maxNumbers": 100
}
````

##### Input fields

| Field | Type | Description |
|---|---|---|
| `numbers` | array | List of Belgian phone numbers to check |
| `timeoutSec` | integer | HTTP timeout per lookup request |
| `maxNumbers` | integer | Maximum number of numbers to process in one run |

#### Output

Each processed number produces one dataset item.

##### Example successful result

```json
{
  "success": true,
  "status": "ok",
  "message": "Provider found",
  "input_number": "0493189190",
  "normalized_number": "0493189190",
  "provider": "Proximus",
  "captcha_used": true,
  "duration_sec": 1.78,
  "_http_status": 200
}
```

##### Example not found result

```json
{
  "success": true,
  "status": "not_found",
  "message": "Provider not found",
  "input_number": "0493000000",
  "normalized_number": "0493000000",
  "provider": null,
  "captcha_used": true,
  "duration_sec": 1.81,
  "_http_status": 200
}
```

##### Example timeout result

```json
{
  "success": false,
  "status": "upstream_timeout",
  "message": "Backend request timed out",
  "input_number": "0493189190",
  "normalized_number": null,
  "provider": null,
  "captcha_used": null,
  "duration_sec": null,
  "_http_status": 504
}
```

#### Status values

Common status values returned by the Actor or backend include:

- `ok` – provider found successfully
- `not_found` – no provider returned for the number
- `bad_request` – invalid input format
- `unauthorized` – backend rejected the request
- `upstream_timeout` – backend request timed out
- `network_error` – connection problem while calling the backend
- `invalid_response` – backend returned an unexpected response
- `error` – unexpected processing failure

#### Run summary output

At the end of the run, the Actor also writes a summary output like:

```json
{
  "success": true,
  "processed": 3,
  "ok_count": 2,
  "not_found_count": 1,
  "error_count": 0,
  "message": "Actor finished successfully"
}
```

#### Notes

- This Actor is based on a backend API workflow, not a direct browser workflow
- Users do not need to configure the backend URL or backend API key in input
- Large runs should be tested gradually before scaling up

#### Limitations

- Results depend on the current behavior of the backend lookup service
- The upstream source may change at any time
- Some numbers may return `not_found` or timeout depending on upstream conditions

#### Changelog

##### 0.1

- Initial Apify Actor release
- Bulk Belgian number provider lookup
- Clean dataset output
- Summary output per run

***

### Français

#### Présentation

Cet Actor vérifie des numéros de téléphone belges via une API backend connectée à **crdc.be**.\
Il est conçu pour un traitement simple en masse sur Apify, sans exposer l’URL du backend ni la clé API aux utilisateurs.

L’Actor envoie chaque numéro à l’API de recherche, enregistre un résultat par numéro dans le dataset, puis écrit un résumé final dans la sortie de l’Actor.

#### Ce que fait l’Actor

- Vérifie des numéros belges via un **backend alimenté par crdc.be**
- Accepte plusieurs formats de numéros belges
- Normalise les numéros au format local belge quand c’est possible
- Retourne une sortie structurée pour chaque numéro traité
- Permet le traitement en masse avec une limite de sécurité configurable
- Produit un résumé final du run

#### Formats d’entrée pris en charge

Exemples de formats acceptés :

- `0493189190`
- `493189190`
- `32493189190`
- `+32493189190`
- `0032493189190`

#### Cas d’usage

- Vérification de l’opérateur télécom belge
- Enrichissement de numéros de téléphone
- Validation de leads
- Contrôles télécom internes
- Recherche en masse du fournisseur pour des numéros belges

#### Fonctionnement

1. L’Actor lit la liste des numéros en entrée.
2. Il supprime les valeurs vides et les doublons.
3. Il envoie chaque numéro à l’API backend.
4. Il enregistre un élément de dataset par numéro traité.
5. Il écrit un résumé final dans la sortie de l’Actor.

#### Entrée

##### Exemple d’entrée

```json
{
  "numbers": [
    "0493189190",
    "+32493189190",
    "32493189190"
  ],
  "timeoutSec": 25,
  "maxNumbers": 100
}
```

##### Champs d’entrée

| Champ | Type | Description |
|---|---|---|
| `numbers` | array | Liste de numéros de téléphone belges à vérifier |
| `timeoutSec` | integer | Délai HTTP maximum par requête |
| `maxNumbers` | integer | Nombre maximal de numéros à traiter dans un run |

#### Sortie

Chaque numéro traité produit un élément dans le dataset.

##### Exemple de résultat réussi

```json
{
  "success": true,
  "status": "ok",
  "message": "Provider found",
  "input_number": "0493189190",
  "normalized_number": "0493189190",
  "provider": "Proximus",
  "captcha_used": true,
  "duration_sec": 1.78,
  "_http_status": 200
}
```

##### Exemple de résultat non trouvé

```json
{
  "success": true,
  "status": "not_found",
  "message": "Provider not found",
  "input_number": "0493000000",
  "normalized_number": "0493000000",
  "provider": null,
  "captcha_used": true,
  "duration_sec": 1.81,
  "_http_status": 200
}
```

##### Exemple de dépassement de délai

```json
{
  "success": false,
  "status": "upstream_timeout",
  "message": "Backend request timed out",
  "input_number": "0493189190",
  "normalized_number": null,
  "provider": null,
  "captcha_used": null,
  "duration_sec": null,
  "_http_status": 504
}
```

#### Valeurs possibles du statut

Les statuts courants retournés par l’Actor ou le backend sont :

- `ok` – fournisseur trouvé avec succès
- `not_found` – aucun fournisseur retourné pour ce numéro
- `bad_request` – format d’entrée invalide
- `unauthorized` – requête refusée par le backend
- `upstream_timeout` – délai dépassé côté backend
- `network_error` – problème de connexion vers le backend
- `invalid_response` – réponse inattendue du backend
- `error` – erreur de traitement non prévue

#### Résumé final du run

À la fin du run, l’Actor écrit aussi un résumé du type :

```json
{
  "success": true,
  "processed": 3,
  "ok_count": 2,
  "not_found_count": 1,
  "error_count": 0,
  "message": "Actor finished successfully"
}
```

#### Remarques

- Cet Actor utilise un workflow backend API, pas un navigateur direct
- Les utilisateurs n’ont pas besoin de configurer l’URL du backend ni la clé API dans l’entrée
- Il est préférable de tester progressivement avant de lancer de gros volumes

#### Limites

- Les résultats dépendent du comportement actuel du service backend
- La source amont peut changer à tout moment
- Certains numéros peuvent retourner `not_found` ou un timeout selon les conditions amont

#### Journal des versions

##### 0.1

- Première version de l’Actor Apify
- Recherche en masse du fournisseur pour des numéros belges
- Sortie dataset propre
- Résumé final par run

# Actor input Schema

## `numbers` (type: `array`):

List of Belgian phone numbers to check. Maximum 100 numbers per run.

## `timeoutSec` (type: `integer`):

HTTP timeout in seconds for each lookup request.

## `maxNumbers` (type: `integer`):

Maximum number of phone numbers to process from the input list. Maximum allowed value is 100.

## Actor input object example

```json
{
  "numbers": [
    "0493189190",
    "+32493189190"
  ],
  "timeoutSec": 25,
  "maxNumbers": 100
}
```

# Actor output Schema

## `summary` (type: `string`):

No description

## `datasetItems` (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 = {
    "numbers": [
        "0493189190",
        "+32493189190"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mostafa-ennadi/crdc-be-belgium-number-provider-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 = { "numbers": [
        "0493189190",
        "+32493189190",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("mostafa-ennadi/crdc-be-belgium-number-provider-lookup").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 '{
  "numbers": [
    "0493189190",
    "+32493189190"
  ]
}' |
apify call mostafa-ennadi/crdc-be-belgium-number-provider-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=mostafa-ennadi/crdc-be-belgium-number-provider-lookup",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "crdc.be Belgium Number Provider Lookup",
        "description": "Fast Belgian mobile operator lookup powered by crdc.be. Verify Belgian phone numbers, normalize formats, and detect operators such as Proximus, Orange, Base, Telenet, VOO, and more. Clean JSON output and ready for bulk checks.",
        "version": "0.0",
        "x-build-id": "auDphxEqit2iBb9PQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mostafa-ennadi~crdc-be-belgium-number-provider-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mostafa-ennadi-crdc-be-belgium-number-provider-lookup",
                "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/mostafa-ennadi~crdc-be-belgium-number-provider-lookup/runs": {
            "post": {
                "operationId": "runs-sync-mostafa-ennadi-crdc-be-belgium-number-provider-lookup",
                "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/mostafa-ennadi~crdc-be-belgium-number-provider-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-mostafa-ennadi-crdc-be-belgium-number-provider-lookup",
                "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": [
                    "numbers"
                ],
                "properties": {
                    "numbers": {
                        "title": "Belgian phone numbers",
                        "type": "array",
                        "description": "List of Belgian phone numbers to check. Maximum 100 numbers per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "timeoutSec": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "HTTP timeout in seconds for each lookup request.",
                        "default": 25
                    },
                    "maxNumbers": {
                        "title": "Maximum numbers to process",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of phone numbers to process from the input list. Maximum allowed value is 100.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```