Argentijnse CUIT/CUIL Generator en Validator

Inleiding

De Argentijnse CUIT (Clave Única de Identificación Tributaria) en CUIL (Clave Única de Identificación Laboral) zijn unieke identificatienummers die in Argentinië worden gebruikt voor belasting- en werkdoeleinden. Deze 11-cijferige codes zijn essentieel voor individuen en bedrijven om legaal te opereren binnen het Argentijnse economische systeem. Onze CUIT/CUIL Generator en Validator-tool biedt een eenvoudige, efficiënte manier om geldige CUIT/CUIL-nummers te genereren voor testdoeleinden en bestaande nummers te valideren om ervoor te zorgen dat ze voldoen aan het officiële formaat en verificatie-algoritme.

Of je nu een ontwikkelaar bent die applicaties test die omgaan met Argentijnse belasting-ID's, een QA-specialist die de functionaliteit van systemen verifieert, of gewoon wilt begrijpen hoe deze identificatienummers werken, deze tool biedt een eenvoudige oplossing zonder onnodige complexiteit. De tool heeft twee hoofdfunctionaliteiten: een generator die geldige CUIT/CUIL-nummers willekeurig of op basis van specifieke parameters genereert, en een validator die controleert of een gegeven CUIT/CUIL-nummer het juiste formaat en de juiste berekeningsregels volgt.

CUIT/CUIL Structuur en Berekening

Het Formaat Begrijpen

Een geldig CUIT/CUIL-nummer bestaat uit 11 cijfers die meestal worden weergegeven in het formaat XX-XXXXXXXX-X:

Typecode (eerste 2 cijfers): Geeft het type entiteit aan
- 20, 23, 24: Mannen (CUIL)
- 27: Vrouwen (CUIL)
- 30, 33, 34: Bedrijven en organisaties (CUIT)
DNI-nummer (midden 8 cijfers): Voor individuen is dit hun nationale identiteitsdocumentnummer (DNI), aangevuld met leidende nullen indien nodig om 8 cijfers te bereiken. Voor bedrijven is dit een uniek toegewezen nummer.
Verificatiecijfer (laatste cijfer): Een controlecijfer dat wordt berekend met behulp van een specifiek algoritme om het hele nummer te valideren.

Berekening van het Verificatiecijfer

Het verificatiecijfer wordt berekend met behulp van het volgende algoritme:

Neem de eerste 10 cijfers van de CUIT/CUIL (typecode + DNI)
Vermenigvuldig elk cijfer met een overeenkomstig gewicht uit deze volgorde: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
Tel alle resulterende producten op
Bereken 11 min de rest van de som gedeeld door 11
Als het resultaat 11 is, is het verificatiecijfer 0
Als het resultaat 10 is, is het verificatiecijfer 9
Anders is het resultaat het verificatiecijfer

Wiskundig kan dit worden uitgedrukt als:

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

Waarbij:

$VD$ het verificatiecijfer is
$d_i$ het $i$ -de cijfer van de eerste 10 cijfers is
$w_i$ het overeenkomstige gewicht uit de volgorde [5, 4, 3, 2, 7, 6, 5, 4, 3, 2] is
Speciale gevallen: als $VD = 11$ dan is $VD = 0$ , als $VD = 10$ dan is $VD = 9$

Stapsgewijze Handleiding

De Generator Gebruiken

