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

Une comparaison technique entre la vérification via le portefeuille EUDI et le KYC traditionnel, du point de vue développeur : complexité API, latence, traitement des données et effort d'intégration.

Équipe eIDAS Pro
12 mars 2026
9 min de lecture

Rectifié le 20 octobre 2026 : une version précédente de cet article affirmait que le portefeuille EUDI renvoie un attribut age_over_18 et montrait un appel SDK qui n'existe pas. Le PID ne contient aucun attribut d'âge : le vérificateur demande la seule date de naissance et en déduit lui-même le oui/non ; age_over_18 n'existe que dans l'attestation de preuve d'âge, un justificatif distinct. Les exemples de code utilisent désormais l'API réelle de @openeudi/core. Nous avons aussi corrigé le prix du service managé (les offres démarrent à 79 €/mois, et non 49 €), précisé que la voie de production d'eIDAS Pro est aujourd'hui l'eID bancaire et que la vérification par portefeuille EUDI n'est pas encore disponible en production, et indiqué qu'OpenEUDI ne couvre que le flux en ligne, pas le flux de proximité/NFC.

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

AspectKYC traditionnelPortefeuille EUDI (OpenEUDI)
Temps de vérificationMinutes à 48 heures2 à 5 secondes
Effort utilisateurTéléversement de document, selfie, saisie manuelleScanner un QR, appuyer sur approuver
Données reçuesImages complètes du document, PII extraitesUniquement les attributs demandés (ex. la date de naissance pour un contrôle d'âge)
Données stockéesConservation requise pour la conformitéPas de stockage de PII nécessaire
Complexité APIREST + webhooks + pollingREST + SSE (temps réel)
Coût SDKPayant (par vérification)Gratuit (OpenEUDI est sous Apache-2.0)
Coût de productionFacturation par vérificationOffres managées à partir de 79 €/mois (eID bancaire disponible aujourd'hui ; portefeuille EUDI dès que les certificats WRPAC pourront être obtenus)
Vérification cryptographiqueVous faites confiance au fournisseur KYCVous vérifiez vous-même la signature de l'émetteur
Couverture transfrontalièreDépend du prestataireLes 27 États membres de l'UE
Base réglementaireConformité propre au prestataireRèglement UE 2024/1183
Charge RGPDÉlevée (vous stockez des PII)Faible (pas de rétention de PII)
Capacité hors ligneNonPrévu par la norme du portefeuille (flux de proximité/NFC) ; OpenEUDI ne couvre que le flux en ligne

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 { VerificationService, DemoMode, VerificationType } from '@openeudi/core';
import { generateQRCode } from '@openeudi/core/qr';

const service = new VerificationService({ mode: new DemoMode() });

// 1. Créer une session de vérification
app.post('/api/verify', async (req, res) => {
  const session = await service.createSession({ type: VerificationType.AGE });
  const qrCode = await generateQRCode(session.walletUrl);
  res.json({ qrCode, sessionId: session.id });
});

// 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 onVerified = (session, result) => {
    if (session.id !== req.params.id) return;
    // Vous recevez: { verified: true, ageVerified: true, ... }
    // Un oui/non dérivé, pas la date de naissance. Pas de documents.
    res.write(`data: ${JSON.stringify(result)}\n\n`);
    res.end();
    service.off('session:verified', onVerified);
  };
  service.on('session:verified', onVerified);
});

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 oui/non dérivé, pas la date de naissance
await service.createSession({ type: VerificationType.AGE });
// Résultat: { verified: true, ageVerified: 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

À partir du PID, le portefeuille ne communique qu'un attribut, la date de naissance, et le vérificateur la réduit à ce oui/non avant tout stockage. Un contrôle qui ne révèle jamais la date de naissance passe par l'attestation de preuve d'âge distincte (age_over_18), qui ne compte pour l'instant d'émetteurs en production qu'au Danemark.

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

Cas d'usageRecommandation
Vérification d'âge au moment du paiementPortefeuille EUDI - un seul attribut partagé, seul le oui/non est conservé
KYC complet pour une entrée en relation financièrePortefeuille EUDI pour les citoyens UE ; KYC traditionnel en solution de secours pour les non-Européens
Vérification au niveau du document (copies notariées, etc.)KYC traditionnel - le portefeuille EUDI ne fournit pas d'images de documents
Vérification en temps réel en présentielPortefeuille EUDI (flux de proximité/NFC — non couvert par OpenEUDI)
Contrôles automatisés à fort volumePortefeuille EUDI - plus rapide et moins cher à grande échelle
Clients hors UEKYC traditionnel - les portefeuilles EUDI sont limités à l'UE

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 Apache-2.0 et gratuit. Les offres managées d'eIDAS Pro démarrent à 79 €/mois : la vérification par eID bancaire est disponible dès aujourd'hui, et la vérification managée par portefeuille EUDI suivra dès que les certificats WRPAC pourront être obtenus.

Articles similaires

Partager cet article

Aidez les autres à en savoir plus sur la vérification eIDAS

Articles similaires

Technique

eu.europa.ec.av.1 expliqué : comment un vérificateur valide une attestation européenne de preuve d'âge avec la liste de confiance

L'application européenne de vérification d'âge remet à votre service un booléen signé dans l'espace de noms eu.europa.ec.av.1 — mais un booléen ne vaut que par la confiance accordée à celui qui l'a signé. Voici ce que contient cet espace de noms, et comment un vérificateur prouve que l'attestation est authentique grâce à l'Age Verification Trusted List.

8 min de lecture
Technique

Valider la preuve d'âge par rapport à la liste de confiance de l'UE : l'étape que tout le monde saute

Recevoir une attestation de preuve d'âge n'équivaut pas à lui faire confiance. Les recommandations relatives au vérificateur de l'UE imposent de valider chaque preuve d'âge par rapport à l'Age Verification Trusted List avant d'accorder l'accès. La Commission héberge déjà une liste de test dans l'environnement ACC du tableau de bord eIDAS — et ce n'est pas la même liste que celle des fournisseurs WRPAC.

9 min de lecture
Technique

Intégrer l'attestation de preuve d'âge de l'UE : guide du développeur sur l'espace de noms eu.europa.ec.av.1

L'émetteur de vérification d'âge de l'UE délivre une attestation « Proof of Age » au format mso_mdoc dans l'espace de noms eu.europa.ec.av.1, via OpenID4VCI. Voici ce que cet espace de noms contient réellement, comment fonctionne l'émission, et comment pointer votre intégration vers l'émetteur de référence en ligne — avec la réserve qu'il s'agit d'une référence, et non d'un point d'accès de production.

11 min de lecture