🛠️

Whiz Tools

Build • Create • Innovate

Generador y Validador de CUIT/CUIL Argentino

Genera números de CUIT/CUIL argentinos válidos para pruebas o valida los existentes. Herramienta sencilla para desarrolladores que trabajan con números de identificación fiscal y laboral argentinos.

Generador de CUIT/CUIL

Ingrese un número de DNI de 8 dígitos o use el generador aleatorio

CUIT/CUIL Generado

📚

Documentación

Generador y Validador de CUIT/CUIL Argentino

Introducción

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 individuos y 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 de 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 aleatoriamente o basados en parámetros específicos, y un validador que verifica si un número de CUIT/CUIL dado sigue el formato y las reglas de cálculo correctas.

Estructura y Cálculo de CUIT/CUIL

Entendiendo el Formato

Un número de CUIT/CUIL válido consta de 11 dígitos que generalmente se muestran en el formato XX-XXXXXXXX-X:

  1. Código de Tipo (primeros 2 dígitos): Indica el tipo de entidad

    • 20, 23, 24: Individuos masculinos (CUIL)
    • 27: Individuos femeninos (CUIL)
    • 30, 33, 34: Empresas y organizaciones (CUIT)

  2. 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 asignado único.

  3. 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.

Cálculo del Dígito de Verificación

El dígito de verificación se calcula utilizando el siguiente algoritmo:

  1. Toma los primeros 10 dígitos del CUIT/CUIL (código de tipo + DNI)
  2. Multiplica cada dígito por un peso correspondiente de esta secuencia: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
  3. Suma todos los productos resultantes
  4. Calcula 11 menos el resto de la suma dividido por 11
  5. Si el resultado es 11, el dígito de verificación es 0
  6. Si el resultado es 10, el dígito de verificación es 9
  7. De lo contrario, el resultado es el dígito de verificación

Matemáticamente, esto se puede expresar como:

VD=11−((∑i=110di×wi) mod 11)VD = 11 - ((\sum_{i=1}^{10} d_i \times w_i) \bmod 11)

