Krankenversichertennummer

Die Krankenversichertennummer (KVNR) dient der Identifikation des Versicherten bei einer Krankenversicherung. Die Krankenversichertennummer wird benötigt, damit Leistungserbringer, z. B. Ärzte oder Zahnärzte ihre Leistungen mittels der Krankenversicherungskarte, über die Kassenärztlichen Vereinigungen, mit der zuständigen Krankenkasse abrechnen können.

Deutschland seit 2012

Seit der Einführung der elektronischen Gesundheitskarte im Jahr 2012 werden die ersten zehn Stellen der Krankenversichertennummer ebenso wie die Rentenversicherungsnummer einmalig vergeben und bleiben lebenslang gleich.

Rechtsgrundlage zur Einführung der einheitlichen Krankenversichertennummer ist § 290 SGB V. Dort ist auch geregelt, welche Stelle die Krankenversichertennummern vergibt.

Die Krankenversichertennummer hat 20 oder 30 Stellen. Die 20-stellige Variante besteht aus

• einem 10-stelligen unveränderbaren Teil, der lesbar auf die Elektronische Gesundheitskarte aufgedruckt ist (hierbei ist die 10. Stelle eine Prüfziffer);
• einem veränderbaren Teil, der die Kassenzugehörigkeit in Form des Institutionskennzeichens der Krankenkasse angibt (9 Stellen);
• einer Prüfziffer (20. Stelle).

Die 30-stellige Variante besteht aus

• einem 10-stelligen unveränderbaren Teil, der lesbar auf die Elektronische Gesundheitskarte aufgedruckt ist (hierbei ist die 10. Stelle eine Prüfziffer);
• einem veränderbaren Teil, bestehend aus
  • Angabe der Kassenzugehörigkeit in Form des Institutionskennzeichens der Krankenkasse (9 Stellen);
  • Daten zum Hauptversicherten (10 Stellen, wobei die 10. Stelle eine Prüfziffer ist);
• einer Prüfziffer (30. Stelle).

Die erste Stelle der Krankenversichertennummer ist ein zufällig vergebener Großbuchstabe (kein Umlaut!), es folgen acht zufällige Zahlen, die zehnte Stelle ist eine Prüfziffer, die mit dem im Folgenden beschriebenen Modulo-10-Verfahren, einem modifizierten Luhn-Algorithmus, mit den Gewichten 1-2-1-2-1-2-1-2-1-2 berechnet wird: Der Buchstabe wird durch eine zweistellige Zahl entsprechend seiner Stelle im Alphabet ersetzt (A = 01, B = 02, …, Z = 26). Die – zusammen mit den acht Zufallszahlen – resultierenden zehn Ziffern werden nun von links nach rechts abwechselnd mit 1 und 2 multipliziert. Danach erfolgt eine Quersummenbildung der einzelnen Produkte mit anschließender Summenbildung über die zehn Quersummen. Die Prüfziffer ist die letzte Stelle dieser Summe (29 ergibt 9, 53 ergibt 3 usw.), die in der EDV mithilfe der Modulo-Funktion und dem Teiler 10 berechnet wird – daher der Name des Verfahrens.

Beispiel für die 20-stellige Krankenversichertennummer

Die ersten neun Stellen des unveränderbaren Teils der Krankenversichertennummer seien A12345678 (d. h. ohne Prüfziffer), das Institutionskennzeichen der Krankenkasse sei 987654321. Die Bildung der 20-stelligen Krankenversichertennummer erfolgt dann nach folgendem Schema:

Stelle	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20
unveränderbarer Teil (9 Stellen ohne Prüfziffer)		A	1	2	3	4	5	6	7	8
Buchstaben in 2-stellige Zahl umwandeln (daher formal 0. Stelle)	0	1	1	2	3	4	5	6	7	8
Gewichte	1	2	1	2	1	2	1	2	1	2
Produkte aus Stelle und Gewicht	0	2	1	4	3	8	5	12	7	16
Quersummen der Produkte	0	2	1	4	3	8	5	3	7	7
Summe hieraus (für Prüfziffer des unveränderbaren Teils)											40
Rest der Summe bei Division durch 10 (Summe modulo 10)											0
unveränderbarer Teil mit Prüfziffer	0	1	1	2	3	4	5	6	7	8	0
Ergänzung um 9-stellige IK-Nr.	0	1	1	2	3	4	5	6	7	8	0	9	8	7	6	5	4	3	2	1
Gewichte	1	2	1	2	1	2	1	2	1	2	1	2	1	2	1	2	1	2	1	2
Produkte aus Stelle und Gewicht	0	2	1	4	3	8	5	12	7	16	0	18	8	14	6	10	4	6	2	2
Quersummen der Produkte	0	2	1	4	3	8	5	3	7	7	0	9	8	5	6	1	4	6	2	2
Summe hieraus (für Prüfziffer der gesamten 20-stelligen KV-Nr.)																					83
Rest der Summe bei Division durch 10 (Summe modulo 10)																					3
gesamte KV-Nr.	0	1	1	2	3	4	5	6	7	8	0	9	8	7	6	5	4	3	2	1	3
erste beide Stellen als Buchstabe ergibt 20-stellige KV-Nr.		A	1	2	3	4	5	6	7	8	0	9	8	7	6	5	4	3	2	1	3

Daher lautet die 20-stellige Krankenversichertennummer A1234567809876543213, und ihr auf der Elektronischen Gesundheitskarte unten mittig aufgedruckter 10-stelliger unveränderbarer Teil ist A123456780.

Prüfung des unveränderbaren Teils der Krankenversichertennummer

Codierung in Swift

func validate(pkkvde: String) -> Bool {
    let regex = /^([A-Z]{1})([\d]{8})([\d]{1})$/

    guard let regexMatch = try? regex.wholeMatch(in: pkkvde) else {
        return false
    }

    guard let firstLetterUnicodeScalar = regexMatch.output.1.unicodeScalars.first?.value else {
        return false
    }

    let cardNo = "0\(firstLetterUnicodeScalar - 64)".suffix(2) + regexMatch.output.2

    var sum = 0
    for i in 0..<10 {
        guard var integerValue = Array(cardNo)[i].wholeNumberValue else {
            return false
        }

        if i % 2 == 1 {
            integerValue *= 2
        }
        if integerValue > 9 {
            integerValue -= 9
        }

        sum += integerValue
    }
    let calculatedCheckDigit = sum % 10

    let checkDigit = Int(String(regexMatch.output.3))
    return calculatedCheckDigit == checkDigit
}

print("A123456789 -> \(validate(pkkvde: "A123456789"))") // false
print("A123456780 -> \(validate(pkkvde: "A123456780"))") // true

Codierung in C#

private static bool CheckEGK(string testling) {
    var m = Regex.Match(testling, "^([A-Z]{1})([0-9]{8})([0-9]{1})$");
    if (m.Success) {
        string cardNo = $"{m.Groups[0].Value[0] - '@':00}{m.Groups[2].Value}";
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            int d = cardNo[i] - '0';
            if (i % 2 == 1) d *= 2;
            if (d > 9) d -= 9;
            sum += d;
        }
        return sum % 10 == m.Groups[3].Value[0] - '0';
    }
    return false;
}

Codierung in JavaScript

const CheckEGK = testling => {
    let m = testling.match(/^([A-Z]{1})([\d]{8})([\d]{1})$/);
    if (m) {
        let cardNo = ('0' + (m[1].charCodeAt(0)-64)).slice(-2) + m[2];
        let sum = 0;
        for (let i = 0; i < 10; i++) {
            let d = cardNo[i];
            if (i % 2 == 1) d *= 2;
            if (d > 9) d -= 9;
            sum += parseInt(d);
        }
        return sum % 10 == m[3];
    }
    return false;
}

Codierung in Python

class Luhn:
    def validate_egk(self,card_number_with_char):
        card_number = f'{self._convert_first_letter_to_digits(card_number_with_char)}{card_number_with_char[1:]}'
        digits = self._digits_of(card_number)
        odd_digits = digits[::-2][::-1]
        prüfziffer = odd_digits.pop()
        even_digits = digits[-2::-2]
        checksum = 0
        checksum += sum(odd_digits)
        for d in even_digits:
            checksum += sum(self._digits_of(d*2))
        return True if checksum % 10 == prüfziffer else False

    def _digits_of(self,n):
        return [int(d) for d in str(n)]

    def _convert_first_letter_to_digits(self,input_string):
        first_letter = input_string[0].upper()  # Stellt sicher, dass der Buchstabe großgeschrieben wird
        if 'A' <= first_letter <= 'Z':
            digit_value = ord(first_letter) - ord('A') + 1

            return f"{digit_value:02}"
        return None

