CompanyBelgium
Automatiser la vérification KYC avec l'API Company Belgium
API & Intégration
APIKYCAutomatisationIntégration

Automatiser la vérification KYC avec l'API Company Belgium

Découvrez comment automatiser vos processus de vérification KYC en intégrant l'API Company Belgium. Exemples de code, cas d'usage et guide d'intégration complet pour centres de domiciliation.

6 avril 202610 min de lecture

En bref

Les centres de domiciliation belges peuvent réduire de 80 % le temps consacré aux vérifications KYC en intégrant l'API REST de Company Belgium, qui donne accès direct aux données officielles de la BCE/KBO. En 2 secondes, l'API retourne le statut, l'adresse, la forme juridique, le numéro de TVA et les bénéficiaires effectifs d'une entreprise — contre 30 minutes de vérification manuelle. Chaque réponse est horodatée et archivable pour les audits AML/KYC requis par la loi du 18 septembre 2017.

Introduction : L'automatisation au service de la conformité

Les centres de domiciliation en Belgique font face à une multiplication des obligations KYC (Know Your Customer) dans le cadre de la lutte anti-blanchiment. La vérification manuelle de chaque client devient rapidement chronophage et source d'erreurs.

Company Belgium propose une solution technologique moderne : une API REST puissante qui permet d'automatiser l'ensemble de vos processus de vérification KYC en accédant directement aux données officielles de la BCE/KBO.

Dans cet article, nous vous guidons pas à pas pour intégrer l'API Company Belgium et réduire de 80% le temps consacré aux vérifications KYC.

Pourquoi automatiser la vérification KYC ?

⏱️ Gain de temps considérable

Une vérification manuelle d'une entreprise prend en moyenne 30 minutes :

  • Recherche sur le site BCE/KBO : 10 min
  • Vérification du registre UBO : 8 min
  • Validation de la TVA : 5 min
  • Consultation des établissements : 7 min

Avec l'API Company Belgium, cette vérification se fait en 2 secondes.

> 💡 Calcul d'impact : Pour un centre traitant 100 nouveaux clients/mois, c'est 50 heures économisées chaque mois, soit l'équivalent de 1,25 ETP !

✅ Fiabilité et conformité garanties

  • Données officielles : accès direct à la base BCE/KBO (mise à jour quotidienne)
  • Horodatage : chaque vérification est timestampée pour les audits
  • Traçabilité complète : historique de toutes les requêtes
  • Conformité RGPD : stockage sécurisé et durée de rétention conforme

🚀 Focus sur votre cœur de métier

Libérez vos équipes des tâches administratives répétitives pour qu'elles se concentrent sur :

  • L'accompagnement conseil aux clients
  • L'analyse de risque approfondie
  • La détection de signaux faibles
  • Le développement commercial

Architecture technique de l'intégration

Endpoints principaux pour le KYC

L'API Company Belgium expose plusieurs endpoints essentiels :

#### 1. Vérification d'entreprise

Code 
1
GET /api/companies/{enterpriseNumber}

Retourne toutes les informations officielles d'une entreprise :

  • Statut (actif/inactif)
  • Forme juridique
  • Adresse du siège social
  • Numéro de TVA
  • Date de création
  • Administrateurs

#### 2. Recherche UBO

Code 
1
GET /api/companies/{enterpriseNumber}/ubo

Accède au registre des bénéficiaires effectifs (si disponible publiquement).

#### 3. Vérification d'établissements

Code 
1
GET /api/companies/{enterpriseNumber}/establishments

Liste tous les établissements opérationnels de l'entreprise.

#### 4. Vérification Peppol

Code 
1
GET /api/peppol/check?vatNumber={vatNumber}

Vérifie si l'entreprise est enregistrée sur le réseau Peppol pour la facturation électronique.

Authentification sécurisée

L'API utilise un système de double clé pour garantir la sécurité :

JavaScript 
1
2
3
4
const headers = {
  class="code-string">'X-API-Key': class="code-string">'pk_live_votre_cle_publique',    class="code-comment">// Identifie votre application
  class="code-string">'X-API-Secret': class="code-string">'sk_live_votre_cle_secrete',  class="code-comment">// Authentifie la requête
};