Selecteer het tabblad "Generator" bovenaan de interface van de tool.
Kies een Typecode uit het dropdownmenu:
- 20: Man (CUIL)
- 23: Bedrijf (CUIT)
- 24: Tijdelijk Bedrijf (CUIT)
- 27: Vrouw (CUIL)
- 30: Corporatie (CUIT)
- 33: Burgerlijke Vereniging (CUIT)
- 34: Stichting (CUIT)
Voer een DNI-nummer in (optioneel):
- Voer een 8-cijferig DNI-nummer in het daarvoor bestemde veld in
- Als dit leeg wordt gelaten, gebruikt de tool een willekeurig gegenereerd DNI
- Als je minder dan 8 cijfers invoert, wordt het systeem aangevuld met leidende nullen
Genereer Willekeurig DNI (optioneel):
- Klik op de knop "Willekeurig" om een willekeurig 8-cijferig DNI-nummer te genereren
Bekijk het Genereerde CUIT/CUIL:
- De tool toont automatisch een geldig CUIT/CUIL op basis van jouw invoer
- Het formaat is XX-XXXXXXXX-X met het juiste verificatiecijfer
Kopieer het Resultaat:
- Klik op het kopieericoon om het gegenereerde CUIT/CUIL naar je klembord te kopiëren
- Een bevestigingsbericht verschijnt wanneer het succesvol is gekopieerd

De Validator Gebruiken

Selecteer het tabblad "Validator" bovenaan de interface van de tool.
Voer het CUIT/CUIL in om te Valideren:
- Voer de CUIT/CUIL in het formaat XX-XXXXXXXX-X in
- De tool zal automatisch je invoer formatteren met streepjes terwijl je typt
- Je kunt het nummer ook zonder streepjes invoeren (XXXXXXXXXXX)
Klik op de "Valideer" Knop:
- De tool controleert het formaat, de typecode en het verificatiecijfer
Bekijk het Validatieresultaat:
- Voor geldige CUIT/CUIL-nummers verschijnt er een groene succesmelding
- Voor ongeldige nummers verschijnt er een rode foutmelding die het probleem uitlegt:
  - Ongeldig formaat (moet XX-XXXXXXXX-X zijn)
  - Ongeldige typecode (moet een van de volgende zijn: 20, 23, 24, 27, 30, 33, 34)
  - Ongeldig verificatiecijfer
Aanvullende Informatie:
- Voor geldige nummers toont de tool een opsplitsing van de componenten:
  - Typecode en betekenis
  - DNI-nummer
  - Verificatiecijfer

Gebruikscases

Ontwikkeling en Testen

Softwareontwikkeling: Genereer geldige CUIT/CUIL-nummers om applicaties te testen die omgaan met Argentijnse belastingidentificatie, zoals:
- E-commerceplatforms
- Boekhoudsoftware
- HR-beheersystemen
- Overheidsdienstportalen
- Banktoepassingen
Databasepopulatie: Maak realistische testgegevens voor systemen die Argentijnse gebruikersinformatie opslaan, zodat databasebeperkingen en validatieregels correct werken.
Formuliervalidatietests: Test invoervalidatie voor webformulieren die CUIT/CUIL-informatie verzamelen, en verifieer dat de juiste foutmeldingen verschijnen voor ongeldige invoer.
API-testen: Genereer geldige payloads voor API-eindpunten die CUIT/CUIL-nummers vereisen, zodat je integratietests geldige gegevens gebruiken.
QA-automatisering: Neem CUIT/CUIL-generatie op in geautomatiseerde testscripts om dynamische testgevallen te creëren in plaats van statische testgegevens te gebruiken.

Onderwijsdoeleinden

Leren van Validatie-algoritmen: Begrijp hoe controlecijferalgoritmen in de praktijk werken door het CUIT/CUIL-verificatieproces in actie te zien.
Onderwijs in Gegevensvalidatie: Gebruik als een educatief voorbeeld bij het onderwijzen van formuliervalidatietechnieken aan nieuwe ontwikkelaars.
Begrip van Argentijnse Bedrijfsvereisten: Leer over het identificatiesysteem dat in Argentinië wordt gebruikt voor internationale bedrijfsontwikkeling.

Alternatieven

Hoewel onze tool een eenvoudige manier biedt om CUIT/CUIL-nummers te genereren en te valideren, zijn er alternatieve benaderingen die je kunt overwegen:

Officiële Overheidsvalidatie: Voor productieomgevingen, valideer altijd CUIT/CUIL-nummers tegen de officiële AFIP (Administración Federal de Ingresos Públicos) database wanneer mogelijk.
Bibliotheken en Pakketten: Verschillende programmeertalen hebben bibliotheken die specifiek zijn ontworpen voor Argentijnse belasting-ID-validatie:
- JavaScript: validar-cuit npm-pakket
- PHP: afip-php bibliotheek
- Python: py-cuit pakket
Handmatige Berekening: Voor educatieve doeleinden kun je het verificatiecijfer handmatig berekenen met behulp van het eerder beschreven algoritme.
Uitgebreide Bedrijfsvalidatiediensten: Voor enterprise-toepassingen, overweeg het gebruik van uitgebreide validatiediensten die niet alleen het formaat controleren, maar ook de aanwezigheid en status van de entiteit die aan de CUIT/CUIL is gekoppeld.

Geschiedenis van het CUIT/CUIL-systeem

Het CUIT/CUIL-identificatiesysteem in Argentinië is sinds de oprichting aanzienlijk geëvolueerd:

Oorsprong en Implementatie

De CUIT (Clave Única de Identificación Tributaria) werd voor het eerst geïntroduceerd in Argentinië in de jaren '70 als onderdeel van de inspanningen om het belastinginning systeem te moderniseren. De Federale Administratie van Publieke Inkomsten (AFIP) implementeerde deze unieke identificator om belastingbetalers efficiënter te volgen en belastingontduiking te verminderen.

De CUIL (Clave Única de Identificación Laboral) werd later geïntroduceerd om specifiek werknemers in het sociale zekerheidsysteem te identificeren, waardoor een onderscheid werd gemaakt tussen belastingidentificatie en arbeidsidentificatie, terwijl een consistent formaat werd behouden.

Evolutie en Digitalisering

In de jaren '90, terwijl Argentinië aanzienlijke economische hervormingen onderging, werd het CUIT/CUIL-systeem steeds belangrijker voor het volgen van economische activiteit. Het systeem werd verder gedigitaliseerd en online verificatiesystemen werden geïmplementeerd.

De vroege jaren 2000 zagen de integratie van het CUIT/CUIL-systeem met verschillende digitale overheidsdiensten, waardoor het een essentieel onderdeel werd van Argentinië's e-overheidinitiatieven. Deze periode zag ook de standaardisatie van het verificatie-algoritme en het formaat dat vandaag de dag nog steeds in gebruik is.

Recente Ontwikkelingen

In de afgelopen jaren heeft de AFIP de beveiligings- en verificatieprocessen voor CUIT/CUIL-nummers verbeterd, door meer geavanceerde validatiesystemen te implementeren en deze te integreren met andere overheidsdatabases. Het systeem speelt nu een cruciale rol in Argentinië's inspanningen om belastingontduiking te bestrijden en de economie te formaliseren.

Vandaag de dag wordt de CUIT/CUIL niet alleen gebruikt voor belasting- en werkdoeleinden, maar ook voor een breed scala aan activiteiten, waaronder bankieren, vastgoedtransacties, nutsvoorzieningen en online aankopen, waardoor het een essentiële identificator is voor zowel individuen als bedrijven die in Argentinië opereren.

Code Voorbeelden

Python

1def calculate_verification_digit(type_code, dni):
2    # Converteer naar string en zorg ervoor dat DNI 8 cijfers heeft met leidende nullen
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # Combineer typecode en DNI
7    digits = type_code_str + dni_str
8    
9    # Gewichten voor elke positie
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # Bereken som van producten
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # Bereken verificatiecijfer
16    verification_digit = 11 - (sum_products % 11)
17    
18    # Speciale gevallen
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    # Geldige typecodes
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"Ongeldige typecode. Moet een van de volgende zijn: {valid_type_codes}")
34    
35    # Genereer willekeurige DNI als deze niet is opgegeven
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # Bereken verificatiecijfer
40    verification_digit = calculate_verification_digit(type_code, dni)
41    
42    # Formatteer CUIT/CUIL
43    return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46    # Verwijder streepjes indien aanwezig
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # Controleer basisformaat
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "Ongeldig formaat"
52    
53    # Extract onderdelen
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    # Valideer typecode
59    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60    if type_code not in valid_type_codes:
61        return False, "Ongeldige typecode"
62    
63    # Bereken en vergelijk verificatiecijfer
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "Ongeldig verificatiecijfer"
67    
68    return True, "Geldige CUIT/CUIL"
69
70# Voorbeeld gebruik
71print(generate_cuit_cuil(20, 12345678))  # Genereer voor specifieke DNI
72print(generate_cuit_cuil(27))  # Genereer met willekeurige DNI
73print(validate_cuit_cuil("20-12345678-9"))  # Valideer een CUIT/CUIL
74

