Generer gyldige argentinske CUIT/CUIL-numre for testing eller valider eksisterende. En enkel verktøy for utviklere som arbeider med argentinske skatte- og arbeidsidentifikasjonsnumre.
Skriv inn et 8-sifret DNI-nummer eller bruk den tilfeldige generatoren
El CUIT (Clave Única de Identificación Tributaria) y el CUIL (Clave Única de Identificación Laboral) argentinos son números de identificación únicos utilizados en Argentina para fines fiscales y laborales, respectivamente. Estos códigos de 11 dígitos son esenciales para que las personas y las empresas operen legalmente dentro del sistema económico argentino. Nuestra herramienta Generador y Validador de CUIT/CUIL proporciona una forma simple y eficiente de generar números de CUIT/CUIL válidos para fines de prueba y validar números existentes para asegurar que se ajusten al formato oficial y al algoritmo de verificación.
Ya sea que seas un desarrollador probando aplicaciones que manejan identificaciones fiscales argentinas, un especialista en QA verificando la funcionalidad del sistema, o simplemente necesites entender cómo funcionan estos números de identificación, esta herramienta ofrece una solución directa sin complejidades innecesarias. La herramienta cuenta con dos funciones principales: un generador que crea números de CUIT/CUIL válidos de forma aleatoria o basada en parámetros específicos, y un validador que verifica si un número de CUIT/CUIL dado sigue las reglas de formato y cálculo correctas.
Un número de CUIT/CUIL válido consiste en 11 dígitos que normalmente se muestran en el formato XX-XXXXXXXX-X:
Código de Tipo (primeros 2 dígitos): Indica el tipo de entidad
Número de DNI (8 dígitos del medio): Para individuos, este es su número de documento nacional de identidad (DNI), completado con ceros a la izquierda si es necesario para alcanzar 8 dígitos. Para empresas, este es un número único asignado.
Dígito de Verificación (último dígito): Un dígito de control calculado utilizando un algoritmo específico para validar el número completo.
El dígito de verificación se calcula utilizando el siguiente algoritmo:
Matemáticamente, esto se puede expresar como:
Donde:
Selecciona la pestaña "Generador" en la parte superior de la interfaz de la herramienta.
Elige un Código de Tipo del menú desplegable:
Ingresa un Número de DNI (opcional):
Generar DNI Aleatorio (opcional):
Ver el CUIT/CUIL Generado:
Copia el Resultado:
Selecciona la pestaña "Validador" en la parte superior de la interfaz de la herramienta.
Ingresa el CUIT/CUIL a Validar:
Haz clic en el botón "Validar":
Ver el Resultado de la Validación:
Información Adicional:
Desarrollo de Software: Genera números de CUIT/CUIL válidos para probar aplicaciones que manejan identificaciones fiscales argentinas, como:
Población de Base de Datos: Crea datos de prueba realistas para sistemas que almacenan información de usuarios argentinos, asegurando que las restricciones de base de datos y las reglas de validación funcionen correctamente.
Pruebas de Validación de Formularios: Prueba la validación de entrada para formularios web que recopilan información de CUIT/CUIL, verificando que aparezcan mensajes de error adecuados para entradas inválidas.
Pruebas de API: Genera cargas útiles válidas para puntos finales de API que requieren números de CUIT/CUIL, asegurando que tus pruebas de integración utilicen datos válidos.
Automatización de QA: Incorpora la generación de CUIT/CUIL en scripts de prueba automatizados para crear casos de prueba dinámicos en lugar de usar datos de prueba estáticos.
Aprender Algoritmos de Validación: Comprender cómo funcionan los algoritmos de dígitos de control en la práctica al ver el proceso de verificación de CUIT/CUIL en acción.
Enseñar Validación de Datos: Usar como un ejemplo educativo al enseñar técnicas de validación de formularios a nuevos desarrolladores.
Entender los Requisitos Empresariales Argentinos: Aprender sobre el sistema de identificación utilizado en Argentina para el desarrollo empresarial internacional.
Mientras que nuestra herramienta proporciona una forma directa de generar y validar números de CUIT/CUIL, hay enfoques alternativos que podrías considerar:
Validación Oficial del Gobierno: Para entornos de producción, siempre valida los números de CUIT/CUIL contra la base de datos oficial de la AFIP (Administración Federal de Ingresos Públicos) cuando sea posible.
Bibliotecas y Paquetes: Varios lenguajes de programación tienen bibliotecas diseñadas específicamente para la validación de identificaciones fiscales argentinas:
validar-cuitafip-phppy-cuitCálculo Manual: Para fines educativos, podrías calcular el dígito de verificación manualmente utilizando el algoritmo descrito anteriormente.
Servicios de Validación Empresarial Integral: Para aplicaciones empresariales, considera utilizar servicios de validación integral que no solo verifiquen el formato, sino que también verifiquen la existencia y el estado de la entidad asociada con el CUIT/CUIL.
El sistema de identificación CUIT/CUIL en Argentina ha evolucionado significativamente desde su inicio:
El CUIT (Clave Única de Identificación Tributaria) fue introducido por primera vez en Argentina en la década de 1970 como parte de los esfuerzos para modernizar el sistema de recaudación de impuestos. La Administración Federal de Ingresos Públicos (AFIP) implementó este identificador único para rastrear a los contribuyentes de manera más eficiente y reducir la evasión fiscal.
El CUIL (Clave Única de Identificación Laboral) se introdujo más tarde para identificar específicamente a los trabajadores en el sistema de seguridad social, creando una distinción entre la identificación fiscal y la identificación laboral, mientras se mantenía un formato consistente.
En la década de 1990, a medida que Argentina atravesaba reformas económicas significativas, el sistema CUIT/CUIL se volvió cada vez más importante para rastrear la actividad económica. El sistema fue digitalizado aún más, y se implementaron sistemas de verificación en línea.
Los primeros años de 2000 vieron la integración del sistema CUIT/CUIL con varios servicios gubernamentales digitales, convirtiéndolo en un componente esencial de las iniciativas de gobierno electrónico de Argentina. Este período también vio la estandarización del algoritmo de verificación y el formato que permanece en uso hoy en día.
En los últimos años, la AFIP ha mejorado los procesos de seguridad y verificación para los números de CUIT/CUIL, implementando sistemas de validación más sofisticados e integrándolos con otras bases de datos gubernamentales. El sistema ahora juega un papel crucial en los esfuerzos de Argentina para combatir la evasión fiscal y formalizar la economía.
Hoy en día, el CUIT/CUIL se utiliza no solo para fines fiscales y laborales, sino también para una amplia gama de actividades, incluidas transacciones bancarias, transacciones de propiedad, servicios públicos y compras en línea, lo que lo convierte en un identificador esencial tanto para individuos como para empresas que operan en Argentina.
1def calculate_verification_digit(type_code, dni):
2 # Convertir a cadena y asegurar que el DNI tenga 8 dígitos con ceros a la izquierda
3 type_code_str = str(type_code)
4 dni_str = str(dni).zfill(8)
5
6 # Combinar código de tipo y DNI
7 digits = type_code_str + dni_str
8
9 # Pesos para cada posición
10 weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11
12 # Calcular suma de productos
13 sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14
15 # Calcular dígito de verificación
16 verification_digit = 11 - (sum_products % 11)
17
18 # Casos especiales
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 # Códigos de tipo válidos
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"Código de tipo inválido. Debe ser uno de: {valid_type_codes}")
34
35 # Generar DNI aleatorio si no se proporciona
36 if dni is None:
37 dni = random.randint(10000000, 99999999)
38
39 # Calcular dígito de verificación
40 verification_digit = calculate_verification_digit(type_code, dni)
41
42 # Formatear CUIT/CUIL
43 return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46 # Eliminar guiones si están presentes
47 cuit_cuil_clean = cuit_cuil.replace("-", "")
48
49 # Comprobar formato básico
50 if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51 return False, "Formato inválido"
52
53 # Extraer partes
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 código de tipo
59 valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60 if type_code not in valid_type_codes:
61 return False, "Código de tipo inválido"
62
63 # Calcular y comparar dígito de verificación
64 calculated_digit = calculate_verification_digit(type_code, dni)
65 if calculated_digit != verification_digit:
66 return False, "Dígito de verificación inválido"
67
68 return True, "CUIT/CUIL válido"
69
70# Ejemplo de uso
71print(generate_cuit_cuil(20, 12345678)) # Generar para un DNI específico
72print(generate_cuit_cuil(27)) # Generar con DNI aleatorio
73print(validate_cuit_cuil("20-12345678-9")) # Validar un CUIT/CUIL
741function calculateVerificationDigit(typeCode, dni) {
2 // Convertir a cadena y asegurar que el DNI tenga 8 dígitos con ceros a la izquierda
3 const typeCodeStr = typeCode.toString();
4 const dniStr = dni.toString().padStart(8, '0');
5
6 // Combinar código de tipo y DNI
7 const digits = typeCodeStr + dniStr;
8
9 // Pesos para cada posición
10 const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11
12 // Calcular suma de productos
13 let sumProducts = 0;
14 for (let i = 0; i < 10; i++) {
15 sumProducts += parseInt(digits[i]) * weights[i];
16 }
17
18 // Calcular dígito de verificación
19 let verificationDigit = 11 - (sumProducts % 11);
20
21 // Casos especiales
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 // Códigos de tipo válidos
33 const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34
35 if (!validTypeCodes.includes(typeCode)) {
36 throw new Error(`Código de tipo inválido. Debe ser uno de: ${validTypeCodes.join(', ')}`);
37 }
38
39 // Generar DNI aleatorio si no se proporciona
40 if (dni === undefined) {
41 dni = Math.floor(Math.random() * 90000000) + 10000000;
42 }
43
44 // Calcular dígito de verificación
45 const verificationDigit = calculateVerificationDigit(typeCode, dni);
46
47 // Formatear CUIT/CUIL
48 return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52 // Eliminar guiones si están presentes
53 const cuitCuilClean = cuitCuil.replace(/-/g, '');
54
55 // Comprobar formato básico
56 if (!/^\d{11}$/.test(cuitCuilClean)) {
57 return { isValid: false, errorMessage: 'Formato inválido' };
58 }
59
60 // Extraer partes
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 código de tipo
66 const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67 if (!validTypeCodes.includes(typeCode)) {
68 return { isValid: false, errorMessage: 'Código de tipo inválido' };
69 }
70
71 // Calcular y comparar dígito de verificación
72 const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73 if (calculatedDigit !== verificationDigit) {
74 return { isValid: false, errorMessage: 'Dígito de verificación inválido' };
75 }
76
77 return { isValid: true };
78}
79
80// Ejemplo de uso
81console.log(generateCuitCuil(20, 12345678)); // Generar para un DNI específico
82console.log(generateCuitCuil(27)); // Generar con DNI aleatorio
83console.log(validateCuitCuil("20-12345678-9")); // Validar un 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 // Convertir a cadena y asegurar que el DNI tenga 8 dígitos con ceros a la izquierda
11 String typeCodeStr = String.valueOf(typeCode);
12 String dniStr = String.format("%08d", dni);
13
14 // Combinar código de tipo y DNI
15 String digits = typeCodeStr + dniStr;
16
17 // Calcular suma de productos
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 dígito de verificación
24 int verificationDigit = 11 - (sumProducts % 11);
25
26 // Casos especiales
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("Código de tipo inválido. Debe ser uno de: " + VALID_TYPE_CODES);
39 }
40
41 // Generar DNI aleatorio si no se proporciona
42 if (dni == null) {
43 Random random = new Random();
44 dni = 10000000 + random.nextInt(90000000);
45 }
46
47 // Calcular dígito de verificación
48 int verificationDigit = calculateVerificationDigit(typeCode, dni);
49
50 // Formatear CUIT/CUIL
51 return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52 }
53
54 public static ValidationResult validateCuitCuil(String cuitCuil) {
55 // Eliminar guiones si están presentes
56 String cuitCuilClean = cuitCuil.replace("-", "");
57
58 // Comprobar formato básico
59 if (!cuitCuilClean.matches("\\d{11}")) {
60 return new ValidationResult(false, "Formato inválido");
61 }
62
63 // Extraer partes
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 código de tipo
69 if (!VALID_TYPE_CODES.contains(typeCode)) {
70 return new ValidationResult(false, "Código de tipo inválido");
71 }
72
73 // Calcular y comparar dígito de verificación
74 int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75 if (calculatedDigit != verificationDigit) {
76 return new ValidationResult(false, "Dígito de verificación inválido");
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 // Ejemplo de uso
102 System.out.println(generateCuitCuil(20, 12345678)); // Generar para un DNI específico
103 System.out.println(generateCuitCuil(27, null)); // Generar con DNI aleatorio
104 System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Validar un CUIT/CUIL
105 }
106}
1071<?php
2
3function calculateVerificationDigit($typeCode, $dni) {
4 // Convertir a cadena y asegurar que el DNI tenga 8 dígitos con ceros a la izquierda
5 $typeCodeStr = (string)$typeCode;
6 $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
7
8 // Combinar código de tipo y DNI
9 $digits = $typeCodeStr . $dniStr;
10
11 // Pesos para cada posición
12 $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
13
14 // Calcular suma de productos
15 $sumProducts = 0;
16 for ($i = 0; $i < 10; $i++) {
17 $sumProducts += (int)$digits[$i] * $weights[$i];
18 }
19
20 // Calcular dígito de verificación
21 $verificationDigit = 11 - ($sumProducts % 11);
22
23 // Casos especiales
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 // Códigos de tipo válidos
35 $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
36
37 if (!in_array($typeCode, $validTypeCodes)) {
38 throw new Exception("Código de tipo inválido. Debe ser uno de: " . implode(', ', $validTypeCodes));
39 }
40
41 // Generar DNI aleatorio si no se proporciona
42 if ($dni === null) {
43 $dni = rand(10000000, 99999999);
44 }
45
46 // Calcular dígito de verificación
47 $verificationDigit = calculateVerificationDigit($typeCode, $dni);
48
49 // Formatear CUIT/CUIL
50 return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit);
51}
52
53function validateCuitCuil($cuitCuil) {
54 // Eliminar guiones si están presentes
55 $cuitCuilClean = str_replace('-', '', $cuitCuil);
56
57 // Comprobar formato básico
58 if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
59 return ['isValid' => false, 'errorMessage' => 'Formato inválido'];
60 }
61
62 // Extraer partes
63 $typeCode = (int)substr($cuitCuilClean, 0, 2);
64 $dni = (int)substr($cuitCuilClean, 2, 8);
65 $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
66
67 // Validar código de tipo
68 $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
69 if (!in_array($typeCode, $validTypeCodes)) {
70 return ['isValid' => false, 'errorMessage' => 'Código de tipo inválido'];
71 }
72
73 // Calcular y comparar dígito de verificación
74 $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
75 if ($calculatedDigit !== $verificationDigit) {
76 return ['isValid' => false, 'errorMessage' => 'Dígito de verificación inválido'];
77 }
78
79 return ['isValid' => true];
80}
81
82// Ejemplo de uso
83echo generateCuitCuil(20, 12345678) . "\n"; // Generar para un DNI específico
84echo generateCuitCuil(27) . "\n"; // Generar con DNI aleatorio
85var_dump(validateCuitCuil("20-12345678-9")); // Validar un CUIT/CUIL
86?>
87El CUIT (Clave Única de Identificación Tributaria) se utiliza para fines de identificación fiscal y se asigna tanto a individuos como a entidades legales que necesitan pagar impuestos en Argentina. El CUIL (Clave Única de Identificación Laboral) es específicamente para trabajadores y se utiliza para fines laborales y de seguridad social. Aunque comparten el mismo formato y algoritmo de cálculo, sirven para diferentes propósitos administrativos.
Para individuos:
Para empresas y organizaciones:
El dígito de verificación se calcula utilizando un algoritmo de suma ponderada. Cada uno de los primeros 10 dígitos se multiplica por un peso correspondiente (5, 4, 3, 2, 7, 6, 5, 4, 3, 2), y los resultados se suman. El dígito de verificación es 11 menos el resto cuando esta suma se divide por 11. Casos especiales: si el resultado es 11, el dígito de verificación es 0; si el resultado es 10, el dígito de verificación es 9.
No, esta herramienta está diseñada solo para fines de prueba y educativos. Los números generados son matemáticamente válidos de acuerdo con el algoritmo de CUIT/CUIL, pero no están oficialmente registrados en las autoridades fiscales argentinas (AFIP). Para el registro oficial de CUIT/CUIL, las personas y las empresas deben seguir los procedimientos legales adecuados a través de la AFIP.
La validación puede fallar por varias razones:
Si bien los números de CUIT/CUIL se escriben y muestran comúnmente con guiones (XX-XXXXXXXX-X), los guiones no son parte del número real para fines de cálculo. Nuestro validador acepta ambos formatos (con o sin guiones) y validará correctamente cualquiera de los formatos.
No, la porción de DNI debe tener siempre exactamente 8 dígitos. Si el DNI real tiene menos dígitos, debe completarse con ceros a la izquierda para alcanzar 8 dígitos. Por ejemplo, si el DNI de alguien es 1234567, en el CUIT/CUIL se representaría como 01234567.
Para verificar si un CUIT/CUIL está oficialmente registrado y activo, debes utilizar el sitio web o los servicios de la AFIP (Administración Federal de Ingresos Públicos). Nuestra herramienta solo verifica la validez matemática del número, no su estado de registro oficial.
Sí, puedes integrar el algoritmo y la lógica demostrados en esta herramienta en tus aplicaciones comerciales. El algoritmo de validación de CUIT/CUIL es un estándar público. Sin embargo, para entornos de producción, recomendamos implementar un manejo adecuado de errores y considerar una validación adicional contra fuentes oficiales cuando sea necesario.
No, esta herramienta no almacena ninguna de las informaciones ingresadas o generadas. Todo el procesamiento se realiza del lado del cliente en tu navegador, y no se envían ni almacenan datos en nuestros servidores. Esto asegura la privacidad y seguridad de cualquier información que ingreses.
AFIP (Administración Federal de Ingresos Públicos). "CUIT/CUIL/CDI." Sitio Oficial. https://www.afip.gob.ar/
Ministerio de Trabajo, Empleo y Seguridad Social. "CUIL - Clave Única de Identificación Laboral." https://www.argentina.gob.ar/trabajo
ANSES (Administración Nacional de la Seguridad Social). "Obtener mi CUIL." https://www.anses.gob.ar/
Boletín Oficial de la República Argentina. "Resolución General AFIP 2854/2010: Procedimiento. Clave Única de Identificación Tributaria (C.U.I.T.)."
Código Fiscal de la República Argentina. "Identificación y Registro de Contribuyentes."
¿Listo para generar o validar números de CUIT/CUIL argentinos? ¡Prueba nuestra herramienta ahora y simplifica tu proceso de prueba!
Oppdag flere verktøy som kan være nyttige for arbeidsflyten din