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

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 { createVerifier } from '@openeudi/core';

// Initialisation en mode DEMO - aucun identifiant requis
const verifier = createVerifier({
  mode: 'demo', // 'demo' | 'mock' | 'production'
});

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

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

const session = await verifier.createSession({
  attributes: ['age_over_18'],
  // La conformité pays est gérée par votre configuration marchand
  // (liste blanche/liste noire) - elle n'est pas demandée à l'utilisateur
});

// session.qrCode contient une data URL pour l'image du QR code
// session.sessionId est l'identifiant unique de session
// session.deepLink sert aux flux mobile-vers-mobile

Le tableau attributes précise ce que vous souhaitez vérifier. eIDAS Pro est conçu autour d'attributs booléens privacy-first : vous obtenez une réponse oui/non, jamais des données personnelles brutes.

La conformité pays (quels pays sont autorisés) se configure dans vos paramètres marchand sous forme de liste blanche ou noire. Le SDK applique ensuite cette logique automatiquement, sans demander de données personnelles à l'utilisateur.

Note : en mode DEMO, les attributs renvoient des données synthétiques. En mode PRODUCTION, le portefeuille prouve cryptographiquement le booléen sans révéler la date de naissance sous-jacente.

Étape 4 : afficher le QR code

La session inclut un QR code que l'utilisateur scanne avec son application portefeuille EUDI.

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

// En React
function VerificationQR({ session }) {
  return <img src={session.qrCode} alt="Scannez avec votre portefeuille EUDI" />;
}

// En Next.js (avec next/image)
import Image from 'next/image';
function VerificationQR({ session }) {
  return <Image src={session.qrCode} alt="Scannez avec votre portefeuille EUDI" width={256} height={256} />;
}

Étape 5 : écouter le résultat

// API orientée événements (recommandée pour les applications web)
session.onVerified((result) => {
  console.log('Vérification réussie !');
  console.log('Âge supérieur à 18 ans :', result.ageOver18);     // true
  console.log('Pays autorisé :', result.countryAllowed); // true (selon votre liste blanche)
  console.log('ID de session :', result.sessionId);
  console.log('Horodatage :', result.verifiedAt);
});

session.onFailed((error) => {
  console.log('Échec de la vérification :', error.reason);
  // 'timeout' | 'rejected' | 'invalid_credential' | 'network_error'
});

session.onExpired(() => {
  console.log('Session expirée - générez un nouveau QR code');
});

Ou utilisez l'API basée sur les promesses :

try {
  const result = await session.waitForResult({ timeout: 120000 }); // timeout de 2 min
  console.log('Vérifié :', result.ageOver18);
} catch (error) {
  console.log('Échec ou délai dépassé :', error.reason);
}

Exemple complet : route API Express.js

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

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

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

  res.json({
    sessionId: session.sessionId,
    qrCode: session.qrCode,
  });
});

// Vérifier l'état de la session (ou utiliser SSE pour le temps réel)
app.get('/api/verify/:sessionId', async (req, res) => {
  const status = await verifier.getSessionStatus(req.params.sessionId);
  res.json(status);
});

// Point 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 session = verifier.getSession(req.params.sessionId);

  session.onVerified((result) => {
    res.write(`data: ${JSON.stringify({ type: 'verified', result })}\n\n`);
    res.end();
  });

  session.onFailed((error) => {
    res.write(`data: ${JSON.stringify({ type: 'failed', error })}\n\n`);
    res.end();
  });
});

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. Des données de vérification synthétiques sont renvoyées (age_over_18: true, countryAllowed: true)
4. Votre callback onVerified 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 (succès, échec, timeout)
• Ajoutez le plugin WooCommerce à votre boutique WordPress pour la vérification au checkout
• Lisez la référence API pour la configuration avancée (style des QR codes, options de session, gestion des erreurs)
• Rejoignez les discussions GitHub pour signaler des problèmes ou proposer des fonctionnalités

Lorsque les portefeuilles EUDI seront lancés en décembre 2026, remplacez mode: 'demo' par mode: 'production' et ajoutez vos identifiants WRPAC, ou utilisez le service managé d'eIDAS Pro pour éviter la gestion des certificats.

---

OpenEUDI est sous licence MIT. Le SDK est actuellement en développement ; mettez le dépôt GitHub en favori pour être informé de la première publication.

Articles similaires

Présentation d'OpenEUDI : un SDK open source pour la vérification d'identité numérique européenne

Nous ouvrons le code de la bibliothèque de protocole qui alimente eIDAS Pro. OpenEUDI est un SDK TypeScript gratuit, sous licence MIT, pour intégrer la vérification via les portefeuilles EUDI dans n'importe quelle application web.

8 min de lecture

Comprendre OpenID4VP : le protocole derrière les portefeuilles d'identité numérique de l'UE

Une analyse technique approfondie d'OpenID4VP, le protocole que les portefeuilles EUDI utilisent pour partager des attributs vérifiés avec les entreprises. Comment il fonctionne, pourquoi il compte et comment OpenEUDI l'implémente.

12 min de lecture