Portefeuille EUDI vs KYC traditionnel : une comparaison pour les développeurs

Le dilemme du développeur

Vous devez vérifier l'identité des utilisateurs dans votre application. Jusqu'ici, cela signifiait généralement intégrer un fournisseur KYC, téléverser des documents, attendre une revue manuelle et gérer toute une série de cas limites. Avec l'arrivée des portefeuilles EUDI en décembre 2026, une nouvelle option apparaît.

Cette comparaison s'adresse aux développeurs qui doivent choisir entre le KYC traditionnel et la vérification via portefeuille EUDI, ou migrer de l'un vers l'autre.

Comparaison d'architecture

Flux KYC traditionnel

L'utilisateur téléverse un document -> Votre serveur -> API KYC -> File d'attente -> Revue IA/manuelle
                                                                                  ↓
                                                                      Résultat (minutes à jours)
                                                                                  ↓
                                                                      Webhook vers votre serveur

Flux portefeuille EUDI

Votre serveur génère un QR -> L'utilisateur scanne avec son portefeuille -> Le portefeuille authentifie
                                                                                  ↓
                                                                      VP cryptographique renvoyée
                                                                                  ↓
                                                                      Résultat (2 à 5 secondes)

Comparaison côte à côte

Effort d'intégration

KYC traditionnel (cas typique)

// 1. Créer une session de vérification
const session = await kycProvider.createSession({
  type: 'identity',
  country: 'DE',
  documentTypes: ['passport', 'id_card'],
  redirectUrl: 'https://yoursite.com/callback',
});

// 2. Rediriger l'utilisateur vers la page hébergée du fournisseur
redirect(session.url);

// 3. Traiter le webhook (asynchrone - minutes ou heures plus tard)
app.post('/webhooks/kyc', async (req, res) => {
  const event = verifyWebhookSignature(req.body, secret);

  if (event.type === 'verification.completed') {
    const result = await kycProvider.getResult(event.verificationId);

    // Vous avez maintenant : nom complet, date de naissance, images du document, selfie, adresse
    // Tout cela est de la PII que vous devez stocker, protéger et supprimer plus tard
    await db.users.update({
      kycStatus: result.status,
      kycData: encrypt(result.extractedData), // RGPD : stockage chiffré de PII
      kycDocuments: result.documentImages, // RGPD : politique de conservation des documents
    });
  }

  res.sendStatus(200);
});

Temps d'intégration : généralement 3 à 5 jours. Sans compter l'infrastructure webhook, la gestion des erreurs, la logique de retry et le stockage documentaire.

Portefeuille EUDI (SDK OpenEUDI)

import { createVerifier } from '@openeudi/core';

const verifier = createVerifier({ mode: 'demo' });

// 1. Créer une session de vérification
app.post('/api/verify', async (req, res) => {
  const session = await verifier.createSession({
    attributes: ['age_over_18'],
  });
  res.json({ qrCode: session.qrCode, sessionId: session.sessionId });
});

// 2. Point SSE pour le résultat en temps réel (secondes, pas heures)
app.get('/api/verify/:id/events', (req, res) => {
  res.setHeader('Content-Type', 'text/event-stream');
  const session = verifier.getSession(req.params.id);

  session.onVerified((result) => {
    // Vous recevez : { ageOver18: true, sessionId: '...', verifiedAt: '...' }
    // Pas de PII. Pas de documents. Pas d'obligation de stockage.
    res.write(`data: ${JSON.stringify(result)}\n\n`);
    res.end();
  });
});

Temps d'intégration : des heures, pas des jours. Pas d'infrastructure webhook. Pas de stockage de PII. Pas de gestion documentaire.

Traitement des données : la différence RGPD

C'est la différence la plus importante en pratique pour les développeurs.

KYC traditionnel : vous êtes responsable de traitement

Quand un fournisseur KYC vous envoie des résultats, vous recevez généralement :

• le nom légal complet
• la date de naissance
• le numéro du document
• les images du document (recto, verso)
• un selfie
• parfois l'adresse

Toutes ces informations sont des données personnelles au sens du RGPD. Vous devez :

• les chiffrer au repos et en transit
• définir et appliquer des durées de conservation
• répondre aux demandes d'accès des personnes concernées
• répondre au droit à l'effacement
• tenir un registre des traitements
• potentiellement mener une AIPD

Portefeuille EUDI : minimisation des données par conception

Avec OpenEUDI, vous ne demandez que ce dont vous avez besoin :

// Vérification d'âge : vous obtenez un booléen, pas une date de naissance
{ attributes: ['age_over_18'] }
// Résultat : { ageOver18: true }

// La conformité pays est gérée par votre configuration marchand
// en liste blanche/liste noire, pas par une demande d'attribut à l'utilisateur

Pas d'images de document. Pas de nom complet, sauf si vous le demandez explicitement. Pas d'obligation de conservation au-delà de vos propres besoins d'audit.

Cette architecture de confidentialité est imposée au niveau du protocole : le portefeuille affiche précisément ce qui est partagé, et l'utilisateur doit l'approuver.

Quand utiliser quoi

Stratégie de migration

Si vous avez déjà intégré un fournisseur KYC traditionnel, le chemin de migration est le suivant :

1. Ajouter le portefeuille EUDI comme option principale : installez OpenEUDI à côté de votre KYC existant
2. Détecter les utilisateurs européens : proposez la vérification par portefeuille aux clients UE, et le KYC traditionnel aux autres
3. Mesurer l'adoption : suivez la part d'utilisateurs UE qui disposent d'un portefeuille et l'utilisent
4. Réduire progressivement la dépendance : à mesure que l'adoption progresse, diminuez l'usage du KYC traditionnel pour les vérifications UE

Le SDK OpenEUDI et les fournisseurs KYC traditionnels peuvent coexister dans la même base de code. Il ne s'agit pas d'un remplacement brutal du jour au lendemain.

---

Le SDK OpenEUDI est sous licence MIT et gratuit. Pour la vérification en production avec des certificats WRPAC managés, consultez les offres managées d'eIDAS Pro.

Articles similaires

eIDAS vs KYC traditionnelle : analyse des coûts et de la conversion

Comparaison fondée sur les données entre la vérification basée sur eIDAS et les méthodes KYC traditionnelles, en analysant le coût total de possession, l'impact sur le taux de conversion et les projections de ROI à long terme pour les entreprises e-commerce.

10 min de lecture

Démarrage rapide du SDK OpenEUDI : votre première vérification en 5 minutes

Un tutoriel pas à pas pour installer le SDK OpenEUDI, créer une session de vérification et traiter le résultat, le tout en moins de 5 minutes avec le mode DEMO.

6 min de lecture