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.

Équipe eIDAS Pro
24 mars 2026
6 min de lecture

Rectifié le 20 octobre 2026 : une version antérieure de cet article listait des attributs de type age_over_18 et affirmait que le portefeuille prouve le booléen sans révéler la date de naissance. Le PID EUDI ne contient aucun attribut d'âge : le vérificateur demande la date de naissance et en déduit lui-même le oui/non. Les exemples de code correspondent désormais aussi à l'API publiée de @openeudi/core.

Prérequis

  • Node.js 20+ installé
  • Un projet TypeScript (ou JavaScript avec ESM)
  • Un terminal et votre éditeur préféré

C'est tout. Pas de clés API, pas d'inscription, pas de certificat WRPAC. Le mode DEMO fonctionne immédiatement.

Étape 1 : installer

npm install @openeudi/core

Ou avec votre gestionnaire de paquets préféré :

pnpm add @openeudi/core
yarn add @openeudi/core

Étape 2 : créer un vérificateur

import { VerificationService, DemoMode, InMemorySessionStore } from '@openeudi/core';

// Initialisation en mode DEMO — aucun identifiant nécessaire
const service = new VerificationService({
  mode: new DemoMode(),
  store: new InMemorySessionStore(), // optionnel : c'est le stockage par défaut
});

L'option mode contrôle le comportement du SDK :

ModeComportementCas d'usage
new DemoMode()Se termine automatiquement après 3 secondes (modifiable via delayMs)Démonstrations, showcases, landing pages
new MockMode()Simule les réponses du portefeuille avec des données configurablesTests d'intégration, pipelines CI/CD
Votre propre IVerificationModeVérification réelle avec des portefeuilles EUDI (OpenID4VP via @openeudi/openid4vp)Vérifications en direct (nécessite un WRPAC)

Étape 3 : créer une session de vérification

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

const session = await service.createSession({ type: VerificationType.AGE });

// session.id est l'identifiant unique de la session
// session.walletUrl est le lien OpenID4VP : à encoder en QR code ou à ouvrir sur mobile
// session.expiresAt indique l'expiration de la session (par défaut : 5 minutes)

Le champ type précise ce que vous souhaitez vérifier. eIDAS Pro est conçu autour de résultats booléens respectueux de la vie privée : votre code obtient une réponse oui/non, jamais des données personnelles brutes.

TypeChamps du résultatDescription
VerificationType.AGEageVerifiedL'utilisateur a-t-il 18 ans ou plus ?
VerificationType.COUNTRYcountry, countryVerifiedLe pays de l'utilisateur est-il autorisé ?
VerificationType.BOTHTous les champs ci-dessusÂge et pays dans une même session

La conformité pays (quels pays sont autorisés) se définit par session avec countryWhitelist ou countryBlacklist (pas les deux). Le SDK compare le pays de l'attestation à cette liste et renvoie countryVerified.

Note : en mode DEMO, les résultats sont synthétiques. Avec un vrai portefeuille, la réponse sur l'âge est déduite : le PID EUDI ne contient pas d'attribut age_over_18, le vérificateur demande donc uniquement la date de naissance (divulgation sélective), applique le seuil de 18 ans et ne conserve que ageVerified. Un oui/non sans aucune date de naissance nécessite l'attestation de preuve d'âge distincte (eu.europa.ec.av.1), que seul le Danemark délivre en production à ce jour.

Étape 4 : afficher le QR code

La walletUrl de la session devient un QR code que l'utilisateur scanne avec son application portefeuille EUDI.

// Nécessite la dépendance pair optionnelle : npm install qrcode
import { generateQRCode } from '@openeudi/core/qr';

const qrCodeUrl = await generateQRCode(session.walletUrl); // data URL PNG en base64

// Dans un contexte web
const img = document.createElement('img');
img.src = qrCodeUrl;
document.getElementById('qr-container').appendChild(img);

// Avec React
function VerificationQR({ qrCodeUrl }) {
  return <img src={qrCodeUrl} alt="Scan with your EUDI Wallet" />;
}

// Avec Next.js (via next/image)
import Image from 'next/image';
function VerificationQR({ qrCodeUrl }) {
  return <Image src={qrCodeUrl} alt="Scan with your EUDI Wallet" width={256} height={256} />;
}