> ⚠️ Sécurité : Ne jamais exposer la clé secrète côté client ! Utilisez-la uniquement côté serveur.

Guide d'intégration étape par étape

Étape 1 : Obtenir vos clés API

  • Créez un compte gratuit sur Company Belgium
  • Accédez à votre tableau de bord
  • Section "Clés API" → "Créer une nouvelle paire"
  • Conservez précieusement vos clés dans un gestionnaire de secrets (ex: Vault, AWS Secrets Manager)

    • Étape 2 : Installation du SDK (optionnel)

    Pour Node.js/TypeScript :

    Terminal 
    1
2
3
    npm install @company-belgium/sdk
# ou
pnpm add @company-belgium/sdk

    Pour Python :

    Terminal 
    1
    pip install company-belgium

    Étape 3 : Configuration initiale

    Node.js / TypeScript

    TypeScript 
    1
2
3
4
5
6
7
    import { CompanyBelgiumClient } from class="code-string">'@company-belgium/sdk';

const client = new CompanyBelgiumClient({
  publicKey: process.env.CB_PUBLIC_KEY,
  secretKey: process.env.CB_SECRET_KEY,
  environment: class="code-string">'production', class="code-comment">// ou class="code-string">'sandbox' pour les tests
});

    Python

    Python 
    1
2
3
4
5
6
7
    from company_belgium import Client

client = Client(
    public_key=os.getenv(class="code-string">'CB_PUBLIC_KEY'),
    secret_key=os.getenv(class="code-string">'CB_SECRET_KEY'),
    environment=class="code-string">'production'
)

    Étape 4 : Première vérification KYC

    Exemple complet en TypeScript

    TypeScript 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
    async function verifyNewClient(enterpriseNumber: string) {
  try {
    class="code-comment">// 1. Vérification de base
    const company = await client.companies.get(enterpriseNumber);
    
    class="code-comment">// 2. Contrôles de conformité
    const checks = {
      isActive: company.status === class="code-string">'AC',
      hasValidVAT: company.vatNumber !== null,
      hasAddress: company.addresses.length > 0,
      isNotBankrupt: company.status !== class="code-string">'ST',
      createdRecently: isWithinLastYear(company.startDate),
    };
    
    class="code-comment">// 3. Vérification du registre UBO (si nécessaire)
    let uboVerified = false;
    if (checks.isActive) {
      const ubo = await client.companies.getUBO(enterpriseNumber);
      uboVerified = ubo !== null && ubo.beneficiaries.length > 0;
    }
    
    class="code-comment">// 4. Vérification Peppol (bonus)
    const peppolRegistered = await client.peppol.check(company.vatNumber);
    
    class="code-comment">// 5. Génération du rapport KYC
    const kycReport = {
      enterpriseNumber,
      companyName: company.denomination,
      verificationDate: new Date().toISOString(),
      checks,
      uboVerified,
      peppolRegistered,
      riskLevel: calculateRiskLevel(checks),
      status: allChecksPassed(checks) ? class="code-string">'APPROVED' : class="code-string">'REVIEW_REQUIRED',
    };
    
    class="code-comment">// 6. Sauvegarde pour audit
    await saveKYCReport(kycReport);
    
    return kycReport;
    
  } catch (error) {
    console.error(class="code-string">'KYC verification failed:', error);
    throw new KYCVerificationError(error.message);
  }
}