Donde:

  • VDVD es el dígito de verificación
  • did_i es el ii-ésimo dígito de los primeros 10 dígitos
  • wiw_i es el peso correspondiente de la secuencia [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
  • Casos especiales: si VD=11VD = 11 entonces VD=0VD = 0, si VD=10VD = 10 entonces VD=9VD = 9

Guía Paso a Paso

Usando el Generador

  1. Selecciona la pestaña "Generador" en la parte superior de la interfaz de la herramienta.

  2. Elige un Código de Tipo del menú desplegable:

    • 20: Masculino (CUIL)
    • 23: Empresa (CUIT)
    • 24: Empresa Temporal (CUIT)
    • 27: Femenino (CUIL)
    • 30: Corporación (CUIT)
    • 33: Asociación Civil (CUIT)
    • 34: Fundación (CUIT)

  3. Ingresa un Número de DNI (opcional):

    • Introduce un número de DNI de 8 dígitos en el campo provisto
    • Si se deja vacío, la herramienta utilizará un DNI generado aleatoriamente
    • Si ingresas menos de 8 dígitos, el sistema completará con ceros a la izquierda

  4. Generar DNI Aleatorio (opcional):

    • Haz clic en el botón "Aleatorio" para generar un número de DNI de 8 dígitos aleatorio

  5. Ver el CUIT/CUIL Generado:

    • La herramienta mostrará automáticamente un CUIT/CUIL válido basado en tus entradas
    • El formato será XX-XXXXXXXX-X con el dígito de verificación correcto

  6. Copia el Resultado:

    • Haz clic en el ícono de copiar para copiar el CUIT/CUIL generado en tu portapapeles
    • Aparecerá un mensaje de confirmación cuando se copie con éxito

Usando el Validador

  1. Selecciona la pestaña "Validador" en la parte superior de la interfaz de la herramienta.

  2. Ingresa el CUIT/CUIL a Validar:

    • Introduce el CUIT/CUIL en el formato XX-XXXXXXXX-X
    • La herramienta formateará automáticamente tu entrada con guiones a medida que escribas
    • También puedes ingresar el número sin guiones (XXXXXXXXXXX)

  3. Haz clic en el botón "Validar":

    • La herramienta verificará el formato, el código de tipo y el dígito de verificación

  4. Ver el Resultado de la Validación:

    • Para números de CUIT/CUIL válidos, aparecerá un mensaje de éxito en verde
    • Para números inválidos, aparecerá un mensaje de error en rojo que explicará el problema:
      • Formato inválido (debe ser XX-XXXXXXXX-X)
      • Código de tipo inválido (debe ser uno de: 20, 23, 24, 27, 30, 33, 34)
      • Dígito de verificación inválido

  5. Información Adicional:

    • Para números válidos, la herramienta muestra un desglose de los componentes:
      • Código de tipo y su significado
      • Número de DNI
      • Dígito de verificación

Casos de Uso

Desarrollo y Pruebas

  1. Desarrollo de Software: Generar números de CUIT/CUIL válidos para probar aplicaciones que manejan identificaciones fiscales argentinas, tales como:

    • Plataformas de comercio electrónico
    • Software de contabilidad
    • Sistemas de gestión de recursos humanos
    • Portales de servicios gubernamentales
    • Aplicaciones bancarias

  2. Población de Base de Datos: Crear datos de prueba realistas para sistemas que almacenan información de usuarios argentinos, asegurando que las restricciones de la base de datos y las reglas de validación funcionen correctamente.

  3. Pruebas de Validación de Formularios: Probar 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.

  4. Pruebas de API: Generar 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.

  5. Automatización de QA: Incorporar la generación de CUIT/CUIL en scripts de prueba automatizados para crear casos de prueba dinámicos en lugar de utilizar datos de prueba estáticos.

Fines Educativos

  1. Aprender Algoritmos de Validación: Entender 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.

  2. Enseñar Validación de Datos: Usar como ejemplo educativo al enseñar técnicas de validación de formularios a nuevos desarrolladores.

  3. Entender Requisitos Empresariales Argentinos: Aprender sobre el sistema de identificación utilizado en Argentina para el desarrollo empresarial internacional.

Alternativas

Si bien nuestra herramienta proporciona una forma directa de generar y validar números de CUIT/CUIL, hay enfoques alternativos que podrías considerar:

  1. 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.

  2. Bibliotecas y Paquetes: Varios lenguajes de programación tienen bibliotecas diseñadas específicamente para la validación de identificaciones fiscales argentinas:

    • JavaScript: paquete npm validar-cuit
    • PHP: biblioteca afip-php
    • Python: paquete py-cuit

  3. Cálculo Manual: Para fines educativos, podrías calcular el dígito de verificación manualmente utilizando el algoritmo descrito anteriormente.

  4. 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.

Historia del Sistema CUIT/CUIL

El sistema de identificación CUIT/CUIL en Argentina ha evolucionado significativamente desde su creación:

Orígenes e Implementación

El CUIT (Clave Única de Identificación Tributaria) se introdujo 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 mantiene un formato consistente.

Evolución y Digitalización

En la década de 1990, a medida que Argentina experimentaba 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 digitales del gobierno, convirtiéndose en un componente esencial de las iniciativas de gobierno electrónico de Argentina. Este período también vio la estandarización del algoritmo y formato de verificación que sigue en uso hoy en día.

Desarrollos Recientes

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 que incluyen servicios bancarios, transacciones de propiedad, servicios públicos y compras en línea, convirtiéndolo en un identificador esencial para tanto individuos como empresas que operan en Argentina.

Ejemplos de Código

Python

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    # Verificar 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 DNI específico
72print(generate_cuit_cuil(27))  # Generar con DNI aleatorio
73print(validate_cuit_cuil("20-12345678-9"))  # Validar un CUIT/CUIL
74

JavaScript

1function 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  // Verificar 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 DNI específico
82console.log(generateCuitCuil(27)); // Generar con DNI aleatorio
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 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        // Verificar 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 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}
107

PHP

1<?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    // Verificar 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 DNI específico
84echo generateCuitCuil(27) . "\n"; // Generar con DNI aleatorio
85var_dump(validateCuitCuil("20-12345678-9")); // Validar un CUIT/CUIL
86?>
87

Preguntas Frecuentes

¿Cuál es la diferencia entre CUIT y CUIL?

El 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.

¿Qué códigos de tipo se utilizan para individuos y cuáles para empresas?

Para individuos:

  • 20, 23, 24: Individuos masculinos (CUIL)
  • 27: Individuos femeninos (CUIL)

Para empresas y organizaciones:

  • 30: Corporaciones (CUIT)
  • 33: Asociaciones Civiles (CUIT)
  • 34: Fundaciones (CUIT)

¿Cómo se calcula el dígito de verificación?

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.

¿Puedo usar esta herramienta para generar números de CUIT/CUIL reales y oficiales?

No, esta herramienta está diseñada solo para fines de prueba y educativos. Los números generados son matemáticamente válidos según el algoritmo de CUIT/CUIL, pero no están registrados oficialmente ante las autoridades fiscales argentinas (AFIP). Para el registro oficial de CUIT/CUIL, individuos y empresas deben seguir los procedimientos legales adecuados a través de la AFIP.

¿Por qué falla la validación de mi CUIT/CUIL aunque el formato se vea correcto?

La validación puede fallar por varias razones:

  1. El código de tipo no es uno de los códigos válidos (20, 23, 24, 27, 30, 33, 34)
  2. El dígito de verificación no coincide con el valor calculado según el algoritmo
  3. El formato es incorrecto (debe ser XX-XXXXXXXX-X)
  4. Hay caracteres no numéricos en la entrada (aparte de los guiones)

¿Son obligatorios los guiones en los números de CUIT/CUIL?

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.

¿Puede un número de CUIT/CUIL tener menos de 8 dígitos en la porción de DNI?

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.

¿Cómo puedo verificar si un CUIT/CUIL está oficialmente registrado en Argentina?

Para verificar si un CUIT/CUIL está oficialmente registrado y activo, debes utilizar el sitio web o servicios oficiales 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.

¿Puedo usar esta herramienta en mi aplicación comercial?

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 validaciones adicionales contra fuentes oficiales cuando sea necesario.

¿La herramienta almacena alguno de los números de CUIT/CUIL generados o validados?

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.

Referencias

  1. AFIP (Administración Federal de Ingresos Públicos). "CUIT/CUIL/CDI." Sitio Web Oficial. https://www.afip.gob.ar/

  2. Ministerio de Trabajo, Empleo y Seguridad Social. "CUIL - Clave Única de Identificación Laboral." https://www.argentina.gob.ar/trabajo

  3. ANSES (Administración Nacional de la Seguridad Social). "Obtener mi CUIL." https://www.anses.gob.ar/

  4. 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.)."

  5. 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!

🔗

Herramientas Relacionadas

Descubre más herramientas que podrían ser útiles para tu flujo de trabajo

Generador y Validador de CUIT de Argentina para Fines de Prueba

Prueba esta herramienta

Generador y Validador de CBU Argentino | Códigos Bancarios

Prueba esta herramienta

Generador y validador de IBAN para pruebas y verificación

Prueba esta herramienta

Generador y validador de CNPJ brasileño para pruebas

Prueba esta herramienta

Generador y Validador de CLABE Mexicana para Pruebas de Software

Prueba esta herramienta

Calculadora de Perímetro Mojado para Canales y Tubos

Prueba esta herramienta

Generador de CPF Válido para Pruebas y Desarrollo de Software

Prueba esta herramienta

Generador de identificadores únicos resistentes a colisiones

Prueba esta herramienta

Generador de RFC Mexicano para Pruebas | Crea Códigos de Identificación Fiscal Válidos

Prueba esta herramienta