Étape 5 : écouter le résultat

// API événementielle (recommandée pour les applications web)
service.on('session:verified', (session, result) => {
  console.log('Verification successful!');
  console.log('Verified:', result.verified);        // true
  console.log('Age verified:', result.ageVerified); // true
  console.log('Session ID:', session.id);
  console.log('Timestamp:', session.completedAt);
});

service.on('session:rejected', (session, reason) => {
  console.log('Verification rejected:', reason);
});

service.on('session:expired', (session) => {
  console.log('Session expired — generate a new QR code');
});

// L'expiration est détectée par un balayage : exécutez-le régulièrement
setInterval(() => service.cleanupExpired(), 60_000);

Ou lisez l'état de la session à la demande :

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

const current = await service.getSession(session.id);
if (current.status === VerificationStatus.VERIFIED) {
  console.log('Age verified:', current.result.ageVerified);
}

Exemple complet : route API Express.js

import express from 'express';
import { VerificationService, DemoMode, InMemorySessionStore, VerificationType } from '@openeudi/core';
import type { CompletedSession, VerificationResult } from '@openeudi/core';
import { generateQRCode } from '@openeudi/core/qr';

const app = express();
const service = new VerificationService({
  mode: new DemoMode(),
  store: new InMemorySessionStore(),
});

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

  res.json({
    sessionId: session.id,
    qrCodeUrl: await generateQRCode(session.walletUrl),
  });
});

// Consulter l'état de la session (ou utiliser SSE pour le temps réel)
app.get('/api/verify/:sessionId', async (req, res) => {
  const session = await service.getSession(req.params.sessionId);
  res.json({ status: session.status, result: 'result' in session ? session.result : null });
});

// Endpoint SSE pour les mises à jour en temps réel
app.get('/api/verify/:sessionId/events', (req, res) => {
  res.setHeader('Content-Type', 'text/event-stream');
  res.setHeader('Cache-Control', 'no-cache');
  res.setHeader('Connection', 'keep-alive');
  const { sessionId } = req.params;

  // Les événements concernent toutes les sessions : filtrez sur celle suivie par ce client
  const onVerified = (session: CompletedSession, result: VerificationResult) => {
    if (session.id !== sessionId) return;
    res.write(`data: ${JSON.stringify({ type: 'verified', result })}\n\n`);
    res.end();
  };
  const onRejected = (session: CompletedSession, reason: string) => {
    if (session.id !== sessionId) return;
    res.write(`data: ${JSON.stringify({ type: 'rejected', reason })}\n\n`);
    res.end();
  };

  service.on('session:verified', onVerified);
  service.on('session:rejected', onRejected);
  req.on('close', () => {
    service.off('session:verified', onVerified);
    service.off('session:rejected', onRejected);
  });
});

app.listen(3000, () => console.log('Server running on port 3000'));

Que se passe-t-il en mode DEMO ?

Quand vous exécutez ce code en mode DEMO :

  1. Un QR code est généré, visuellement identique à un vrai
  2. Après 3 secondes, la session se termine automatiquement
  3. Un résultat synthétique est renvoyé (verified: true, ageVerified: true)
  4. Votre écouteur session:verified est déclenché avec le résultat

Aucun portefeuille réel n'est impliqué. Vous pouvez ainsi construire et tester tout le flux UI et backend avant le lancement des portefeuilles EUDI.

Étapes suivantes

  • Passez au mode MOCK pour tester des réponses configurables (un résultat par défaut, ou des surcharges par session avec setSessionResult())
  • Ajoutez l'extension WooCommerce à votre boutique WordPress pour la vérification au moment du paiement
  • Lisez la référence API pour la configuration avancée (durée de vie des sessions, stockages de sessions personnalisés, gestion des erreurs)
  • Rejoignez les discussions GitHub pour signaler des problèmes ou proposer des fonctionnalités

Lorsque les portefeuilles EUDI seront lancés, remplacez new DemoMode() par un IVerificationMode de production construit sur @openeudi/openid4vp et vos identifiants WRPAC, ou utilisez le service managé d'eIDAS Pro pour éviter la gestion des certificats.


OpenEUDI est sous licence Apache-2.0 et publié sur npm ; mettez le dépôt GitHub en favori pour être informé des nouvelles versions.

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