Altersüberprüfung im Online-Gaming: Leitfaden zur eIDAS-Compliance

Korrigiert am 20. Oktober 2026: In einer früheren Fassung fragte der Beispielcode dieses Beitrags die Attribute age_over_18 und age_over_21 aus den PID der EUDI-Wallet ab. Die PID enthalten jedoch kein Altersattribut – der Prüfer fordert allein das Geburtsdatum an und leitet das Ja/Nein selbst ab. age_over_18 gibt es nur im separaten Altersnachweis (Proof-of-Age-Attestation), der im Produktivbetrieb bislang nur in Dänemark verfügbar ist. Entfernt haben wir außerdem Formulierungen, nach denen eIDAS Pro nationale Systeme wie ID Austria, MitID, Smart-ID, itsme oder BankID nativ unterstütze oder schon heute Spieler in allen 27 Mitgliedstaaten über eine Integration bediene: Unsere live genutzte Methode ist die Bank-eID (iDIN, Niederlande). Ebenfalls entfernt wurden unbelegte Bewertungen zur „Akzeptanz im Gaming“, die Aussage zu Antwortzeiten unter einer Sekunde und eine nicht belegbare Aussage über die regulatorische Erfahrung unseres Teams.

Die Regulierungslandschaft für Online-Glücksspiele

Die Online-Gaming- und Glücksspielbranche unterliegt einem der strengsten regulatorischen Rahmenwerke im E-Commerce. Im Gegensatz zum klassischen Einzelhandel, in dem Verstöße gegen die Altersprüfung meist zu Bußgeldern führen, stehen Glücksspielbetreiber vor existenziellen Risiken: Lizenzentzug, strafrechtliche Verfolgung von Führungskräften und dauerhafter Ausschluss aus lukrativen Märkten.

Ein solides Verständnis dieser Regulierungslandschaft ist für jeden Betreiber essenziell, der eine eIDAS-Integration prüft.

Wichtige Regulierungsbehörden und Anforderungen

Glücksspielkommission des Vereinigten Königreichs (UKGC)

Die UKGC gilt als globaler Maßstab in der Glücksspielregulierung. Seit 2019 müssen Betreiber Alter und Identität von Kunden prüfen, bevor Glücksspielangebote freigeschaltet werden - einschließlich kostenloser Spiele. Zentrale Anforderungen:

• Altersüberprüfung vor der ersten Einzahlung
• Erneute Verifizierung bei Änderungen der Kundendaten
• Prüfung der Mittelherkunft bei Spielern mit hohen Einsätzen
• Verpflichtende Anbindung an die Selbstausschlussdatenbank (GAMSTOP)
• Bei Verstößen drohen Geldstrafen von bis zu 11,6 Millionen Pfund sowie Lizenzentzug

Malta Gaming Authority (MGA)

Als zentrale Lizenzierungsbehörde für viele europäische Betreiber betreffen die MGA-Anforderungen Hunderte Plattformen:

• KYC-Verifizierung innerhalb von 72 Stunden nach Kontoerstellung
• Verstärkte Sorgfaltspflichten für Kunden mit erhöhtem Risiko
• Regelmäßige Compliance-Audits
• Mindestanforderungen an das Sicherheitsniveau der Identitätsprüfung
• Bußgelder von bis zu 500.000 EUR je Verstoß

Glücksspielstaatsvertrag (GlüStV 2021)

Mit der umfassenden Glücksspielreform in Deutschland wurden strenge Vorgaben eingeführt:

• Vollständige Identitätsprüfung vor der ersten Wette
• Monatliches Einzahlungslimit von 1.000 EUR pro Spieler (plattformübergreifend)
• Zwingende Integration der zentralen Sperrdatei (OASIS)
• Verpflichtende Pause von 5 Sekunden zwischen Wetten
• Automatische Warnhinweise zur Sitzungsdauer
• Bußgelder von bis zu 500.000 EUR zzgl. Lizenzentzug

Schwedische Glücksspielbehörde (Spelinspektionen)

Der regulierte schwedische Markt erfordert:

• BankID oder gleichwertige starke Authentifizierung
• Anbindung an das nationale Selbstausschlussregister (Spelpaus)
• Beschränkungen für Bonusangebote
• Strenge Werbevorgaben
• Bußgelder von bis zu 100 Millionen SEK (ca. 9 Millionen EUR)

Zeitdruck bei der Compliance-Umsetzung

Neue Vorschriften sehen häufig enge Umsetzungsfristen vor:

Betreiber benötigen daher eine Verifizierungsinfrastruktur, die sich schnell an neue Vorgaben anpassen lässt.

Warum Gaming eine verlässliche Altersverifizierung braucht

Über die reine Erfüllung gesetzlicher Vorgaben hinaus stehen Gaming-Plattformen vor Herausforderungen, die eine verlässliche Altersverifizierung zwingend machen:

Schutz Minderjähriger vor Glücksspielschäden

Glücksspielbezogene Probleme bei jungen Menschen geben zunehmend Anlass zur Sorge. Studien zeigen, dass Jugendliche zwei- bis viermal häufiger von problematischem Glücksspiel betroffen sind als Erwachsene. Die Branche hat daher eine ethische und regulatorische Pflicht, Minderjährigen den Zugang zu verwehren.

Herkömmliche Methoden zur Altersüberprüfung versagen in diesem Zusammenhang:

Einschränkungen bei der Kreditkartenprüfung: In vielen Jurisdiktionen gilt die Kreditkarte nicht als zulässiger Altersnachweis. Selbst wenn sie erlaubt ist, bleibt das Verfahren wegen gemeinsam genutzter Familienkarten und gestohlener Kartendaten unzuverlässig.

Schwächen bei Selbstangaben: Alters-Checkboxen und die manuelle Eingabe des Geburtsdatums lassen sich leicht umgehen. Aus Sicht der Aufsichtsbehörden sind diese Methoden für Glücksspiel ungeeignet.

Verzögerungen bei der Dokumentenprüfung: Online-Glücksspiel ist ein Echtzeitgeschäft. Spieler erwarten sofortigen Zugriff. Mehrtägige Prüfprozesse treiben Kunden zu unregulierten Anbietern.

Anforderungen an die finanzielle Integrität

Glücksspielbetreiber unterliegen AML-Vorgaben, die mit den Anforderungen an Finanzinstitute vergleichbar sind:

• Prüfung der Herkunft von Geldern bei hohen Einzahlungen
• Transaktionsmonitoring auf verdächtige Muster
• Meldepflichten für Transaktionen mit hohem Wert
• Aufbewahrung von Unterlagen zur Kundensorgfaltspflicht (in der Regel 5-7 Jahre)

Die eIDAS-Verifizierung liefert einen kryptografisch prüfbaren Nachweis, der AML-Anforderungen erfüllt und gleichzeitig ein sofortiges Kunden-Onboarding ermöglicht.

Marktzugangsanforderungen

Viele Jurisdiktionen machen bestimmte Verifizierungsstandards zur Voraussetzung für den Marktzugang:

Das sind nationale Systeme, die Betreiber direkt oder über einen Broker anbinden können. eIDAS Pro integriert sie heute nicht: Die live genutzte Verifizierungsmethode ist die Bank-eID über iDIN in den Niederlanden.

Einzigartige Herausforderungen für Gaming-Plattformen

Gaming-Plattformen stehen vor operativen Herausforderungen, die sie von anderen E-Commerce-Bereichen unterscheiden:

Hohe Volumen- und Echtzeitanforderungen

Ein großer Sportwettenanbieter kann beispielsweise Folgendes verarbeiten:

• Über 100.000 Neuanmeldungen während eines großen Turniers
• Über 1 Million aktive Sitzungen bei Spitzenereignissen
• Über 10.000 gleichzeitige Verifizierungsanfragen während Marketingkampagnen

Die Verifizierungsinfrastruktur muss diese Spitzen abfangen, ohne das Nutzererlebnis zu beeinträchtigen oder legitime Spieler in umsatzstarken Momenten zu blockieren.

Globale Spielerbasis mit lokalen Anforderungen

Eine einzelne Plattform kann Spieler aus mehr als 20 Jurisdiktionen bedienen, jeweils mit eigenen:

• Akzeptierten Verifizierungsmethoden
• Anforderungen an die Datenaufbewahrung
• Vorgaben zu Sprache und Barrierefreiheit
• Anbindungen an Selbstausschlussregister
• Anforderungen an Instrumente für verantwortungsvolles Spielen

Anforderungen an die 24/7-Verfügbarkeit

Im Gegensatz zum stationären Einzelhandel läuft Online-Glücksspiel rund um die Uhr. Verifizierungssysteme müssen Folgendes gewährleisten:

• 99,99 % Verfügbarkeit (weniger als 53 Minuten Ausfallzeit pro Jahr)
• Antwortzeiten von unter einer Sekunde
• Kontrolliertes Verhalten unter Last
• Geografische Redundanz für regionale Ausfälle

Betrugsdruck in Echtzeit

Gaming-Plattformen sehen sich mit ausgefeilten Betrugsmustern konfrontiert:

• Bonusmissbrauch durch mehrere Konten
• Match-Betting-Netzwerke
• Bot-Netzwerke zum Missbrauch von Werbeaktionen
• Identitätsdiebstahl zur Geldwäsche

Die Verifizierung muss den Spagat schaffen: reibungsloser Zugang für legitime Nutzer bei gleichzeitiger Abwehr hartnäckiger Betrugsversuche.

eIDAS für Gaming: Technische Integration

eIDAS bietet Gaming-Plattformen eine Verifizierungslösung, die branchenspezifische Herausforderungen gezielt adressiert. So setzen Sie sie effektiv um (der folgende Code ist eine illustrative Architekturskizze, nicht die eIDAS-Pro-API):

Architektur mit hohem Durchsatz

// Für Gaming optimierter Verifizierungsdienst
import { Redis } from 'ioredis';
import { EventEmitter } from 'events';

interface GamingVerificationConfig {
  maxConcurrentSessions: number;
  sessionTimeoutMs: number;
  retryAttempts: number;
  circuitBreakerThreshold: number;
}

class GamingVerificationService {
  private redis: Redis;
  private sessionPool: Map<string, VerificationSession>;
  private metrics: MetricsCollector;
  private circuitBreaker: CircuitBreaker;

  constructor(config: GamingVerificationConfig) {
    this.redis = new Redis({
      maxRetriesPerRequest: config.retryAttempts,
      enableReadyCheck: true,
      enableOfflineQueue: false // Fail fast under pressure
    });

    this.circuitBreaker = new CircuitBreaker({
      threshold: config.circuitBreakerThreshold,
      resetTimeout: 30000
    });
  }

  async createVerificationSession(
    playerId: string,
    requirements: VerificationRequirements
  ): Promise<SessionResponse> {
    // Circuit Breaker prüfen
    if (this.circuitBreaker.isOpen()) {
      throw new ServiceUnavailableError('Verification temporarily unavailable');
    }

    // Rate-Limiting pro Spieler
    const rateLimitKey = `verify:rate:${playerId}`;
    const attempts = await this.redis.incr(rateLimitKey);
    await this.redis.expire(rateLimitKey, 300); // 5 minute window

    if (attempts > 5) {
      throw new RateLimitError('Too many verification attempts');
    }

    // Sitzung mit Gaming-spezifischen Attributen erstellen
    const session = await this.createEidasSession({
      requestedAttributes: this.mapRequirementsToAttributes(requirements),
      minAge: requirements.minAge, // Schwellenwert wird serverseitig auf das Geburtsdatum angewendet
      returnUrl: `${config.baseUrl}/verification/callback`,
      metadata: {
        playerId,
        jurisdiction: requirements.jurisdiction,
        verificationLevel: requirements.level
      }
    });

    // Sitzung für schnellen Zugriff zwischenspeichern
    await this.redis.setex(
      `verify:session:${session.sessionId}`,
      600, // 10 minute TTL
      JSON.stringify(session)
    );

    this.metrics.increment('verification.sessions.created', {
      jurisdiction: requirements.jurisdiction
    });

    return session;
  }

  private mapRequirementsToAttributes(
    requirements: VerificationRequirements
  ): string[] {
    // Altersverifikation (für Gaming immer erforderlich). Die EUDI-PID kennen
    // kein Attribut age_over_18 / age_over_21: nur das Geburtsdatum anfordern
    // (selektive Offenlegung), das Ja/Nein serverseitig gegen minAge ableiten
    // und nur dieses Ergebnis behalten – nie das Datum selbst.
    const attributes: string[] = ['birthdate'];

    // Wohnsitzverifikation (rechtsraumabhängig). Die PID enthalten kein
    // is_eu_resident-Flag, und das Wohnsitzland ist optional – ein fehlender
    // Wert gilt daher als „nicht verifiziert“.
    if (requirements.verifyResidency) {
      attributes.push('address.country');
    }

    return attributes;
  }
}

Caching-Strategien für Spitzenlasten

Gaming-Plattformen können eIDAS-Verifizierungsergebnisse nutzen, um den Aufwand für erneute Verifizierungen zu reduzieren:

interface VerificationCache {
  playerId: string;
  verificationId: string;
  verifiedAt: Date;
  expiresAt: Date;
  attributes: VerifiedAttributes;
  jurisdiction: string;
  assuranceLevel: 'low' | 'substantial' | 'high';
}

class CachedVerificationService {
  private cache: Redis;
  private verificationService: GamingVerificationService;

  async getOrVerify(
    playerId: string,
    requirements: VerificationRequirements
  ): Promise<VerifiedAttributes> {
    // Zuerst den Cache prüfen
    const cacheKey = `verified:${playerId}:${requirements.jurisdiction}`;
    const cached = await this.cache.get(cacheKey);

    if (cached) {
      const verification: VerificationCache = JSON.parse(cached);

      // Prüfen, ob die zwischengespeicherte Verifikation die Anforderungen noch erfüllt
      if (this.validatesCachedResult(verification, requirements)) {
        this.metrics.increment('verification.cache.hit');
        return verification.attributes;
      }
    }

    this.metrics.increment('verification.cache.miss');

    // Neue Verifikation durchführen
    return this.performNewVerification(playerId, requirements);
  }

  private validatesCachedResult(
    cached: VerificationCache,
    requirements: VerificationRequirements
  ): boolean {
    // Ablaufzeit prüfen (rechtsraumabhängig)
    if (new Date() > cached.expiresAt) {
      return false;
    }

    // Prüfen, ob das Vertrauensniveau die Anforderungen erfüllt
    const assuranceLevels = { low: 1, substantial: 2, high: 3 };
    if (assuranceLevels[cached.assuranceLevel] <
        assuranceLevels[requirements.minAssuranceLevel || 'low']) {
      return false;
    }

    // Prüfen, ob alle erforderlichen Attribute vorhanden sind
    return requirements.requiredAttributes.every(
      attr => cached.attributes[attr] !== undefined
    );
  }
}

Echtzeitstatus mit WebSockets

Für bidirektionale Kommunikation setzen Gaming-Plattformen häufig auf WebSockets statt auf SSE:

// WebSocket-basierter Verifizierungsstatus
import { WebSocketServer, WebSocket } from 'ws';

class VerificationWebSocketHandler {
  private wss: WebSocketServer;
  private sessions: Map<string, WebSocket>;

  async handleConnection(ws: WebSocket, playerId: string) {
    // WebSocket-Verbindung authentifizieren
    const token = await this.validatePlayerToken(ws);
    if (!token) {
      ws.close(4001, 'Unauthorized');
      return;
    }

    ws.on('message', async (data) => {
      const message = JSON.parse(data.toString());

      switch (message.type) {
        case 'START_VERIFICATION':
          await this.handleStartVerification(ws, playerId, message);
          break;
        case 'CHECK_STATUS':
          await this.handleCheckStatus(ws, message.sessionId);
          break;
      }
    });
  }

  private async handleStartVerification(
    ws: WebSocket,
    playerId: string,
    message: StartVerificationMessage
  ) {
    try {
      const session = await this.verificationService.createVerificationSession(
        playerId,
        message.requirements
      );

      // Send QR code data immediately
      ws.send(JSON.stringify({
        type: 'VERIFICATION_STARTED',
        sessionId: session.sessionId,
        qrCodeData: session.qrCodeData,
        deepLink: session.deepLink,
        expiresAt: session.expiresAt
      }));

      // Subscribe to status updates
      this.subscribeToSession(session.sessionId, ws);

    } catch (error) {
      ws.send(JSON.stringify({
        type: 'VERIFICATION_ERROR',
        error: error.message
      }));
    }
  }

  private subscribeToSession(sessionId: string, ws: WebSocket) {
    // Redis Pub/Sub für Statusupdates
    this.redis.subscribe(`verification:${sessionId}`);

    this.redis.on('message', (channel, message) => {
      if (channel === `verification:${sessionId}`) {
        ws.send(JSON.stringify({
          type: 'VERIFICATION_UPDATE',
          ...JSON.parse(message)
        }));
      }
    });
  }
}

Länderspezifische Compliance-Matrix

Die EU-Mitgliedstaaten haben jeweils eigene nationale eID-Systeme. Ob eine Glücksspielaufsicht ein bestimmtes System für die Spielerverifizierung akzeptiert, ist unterschiedlich – klären Sie das mit Ihrer Lizenzbehörde. Die Tabelle dient nur der Orientierung und beschreibt keine Integrationen von eIDAS Pro (unsere heute live genutzte Methode ist die Bank-eID über iDIN in den Niederlanden). Die eIDAS-Niveaus sind Richtwerte.

