Generator și Validator CUIT/CUIL Argentinian

Introducere

CUIT-ul (Clave Única de Identificación Tributaria) și CUIL-ul (Clave Única de Identificación Laboral) argentinian sunt numere de identificare unice utilizate în Argentina în scopuri fiscale și de angajare, respectiv. Aceste coduri de 11 cifre sunt esențiale pentru indivizi și afaceri pentru a opera legal în cadrul sistemului economic argentinian. Instrumentul nostru Generator și Validator CUIT/CUIL oferă o modalitate simplă și eficientă de a genera numere CUIT/CUIL valide în scopuri de testare și de a valida numerele existente pentru a asigura conformitatea cu formatul oficial și algoritmul de verificare.

Indiferent dacă ești un dezvoltator care testează aplicații care gestionează ID-urile fiscale argentiniene, un specialist QA care verifică funcționalitatea sistemului sau pur și simplu ai nevoie să înțelegi cum funcționează aceste numere de identificare, acest instrument oferă o soluție clară fără complexe inutile. Instrumentul dispune de două funcții principale: un generator care creează numere CUIT/CUIL valide aleatoriu sau pe baza unor parametri specifici și un validator care verifică dacă un anumit număr CUIT/CUIL respectă formatul corect și regulile de calcul.

Structura și Calculul CUIT/CUIL

Înțelegerea Formatului

Un număr CUIT/CUIL valid constă din 11 cifre, de obicei afișate în formatul XX-XXXXXXXX-X:

Cod de tip (primele 2 cifre): Indică tipul entității
- 20, 23, 24: Indivizi de sex masculin (CUIL)
- 27: Indivizi de sex feminin (CUIL)
- 30, 33, 34: Companii și organizații (CUIT)
Numărul DNI (cifrele din mijloc 8): Pentru indivizi, acesta este numărul lor de document de identitate național (DNI), completat cu zerouri la început, dacă este necesar, pentru a ajunge la 8 cifre. Pentru companii, acesta este un număr unic atribuit.
Cifra de verificare (ultima cifră): O cifră de control calculată folosind un algoritm specific pentru a valida întregul număr.

Calculul Cifrei de Verificare

Cifra de verificare este calculată folosind următorul algoritm:

Ia primele 10 cifre ale CUIT/CUIL (cod de tip + DNI)
Înmulțește fiecare cifră cu un coeficient corespunzător din această secvență: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
Suma tuturor produselor rezultate
Calculează 11 minus restul sumei împărțite la 11
Dacă rezultatul este 11, cifra de verificare este 0
Dacă rezultatul este 10, cifra de verificare este 9
În caz contrar, rezultatul este cifra de verificare

Matematic, acest lucru poate fi exprimat ca:

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

Unde:

