Generador i Validador de CUIT/CUIL Argentí

Introducció

El CUIT argentí (Clave Única de Identificación Tributaria) i el CUIL (Clave Única de Identificación Laboral) són números d'identificació únics que s'utilitzen a Argentina per a fins fiscals i laborals, respectivament. Aquests codis de 11 dígits són essencials perquè les persones i les empreses operin legalment dins del sistema econòmic argentí. La nostra eina Generador i Validador de CUIT/CUIL proporciona una manera senzilla i eficient de generar números de CUIT/CUIL vàlids per a fins de prova i validar números existents per assegurar-se que s'ajustin al format oficial i a l'algorisme de verificació.

Ja siguis un desenvolupador provant aplicacions que gestionen identificadors fiscals argentins, un especialista en QA verificant la funcionalitat del sistema, o simplement necessitis entendre com funcionen aquests números d'identificació, aquesta eina ofereix una solució directa sense complexitats innecessàries. L'eina presenta dues funcions principals: un generador que crea números de CUIT/CUIL vàlids aleatòriament o basats en paràmetres específics, i un validador que verifica si un número de CUIT/CUIL donat segueix les regles de format i càlcul correctes.

Estructura i Càlcul del CUIT/CUIL

Comprendre el Format

Un número de CUIT/CUIL vàlid consisteix en 11 dígits que normalment es mostren en el format XX-XXXXXXXX-X:

Codi de Tipus (primeres 2 xifres): Indica el tipus d'entitat
- 20, 23, 24: Individus masculins (CUIL)
- 27: Individus femenins (CUIL)
- 30, 33, 34: Empreses i organitzacions (CUIT)
Número de DNI (8 dígits del mig): Per a individus, aquest és el seu número de document d'identitat nacional (DNI), completat amb zeros a l'esquerra si és necessari per arribar a 8 dígits. Per a empreses, aquest és un número assignat únic.
Dígits de Verificació (últim dígit): Un dígit de control calculat mitjançant un algorisme específic per validar tot el número.

Càlcul del Dígit de Verificació

El dígit de verificació es calcula mitjançant l'algorisme següent:

Pren les primeres 10 xifres del CUIT/CUIL (codi de tipus + DNI)
Multiplica cada xifra per un pes corresponent d'aquesta seqüència: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
Suma tots els productes resultants
Calcula 11 menys el residu de la suma dividida per 11
Si el resultat és 11, el dígit de verificació és 0
Si el resultat és 10, el dígit de verificació és 9
En cas contrari, el resultat és el dígit de verificació

Matemàticament, això es pot expressar com:

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

On:

$VD$ és el dígit de verificació
$d_i$ és la $i$ -è xifra de les primeres 10 xifres
$w_i$ és el pes corresponent de la seqüència [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
Casos especials: si $VD = 11$ llavors $VD = 0$ , si $VD = 10$ llavors $VD = 9$

Guia Pas a Pas

Ús del Generador

Selecciona la pestanya "Generador" a la part superior de la interfície de l'eina.
Tria un Codi de Tipus del menú desplegable:
- 20: Masculí (CUIL)
- 23: Empresarial (CUIT)
- 24: Empresarial Temporal (CUIT)
- 27: Femení (CUIL)
- 30: Corporació (CUIT)
- 33: Associació Civil (CUIT)
- 34: Fundació (CUIT)
Introdueix un Número de DNI (opcional):
- Introdueix un número de DNI de 8 dígits al camp proporcionat
- Si es deixa buit, l'eina utilitzarà un DNI generat aleatòriament
- Si introdueixes menys de 8 dígits, el sistema completarà amb zeros a l'esquerra
Generar DNI Aleatori (opcional):
- Fes clic al botó "Aleatori" per generar un número de DNI de 8 dígits aleatori
Veure el CUIT/CUIL Generat:
- L'eina mostra automàticament un CUIT/CUIL vàlid basat en les teves entrades
- El format serà XX-XXXXXXXX-X amb el dígit de verificació correcte
Copia el Resultat:
- Fes clic a la icona de còpia per copiar el CUIT/CUIL generat al teu portapapers
- Apareixerà un missatge de confirmació quan s'hagi copiat amb èxit

Ús del Validador

Selecciona la pestanya "Validador" a la part superior de la interfície de l'eina.
Introdueix el CUIT/CUIL a Validar:
- Introdueix el CUIT/CUIL en el format XX-XXXXXXXX-X
- L'eina formatarà automàticament la teva entrada amb guions mentre escrius
- També pots introduir el número sense guions (XXXXXXXXXXX)
Fes clic al botó "Validar":
- L'eina comprovarà el format, el codi de tipus i el dígit de verificació
Veure el Resultat de Validació:
- Per a números de CUIT/CUIL vàlids, apareixerà un missatge d'èxit en verd
- Per a números no vàlids, apareixerà un missatge d'error en vermell que explicarà el problema:
  - Format no vàlid (ha de ser XX-XXXXXXXX-X)
  - Codi de tipus no vàlid (ha de ser un dels següents: 20, 23, 24, 27, 30, 33, 34)
  - Dígit de verificació no vàlid
Informació Addicional:
- Per a números vàlids, l'eina mostra un desglossament dels components:
  - Codi de tipus i el seu significat
  - Número de DNI
  - Dígit de verificació

Casos d'Ús

Desenvolupament i Proves

Desenvolupament de Programari: Genera números de CUIT/CUIL vàlids per provar aplicacions que gestionen identificadors fiscals argentins, com ara:
- Plataformes de comerç electrònic
- Programari de comptabilitat
- Sistemes de gestió de recursos humans
- Portals de serveis governamentals
- Aplicacions bancàries
Població de Bases de Dades: Crea dades de prova realistes per a sistemes que emmagatzemen informació d'usuaris argentins, assegurant que les restriccions de la base de dades i les regles de validació funcionin correctament.
Proves de Validació de Formes: Prova la validació d'entrada per formularis web que recullen informació de CUIT/CUIL, verificando que apareguin missatges d'error adequats per a entrades no vàlides.
Proves d'API: Genera càrregues vàlides per a punts finals d'API que requereixen números de CUIT/CUIL, assegurant que les teves proves d'integració utilitzin dades vàlides.
Automatització de QA: Incorpora la generació de CUIT/CUIL en scripts de prova automatitzats per crear casos de prova dinàmics en lloc d'utilitzar dades de prova estàtiques.

Propòsits Educatius

Aprendre Algorismes de Validació: Entendre com funcionen els algorismes de dígits de control en la pràctica veient el procés de verificació de CUIT/CUIL en acció.
Ensenyar Validació de Dades: Utilitzar com a exemple educatiu quan s'ensenya tècniques de validació de formularis a nous desenvolupadors.
Entendre els Requisits Empresarials Argentins: Aprendre sobre el sistema d'identificació utilitzat a Argentina per al desenvolupament empresarial internacional.

Alternatives

Si bé la nostra eina proporciona una manera senzilla de generar i validar números de CUIT/CUIL, hi ha enfocaments alternatius que podríeu considerar:

Validació Oficial del Govern: Per a entorns de producció, sempre valida els números de CUIT/CUIL contra la base de dades oficial de l'AFIP (Administración Federal de Ingresos Públicos) quan sigui possible.
Llibreries i Paquets: Diversos llenguatges de programació tenen llibreries dissenyades específicament per a la validació d'identificadors fiscals argentins:
- JavaScript: paquet npm validar-cuit
- PHP: llibreria afip-php
- Python: paquet py-cuit
Càlcul Manual: Per a fins educatius, podríeu calcular el dígit de verificació manualment utilitzant l'algorisme descrit anteriorment.
Serveis de Validació Empresarials Complets: Per a aplicacions empresarials, considereu utilitzar serveis de validació complets que no només comprovin el format, sinó que també verifiquin l'existència i l'estat de l'entitat associada al CUIT/CUIL.

Història del Sistema CUIT/CUIL

El sistema d'identificació CUIT/CUIL a Argentina ha evolucionat significativament des de la seva creació:

Orígens i Implementació

El CUIT (Clave Única de Identificación Tributaria) es va introduir per primera vegada a Argentina als anys 70 com a part dels esforços per modernitzar el sistema de recaptació d'impostos. L'Administració Federal d'Ingressos Públics (AFIP) va implementar aquest identificador únic per rastrejar els contribuents de manera més eficient i reduir l'evasió fiscal.

El CUIL (Clave Única de Identificación Laboral) es va introduir més tard per identificar específicament els treballadors en el sistema de seguretat social, creant una distinció entre la identificació fiscal i la identificació laboral, tot mantenint un format consistent.

Evolució i Digitalització

Als anys 90, a mesura que Argentina va passar per reformes econòmiques significatives, el sistema CUIT/CUIL es va convertir en cada vegada més important per rastrejar l'activitat econòmica. El sistema es va digitalitzar encara més, i es van implementar sistemes de verificació en línia.

A principis dels anys 2000, el sistema CUIT/CUIL es va integrar amb diversos serveis governamentals digitals, convertint-se en un component essencial de les iniciatives d'e-governament d'Argentina. Aquest període també va veure la normalització de l'algorisme de verificació i el format que romanen en ús avui dia.

Desenvolupaments Recents

En els darrers anys, l'AFIP ha millorat els processos de seguretat i verificació per als números de CUIT/CUIL, implementant sistemes de validació més sofisticats i integrant-los amb altres bases de dades governamentals. El sistema ara juga un paper crucial en els esforços d'Argentina per combatre l'evasió fiscal i formalitzar l'economia.

Avui, el CUIT/CUIL s'utilitza no només per a fins fiscals i laborals, sinó també per a una àmplia gamma d'activitats, incloent transaccions bancàries, transaccions immobiliàries, serveis públics i compres en línia, convertint-se en un identificador essencial tant per a individus com per a empreses que operen a Argentina.

Exemples de Codi

Python

1def calculate_verification_digit(type_code, dni):
2    # Convertir a cadena i assegurar-se que el DNI sigui de 8 dígits amb zeros a l'esquerra
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # Combinar codi de tipus i DNI
7    digits = type_code_str + dni_str
8    
9    # Pesos per a cada posició
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # Calcular la suma dels productes
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # Calcular el dígit de verificació
16    verification_digit = 11 - (sum_products % 11)
17    
18    # Casos especials
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    # Codis de tipus vàlids
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"Codi de tipus no vàlid. Ha de ser un dels següents: {valid_type_codes}")
34    
35    # Generar DNI aleatori si no es proporciona
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # Calcular el dígit de verificació
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    # Eliminar guions si estan presents
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # Comprovar format bàsic
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "Format no vàlid"
52    
53    # Extreure 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    # Validar codi de tipus
59    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60    if type_code not in valid_type_codes:
61        return False, "Codi de tipus no vàlid"
62    
63    # Calcular i comparar el dígit de verificació
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "Dígit de verificació no vàlid"
67    
68    return True, "CUIT/CUIL vàlid"
69
70# Exemple d'ús
71print(generate_cuit_cuil(20, 12345678))  # Generar per a un DNI específic
72print(generate_cuit_cuil(27))  # Generar amb DNI aleatori
73print(validate_cuit_cuil("20-12345678-9"))  # Validar un CUIT/CUIL
74