Grenzüberschreitende Verifizierung

eIDAS ist auf grenzüberschreitende Verifizierung ausgelegt. Ein deutscher Staatsbürger mit Wohnsitz in Österreich könnte sich auf einer in Malta lizenzierten Plattform mit einer österreichischen eID verifizieren – sofern Betreiber und Aufsicht dieses System akzeptieren:

// Verarbeitung grenzüberschreitender Verifikation
interface CrossBorderVerification {
  playerNationality: string;      // DE - German citizen
  playerResidence: string;        // AT - Living in Austria
  operatorJurisdiction: string;   // MT - Malta licensed
  verificationCountry: string;    // AT - österreichische eID wird genutzt
}

async function handleCrossBorderVerification(
  context: CrossBorderVerification
): Promise<VerificationResult> {
  // Determine applicable regulatory requirements
  const regulations = await determineApplicableRegulations(
    context.operatorJurisdiction,
    context.playerResidence
  );

  // Passendes eID-Schema anhand der verfügbaren Wallets des Spielers auswählen
  const availableSchemes = await getAvailableSchemes(
    context.playerNationality,
    context.playerResidence
  );

  // Mit dem bevorzugten oder verfügbaren Schema des Spielers verifizieren
  const verification = await performVerification({
    scheme: availableSchemes[0],
    requestedAttributes: regulations.requiredAttributes,
    assuranceLevel: regulations.minAssuranceLevel
  });

  // Mit regulatorischem Kontext für Audits speichern
  await storeVerificationResult({
    ...verification,
    regulatoryContext: {
      applicableRegulations: regulations.ids,
      crossBorder: true,
      verificationScheme: availableSchemes[0]
    }
  });

  return verification;
}

Verantwortungsvolle Glücksspielintegration

Die eIDAS-Verifizierung lässt sich nahtlos in Funktionen für verantwortungsvolles Spielen integrieren:

Anbindung von Selbstausschlussregistern

interface SelfExclusionCheck {
  playerId: string;
  verifiedIdentity: VerifiedIdentity;
  jurisdiction: string;
}

async function performSelfExclusionChecks(
  check: SelfExclusionCheck
): Promise<SelfExclusionStatus> {
  const results: SelfExclusionResult[] = [];

  // Rechtsraumspezifische Sperrregister prüfen
  const registers = getSelfExclusionRegisters(check.jurisdiction);

  for (const register of registers) {
    try {
      const status = await register.checkExclusion({
        // Der Sperrdateiabgleich braucht vollständige Identitätsdaten (Name,
        // Geburtsdatum) aus dem eigenen KYC des Betreibers – eine reine
        // Altersprüfung liefert nur ein Ja/Nein und kein Geburtsdatum
        dateOfBirth: check.verifiedIdentity.dateOfBirth,
        nationalId: check.verifiedIdentity.nationalIdHash,
        name: check.verifiedIdentity.nameHash
      });

      results.push({
        register: register.name,
        excluded: status.isExcluded,
        excludedUntil: status.excludedUntil,
        reason: status.reason
      });
    } catch (error) {
      // Log but don't block - some registers may be unavailable
      console.error(`Self-exclusion check failed for ${register.name}:`, error);
      results.push({
        register: register.name,
        excluded: false,
        checkFailed: true,
        error: error.message
      });
    }
  }

  // Any exclusion blocks access
  const isExcluded = results.some(r => r.excluded);

  return {
    canPlay: !isExcluded,
    exclusions: results.filter(r => r.excluded),
    failedChecks: results.filter(r => r.checkFailed)
  };
}

Durchsetzung des Einzahlungslimits

Der GlüStV schreibt plattformübergreifende Einzahlungslimits vor. Eine eIDAS-verifizierte Identität ermöglicht:

interface DepositLimitContext {
  playerId: string;
  verifiedIdentity: VerifiedIdentity;
  requestedDeposit: number;
  currency: string;
}

