Generați numere valide de CUIT/CUIL argentinian pentru testare sau validați numerele existente. Un instrument simplu pentru dezvoltatori care lucrează cu numerele de identificare fiscală și de muncă argentiniene.
Introduceți un număr DNI de 8 cifre sau folosiți generatorul aleator
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.
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
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.
Cifra de verificare este calculată folosind următorul algoritm:
Matematic, acest lucru poate fi exprimat ca:
Unde:
Selectează tab-ul "Generator" din partea de sus a interfeței instrumentului.
Alege un Cod de Tip din meniul derulant:
Introdu un Număr DNI (opțional):
Generează un DNI Aleator (opțional):
Vezi CUIT/CUIL Generat:
Copiază Rezultatul:
Selectează tab-ul "Validator" din partea de sus a interfeței instrumentului.
Introdu CUIT/CUIL-ul de Validat:
Apasă butonul "Validare":
Vezi Rezultatul Validării:
Informații Suplimentare:
Dezvoltare Software: Generează numere CUIT/CUIL valide pentru a testa aplicații care gestionează identificarea fiscală argentiniană, cum ar fi:
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.
Î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.
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:
validar-cuitafip-phppy-cuitCalcul 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.
Sistemul de identificare CUIT/CUIL din Argentina a evoluat semnificativ de la începuturile sale:
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.
Î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.
Î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.
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
741function 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
841import 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}
1071<?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?>
87CUIT-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.
Pentru indivizi:
Pentru companii și organizații:
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.
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.
Validarea poate eșua din mai multe motive:
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.
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.
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.
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.
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.
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!
Descoperiți mai multe instrumente care ar putea fi utile pentru fluxul dvs. de lucru