JavaScript

1function calculateVerificationDigit(typeCode, dni) {
2  // Convertir a cadena i assegurar-se que el DNI sigui de 8 dígits amb zeros a l'esquerra
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // Combinar codi de tipus i DNI
7  const digits = typeCodeStr + dniStr;
8  
9  // Pesos per a cada posició
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // Calcular la suma dels productes
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // Calcular el dígit de verificació
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // Casos especials
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  // Codis de tipus vàlids
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`Codi de tipus no vàlid. Ha de ser un dels següents: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // Generar DNI aleatori si no es proporciona
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // Calcular el dígit de verificació
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  // Eliminar guions si estan presents
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // Comprovar format bàsic
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'Format no vàlid' };
58  }
59  
60  // Extreure 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  // Validar codi de tipus
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'Codi de tipus no vàlid' };
69  }
70  
71  // Calcular i comparar el dígit de verificació
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'Dígit de verificació no vàlid' };
75  }
76  
77  return { isValid: true };
78}
79
80// Exemple d'ús
81console.log(generateCuitCuil(20, 12345678)); // Generar per a un DNI específic
82console.log(generateCuitCuil(27)); // Generar amb DNI aleatori
83console.log(validateCuitCuil("20-12345678-9")); // Validar un 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        // Convertir a cadena i assegurar-se que el DNI sigui de 8 dígits amb zeros a l'esquerra
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // Combinar codi de tipus i DNI
15        String digits = typeCodeStr + dniStr;
16        
17        // Calcular la suma dels productes
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // Calcular el dígit de verificació
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // Casos especials
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("Codi de tipus no vàlid. Ha de ser un dels següents: " + VALID_TYPE_CODES);
39        }
40        
41        // Generar DNI aleatori si no es proporciona
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // Calcular el dígit de verificació
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        // Eliminar guions si estan presents
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // Comprovar format bàsic
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "Format no vàlid");
61        }
62        
63        // Extreure 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        // Validar codi de tipus
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "Codi de tipus no vàlid");
71        }
72        
73        // Calcular i comparar el dígit de verificació
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "Dígit de verificació no vàlid");
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        // Exemple d'ús
102        System.out.println(generateCuitCuil(20, 12345678)); // Generar per a un DNI específic
103        System.out.println(generateCuitCuil(27, null)); // Generar amb DNI aleatori
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Validar un CUIT/CUIL
105    }
106}
107

PHP

1<?php
2
3function calculateVerificationDigit($typeCode, $dni) {
4    // Convertir a cadena i assegurar-se que el DNI sigui de 8 dígits amb zeros a l'esquerra
5    $typeCodeStr = (string)$typeCode;
6    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
7    
8    // Combinar codi de tipus i DNI
9    $digits = $typeCodeStr . $dniStr;
10    
11    // Pesos per a cada posició
12    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
13    
14    // Calcular la suma dels productes
15    $sumProducts = 0;
16    for ($i = 0; $i < 10; $i++) {
17        $sumProducts += (int)$digits[$i] * $weights[$i];
18    }
19    
20    // Calcular el dígit de verificació
21    $verificationDigit = 11 - ($sumProducts % 11);
22    
23    // Casos especials
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    // Codis de tipus vàlids
35    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
36    
37    if (!in_array($typeCode, $validTypeCodes)) {
38        throw new Exception("Codi de tipus no vàlid. Ha de ser un dels següents: " . implode(', ', $validTypeCodes));
39    }
40    
41    // Generar DNI aleatori si no es proporciona
42    if ($dni === null) {
43        $dni = rand(10000000, 99999999);
44    }
45    
46    // Calcular el dígit de verificació
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    // Eliminar guions si estan presents
55    $cuitCuilClean = str_replace('-', '', $cuitCuil);
56    
57    // Comprovar format bàsic
58    if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
59        return ['isValid' => false, 'errorMessage' => 'Format no vàlid'];
60    }
61    
62    // Extreure parts
63    $typeCode = (int)substr($cuitCuilClean, 0, 2);
64    $dni = (int)substr($cuitCuilClean, 2, 8);
65    $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
66    
67    // Validar codi de tipus
68    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
69    if (!in_array($typeCode, $validTypeCodes)) {
70        return ['isValid' => false, 'errorMessage' => 'Codi de tipus no vàlid'];
71    }
72    
73    // Calcular i comparar el dígit de verificació
74    $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
75    if ($calculatedDigit !== $verificationDigit) {
76        return ['isValid' => false, 'errorMessage' => 'Dígit de verificació no vàlid'];
77    }
78    
79    return ['isValid' => true];
80}
81
82// Exemple d'ús
83echo generateCuitCuil(20, 12345678) . "\n"; // Generar per a un DNI específic
84echo generateCuitCuil(27) . "\n"; // Generar amb DNI aleatori
85var_dump(validateCuitCuil("20-12345678-9")); // Validar un CUIT/CUIL
86?>
87

Preguntes Freqüents

Quina és la diferència entre CUIT i CUIL?

El CUIT (Clave Única de Identificación Tributaria) s'utilitza per a fins d'identificació fiscal i s'assigna tant a individus com a entitats legals que necessiten pagar impostos a Argentina. El CUIL (Clave Única de Identificación Laboral) és específic per a treballadors i s'utilitza per a fins laborals i de seguretat social. Si bé comparteixen el mateix format i algorisme de càlcul, serveixen a diferents fins administratius.

Quins codis de tipus s'utilitzen per a individus i quins per a empreses?

Per a individus:

20, 23, 24: Individus masculins (CUIL)
27: Individus femenins (CUIL)

Per a empreses i organitzacions:

30: Corporacions (CUIT)
33: Associació Civil (CUIT)
34: Fundació (CUIT)

Com es calcula el dígit de verificació?

El dígit de verificació es calcula mitjançant un algorisme de suma ponderada. Cada una de les primeres 10 xifres es multiplica per un pes corresponent (5, 4, 3, 2, 7, 6, 5, 4, 3, 2), i els resultats es sumen. El dígit de verificació és 11 menys el residu quan aquesta suma es divideix per 11. Casos especials: si el resultat és 11, el dígit de verificació és 0; si el resultat és 10, el dígit de verificació és 9.

Puc utilitzar aquesta eina per generar números de CUIT/CUIL reals i oficials?

No, aquesta eina està dissenyada per a fins de prova i educatius només. Els números generats són matemàticament vàlids segons l'algorisme de CUIT/CUIL, però no estan registrats oficialment amb les autoritats fiscals argentines (AFIP). Per al registre oficial de CUIT/CUIL, les persones i les empreses han de seguir els procediments legals adequats a través de l'AFIP.

Per què falla la meva validació de CUIT/CUIL encara que el format sembli correcte?

La validació pot fallar per diverses raons:

El codi de tipus no és un dels codis vàlids (20, 23, 24, 27, 30, 33, 34)
El dígit de verificació no coincideix amb el valor calculat segons l'algorisme
El format és incorrecte (ha de ser XX-XXXXXXXX-X)
Hi ha caràcters no numèrics a l'entrada (a part dels guions)

Són necessaris els guions en els números de CUIT/CUIL?

Si bé els números de CUIT/CUIL es solen escriure i mostrar amb guions (XX-XXXXXXXX-X), els guions no formen part del número real per a fins de càlcul. El nostre validador accepta ambdós formats (amb o sense guions) i validarà correctament qualsevol format.

Pot un número de CUIT/CUIL tenir menys de 8 dígits a la porció de DNI?

No, la porció de DNI ha de tenir sempre exactament 8 dígits. Si el DNI real té menys dígits, s'ha de completar amb zeros a l'esquerra per arribar a 8 dígits. Per exemple, si el DNI d'algú és 1234567, en el CUIT/CUIL es representaria com 01234567.

Com puc verificar si un CUIT/CUIL està oficialment registrat a Argentina?

Per verificar si un CUIT/CUIL està oficialment registrat i actiu, hauríeu d'utilitzar el lloc web o els serveis oficials de l'AFIP (Administración Federal de Ingresos Públicos). La nostra eina només verifica la validesa matemàtica del número, no el seu estat de registre oficial.

Puc utilitzar aquesta eina en la meva aplicació comercial?

Sí, podeu integrar l'algorisme i la lògica demostrada en aquesta eina a les vostres aplicacions comercials. L'algorisme de validació de CUIT/CUIL és un estàndard públic. No obstant això, per a entorns de producció, recomanem implementar una gestió d'errors adequada i considerar una validació addicional contra fonts oficials quan sigui necessari.

L'eina emmagatzema algun dels números de CUIT/CUIL generats o validades?

No, aquesta eina no emmagatzema cap de la informació introduïda o generada. Tots els processos es realitzen al costat del client al vostre navegador, i no es envia ni s'emmagatzema cap dada als nostres servidors. Això assegura la privadesa i la seguretat de qualsevol informació que introduïu.

Referències

AFIP (Administración Federal de Ingresos Públics). "CUIT/CUIL/CDI." Lloc web oficial. https://www.afip.gob.ar/
Ministeri de Treball, Empleament i Seguretat Social. "CUIL - Clave Única de Identificación Laboral." https://www.argentina.gob.ar/trabajo
ANSES (Administración Nacional de la Seguridad Social). "Obtenir el meu CUIL." https://www.anses.gob.ar/
Butlletí Oficial de la República Argentina. "Resolució General AFIP 2854/2010: Procediment. Clave Única de Identificación Tributaria (C.U.I.T.)."
Codi Fiscal de la República Argentina. "Identificació i Registre de Contribuents."

Preparat per generar o validar números de CUIT/CUIL argentins? Prova la nostra eina ara i simplifica el teu procés de prova!

Eina de Generació i Validació de CUIT/CUIL Argentins

Generador de CUIT/CUIL

CUIT/CUIL Generat

Documentació