async function enforceDepositLimits(
  context: DepositLimitContext
): Promise<DepositLimitResult> {
  // Einzahlungen im aktuellen Zeitraum berechnen
  const periodStart = getMonthStart();

  // Einzahlungen bei diesem Betreiber prüfen
  const localDeposits = await getPlayerDeposits(
    context.playerId,
    periodStart
  );

  // Für GlüStV-Compliance: zentrales Einzahlungslimitregister prüfen
  // Nutzt verifizierte Identität für den Abgleich über Betreiber hinweg
  const centralDeposits = await queryCentralDepositRegister({
    identityHash: context.verifiedIdentity.uniqueIdHash,
    periodStart,
    jurisdiction: 'DE'
  });

  const totalDeposits = localDeposits + centralDeposits.otherOperators;
  const remainingLimit = GLUSTVO_MONTHLY_LIMIT - totalDeposits;

  if (context.requestedDeposit > remainingLimit) {
    return {
      allowed: false,
      reason: 'MONTHLY_LIMIT_EXCEEDED',
      requestedAmount: context.requestedDeposit,
      remainingLimit,
      periodEnd: getMonthEnd()
    };
  }

  return {
    allowed: true,
    remainingLimit: remainingLimit - context.requestedDeposit
  };
}

Überwachung der Sitzungszeit

class ResponsibleGamblingMonitor {
  async trackSession(playerId: string, verifiedIdentity: VerifiedIdentity) {
    const sessionStart = new Date();
    let lastWarning: Date | null = null;

  // Laufende Sitzungsüberwachung
    const interval = setInterval(async () => {
      const sessionDuration = Date.now() - sessionStart.getTime();
      const hoursDuration = sessionDuration / (1000 * 60 * 60);

        // Warnung nach 1 Stunde
      if (hoursDuration >= 1 && !lastWarning) {
        await this.sendSessionWarning(playerId, {
          type: 'ONE_HOUR',
          sessionDuration,
          recommendation: 'Consider taking a break'
        });
        lastWarning = new Date();
      }

        // Deutlichere Warnung nach 2 Stunden
      if (hoursDuration >= 2 &&
          lastWarning &&
          (Date.now() - lastWarning.getTime()) > 60 * 60 * 1000) {
        await this.sendSessionWarning(playerId, {
          type: 'TWO_HOURS',
          sessionDuration,
          recommendation: 'Extended play detected. Please consider stopping.'
        });
        lastWarning = new Date();
      }

      // Verpflichtende Pause bei rechtsraumspezifischen Grenzwerten
      const jurisdictionLimits = await this.getJurisdictionLimits(playerId);
      if (hoursDuration >= jurisdictionLimits.maxSessionHours) {
        await this.enforceSessionBreak(playerId, {
          minimumBreakMinutes: jurisdictionLimits.mandatoryBreakMinutes
        });
      }
  }, 60000); // Jede Minute prüfen

    return interval;
  }
}

Fallstudie: Hypothetische Online-Casino-Implementierung

Im Folgenden betrachten wir eine umfassende Implementierung für ein fiktives Casino, "EuroVegas Online":

Anforderungen

• Lizenziert in Malta (MGA) und Deutschland (GlüStV)
• Zielmarkt: Spieler in 15 EU-Märkten
• 50.000 täglich aktive Nutzer
• Maximal 10.000 gleichzeitige Nutzer
• Durchschnittlich 500 Verifizierungen pro Minute in Spitzenzeiten

Architektur

// Produktionsinfrastruktur für Gaming-Verifikation
const verificationConfig: GamingPlatformConfig = {
  // Multi-Region-Deployment zur Latenzreduktion
  regions: ['eu-west-1', 'eu-central-1'],

  // Konfiguration des Verifizierungsdienstes
  verification: {
    providers: {
      primary: 'eidas-pro',
      fallback: 'document-verification' // Für Nicht-EU-Spieler
    },
    caching: {
      enabled: true,
      ttl: 30 * 24 * 60 * 60 * 1000, // 30 days
      jurisdictionOverrides: {
        DE: 0, // GlüStV verlangt frische Verifikation
        UK: 24 * 60 * 60 * 1000 // 24 Stunden für UKGC
      }
    },
    rateLimit: {
      perPlayer: { requests: 5, windowSeconds: 300 },
      global: { requests: 1000, windowSeconds: 60 }
    }
  },

  // Responsible gambling integration
  responsibleGambling: {
    selfExclusion: {
      DE: 'OASIS',
      UK: 'GAMSTOP',
      SE: 'Spelpaus',
      DK: 'ROFUS'
    },
    depositLimits: {
      DE: { monthly: 1000, currency: 'EUR' },
      UK: { mandatory: false, playerSet: true }
    }
  },

  // Compliance und Audit
  compliance: {
    auditLogRetention: 7 * 365 * 24 * 60 * 60 * 1000, // 7 years
    realTimeReporting: ['MGA', 'GGL'],
    encryptionAtRest: true,
    piiHandling: 'minimized' // Altersprüfung: Ja/Nein speichern, nie das Geburtsdatum
  }
};

