Argentinischer CUIT/CUIL Generator und Validator

Einführung

Die argentinische CUIT (Clave Única de Identificación Tributaria) und CUIL (Clave Única de Identificación Laboral) sind eindeutige Identifikationsnummern, die in Argentinien für Steuer- und Beschäftigungszwecke verwendet werden. Diese 11-stelligen Codes sind unerlässlich für Einzelpersonen und Unternehmen, um legal im argentinischen Wirtschaftssystem zu operieren. Unser CUIT/CUIL Generator und Validator-Tool bietet eine einfache, effiziente Möglichkeit, gültige CUIT/CUIL-Nummern für Testzwecke zu generieren und vorhandene Nummern zu validieren, um sicherzustellen, dass sie dem offiziellen Format und dem Verifizierungsalgorithmus entsprechen.

Egal, ob Sie ein Entwickler sind, der Anwendungen testet, die argentinische Steuer-IDs verarbeiten, ein QA-Spezialist, der die Systemfunktionalität überprüft, oder einfach nur verstehen möchten, wie diese Identifikationsnummern funktionieren, dieses Tool bietet eine unkomplizierte Lösung ohne unnötige Komplexität. Das Tool verfügt über zwei Hauptfunktionen: einen Generator, der gültige CUIT/CUIL-Nummern zufällig oder basierend auf bestimmten Parametern erstellt, und einen Validator, der überprüft, ob eine gegebene CUIT/CUIL-Nummer dem richtigen Format und den Berechnungsregeln folgt.

CUIT/CUIL Struktur und Berechnung

Verständnis des Formats

Eine gültige CUIT/CUIL-Nummer besteht aus 11 Ziffern, die typischerweise im Format XX-XXXXXXXX-X angezeigt werden:

Typcode (erste 2 Ziffern): Gibt den Entitätstyp an
- 20, 23, 24: Männliche Einzelpersonen (CUIL)
- 27: Weibliche Einzelpersonen (CUIL)
- 30, 33, 34: Unternehmen und Organisationen (CUIT)
DNI-Nummer (mittlere 8 Ziffern): Für Einzelpersonen ist dies ihre nationale Identitätsdokumentnummer (DNI), die bei Bedarf mit führenden Nullen aufgefüllt wird, um 8 Ziffern zu erreichen. Für Unternehmen ist dies eine eindeutig zugewiesene Nummer.
Verifizierungsziffer (letzte Ziffer): Eine Prüfziffer, die mit einem spezifischen Algorithmus berechnet wird, um die gesamte Nummer zu validieren.

Berechnung der Verifizierungsziffer

Die Verifizierungsziffer wird mit folgendem Algorithmus berechnet:

Nehmen Sie die ersten 10 Ziffern der CUIT/CUIL (Typcode + DNI)
Multiplizieren Sie jede Ziffer mit einem entsprechenden Gewicht aus dieser Sequenz: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
Summieren Sie alle resultierenden Produkte
Berechnen Sie 11 minus den Rest der Summe geteilt durch 11
Wenn das Ergebnis 11 ist, ist die Verifizierungsziffer 0
Wenn das Ergebnis 10 ist, ist die Verifizierungsziffer 9
Andernfalls ist das Ergebnis die Verifizierungsziffer

Mathematisch kann dies ausgedrückt werden als:

$VD = 11 - ((\sum_{i=1}^{10} d_i \times w_i) \bmod 11)$

Wobei:

$VD$ die Verifizierungsziffer ist
$d_i$ die $i$ -te Ziffer der ersten 10 Ziffern ist
$w_i$ das entsprechende Gewicht aus der Sequenz [5, 4, 3, 2, 7, 6, 5, 4, 3, 2] ist
Sonderfälle: wenn $VD = 11$ , dann $VD = 0$ , wenn $VD = 10$ , dann $VD = 9$

Schritt-für-Schritt-Anleitung

Verwendung des Generators