class="code-comment">// Fonction auxiliaire
function calculateRiskLevel(checks: Checks): class="code-string">'LOW' | class="code-string">'MEDIUM' | class="code-string">'HIGH' {
  const passedChecks = Object.values(checks).filter(Boolean).length;
  const totalChecks = Object.values(checks).length;
  const ratio = passedChecks / totalChecks;
  
  if (ratio >= 0.9) return class="code-string">'LOW';
  if (ratio >= 0.7) return class="code-string">'MEDIUM';
  return class="code-string">'HIGH';
}

    Cas d'usage avancés

    Cas 1 : Onboarding automatisé

    Créez un workflow complet d'onboarding client :

    TypeScript 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
    async function automaticOnboarding(clientData: ClientData) {
  class="code-comment">// Étape 1 : Validation du numéro dclass="code-string">'entreprise
  if (!isValidBCENumber(clientData.enterpriseNumber)) {
    return { status: 'REJECTEDclass="code-string">', reason: 'Invalid BCE number formatclass="code-string">' };
  }
  
  class="code-comment">// Étape 2 : Vérification KYC via API
  const kycReport = await verifyNewClient(clientData.enterpriseNumber);
  
  class="code-comment">// Étape 3 : Décision automatique
  if (kycReport.status === 'APPROVEDclass="code-string">' && kycReport.riskLevel === 'LOWclass="code-string">') {
    class="code-comment">// Auto-approval : création du dossier client
    await createClientFile(clientData, kycReport);
    await sendWelcomeEmail(clientData.email);
    return { status: 'APPROVEDclass="code-string">', clientId: newClientId };
  }
  
  class="code-comment">// Étape 4 : Revue manuelle pour les cas complexes
  if (kycReport.riskLevel === 'HIGHclass="code-string">') {
    await notifyComplianceOfficer(kycReport);
    return { status: 'PENDING_REVIEWclass="code-string">', reason: 'High risk - manual review requiredclass="code-string">' };
  }
  
  class="code-comment">// Étape 5 : Demande de documents supplémentaires
  await requestAdditionalDocuments(clientData.email, kycReport.missingData);
  return { status: 'PENDING_DOCUMENTS' };
}

    Cas 2 : Surveillance continue (monitoring)

    Mettez en place une surveillance automatique de vos clients :

    TypeScript 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
    class="code-comment">// Cron job quotidien
async function dailyClientMonitoring() {
  const activeClients = await getActiveClients();
  
  for (const client of activeClients) {
    class="code-comment">// Vérifier les changements depuis la dernière vérification
    const changes = await client.companies.getChanges(
      client.enterpriseNumber,
      { since: client.lastVerificationDate }
    );
    
    if (changes.length > 0) {
      class="code-comment">// Analyse des changements significatifs
      const significantChanges = changes.filter(change => 
        [class="code-string">'status', class="code-string">'address', class="code-string">'administrators', class="code-string">'juridicalForm'].includes(change.field)
      );
      
      if (significantChanges.length > 0) {
        class="code-comment">// Alerte à lclass="code-string">'équipe compliance
        await notifyComplianceTeam({
          client,
          changes: significantChanges,
          urgency: 'MEDIUM',
        });
        
        class="code-comment">// Marquer pour revue KYC
        await flagForKYCReview(client.id);
      }
      
      class="code-comment">// Mise à jour de la date de dernière vérification
      await updateLastVerificationDate(client.id);
    }
  }
}

    Cas 3 : Vérification de masse (batch processing)

    Vérifiez plusieurs entreprises en parallèle :

    TypeScript 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
    async function batchVerification(enterpriseNumbers: string[]) {
  const results = await Promise.allSettled(
    enterpriseNumbers.map(num => verifyNewClient(num))
  );
  
  const report = {
    total: enterpriseNumbers.length,
    successful: results.filter(r => r.status === class="code-string">'fulfilled').length,
    failed: results.filter(r => r.status === class="code-string">'rejected').length,
    details: results.map((r, i) => ({
      enterpriseNumber: enterpriseNumbers[i],
      status: r.status,
      data: r.status === class="code-string">'fulfilled' ? r.value : null,
      error: r.status === class="code-string">'rejected' ? r.reason : null,
    })),
  };
  
  return report;
}

    Gestion des cas particuliers

    Entreprises inactives ou radiées

    TypeScript 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
    async function handleInactiveCompany(enterpriseNumber: string) {
  const company = await client.companies.get(enterpriseNumber);
  
  if (company.status === class="code-string">'ST') {
    class="code-comment">// Entreprise cessée : conserver les données historiques
    return {
      status: class="code-string">'INACTIVE',
      message: class="code-string">'Company ceased operations',
      retainData: true, class="code-comment">// Important pour la conformité AML
      lastActiveDate: company.endDate,
    };
  }
  
  if (company.status === class="code-string">'FA') {
    class="code-comment">// Faillite : alerter immédiatement
    await notifyComplianceOfficer({
      urgency: class="code-string">'HIGH',
      alert: class="code-string">'Client company declared bankrupt',
      enterpriseNumber,
    });
    
    return { status: class="code-string">'BANKRUPT', requiresAction: true };
  }
}

    Gestion des erreurs et retry logic

    TypeScript 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
    async function robustKYCVerification(enterpriseNumber: string, maxRetries = 3) {
  let attempt = 0;
  let lastError: Error;
  
  while (attempt < maxRetries) {
    try {
      return await verifyNewClient(enterpriseNumber);
    } catch (error) {
      lastError = error;
      attempt++;
      
      class="code-comment">// Backoff exponentiel
      if (attempt < maxRetries) {
        await sleep(Math.pow(2, attempt) * 1000);
      }
    }
  }
  
  class="code-comment">// Après tous les retries échoués
  await logFailedVerification(enterpriseNumber, lastError);
  throw new Error(class="code-string">`KYC verification failed after ${maxRetries} attempts`);
}

    Optimisations et bonnes pratiques

    1. Mise en cache intelligente

    TypeScript 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
    import Redis from class="code-string">'ioredis';