Registrierungsablauf

async function handlePlayerRegistration(
  registrationData: RegistrationData
): Promise<RegistrationResult> {
  // Schritt 1: Ausstehendes Spielerkonto erstellen
  const pendingPlayer = await createPendingPlayer(registrationData);

  // Schritt 2: Verifikationsanforderungen bestimmen
  const jurisdiction = determineJurisdiction(registrationData);
  const requirements = getVerificationRequirements(jurisdiction);

  // Schritt 3: eIDAS-Verifikation starten
  const verificationSession = await verificationService.createVerificationSession(
    pendingPlayer.id,
    {
      jurisdiction,
      minAge: requirements.minimumAge,
      verifyResidency: requirements.residencyCheck,
      minAssuranceLevel: requirements.assuranceLevel
    }
  );

  // Schritt 4: Verifizierungsaufforderung an den Client zurückgeben
  return {
    status: 'VERIFICATION_REQUIRED',
    playerId: pendingPlayer.id,
    verification: {
      sessionId: verificationSession.sessionId,
      qrCodeUrl: verificationSession.qrCodeUrl,
      deepLink: verificationSession.deepLink,
      instructions: getLocalizedInstructions(jurisdiction),
      timeout: verificationSession.expiresAt
    }
  };
}

Aktivierung nach der Verifizierung

async function handleVerificationComplete(
  sessionId: string,
  result: VerificationResult
): Promise<ActivationResult> {
  // Ausstehenden Spieler abrufen
  const session = await getVerificationSession(sessionId);
  const pendingPlayer = await getPendingPlayer(session.playerId);

  if (result.status !== 'SUCCESS') {
    await markVerificationFailed(pendingPlayer.id, result);
    return { status: 'VERIFICATION_FAILED', reason: result.failureReason };
  }

  // Selbstausschlussregister prüfen
  const exclusionStatus = await performSelfExclusionChecks({
    playerId: pendingPlayer.id,
    verifiedIdentity: result.verifiedIdentity,
    jurisdiction: pendingPlayer.jurisdiction
  });

  if (!exclusionStatus.canPlay) {
    await markPlayerExcluded(pendingPlayer.id, exclusionStatus);
    return {
      status: 'SELF_EXCLUDED',
      exclusions: exclusionStatus.exclusions.map(e => ({
        register: e.register,
        excludedUntil: e.excludedUntil
      }))
    };
  }

  // Doppelte Konten prüfen (mit verifizierter Identität)
  const duplicateCheck = await checkDuplicateAccounts(
    result.verifiedIdentity.uniqueIdHash
  );

  if (duplicateCheck.found) {
    return {
      status: 'DUPLICATE_ACCOUNT',
      existingAccountHint: duplicateCheck.hint
    };
  }

  // Spielerkonto aktivieren
  const activePlayer = await activatePlayer(pendingPlayer, {
    verificationId: result.verificationId,
    verifiedAt: result.timestamp,
    assuranceLevel: result.assuranceLevel,
    verificationCountry: result.issuerCountry
  });

  // Limits für verantwortungsvolles Spielen initialisieren
  await initializePlayerLimits(activePlayer, pendingPlayer.jurisdiction);

  return {
    status: 'ACTIVATED',
    playerId: activePlayer.id,
    welcomeBonus: await calculateWelcomeBonus(activePlayer)
  };
}

Leistungsoptimierung für Spitzenzeiten

Das Verkehrsaufkommen im Gaming schwankt stark. Große Sportveranstaltungen können den Verkehr um das Zehnfache erhöhen:

Prädiktive Skalierung

  // Vorausschauende Skalierung anhand des Veranstaltungskalenders
class VerificationCapacityManager {
  private eventCalendar: EventCalendar;

  async planCapacity(date: Date): Promise<CapacityPlan> {
    // Get scheduled events
    const events = await this.eventCalendar.getEvents(date);

    // Erwartetes Verifikationsvolumen berechnen
    const baselineVolume = this.getBaselineVolume(date);
    const eventMultiplier = this.calculateEventMultiplier(events);
    const expectedVolume = baselineVolume * eventMultiplier;

    // Kapazität mit Reserve planen
    return {
      expectedVerifications: expectedVolume,
      plannedCapacity: expectedVolume * 1.5, // 50 % Reserve
      preWarmAt: new Date(date.getTime() - 60 * 60 * 1000), // 1 hour before
      events: events.map(e => ({
        name: e.name,
        expectedImpact: e.trafficMultiplier
      }))
    };
  }