Codierung in Java

boolean validate(String kvnrValue) {

    var m = Pattern.compile("^([A-Z]{1})([0-9]{8})([0-9]{1})$").matcher(kvnrValue);

    if (!m.matches()) {
        return false;
    }

    int[] digits = new int[10];

    int alpha = (m.group(1).charAt(0) - ((int) 'A')) + 1;

    digits[0] = alpha < 10 ? 0     : alpha / 10;
    digits[1] = alpha < 10 ? alpha : alpha % 10;

    for (int i = 2; i < 10; i++) {
        digits[i] = Character.digit(m.group(2).charAt(i-2), 10);
    }

    for (int i =0; i < 10; i++) {
        digits[i] = ((i+1) % 2 == 0) ? digits[i] * 2 : digits[i];
    }

    for (int i = 0; i < 10; i++) {
        digits[i] = digits[i] < 10 ? digits[i] : (digits[i] / 10 + digits[i] % 10);
    }

    var checksum = Arrays.stream(digits).sum() % 10;

    return checksum == Character.digit(m.group(3).charAt(0), 10);
}

Rentenversicherungsnummer und Krankenversichertennummer

Die Rentenversicherungsnummer darf aus Datenschutzgründen wegen der enthaltenen personenbezogenen Daten nicht zugleich als Krankenversichertennummer verwendet werden. Die gesetzlichen Krankenkassen haben die „Vertrauensstelle Krankenversichertennummer“ (VST) bei der ITSG eingerichtet. Sie erstellt auf Basis der Rentenversicherungsnummer für jeden Bürger eine Krankenversichertennummer. Bürger, die bisher keine Rentenversicherungsnummer haben, erhalten zu diesem Zweck eine.

Die Krankenkassen senden die Rentenversichertennummer (RVNR) und ein Aktenzeichen zur VST. Aus der RVNR wird mit einer Hashfunktion RIPEMD-160 eine Krankenversicherten-Hilfsnummer (KVNR-Hilfsnummer) berechnet. Die Nutzung des Verfahrens darf nur innerhalb einer Vertrauensstelle erfolgen, um zu verhindern, dass Dritte aus einer bekannten RVNR die KVNR ermitteln können. Daher wird die Prüfziffer zusätzlich mit einem geheimen Schlüssel verschlüsselt. Die Erstellung der KVNR-Hilfsnummer erfolgt in einer gesicherten Umgebung. Die Nutzung einer 20-stelligen Nummer ist aus Sicht der Bedarfsträger jedoch nicht praktikabel, da in einigen Verfahren die Krankenversichertennummer manuell auf eine Vorlage übertragen werden muss und dabei leicht Fehler unterlaufen können. Deshalb soll jeder 20-stelligen KVNR-Hilfsnummer nach dem Zufallsprinzip eine zehnstellige KVNR zugeordnet werden. In der Datenbank der VST werden nur die KVNR, die KVNR-Hilfsnummer, das Aktenzeichen der Krankenkasse sowie das Institutionskennzeichen der anfordernden Krankenkasse gespeichert.

Deutschland vor 2012

Die Krankenversichertennummer war vor dem Jahr 2012 nicht lebenslang gleichbleibend, sondern wurde von den Krankenkassen nach jeweils eigenen, internen Systematiken vergeben. Bei einem Kassenwechsel oder einer Änderung des Versichertenstatus wurde so ggf. eine neue Krankenversichertennummer vergeben. In der Regel handelte es sich bei den Nummern um 6-12 stellige Nummernfolgen. Bei einigen Krankenkassen wie z. B. der TK war in der Versichertennummer das Geburtsdatum sowie eine laufende Nummer codiert.

Pflegeversicherung

Die im Bereich der Pflegeversicherung existierende Pflegeversichertennummer kann gemäß § 101 SGB XI ganz oder teilweise mit der Krankenversichertennummer übereinstimmen.