Wählen Sie die Registerkarte "Generator" oben in der Benutzeroberfläche des Tools.
Wählen Sie einen Typcode aus dem Dropdown-Menü:
- 20: Männlich (CUIL)
- 23: Unternehmen (CUIT)
- 24: Temporäres Unternehmen (CUIT)
- 27: Weiblich (CUIL)
- 30: Körperschaft (CUIT)
- 33: Zivilgesellschaft (CUIT)
- 34: Stiftung (CUIT)
Geben Sie eine DNI-Nummer ein (optional):
- Geben Sie eine 8-stellige DNI-Nummer in das bereitgestellte Feld ein
- Wenn das Feld leer gelassen wird, verwendet das Tool eine zufällig generierte DNI
- Wenn Sie weniger als 8 Ziffern eingeben, wird das System mit führenden Nullen auffüllen
Zufällige DNI generieren (optional):
- Klicken Sie auf die Schaltfläche "Zufällig", um eine zufällige 8-stellige DNI-Nummer zu generieren
Sehen Sie sich die generierte CUIT/CUIL an:
- Das Tool zeigt automatisch eine gültige CUIT/CUIL basierend auf Ihren Eingaben an
- Das Format wird XX-XXXXXXXX-X mit der richtigen Verifizierungsziffer sein
Kopieren Sie das Ergebnis:
- Klicken Sie auf das Kopiersymbol, um die generierte CUIT/CUIL in Ihre Zwischenablage zu kopieren
- Eine Bestätigungsnachricht wird angezeigt, wenn sie erfolgreich kopiert wurde

Verwendung des Validators

Wählen Sie die Registerkarte "Validator" oben in der Benutzeroberfläche des Tools.
Geben Sie die CUIT/CUIL zur Validierung ein:
- Geben Sie die CUIT/CUIL im Format XX-XXXXXXXX-X ein
- Das Tool formatiert Ihre Eingabe automatisch mit Bindestrichen, während Sie tippen
- Sie können die Nummer auch ohne Bindestriche eingeben (XXXXXXXXXXX)
Klicken Sie auf die Schaltfläche "Validieren":
- Das Tool überprüft das Format, den Typcode und die Verifizierungsziffer
Sehen Sie sich das Validierungsergebnis an:
- Bei gültigen CUIT/CUIL-Nummern wird eine grüne Erfolgsmeldung angezeigt
- Bei ungültigen Nummern wird eine rote Fehlermeldung angezeigt, die das Problem erklärt:
  - Ungültiges Format (muss XX-XXXXXXXX-X sein)
  - Ungültiger Typcode (muss einer der folgenden sein: 20, 23, 24, 27, 30, 33, 34)
  - Ungültige Verifizierungsziffer
Zusätzliche Informationen:
- Bei gültigen Nummern zeigt das Tool eine Aufschlüsselung der Komponenten an:
  - Typcode und dessen Bedeutung
  - DNI-Nummer
  - Verifizierungsziffer

Anwendungsfälle

Entwicklung und Testen

Softwareentwicklung: Generieren Sie gültige CUIT/CUIL-Nummern, um Anwendungen zu testen, die argentinische Steueridentifikationen verarbeiten, wie z.B.:
- E-Commerce-Plattformen
- Buchhaltungssoftware
- HR-Management-Systeme
- Regierungsdienstportale
- Bankanwendungen
Datenbankbefüllung: Erstellen Sie realistische Testdaten für Systeme, die argentinische Benutzerinformationen speichern, um sicherzustellen, dass Datenbankbeschränkungen und Validierungsregeln korrekt funktionieren.
Formularvalidierungstest: Testen Sie die Eingabevalidierung für Webformulare, die CUIT/CUIL-Informationen sammeln, und überprüfen Sie, ob bei ungültigen Eingaben die richtigen Fehlermeldungen angezeigt werden.
API-Tests: Generieren Sie gültige Payloads für API-Endpunkte, die CUIT/CUIL-Nummern erfordern, um sicherzustellen, dass Ihre Integrationstests gültige Daten verwenden.
QA-Automatisierung: Integrieren Sie die CUIT/CUIL-Generierung in automatisierte Testskripte, um dynamische Testfälle zu erstellen, anstatt statische Testdaten zu verwenden.

Bildungszwecke