$VD$ este cifra de verificare
$d_i$ este cifra $i$ -a din primele 10 cifre
$w_i$ este coeficientul corespunzător din secvența [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
Cazuri speciale: dacă $VD = 11$ , atunci $VD = 0$ , dacă $VD = 10$ , atunci $VD = 9$

Ghid Pas cu Pas

Utilizarea Generatorului

Selectează tab-ul "Generator" din partea de sus a interfeței instrumentului.
Alege un Cod de Tip din meniul derulant:
- 20: Masculin (CUIL)
- 23: Afacere (CUIT)
- 24: Afacere Temporară (CUIT)
- 27: Feminin (CUIL)
- 30: Corporație (CUIT)
- 33: Asociație Civilă (CUIT)
- 34: Fundație (CUIT)
Introdu un Număr DNI (opțional):
- Introdu un număr DNI de 8 cifre în câmpul furnizat
- Dacă este lăsat gol, instrumentul va folosi un DNI generat aleatoriu
- Dacă introduci mai puțin de 8 cifre, sistemul va completa cu zerouri la început
Generează un DNI Aleator (opțional):
- Apasă butonul "Aleator" pentru a genera un număr DNI de 8 cifre aleator
Vezi CUIT/CUIL Generat:
- Instrumentul afișează automat un CUIT/CUIL valid pe baza introducerilor tale
- Formatul va fi XX-XXXXXXXX-X cu cifra de verificare corectă
Copiază Rezultatul:
- Apasă pe pictograma de copiere pentru a copia CUIT/CUIL generat în clipboard-ul tău
- Un mesaj de confirmare va apărea când a fost copiat cu succes

Utilizarea Validatorului

Selectează tab-ul "Validator" din partea de sus a interfeței instrumentului.
Introdu CUIT/CUIL-ul de Validat:
- Introdu CUIT/CUIL-ul în formatul XX-XXXXXXXX-X
- Instrumentul va formata automat introducerea ta cu cratime pe măsură ce scrii
- Poți introduce și numărul fără cratime (XXXXXXXXXXX)
Apasă butonul "Validare":
- Instrumentul va verifica formatul, codul de tip și cifra de verificare
Vezi Rezultatul Validării:
- Pentru numerele CUIT/CUIL valide, va apărea un mesaj de succes verde
- Pentru numerele invalide, va apărea un mesaj de eroare roșu care va explica problema:
  - Format invalid (trebuie să fie XX-XXXXXXXX-X)
  - Cod de tip invalid (trebuie să fie unul dintre: 20, 23, 24, 27, 30, 33, 34)
  - Cifră de verificare invalidă
Informații Suplimentare:
- Pentru numerele valide, instrumentul afișează o defalcare a componentelor:
  - Cod de tip și semnificația acestuia
  - Numărul DNI
  - Cifra de verificare

Cazuri de Utilizare

Dezvoltare și Testare

Dezvoltare Software: Generează numere CUIT/CUIL valide pentru a testa aplicații care gestionează identificarea fiscală argentiniană, cum ar fi:
- Platforme de comerț electronic
- Software de contabilitate
- Sisteme de management HR
- Portaluri de servicii guvernamentale
- Aplicații bancare
Popularea Bazei de Date: Creează date de testare realiste pentru sistemele care stochează informații despre utilizatorii argentinieni, asigurându-te că constrângerile bazei de date și regulile de validare funcționează corect.
Testarea Validării Formularelor: Testează validarea introducerii pentru formularele web care colectează informații CUIT/CUIL, verificând că mesajele de eroare corespunzătoare apar pentru introducerile invalide.
Testarea API-urilor: Generează payload-uri valide pentru endpoint-urile API care necesită numere CUIT/CUIL, asigurându-te că testele tale de integrare folosesc date valide.
Automatizarea QA: Încorporează generarea CUIT/CUIL în scripturile de testare automate pentru a crea cazuri de testare dinamice în loc de a folosi date de testare statice.

Scopuri Educaționale

Învățarea Algoritmilor de Validare: Înțelege cum funcționează algoritmii de cifre de control în practică, văzând procesul de verificare CUIT/CUIL în acțiune.
Predarea Validării Datelor: Folosește ca exemplu educațional atunci când predai tehnici de validare a formularelor dezvoltatorilor noi.
Înțelegerea Cerințelor de Afaceri Argentiniene: Învață despre sistemul de identificare utilizat în Argentina pentru dezvoltarea afacerilor internaționale.

Alternative

Deși instrumentul nostru oferă o modalitate clară de a genera și valida numere CUIT/CUIL, există abordări alternative pe care le-ai putea lua în considerare:

Validarea Oficială a Guvernului: Pentru medii de producție, validează întotdeauna numerele CUIT/CUIL împotriva bazei de date oficiale AFIP (Administración Federal de Ingresos Públicos) atunci când este posibil.
Biblioteci și Pachete: Mai multe limbaje de programare au biblioteci special concepute pentru validarea ID-urilor fiscale argentiniene:
- JavaScript: pachet npm validar-cuit
- PHP: bibliotecă afip-php
- Python: pachet py-cuit
Calcul Manual: În scopuri educaționale, ai putea calcula cifra de verificare manual folosind algoritmul descris anterior.
Servicii Cuprinzătoare de Validare a Afacerilor: Pentru aplicațiile de întreprindere, ia în considerare utilizarea serviciilor cuprinzătoare de validare care nu doar verifică formatul, ci și confirmă existența și statutul entității asociate cu CUIT/CUIL.

Istoria Sistemului CUIT/CUIL

Sistemul de identificare CUIT/CUIL din Argentina a evoluat semnificativ de la începuturile sale:

Origini și Implementare

CUIT-ul (Clave Única de Identificación Tributaria) a fost introdus pentru prima dată în Argentina în anii 1970 ca parte a eforturilor de modernizare a sistemului de colectare a impozitelor. Administrația Federală a Veniturilor Publice (AFIP) a implementat acest identificator unic pentru a urmări contribuabilii mai eficient și a reduce evaziunea fiscală.

CUIL-ul (Clave Única de Identificación Laboral) a fost introdus ulterior pentru a identifica în mod specific lucrătorii în sistemul de securitate socială, creând o distincție între identificarea fiscală și identificarea muncii, menținând în același timp un format consistent.

Evoluție și Digitalizare

În anii 1990, pe măsură ce Argentina a trecut prin reforme economice semnificative, sistemul CUIT/CUIL a devenit din ce în ce mai important pentru urmărirea activității economice. Sistemul a fost ulterior digitalizat, iar sistemele de verificare online au fost implementate.

În anii 2000, sistemul CUIT/CUIL a fost integrat cu diverse servicii guvernamentale digitale, făcându-l o componentă esențială a inițiativelor de e-guvernare din Argentina. Această perioadă a văzut, de asemenea, standardizarea algoritmului de verificare și a formatului care rămâne în uz și astăzi.

Dezvoltări Recente

În ultimii ani, AFIP a îmbunătățit procesele de securitate și verificare pentru numerele CUIT/CUIL, implementând sisteme de validare mai sofisticate și integrându-le cu alte baze de date guvernamentale. Sistemul joacă acum un rol crucial în eforturile Argentinei de a combate evaziunea fiscală și de a formaliza economia.

Astăzi, CUIT-ul/CUIL-ul este folosit nu doar pentru scopuri fiscale și de angajare, ci și pentru o gamă largă de activități, inclusiv tranzacții bancare, tranzacții imobiliare, servicii de utilitate și achiziții online, făcându-l un identificator esențial pentru atât indivizi, cât și afaceri care operează în Argentina.

Exemple de Cod

Python

1def calculate_verification_digit(type_code, dni):
2    # Convert to string and ensure DNI is 8 digits with leading zeros
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # Combine type code and DNI
7    digits = type_code_str + dni_str
8    
9    # Weights for each position
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # Calculate sum of products
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # Calculate verification digit
16    verification_digit = 11 - (sum_products % 11)
17    
18    # Special cases
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    # Valid type codes
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"Invalid type code. Must be one of: {valid_type_codes}")
34    
35    # Generate random DNI if not provided
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # Calculate verification digit
40    verification_digit = calculate_verification_digit(type_code, dni)
41    
42    # Format CUIT/CUIL
43    return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46    # Remove hyphens if present
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # Check basic format
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "Invalid format"
52    
53    # Extract parts
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    # Validate type code
59    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60    if type_code not in valid_type_codes:
61        return False, "Invalid type code"
62    
63    # Calculate and compare verification digit
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "Invalid verification digit"
67    
68    return True, "Valid CUIT/CUIL"
69
70# Example usage
71print(generate_cuit_cuil(20, 12345678))  # Generate for specific DNI
72print(generate_cuit_cuil(27))  # Generate with random DNI
73print(validate_cuit_cuil("20-12345678-9"))  # Validate a CUIT/CUIL
74