const redis = new Redis(process.env.REDIS_URL);

async function getCachedCompany(enterpriseNumber: string) {
  class="code-comment">// Vérifier le cache Redis
  const cached = await redis.get(class="code-string">`company:${enterpriseNumber}`);
  
  if (cached) {
    return JSON.parse(cached);
  }
  
  class="code-comment">// Sinon, appel API
  const company = await client.companies.get(enterpriseNumber);
  
  class="code-comment">// Mise en cache pour 24h
  await redis.setex(
    class="code-string">`company:${enterpriseNumber}`,
    86400,
    JSON.stringify(company)
  );
  
  return company;
}

    2. Rate limiting côté client

    TypeScript 
    1
2
3
4
5
6
7
8
9
10
11
12
    import pLimit from class="code-string">'p-limit';

class="code-comment">// Limiter à 10 requêtes simultanées
const limit = pLimit(10);

async function verifyClientList(clients: Client[]) {
  const promises = clients.map(client =>
    limit(() => verifyNewClient(client.enterpriseNumber))
  );
  
  return Promise.all(promises);
}

    3. Webhooks pour les notifications temps réel

    Configurez des webhooks pour être notifié des changements :

    TypeScript 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
    class="code-comment">// Sur votre serveur, endpoint pour recevoir les webhooks
app.post(class="code-string">'/webhooks/company-belgium', async (req, res) => {
  const { event, data } = req.body;
  
  class="code-comment">// Vérifier la signature du webhook
  if (!verifyWebhookSignature(req)) {
    return res.status(401).send(class="code-string">'Invalid signature');
  }
  
  switch (event) {
    case class="code-string">'company.updated':
      await handleCompanyUpdate(data);
      break;
    case class="code-string">'company.status.changed':
      await handleStatusChange(data);
      break;
  }
  
  res.status(200).send(class="code-string">'OK');
});

    Conformité et audit trail

    Conservation des preuves de vérification

    TypeScript 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
    interface KYCAuditLog {
  id: string;
  timestamp: Date;
  enterpriseNumber: string;
  apiResponse: any;
  verifiedBy: string;
  verificationResult: class="code-string">'APPROVED' | class="code-string">'REJECTED' | class="code-string">'REVIEW';
  riskLevel: class="code-string">'LOW' | class="code-string">'MEDIUM' | class="code-string">'HIGH';
}