Lernen von Validierungsalgorithmen: Verstehen Sie, wie Prüfziffernalgorithmen in der Praxis funktionieren, indem Sie den CUIT/CUIL-Verifizierungsprozess in Aktion sehen.
Lehren von Datenvalidierung: Verwenden Sie es als Bildungsbeispiel, wenn Sie neuen Entwicklern Techniken zur Formularvalidierung beibringen.
Verstehen der argentinischen Geschäftsanforderungen: Lernen Sie das Identifikationssystem kennen, das in Argentinien für die internationale Geschäftsentwicklung verwendet wird.

Alternativen

Während unser Tool eine unkomplizierte Möglichkeit bietet, CUIT/CUIL-Nummern zu generieren und zu validieren, gibt es alternative Ansätze, die Sie in Betracht ziehen könnten:

Offizielle Regierungsvalidierung: Für Produktionsumgebungen sollten CUIT/CUIL-Nummern immer gegen die offizielle AFIP (Administración Federal de Ingresos Públicos) Datenbank validiert werden, wenn möglich.
Bibliotheken und Pakete: Verschiedene Programmiersprachen haben Bibliotheken, die speziell für die Validierung argentinischer Steuer-IDs entwickelt wurden:
- JavaScript: validar-cuit npm-Paket
- PHP: afip-php Bibliothek
- Python: py-cuit Paket
Manuelle Berechnung: Zu Bildungszwecken könnten Sie die Verifizierungsziffer manuell mit dem zuvor beschriebenen Algorithmus berechnen.
Umfassende Geschäftsvalidierungsdienste: Für Unternehmensanwendungen sollten Sie umfassende Validierungsdienste in Betracht ziehen, die nicht nur das Format überprüfen, sondern auch die Existenz und den Status der mit der CUIT/CUIL verbundenen Entität verifizieren.

Geschichte des CUIT/CUIL-Systems

Das CUIT/CUIL-Identifikationssystem in Argentinien hat sich seit seiner Einführung erheblich weiterentwickelt:

Ursprünge und Implementierung

Die CUIT (Clave Única de Identificación Tributaria) wurde erstmals in den 1970er Jahren in Argentinien eingeführt, um die Steuererhebung zu modernisieren. Die Bundesverwaltung für öffentliche Einnahmen (AFIP) implementierte diese eindeutige Kennung, um Steuerzahler effizienter zu verfolgen und Steuerhinterziehung zu reduzieren.

Die CUIL (Clave Única de Identificación Laboral) wurde später eingeführt, um speziell Arbeitnehmer im Sozialversicherungssystem zu identifizieren, wodurch eine Unterscheidung zwischen Steueridentifikation und Arbeitsidentifikation geschaffen wurde, während ein konsistentes Format beibehalten wurde.

Evolution und Digitalisierung

In den 1990er Jahren, als Argentinien bedeutende wirtschaftliche Reformen durchlief, wurde das CUIT/CUIL-System zunehmend wichtig für die Verfolgung wirtschaftlicher Aktivitäten. Das System wurde weiter digitalisiert, und Online-Überprüfungssysteme wurden implementiert.

Die frühen 2000er Jahre sahen die Integration des CUIT/CUIL-Systems mit verschiedenen digitalen Regierungsdiensten, wodurch es zu einem wesentlichen Bestandteil der E-Government-Initiativen Argentiniens wurde. In diesem Zeitraum wurde auch der Verifizierungsalgorithmus und das Format standardisiert, das bis heute verwendet wird.

Jüngste Entwicklungen

In den letzten Jahren hat die AFIP die Sicherheits- und Überprüfungsprozesse für CUIT/CUIL-Nummern verbessert, indem sie ausgeklügeltere Validierungssysteme implementiert und diese mit anderen Regierungsdatenbanken integriert hat. Das System spielt nun eine entscheidende Rolle in Argentiniens Bemühungen, Steuerhinterziehung zu bekämpfen und die Wirtschaft zu formalisieren.

Heute wird die CUIT/CUIL nicht nur für Steuer- und Beschäftigungszwecke, sondern auch für eine Vielzahl von Aktivitäten verwendet, darunter Bankgeschäfte, Immobilientransaktionen, Versorgungsdienste und Online-Käufe, was sie zu einer wesentlichen Kennung für sowohl Einzelpersonen als auch Unternehmen macht, die in Argentinien tätig sind.

Codebeispiele

Python