JavaScript

1function calculateVerificationDigit(typeCode, dni) {
2  // Converteer naar string en zorg ervoor dat DNI 8 cijfers heeft met leidende nullen
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // Combineer typecode en DNI
7  const digits = typeCodeStr + dniStr;
8  
9  // Gewichten voor elke positie
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // Bereken som van producten
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // Bereken verificatiecijfer
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // Speciale gevallen
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  // Geldige typecodes
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`Ongeldige typecode. Moet een van de volgende zijn: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // Genereer willekeurige DNI als deze niet is opgegeven
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // Bereken verificatiecijfer
45  const verificationDigit = calculateVerificationDigit(typeCode, dni);
46  
47  // Formatteer CUIT/CUIL
48  return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52  // Verwijder streepjes indien aanwezig
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // Controleer basisformaat
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'Ongeldig formaat' };
58  }
59  
60  // Extract onderdelen
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  // Valideer typecode
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'Ongeldige typecode' };
69  }
70  
71  // Bereken en vergelijk verificatiecijfer
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'Ongeldig verificatiecijfer' };
75  }
76  
77  return { isValid: true };
78}
79
80// Voorbeeld gebruik
81console.log(generateCuitCuil(20, 12345678)); // Genereer voor specifieke DNI
82console.log(generateCuitCuil(27)); // Genereer met willekeurige DNI
83console.log(validateCuitCuil("20-12345678-9")); // Valideer een 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        // Converteer naar string en zorg ervoor dat DNI 8 cijfers heeft met leidende nullen
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // Combineer typecode en DNI
15        String digits = typeCodeStr + dniStr;
16        
17        // Bereken som van producten
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // Bereken verificatiecijfer
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // Speciale gevallen
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("Ongeldige typecode. Moet een van de volgende zijn: " + VALID_TYPE_CODES);
39        }
40        
41        // Genereer willekeurige DNI als deze niet is opgegeven
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // Bereken verificatiecijfer
48        int verificationDigit = calculateVerificationDigit(typeCode, dni);
49        
50        // Formatteer CUIT/CUIL
51        return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52    }
53    
54    public static ValidationResult validateCuitCuil(String cuitCuil) {
55        // Verwijder streepjes indien aanwezig
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // Controleer basisformaat
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "Ongeldig formaat");
61        }
62        
63        // Extract onderdelen
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        // Valideer typecode
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "Ongeldige typecode");
71        }
72        
73        // Bereken en vergelijk verificatiecijfer
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "Ongeldig verificatiecijfer");
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        // Voorbeeld gebruik
102        System.out.println(generateCuitCuil(20, 12345678)); // Genereer voor specifieke DNI
103        System.out.println(generateCuitCuil(27, null)); // Genereer met willekeurige DNI
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Valideer een CUIT/CUIL
105    }
106}
107

PHP

1<?php
2
3function calculateVerificationDigit($typeCode, $dni) {
4    // Converteer naar string en zorg ervoor dat DNI 8 cijfers heeft met leidende nullen
5    $typeCodeStr = (string)$typeCode;
6    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
7    
8    // Combineer typecode en DNI
9    $digits = $typeCodeStr . $dniStr;
10    
11    // Gewichten voor elke positie
12    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
13    
14    // Bereken som van producten
15    $sumProducts = 0;
16    for ($i = 0; $i < 10; $i++) {
17        $sumProducts += (int)$digits[$i] * $weights[$i];
18    }
19    
20    // Bereken verificatiecijfer
21    $verificationDigit = 11 - ($sumProducts % 11);
22    
23    // Speciale gevallen
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    // Geldige typecodes
35    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
36    
37    if (!in_array($typeCode, $validTypeCodes)) {
38        throw new Exception("Ongeldige typecode. Moet een van de volgende zijn: " . implode(', ', $validTypeCodes));
39    }
40    
41    // Genereer willekeurige DNI als deze niet is opgegeven
42    if ($dni === null) {
43        $dni = rand(10000000, 99999999);
44    }
45    
46    // Bereken verificatiecijfer
47    $verificationDigit = calculateVerificationDigit($typeCode, $dni);
48    
49    // Formatteer CUIT/CUIL
50    return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit);
51}
52
53function validateCuitCuil($cuitCuil) {
54    // Verwijder streepjes indien aanwezig
55    $cuitCuilClean = str_replace('-', '', $cuitCuil);
56    
57    // Controleer basisformaat
58    if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
59        return ['isValid' => false, 'errorMessage' => 'Ongeldig formaat'];
60    }
61    
62    // Extract onderdelen
63    $typeCode = (int)substr($cuitCuilClean, 0, 2);
64    $dni = (int)substr($cuitCuilClean, 2, 8);
65    $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
66    
67    // Valideer typecode
68    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
69    if (!in_array($typeCode, $validTypeCodes)) {
70        return ['isValid' => false, 'errorMessage' => 'Ongeldige typecode'];
71    }
72    
73    // Bereken en vergelijk verificatiecijfer
74    $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
75    if ($calculatedDigit !== $verificationDigit) {
76        return ['isValid' => false, 'errorMessage' => 'Ongeldig verificatiecijfer'];
77    }
78    
79    return ['isValid' => true];
80}
81
82// Voorbeeld gebruik
83echo generateCuitCuil(20, 12345678) . "\n"; // Genereer voor specifieke DNI
84echo generateCuitCuil(27) . "\n"; // Genereer met willekeurige DNI
85var_dump(validateCuitCuil("20-12345678-9")); // Valideer een CUIT/CUIL
86?>
87

Veelgestelde Vragen

Wat is het verschil tussen CUIT en CUIL?

CUIT (Clave Única de Identificación Tributaria) wordt gebruikt voor belastingidentificatie en wordt toegewezen aan zowel individuen als rechtspersonen die belasting moeten betalen in Argentinië. CUIL (Clave Única de Identificación Laboral) is specifiek voor werknemers en wordt gebruikt voor arbeids- en sociale zekerheidsdoeleinden. Hoewel ze hetzelfde formaat en dezelfde berekeningsalgoritme delen, dienen ze verschillende administratieve doeleinden.

Welke typecodes worden gebruikt voor individuen en welke voor bedrijven?

Voor individuen:

20, 23, 24: Mannen (CUIL)
27: Vrouwen (CUIL)

Voor bedrijven en organisaties:

30: Corporaties (CUIT)
33: Burgerlijke Verenigingen (CUIT)
34: Stichtingen (CUIT)

Hoe wordt het verificatiecijfer berekend?

Het verificatiecijfer wordt berekend met behulp van een gewogen som-algoritme. Elk van de eerste 10 cijfers wordt vermenigvuldigd met een overeenkomstig gewicht (5, 4, 3, 2, 7, 6, 5, 4, 3, 2), en de resultaten worden opgeteld. Het verificatiecijfer is 11 min de rest wanneer deze som door 11 wordt gedeeld. Speciale gevallen: als het resultaat 11 is, is het verificatiecijfer 0; als het resultaat 10 is, is het verificatiecijfer 9.

Kan ik deze tool gebruiken om echte, officiële CUIT/CUIL-nummers te genereren?

Nee, deze tool is ontworpen voor test- en educatieve doeleinden. De gegenereerde nummers zijn wiskundig geldig volgens het CUIT/CUIL-algoritme, maar zijn niet officieel geregistreerd bij de Argentijnse belastingautoriteiten (AFIP). Voor officiële CUIT/CUIL-registratie moeten individuen en bedrijven de juiste wettelijke procedures volgen via de AFIP.

Waarom faalt mijn CUIT/CUIL-validatie, terwijl het formaat correct lijkt?

Validatie kan om verschillende redenen falen:

De typecode is niet een van de geldige codes (20, 23, 24, 27, 30, 33, 34)
Het verificatiecijfer komt niet overeen met de berekende waarde op basis van het algoritme
Het formaat is onjuist (moet XX-XXXXXXXX-X zijn)
Er zijn niet-numerieke tekens in de invoer (behalve streepjes)

Zijn streepjes vereist in CUIT/CUIL-nummers?

Hoewel CUIT/CUIL-nummers meestal met streepjes worden geschreven en weergegeven (XX-XXXXXXXX-X), maken de streepjes geen deel uit van het daadwerkelijke nummer voor berekeningsdoeleinden. Onze validator accepteert beide formaten (met of zonder streepjes) en zal elk formaat correct valideren.

Kan een CUIT/CUIL-nummer minder dan 8 cijfers in het DNI-gedeelte hebben?

Nee, het DNI-gedeelte moet altijd precies 8 cijfers zijn. Als het werkelijke DNI minder cijfers heeft, moet het worden aangevuld met leidende nullen om 8 cijfers te bereiken. Bijvoorbeeld, als iemands DNI 1234567 is, zou het in de CUIT/CUIL worden weergegeven als 01234567.

Hoe kan ik verifiëren of een CUIT/CUIL officieel geregistreerd is in Argentinië?

Om te verifiëren of een CUIT/CUIL officieel geregistreerd en actief is, moet je de officiële AFIP (Administración Federal de Ingresos Públicos) website of diensten gebruiken. Onze tool valideert alleen de wiskundige geldigheid van het nummer, niet de officiële registratiestatus.

Kan ik deze tool gebruiken in mijn commerciële applicatie?

Ja, je kunt de algoritme en logica die in deze tool worden gedemonstreerd integreren in je commerciële applicaties. Het CUIT/CUIL-validatie-algoritme is een openbare standaard. Voor productieomgevingen raden we echter aan om een goede foutafhandeling te implementeren en aanvullende validatie tegen officiële bronnen te overwegen wanneer dat nodig is.

Slaat de tool een van de gegenereerde of gevalideerde CUIT/CUIL-nummers op?

Nee, deze tool slaat geen van de ingevoerde of gegenereerde informatie op. Alle verwerking gebeurt client-side in je browser, en er worden geen gegevens naar of opgeslagen op onze servers. Dit zorgt voor de privacy en veiligheid van alle informatie die je invoert.

Referenties

AFIP (Administración Federal de Ingresos Públicos). "CUIT/CUIL/CDI." Officiële Website. https://www.afip.gob.ar/
Ministerie van Werk, Werkgelegenheid en Sociale Zekerheid. "CUIL - Clave Única de Identificación Laboral." https://www.argentina.gob.ar/trabajo
ANSES (Administración Nacional de la Seguridad Social). "Mijn CUIL Verkrijgen." https://www.anses.gob.ar/
Officiële Publicatie van de Republiek Argentinië. "Resolutie Algemene AFIP 2854/2010: Procedure. Clave Única de Identificación Tributaria (C.U.I.T.)."
Fiscaal Wetboek van de Republiek Argentinië. "Identificatie en Registratie van Belastingbetalers."

Klaar om Argentijnse CUIT/CUIL-nummers te genereren of te valideren? Probeer nu onze tool en vereenvoudig je testproces!

Argentijnse CUIT/CUIL Generator en Validator Tool

CUIT/CUIL Generator

Gegenereerde CUIT/CUIL

Documentatie