async function saveAuditLog(verification: KYCAuditLog) {
  class="code-comment">// Stockage en base de données sécurisée
  await db.kycAuditLogs.insert({
    ...verification,
    createdAt: new Date(),
    retentionUntil: addYears(new Date(), 10), class="code-comment">// Conservation 10 ans
  });
  
  class="code-comment">// Backup chiffré pour les audits
  await s3.putObject({
    Bucket: class="code-string">'kyc-audit-logs',
    Key: class="code-string">`${verification.id}.json`,
    Body: JSON.stringify(verification),
    ServerSideEncryption: class="code-string">'AES256',
  });
}

    Tableau de bord et reporting

    Créez un dashboard pour suivre vos vérifications :

    TypeScript 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    async function getKYCDashboard(startDate: Date, endDate: Date) {
  const stats = await db.kycVerifications.aggregate([
    { $match: { createdAt: { $gte: startDate, $lte: endDate } } },
    {
      $group: {
        _id: class="code-string">'$verificationResult',
        count: { $sum: 1 },
        avgDuration: { $avg: class="code-string">'$duration' },
      },
    },
  ]);
  
  return {
    period: { start: startDate, end: endDate },
    totalVerifications: stats.reduce((sum, s) => sum + s.count, 0),
    approved: stats.find(s => s._id === class="code-string">'APPROVED')?.count || 0,
    rejected: stats.find(s => s._id === class="code-string">'REJECTED')?.count || 0,
    pending: stats.find(s => s._id === class="code-string">'REVIEW')?.count || 0,
    avgVerificationTime: calculateAverage(stats.map(s => s.avgDuration)),
  };
}

    Coûts et limites

    Plans tarifaires Company Belgium

    PlanRequêtes/moisPrixIdéal pour
    Gratuit1000€Tests et petits volumes
    Starter1 00029€/moisCentres démarrant
    Professional10 000149€/moisCentres établis
    EnterpriseIllimitéSur devisGros volumes

    > 💡 Calcul ROI : Si votre équipe facture 50€/h, économiser 30 min par vérification = 25€ d'économie. À partir de 6 vérifications/mois, le plan Starter est rentabilisé !

    Rate limits

    • Gratuit : 10 req/min
    • Starter : 60 req/min
    • Professional : 300 req/min
    • Enterprise : Sur mesure

    Migration depuis un système manuel

    Plan de migration en 4 phases

    Phase 1 : Pilote (Semaine 1-2)

    • Sélectionner 10-20 clients test
    • Vérification parallèle manuelle + API
    • Comparaison des résultats
    • Ajustement des paramètres

    Phase 2 : Déploiement progressif (Semaine 3-4)

    • 50% des nouveaux clients via API
    • Formation des équipes
    • Documentation interne

    Phase 3 : Généralisation (Mois 2)

    • 100% des nouveaux clients via API
    • Monitoring automatisé activé
    • Processus d'exception défini

    Phase 4 : Optimisation (Mois 3+)

    • Analyse des KPI
    • Automatisation des cas complexes
    • Intégration webhooks

    Support et ressources

    Documentation officielle

    Support technique

    • Email : support@companybelgium.be
    • Chat en direct : 9h-18h (jours ouvrables)

    Conclusion

    L'automatisation de la vérification KYC via l'API Company Belgium transforme radicalement votre processus de conformité :

    ✅ 80% de temps gagné sur les vérifications

    ✅ 100% de fiabilité avec les données officielles BCE/KBO

    ✅ Conformité garantie avec audit trail complet

    ✅ Scalabilité : de 10 à 10 000 vérifications/mois

    ✅ ROI immédiat dès les premières semaines

    Commencez dès aujourd'hui

  • Créez votre compte gratuit (100 requêtes/mois offertes)
  • Testez l'API en 5 minutes avec notre sandbox
  • Intégrez dans votre application en suivant ce guide
  • Déployez et économisez des centaines d'heures

    • > 🚀 Offre de lancement : Premier mois gratuit sur le plan Professional avec le code AUTOKYC2026

    Des questions ? Notre équipe est à votre disposition pour vous accompagner dans votre intégration.

    👉 Contactez-nous ou Réservez une démo

    ---

    Articles connexes :

    Questions fréquentes

    Comment automatiser la verification KYC d'une entreprise belge avec l'API BCE/KBO ?

    Via l'API Company Belgium, appelez successivement l'endpoint GET /api/companies/{numero} pour obtenir le statut, la forme juridique, l'adresse et le numéro TVA, puis GET /api/companies/{numero}/ubo pour accéder au registre UBO si disponible publiquement. Chaque réponse est horodatée. Vous pouvez ensuite calculer un niveau de risque automatiquement et déclencher une approbation immédiate, un passage en revue manuelle ou une demande de documents supplémentaires selon le résultat.

    La verification KYC via l'API BCE est-elle conforme a la loi belge anti-blanchiment du 18 septembre 2017 ?

    L'API Company Belgium accède aux données officielles de la BCE/KBO, qui constituent une source de référence reconnue pour la vérification d'identité des personnes morales. Pour être pleinement conforme à la loi du 18 septembre 2017, vous devez conserver un audit trail complet de chaque vérification avec horodatage, résultat et source, pendant une durée minimale de 10 ans. L'API fourni le timestamp et la traçabilité ; la conservation relève de votre système de gestion documentaire.

    Combien de temps prend une verification KYC automatisee vs manuelle pour un centre de domiciliation belge ?

    Une vérification manuelle prend en moyenne 30 minutes : 10 minutes de recherche sur le site BCE/KBO, 8 minutes pour le registre UBO, 5 minutes pour la validation TVA et 7 minutes pour les établissements. Avec l'API Company Belgium, la même vérification s'effectue en environ 2 secondes. Pour un centre traitant 100 nouveaux clients par mois, l'automatisation libère environ 50 heures de travail mensuel.

    Comment gerer les entreprises inactives ou en faillite dans un processus KYC automatise en Belgique ?

    L'API retourne le champ status pour chaque entreprise : AC signifie actif, ST signifie cessée, FA signifie faillite. Votre code KYC doit traiter ces cas spécifiquement. Pour une entreprise avec statut ST, conservez les données historiques pour la conformité AML (obligation de conservation 10 ans). Pour le statut FA, déclenchez une alerte immédiate vers l'équipe de conformité. La BCE/KBO conserve les données même des entreprises cessées, ce qui garantit la traçabilité.

    Prêt à commencer ?

    Créez votre compte gratuitement et obtenez vos clés API en quelques minutes.

    Commentaires

    Chargement des commentaires…

    Laisser un commentaire

    Non publié — sert uniquement à vous notifier.

    Les commentaires sont modérés avant publication.

    Articles similaires

    Belgian Crossroads Bank for Enterprises (BCE/KBO) API : documentation développeur complète en anglais

    Belgian Crossroads Bank for Enterprises (BCE/KBO) API : documentation développeur complète en anglais

    Documentation développeur en anglais pour l'API de la Banque-Carrefour des Entreprises belge. Vue d'ensemble du registre BCE/KBO, contexte légal, options d'accès, démarrage rapide avec exemples cURL et patterns d'intégration pour les développeurs internationaux.

    Rate limits, quotas et caching pour scaler une application BCE/KBO : architecture de référence

    Rate limits, quotas et caching pour scaler une application BCE/KBO : architecture de référence

    Votre app interroge l'API BCE/KBO en volume — comment éviter les 429, maîtriser les coûts et garantir la latence ? Architecture de référence avec cache à plusieurs niveaux, file de requêtes, observabilité et webhooks. Patterns concrets et chiffres à viser.

    BCE API endpoints reference : liste complète des routes REST (companies, addresses, NACE, UBO, établissements, Peppol)

    BCE API endpoints reference : liste complète des routes REST (companies, addresses, NACE, UBO, établissements, Peppol)

    Référence technique exhaustive des endpoints REST de l'API Company Belgium : recherche, fiche entreprise, adresses, activités NACE, établissements, dirigeants, UBO, vérification Peppol. Avec schémas de réponse, paramètres et codes d'erreur.

    Retour au blog