1def calculate_verification_digit(type_code, dni):
2    # In String umwandeln und sicherstellen, dass DNI 8 Ziffern mit führenden Nullen hat
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # Kombinieren Sie Typcode und DNI
7    digits = type_code_str + dni_str
8    
9    # Gewichte für jede Position
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # Berechnen Sie die Summe der Produkte
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # Berechnen Sie die Verifizierungsziffer
16    verification_digit = 11 - (sum_products % 11)
17    
18    # Sonderfälle
19    if verification_digit == 11:
20        verification_digit = 0
21    elif verification_digit == 10:
22        verification_digit = 9
23    
24    return verification_digit
25
26def generate_cuit_cuil(type_code, dni=None):
27    import random
28    
29    # Gültige Typcodes
30    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
31    
32    if type_code not in valid_type_codes:
33        raise ValueError(f"Ungültiger Typcode. Muss einer von: {valid_type_codes} sein.")
34    
35    # Zufällige DNI generieren, wenn nicht angegeben
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # Berechnen Sie die Verifizierungsziffer
40    verification_digit = calculate_verification_digit(type_code, dni)
41    
42    # Formatieren Sie CUIT/CUIL
43    return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46    # Entfernen Sie Bindestriche, wenn vorhanden
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # Überprüfen Sie das grundlegende Format
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "Ungültiges Format"
52    
53    # Teile extrahieren
54    type_code = int(cuit_cuil_clean[0:2])
55    dni = int(cuit_cuil_clean[2:10])
56    verification_digit = int(cuit_cuil_clean[10])
57    
58    # Typcode validieren
59    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60    if type_code not in valid_type_codes:
61        return False, "Ungültiger Typcode"
62    
63    # Berechnen und vergleichen Sie die Verifizierungsziffer
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "Ungültige Verifizierungsziffer"
67    
68    return True, "Gültige CUIT/CUIL"
69
70# Beispielverwendung
71print(generate_cuit_cuil(20, 12345678))  # Generieren für spezifische DNI
72print(generate_cuit_cuil(27))  # Generieren mit zufälliger DNI
73print(validate_cuit_cuil("20-12345678-9"))  # Validieren einer CUIT/CUIL
74

JavaScript