  private calculateEventMultiplier(events: Event[]): number {
    // Major football: 5x
    // Boxing/UFC: 3x
    // Tennis Grand Slam: 2x
    // Regular league: 1.5x
    return Math.max(...events.map(e => e.trafficMultiplier), 1);
  }
}

Verbindungs-Pooling

// Optimiertes Verbindungsmanagement
const verificationPool = new VerificationConnectionPool({
  // Minimum connections kept warm
  minConnections: 20,

  // Maximum connections during peak
  maxConnections: 200,

  // Timeout beim Verbindungsaufbau
  acquireTimeoutMs: 5000,

  // Timeout für inaktive Verbindungen
  idleTimeoutMs: 30000,

  // Intervall für Verbindungs-Health-Checks
  healthCheckIntervalMs: 10000,

  // Pre-Warming-Konfiguration
  preWarm: {
    enabled: true,
    targetConnections: 50,
    warmupDelayMs: 100
  }
});

Fazit

Online-Gaming-Plattformen stehen unter intensiver aufsichtsrechtlicher Kontrolle. Die Altersüberprüfung ist dabei ein zentraler Bestandteil der Compliance. Herkömmliche Verifizierungsmethoden erfüllen die Anforderungen moderner Glücksspielbetriebe an Geschwindigkeit, Genauigkeit und Nachvollziehbarkeit oft nicht.

Die eIDAS-basierte Verifizierung bietet Glücksspielbetreibern Folgendes:

• Schnelle Verifizierung: Ein einziger Authentifizierungsschritt in der eID-App oder Wallet des Spielers, ohne Dokumentenprüfung
• Hohe Vertrauenswürdigkeit: Identitätsprüfung auf eIDAS-Niveau „substanziell“ oder „hoch“ – das unterstützt die Compliance etwa gegenüber der MGA oder nach dem GlüStV, garantiert sie aber nicht allein
• Grenzüberschreitendes Potenzial: Mit der EUDI-Wallet eine Integration, die Spieler aus allen 27 Mitgliedstaaten bedienen soll, sobald Wallets und Zertifikate für vertrauende Parteien verfügbar sind
• Prüfpfad: Kryptografisch signierte Verifizierungsnachweise für behördliche Inspektionen
• Betrugsprävention: Erkennung synthetischer Identitäten und Schutz vor Dokumentenbetrug
• Integration verantwortungsvollen Spielens: Zuverlässiger Identitätsabgleich für Selbstausschluss und Einzahlungslimits

Die technische Investition in eIDAS-Integration zahlt sich aus: geringere Compliance-Kosten, schnellere Spieleraktivierung und besserer Schutz vor behördlichen Strafen, die in die Millionen gehen können.

Da EU-Mitgliedstaaten ihre Vorgaben für Online-Glücksspiel weiter verschärfen, sind Betreiber mit implementierter eIDAS-Verifizierung klar im Vorteil: Sie erfüllen regulatorische Anforderungen und bieten gleichzeitig erstklassige Spielererlebnisse.

---

Bereit, eine konforme Altersüberprüfung für Ihre Gaming-Plattform umzusetzen? eIDAS Pro bietet heute Altersverifikation per Bank-eID (iDIN, Niederlande); die Verifizierung mit der EUDI-Wallet folgt, sobald Zertifikate für vertrauende Parteien erhältlich sind. Erzählen Sie uns von Ihren Lizenzanforderungen. Compliance-Beratung vereinbaren →

Verwandte Artikel

Betrugsprävention: Wie eIDAS gefälschte Ausweise und Identitätsdiebstahl eliminiert

Erfahren Sie, wie die eIDAS-basierte Identitätsverifikation Betrug an der Quelle stoppt: mit kryptografischen Signaturen und staatlicher PKI statt anfälliger, dokumentbasierter Prüfprozesse.

11 Min. Lesezeit

Altersverifizierung in WooCommerce mit eIDAS umsetzen

Umfassender Leitfaden zur Integration einer eIDAS-basierten Altersverifizierung in Ihren WooCommerce-Shop. Erfahren Sie, wie Sie rechtssichere und reibungsarme Verifizierung für Alkohol, Tabak und andere altersbeschränkte Produkte umsetzen.

11 Min. Lesezeit