EUDI Wallet vs. Traditional KYC: A Developer's Comparison

Corrected 20 October 2026: an earlier version of this post said the EUDI Wallet returns an age_over_18 attribute and showed an SDK call that does not exist. The PID carries no age attribute: the verifier requests the birth date alone and derives the yes/no itself; age_over_18 exists only in the separate proof-of-age attestation. The code samples now use the real @openeudi/core API. We also corrected the managed-service price (plans start at €79/month, not €49), made clear that eIDAS Pro's live production route today is bank eID while EUDI Wallet verification is not yet available in production, and noted that OpenEUDI covers the online flow only, not the proximity/NFC flow.

The Developer's Dilemma

You need to verify user identity in your application. Traditionally, that meant integrating a KYC provider — uploading documents, waiting for manual review, handling edge cases. With EUDI Wallets launching in December 2026, there's a new option.

This comparison is written for developers who need to choose between — or migrate from — traditional KYC to EUDI Wallet verification.

Architecture Comparison

Traditional KYC Flow

User uploads document → Your server → KYC API → Queue → AI/Manual review
                                                            ↓
                                              Result (minutes to days)
                                                            ↓
                                              Webhook to your server

EUDI Wallet Flow

Your server generates QR → User scans with wallet → Wallet authenticates
                                                            ↓
                                              Cryptographic VP sent back
                                                            ↓
                                              Result (2-5 seconds)

Side-by-Side Comparison

Integration Effort

Traditional KYC (Typical)

// 1. Create verification session
const session = await kycProvider.createSession({
  type: 'identity',
  country: 'DE',
  documentTypes: ['passport', 'id_card'],
  redirectUrl: 'https://yoursite.com/callback',
});

// 2. Redirect user to provider's hosted page
redirect(session.url);

// 3. Handle webhook (async — could be minutes or hours later)
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);

    // You now have: full name, DOB, document images, selfie, address
    // All of this is PII that you must store, protect, and eventually delete
    await db.users.update({
      kycStatus: result.status,
      kycData: encrypt(result.extractedData), // GDPR: encrypted PII storage
      kycDocuments: result.documentImages, // GDPR: document retention policy
    });
  }

  res.sendStatus(200);
});

Integration time: 3-5 days typical. Plus webhook infrastructure, error handling, retry logic, and document storage.

EUDI Wallet (OpenEUDI SDK)

import { VerificationService, DemoMode, VerificationType } from '@openeudi/core';
import { generateQRCode } from '@openeudi/core/qr';

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

// 1. Create verification session
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. SSE endpoint for real-time result (seconds, not hours)
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;
    // You receive: { verified: true, ageVerified: true, ... }
    // A derived yes/no, not the birth date. No documents.
    res.write(`data: ${JSON.stringify(result)}\n\n`);
    res.end();
    service.off('session:verified', onVerified);
  };
  service.on('session:verified', onVerified);
});

Integration time: Hours, not days. No webhook infrastructure needed. No PII storage. No document handling.

Data Handling: The GDPR Difference

This is the biggest practical difference for developers.

Traditional KYC — You're a Data Controller

When a KYC provider sends you verification results, you typically receive:

• Full legal name
• Date of birth
• Document number
• Document images (front, back)
• Selfie image
• Address (sometimes)

All of this is personal data under GDPR. You must:

• Encrypt it at rest and in transit
• Define and enforce retention policies
• Support data subject access requests (DSAR)
• Support right to erasure
• Maintain Records of Processing Activities (ROPA)
• Potentially conduct a DPIA

EUDI Wallet — Minimal Data by Design

With OpenEUDI, you request only what you need:

// Age verification: you get a derived yes/no, not the birth date
await service.createSession({ type: VerificationType.AGE });
// Result: { verified: true, ageVerified: true }

// Country compliance is handled by your merchant whitelist/blacklist
// configuration — not by requesting data from the user

From a PID, the wallet discloses one attribute — the birth date — and the verifier reduces it to that yes/no before anything is stored. A check that never reveals the birth date needs the separate proof-of-age attestation (age_over_18), which so far has production issuers in Denmark only.

No document images. No full names (unless you specifically request them). No storage obligation for the verification result beyond your own audit needs.

The privacy architecture is enforced at the protocol level — the wallet shows the user exactly what's being shared, and the user must approve.

When to Use Which

Migration Strategy

If you already have traditional KYC integrated, the migration path is:

1. Add EUDI Wallet as a primary option — Install OpenEUDI alongside your existing KYC
2. Detect EU users — Offer wallet verification to EU customers, traditional KYC to others
3. Measure adoption — Track what percentage of EU users have and use wallets
4. Gradually phase out — As wallet adoption grows, reduce reliance on traditional KYC for EU verifications

The OpenEUDI SDK and traditional KYC providers can coexist in the same codebase. You're not replacing one with the other overnight.

---

The OpenEUDI SDK is Apache-2.0-licensed and free. eIDAS Pro's managed plans start at €79/month: bank eID verification is live today, and managed EUDI Wallet verification follows once WRPAC certificates can be obtained.

Related Articles

eIDAS vs Traditional KYC: A Cost and Conversion Analysis

A data-driven comparison of eIDAS-based verification against traditional KYC methods, analyzing total cost of ownership, conversion rate impact, and long-term ROI projections for e-commerce businesses.

10 min read

OpenEUDI SDK Quickstart: Your First Verification in 5 Minutes

A step-by-step tutorial to install the OpenEUDI SDK, create a verification session, and handle the result — all in under 5 minutes using DEMO mode.

6 min read