1function calculateVerificationDigit(typeCode, dni) {
2  // In String umwandeln und sicherstellen, dass DNI 8 Ziffern mit führenden Nullen hat
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // Kombinieren Sie Typcode und DNI
7  const digits = typeCodeStr + dniStr;
8  
9  // Gewichte für jede Position
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // Berechnen Sie die Summe der Produkte
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // Berechnen Sie die Verifizierungsziffer
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // Sonderfälle
22  if (verificationDigit === 11) {
23    verificationDigit = 0;
24  } else if (verificationDigit === 10) {
25    verificationDigit = 9;
26  }
27  
28  return verificationDigit;
29}
30
31function generateCuitCuil(typeCode, dni) {
32  // Gültige Typcodes
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`Ungültiger Typcode. Muss einer von: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // Zufällige DNI generieren, wenn nicht angegeben
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // Berechnen Sie die Verifizierungsziffer
45  const verificationDigit = calculateVerificationDigit(typeCode, dni);
46  
47  // Formatieren Sie CUIT/CUIL
48  return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52  // Entfernen Sie Bindestriche, wenn vorhanden
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // Überprüfen Sie das grundlegende Format
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'Ungültiges Format' };
58  }
59  
60  // Teile extrahieren
61  const typeCode = parseInt(cuitCuilClean.substring(0, 2));
62  const dni = parseInt(cuitCuilClean.substring(2, 10));
63  const verificationDigit = parseInt(cuitCuilClean.substring(10, 11));
64  
65  // Typcode validieren
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'Ungültiger Typcode' };
69  }
70  
71  // Berechnen und vergleichen Sie die Verifizierungsziffer
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'Ungültige Verifizierungsziffer' };
75  }
76  
77  return { isValid: true };
78}
79
80// Beispielverwendung
81console.log(generateCuitCuil(20, 12345678)); // Generieren für spezifische DNI
82console.log(generateCuitCuil(27)); // Generieren mit zufälliger DNI
83console.log(validateCuitCuil("20-12345678-9")); // Validieren einer CUIT/CUIL
84

Java

1import java.util.Arrays;
2import java.util.List;
3import java.util.Random;
4
5public class CuitCuilUtils {
6    private static final List<Integer> VALID_TYPE_CODES = Arrays.asList(20, 23, 24, 27, 30, 33, 34);
7    private static final int[] WEIGHTS = {5, 4, 3, 2, 7, 6, 5, 4, 3, 2};
8    
9    public static int calculateVerificationDigit(int typeCode, int dni) {
10        // In String umwandeln und sicherstellen, dass DNI 8 Ziffern mit führenden Nullen hat
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // Kombinieren Sie Typcode und DNI
15        String digits = typeCodeStr + dniStr;
16        
17        // Berechnen Sie die Summe der Produkte
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // Berechnen Sie die Verifizierungsziffer
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // Sonderfälle
27        if (verificationDigit == 11) {
28            verificationDigit = 0;
29        } else if (verificationDigit == 10) {
30            verificationDigit = 9;
31        }
32        
33        return verificationDigit;
34    }
35    
36    public static String generateCuitCuil(int typeCode, Integer dni) {
37        if (!VALID_TYPE_CODES.contains(typeCode)) {
38            throw new IllegalArgumentException("Ungültiger Typcode. Muss einer von: " + VALID_TYPE_CODES);
39        }
40        
41        // Zufällige DNI generieren, wenn nicht angegeben
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // Berechnen Sie die Verifizierungsziffer
48        int verificationDigit = calculateVerificationDigit(typeCode, dni);
49        
50        // Formatieren Sie CUIT/CUIL
51        return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52    }
53    
54    public static ValidationResult validateCuitCuil(String cuitCuil) {
55        // Entfernen Sie Bindestriche, wenn vorhanden
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // Überprüfen Sie das grundlegende Format
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "Ungültiges Format");
61        }
62        
63        // Teile extrahieren
64        int typeCode = Integer.parseInt(cuitCuilClean.substring(0, 2));
65        int dni = Integer.parseInt(cuitCuilClean.substring(2, 10));
66        int verificationDigit = Integer.parseInt(cuitCuilClean.substring(10, 11));
67        
68        // Typcode validieren
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "Ungültiger Typcode");
71        }
72        
73        // Berechnen und vergleichen Sie die Verifizierungsziffer
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "Ungültige Verifizierungsziffer");
77        }
78        
79        return new ValidationResult(true, null);
80    }
81    
82    public static class ValidationResult {
83        private final boolean isValid;
84        private final String errorMessage;
85        
86        public ValidationResult(boolean isValid, String errorMessage) {
87            this.isValid = isValid;
88            this.errorMessage = errorMessage;
89        }
90        
91        public boolean isValid() {
92            return isValid;
93        }
94        
95        public String getErrorMessage() {
96            return errorMessage;
97        }
98    }
99    
100    public static void main(String[] args) {
101        // Beispielverwendung
102        System.out.println(generateCuitCuil(20, 12345678)); // Generieren für spezifische DNI
103        System.out.println(generateCuitCuil(27, null)); // Generieren mit zufälliger DNI
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Validieren einer CUIT/CUIL
105    }
106}
107

PHP

1<?php
2
3function calculateVerificationDigit($typeCode, $dni) {
4    // In String umwandeln und sicherstellen, dass DNI 8 Ziffern mit führenden Nullen hat
5    $typeCodeStr = (string)$typeCode;
6    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
7    
8    // Kombinieren Sie Typcode und DNI
9    $digits = $typeCodeStr . $dniStr;
10    
11    // Gewichte für jede Position
12    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
13    
14    // Berechnen Sie die Summe der Produkte
15    $sumProducts = 0;
16    for ($i = 0; $i < 10; $i++) {
17        $sumProducts += (int)$digits[$i] * $weights[$i];
18    }
19    
20    // Berechnen Sie die Verifizierungsziffer
21    $verificationDigit = 11 - ($sumProducts % 11);
22    
23    // Sonderfälle
24    if ($verificationDigit == 11) {
25        $verificationDigit = 0;
26    } else if ($verificationDigit == 10) {
27        $verificationDigit = 9;
28    }
29    
30    return $verificationDigit;
31}
32
33function generateCuitCuil($typeCode, $dni = null) {
34    // Gültige Typcodes
35    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
36    
37    if (!in_array($typeCode, $validTypeCodes)) {
38        throw new Exception("Ungültiger Typcode. Muss einer von: " . implode(', ', $validTypeCodes));
39    }
40    
41    // Zufällige DNI generieren, wenn nicht angegeben
42    if ($dni === null) {
43        $dni = rand(10000000, 99999999);
44    }
45    
46    // Berechnen Sie die Verifizierungsziffer
47    $verificationDigit = calculateVerificationDigit($typeCode, $dni);
48    
49    // Formatieren Sie CUIT/CUIL
50    return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit);
51}
52
53function validateCuitCuil($cuitCuil) {
54    // Entfernen Sie Bindestriche, wenn vorhanden
55    $cuitCuilClean = str_replace('-', '', $cuitCuil);
56    
57    // Überprüfen Sie das grundlegende Format
58    if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
59        return ['isValid' => false, 'errorMessage' => 'Ungültiges Format'];
60    }
61    
62    // Teile extrahieren
63    $typeCode = (int)substr($cuitCuilClean, 0, 2);
64    $dni = (int)substr($cuitCuilClean, 2, 8);
65    $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
66    
67    // Typcode validieren
68    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
69    if (!in_array($typeCode, $validTypeCodes)) {
70        return ['isValid' => false, 'errorMessage' => 'Ungültiger Typcode'];
71    }
72    
73    // Berechnen und vergleichen Sie die Verifizierungsziffer
74    $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
75    if ($calculatedDigit !== $verificationDigit) {
76        return ['isValid' => false, 'errorMessage' => 'Ungültige Verifizierungsziffer'];
77    }
78    
79    return ['isValid' => true];
80}
81
82// Beispielverwendung
83echo generateCuitCuil(20, 12345678) . "\n"; // Generieren für spezifische DNI
84echo generateCuitCuil(27) . "\n"; // Generieren mit zufälliger DNI
85var_dump(validateCuitCuil("20-12345678-9")); // Validieren einer CUIT/CUIL
86?>
87

Häufig gestellte Fragen

Was ist der Unterschied zwischen CUIT und CUIL?

CUIT (Clave Única de Identificación Tributaria) wird für steuerliche Identifikationszwecke verwendet und wird sowohl Einzelpersonen als auch juristischen Personen zugewiesen, die in Argentinien Steuern zahlen müssen. CUIL (Clave Única de Identificación Laboral) ist speziell für Arbeitnehmer und wird für Arbeits- und Sozialversicherungszwecke verwendet. Während sie dasselbe Format und denselben Berechnungsalgorithmus teilen, dienen sie unterschiedlichen administrativen Zwecken.

Welche Typcodes werden für Einzelpersonen und welche für Unternehmen verwendet?

Für Einzelpersonen:

20, 23, 24: Männliche Einzelpersonen (CUIL)
27: Weibliche Einzelpersonen (CUIL)

Für Unternehmen und Organisationen:

30: Körperschaften (CUIT)
33: Zivilgesellschaften (CUIT)
34: Stiftungen (CUIT)

Wie wird die Verifizierungsziffer berechnet?

Die Verifizierungsziffer wird mit einem gewichteten Summenalgorithmus berechnet. Jede der ersten 10 Ziffern wird mit einem entsprechenden Gewicht (5, 4, 3, 2, 7, 6, 5, 4, 3, 2) multipliziert, und die Ergebnisse werden summiert. Die Verifizierungsziffer ist 11 minus der Rest, wenn diese Summe durch 11 geteilt wird. Sonderfälle: Wenn das Ergebnis 11 ist, ist die Verifizierungsziffer 0; wenn das Ergebnis 10 ist, ist die Verifizierungsziffer 9.

Kann ich dieses Tool verwenden, um echte, offizielle CUIT/CUIL-Nummern zu generieren?

Nein, dieses Tool ist nur für Test- und Bildungszwecke gedacht. Die generierten Nummern sind mathematisch gültig gemäß dem CUIT/CUIL-Algorithmus, sind jedoch nicht offiziell bei den argentinischen Steuerbehörden (AFIP) registriert. Für die offizielle Registrierung von CUIT/CUIL müssen Einzelpersonen und Unternehmen die entsprechenden gesetzlichen Verfahren über die AFIP einhalten.

Warum schlägt meine CUIT/CUIL-Validierung fehl, obwohl das Format korrekt aussieht?

Die Validierung kann aus mehreren Gründen fehlschlagen:

Der Typcode ist nicht einer der gültigen Codes (20, 23, 24, 27, 30, 33, 34)
Die Verifizierungsziffer stimmt nicht mit dem berechneten Wert gemäß dem Algorithmus überein
Das Format ist falsch (sollte XX-XXXXXXXX-X sein)
Es sind nicht-numerische Zeichen in der Eingabe vorhanden (außer Bindestrichen)

Sind Bindestriche im CUIT/CUIL-Nummern erforderlich?

Obwohl CUIT/CUIL-Nummern üblicherweise mit Bindestrichen (XX-XXXXXXXX-X) geschrieben und angezeigt werden, sind die Bindestriche nicht Teil der tatsächlichen Zahl für Berechnungszwecke. Unser Validator akzeptiert beide Formate (mit oder ohne Bindestriche) und validiert ordnungsgemäß jedes Format.

Kann eine CUIT/CUIL-Nummer weniger als 8 Ziffern im DNI-Teil haben?

Nein, der DNI-Teil muss immer genau 8 Ziffern haben. Wenn die tatsächliche DNI weniger Ziffern hat, muss sie mit führenden Nullen aufgefüllt werden, um 8 Ziffern zu erreichen. Zum Beispiel, wenn die DNI einer Person 1234567 ist, würde sie in der CUIT/CUIL als 01234567 dargestellt werden.

Wie kann ich überprüfen, ob eine CUIT/CUIL offiziell in Argentinien registriert ist?

Um zu überprüfen, ob eine CUIT/CUIL offiziell registriert und aktiv ist, sollten Sie die offizielle Website oder die Dienste der AFIP (Administración Federal de Ingresos Públicos) nutzen. Unser Tool überprüft nur die mathematische Gültigkeit der Nummer, nicht ihren offiziellen Registrierungsstatus.

Kann ich dieses Tool in meiner kommerziellen Anwendung verwenden?

Ja, Sie können den Algorithmus und die Logik, die in diesem Tool demonstriert werden, in Ihre kommerziellen Anwendungen integrieren. Der CUIT/CUIL-Validierungsalgorithmus ist ein öffentlicher Standard. Für Produktionsumgebungen empfehlen wir jedoch, eine ordnungsgemäße Fehlerbehandlung zu implementieren und zusätzliche Validierungen gegen offizielle Quellen in Betracht zu ziehen, wenn dies erforderlich ist.

Speichert das Tool irgendwelche der generierten oder validierten CUIT/CUIL-Nummern?

Nein, dieses Tool speichert keine der eingegebenen oder generierten Informationen. Alle Verarbeitungen erfolgen clientseitig in Ihrem Browser, und es werden keine Daten an unsere Server gesendet oder dort gespeichert. Dies gewährleistet die Privatsphäre und Sicherheit aller Informationen, die Sie eingeben.

Referenzen

AFIP (Administración Federal de Ingresos Públicos). "CUIT/CUIL/CDI." Offizielle Website. https://www.afip.gob.ar/
Ministerio de Trabajo, Empleo y Seguridad Social. "CUIL - Clave Única de Identificación Laboral." https://www.argentina.gob.ar/trabajo
ANSES (Administración Nacional de la Seguridad Social). "Obtener mi CUIL." https://www.anses.gob.ar/
Boletín Oficial de la República Argentina. "Resolución General AFIP 2854/2010: Verfahren. Clave Única de Identificación Tributaria (C.U.I.T.)."
Código Fiscal de la República Argentina. "Identifizierung und Registrierung von Steuerpflichtigen."

Bereit, argentinische CUIT/CUIL-Nummern zu generieren oder zu validieren? Probieren Sie jetzt unser Tool aus und vereinfachen Sie Ihren Testprozess!

Argentinischer CUIT/CUIL Generator und Validator Tool

CUIT/CUIL Generator

Generierter CUIT/CUIL

Dokumentation