JavaScript

1function calculateVerificationDigit(typeCode, dni) {
2  // Convert to string and ensure DNI is 8 digits with leading zeros
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // Combine type code and DNI
7  const digits = typeCodeStr + dniStr;
8  
9  // Weights for each position
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // Calculate sum of products
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // Calculate verification digit
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // Special cases
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  // Valid type codes
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`Invalid type code. Must be one of: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // Generate random DNI if not provided
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // Calculate verification digit
45  const verificationDigit = calculateVerificationDigit(typeCode, dni);
46  
47  // Format CUIT/CUIL
48  return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52  // Remove hyphens if present
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // Check basic format
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'Invalid format' };
58  }
59  
60  // Extract parts
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  // Validate type code
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'Invalid type code' };
69  }
70  
71  // Calculate and compare verification digit
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'Invalid verification digit' };
75  }
76  
77  return { isValid: true };
78}
79
80// Example usage
81console.log(generateCuitCuil(20, 12345678)); // Generate for specific DNI
82console.log(generateCuitCuil(27)); // Generate with random DNI
83console.log(validateCuitCuil("20-12345678-9")); // Validate a 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        // Convert to string and ensure DNI is 8 digits with leading zeros
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // Combine type code and DNI
15        String digits = typeCodeStr + dniStr;
16        
17        // Calculate sum of products
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // Calculate verification digit
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // Special cases
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("Invalid type code. Must be one of: " + VALID_TYPE_CODES);
39        }
40        
41        // Generate random DNI if not provided
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // Calculate verification digit
48        int verificationDigit = calculateVerificationDigit(typeCode, dni);
49        
50        // Format CUIT/CUIL
51        return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52    }
53    
54    public static ValidationResult validateCuitCuil(String cuitCuil) {
55        // Remove hyphens if present
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // Check basic format
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "Invalid format");
61        }
62        
63        // Extract parts
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        // Validate type code
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "Invalid type code");
71        }
72        
73        // Calculate and compare verification digit
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "Invalid verification digit");
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        // Example usage
102        System.out.println(generateCuitCuil(20, 12345678)); // Generate for specific DNI
103        System.out.println(generateCuitCuil(27, null)); // Generate with random DNI
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Validate a CUIT/CUIL
105    }
106}
107

PHP

1<?php
2
3function calculateVerificationDigit($typeCode, $dni) {
4    // Convert to string and ensure DNI is 8 digits with leading zeros
5    $typeCodeStr = (string)$typeCode;
6    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
7    
8    // Combine type code and DNI
9    $digits = $typeCodeStr . $dniStr;
10    
11    // Weights for each position
12    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
13    
14    // Calculate sum of products
15    $sumProducts = 0;
16    for ($i = 0; $i < 10; $i++) {
17        $sumProducts += (int)$digits[$i] * $weights[$i];
18    }
19    
20    // Calculate verification digit
21    $verificationDigit = 11 - ($sumProducts % 11);
22    
23    // Special cases
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    // Valid type codes
35    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
36    
37    if (!in_array($typeCode, $validTypeCodes)) {
38        throw new Exception("Invalid type code. Must be one of: " . implode(', ', $validTypeCodes));
39    }
40    
41    // Generate random DNI if not provided
42    if ($dni === null) {
43        $dni = rand(10000000, 99999999);
44    }
45    
46    // Calculate verification digit
47    $verificationDigit = calculateVerificationDigit($typeCode, $dni);
48    
49    // Format CUIT/CUIL
50    return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit);
51}
52
53function validateCuitCuil($cuitCuil) {
54    // Remove hyphens if present
55    $cuitCuilClean = str_replace('-', '', $cuitCuil);
56    
57    // Check basic format
58    if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
59        return ['isValid' => false, 'errorMessage' => 'Invalid format'];
60    }
61    
62    // Extract parts
63    $typeCode = (int)substr($cuitCuilClean, 0, 2);
64    $dni = (int)substr($cuitCuilClean, 2, 8);
65    $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
66    
67    // Validate type code
68    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
69    if (!in_array($typeCode, $validTypeCodes)) {
70        return ['isValid' => false, 'errorMessage' => 'Invalid type code'];
71    }
72    
73    // Calculate and compare verification digit
74    $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
75    if ($calculatedDigit !== $verificationDigit) {
76        return ['isValid' => false, 'errorMessage' => 'Invalid verification digit'];
77    }
78    
79    return ['isValid' => true];
80}
81
82// Example usage
83echo generateCuitCuil(20, 12345678) . "\n"; // Generate for specific DNI
84echo generateCuitCuil(27) . "\n"; // Generate with random DNI
85var_dump(validateCuitCuil("20-12345678-9")); // Validate a CUIT/CUIL
86?>
87

Întrebări Frecvente

Care este diferența dintre CUIT și CUIL?

CUIT-ul (Clave Única de Identificación Tributaria) este utilizat în scopuri de identificare fiscală și este atribuit atât indivizilor, cât și entităților legale care trebuie să plătească impozite în Argentina. CUIL-ul (Clave Única de Identificación Laboral) este specific pentru lucrători și este utilizat în scopuri de muncă și securitate socială. Deși împărtășesc același format și algoritm de calcul, acestea servesc scopuri administrative diferite.

Ce coduri de tip sunt utilizate pentru indivizi și care pentru companii?

Pentru indivizi:

20, 23, 24: Indivizi de sex masculin (CUIL)
27: Indivizi de sex feminin (CUIL)

Pentru companii și organizații:

30: Corporații (CUIT)
33: Asociații Civile (CUIT)
34: Fundații (CUIT)

Cum se calculează cifra de verificare?

Cifra de verificare este calculată folosind un algoritm de sumă ponderată. Fiecare dintre primele 10 cifre este înmulțită cu un coeficient corespunzător (5, 4, 3, 2, 7, 6, 5, 4, 3, 2), iar rezultatele sunt adunate. Cifra de verificare este 11 minus restul când această sumă este împărțită la 11. Cazuri speciale: dacă rezultatul este 11, cifra de verificare este 0; dacă rezultatul este 10, cifra de verificare este 9.

Pot folosi acest instrument pentru a genera numere CUIT/CUIL reale, oficiale?

Nu, acest instrument este conceput pentru scopuri de testare și educaționale doar. Numerele generate sunt valide din punct de vedere matematic conform algoritmului CUIT/CUIL, dar nu sunt înregistrate oficial la autoritățile fiscale argentiniene (AFIP). Pentru înregistrarea oficială a CUIT/CUIL, indivizii și companiile trebuie să urmeze procedurile legale corespunzătoare prin AFIP.

De ce eșuează validarea CUIT/CUIL-ului meu, chiar dacă formatul pare corect?

Validarea poate eșua din mai multe motive:

Codul de tip nu este unul dintre codurile valide (20, 23, 24, 27, 30, 33, 34)
Cifra de verificare nu se potrivește cu valoarea calculată pe baza algoritmului
Formatul este incorect (ar trebui să fie XX-XXXXXXXX-X)
Există caractere non-numerice în introducerea ta (în afară de cratime)

Sunt necesare cratime în numerele CUIT/CUIL?

Deși numerele CUIT/CUIL sunt de obicei scrise și afișate cu cratime (XX-XXXXXXXX-X), cratimele nu fac parte din numărul efectiv pentru scopuri de calcul. Validatorul nostru acceptă ambele formate (cu sau fără cratime) și va valida corect orice format.

Poate un număr CUIT/CUIL avea mai puțin de 8 cifre în porțiunea DNI?

Nu, porțiunea DNI trebuie să fie întotdeauna exact 8 cifre. Dacă DNI-ul real are mai puține cifre, acesta trebuie completat cu zerouri la început pentru a ajunge la 8 cifre. De exemplu, dacă DNI-ul cuiva este 1234567, în CUIT/CUIL acesta ar fi reprezentat ca 01234567.

Cum pot verifica dacă un CUIT/CUIL este înregistrat oficial în Argentina?

Pentru a verifica dacă un CUIT/CUIL este înregistrat oficial și activ, ar trebui să folosești site-ul oficial AFIP (Administración Federal de Ingresos Públicos) sau serviciile acestuia. Instrumentul nostru verifică doar validitatea matematică a numărului, nu statutul său oficial de înregistrare.

Pot folosi acest instrument în aplicația mea comercială?

Da, poți integra algoritmul și logica demonstrate în acest instrument în aplicațiile tale comerciale. Algoritmul de validare CUIT/CUIL este un standard public. Cu toate acestea, pentru medii de producție, recomandăm implementarea unei gestionări corespunzătoare a erorilor și luarea în considerare a validării suplimentare împotriva surselor oficiale atunci când este necesar.

Instrumentul stochează vreunul dintre numerele CUIT/CUIL generate sau validate?

Nu, acest instrument nu stochează nicio informație introdusă sau generată. Toate procesările se fac pe partea clientului în browserul tău, iar nicio dată nu este trimisă sau stocată pe serverele noastre. Acest lucru asigură confidențialitatea și securitatea oricărei informații introduse.

Referințe

AFIP (Administración Federal de Ingresos Públicos). "CUIT/CUIL/CDI." Site oficial. https://www.afip.gob.ar/
Ministerul Muncii, Ocupării și Securității Sociale. "CUIL - Clave Única de Identificación Laboral." https://www.argentina.gob.ar/trabajo
ANSES (Administración Nacional de la Seguridad Social). "Obține-mi CUIL." https://www.anses.gob.ar/
Buletin Oficial al Republicii Argentina. "Rezoluția Generală AFIP 2854/2010: Procedură. Clave Única de Identificación Tributaria (C.U.I.T.)."
Codul Fiscal al Republicii Argentina. "Identificarea și Înregistrarea Contribuabililor."

Ești gata să generezi sau să validezi numere CUIT/CUIL argentiniene? Încearcă instrumentul nostru acum și simplifică procesul tău de testare!

Generator și Validator de CUIT/CUIL Argentinian

Generator CUIT/CUIL

CUIT/CUIL Generat

Documentație