Clave Única de Identificación Tributaria

(Redirigido desde «CUIT»)

La Clave Única de Identificación Tributaria (CUIT) es una clave que se utiliza en el sistema tributario de la República Argentina para poder identificar inequívocamente a las personas físicas o jurídicas autónomas de la República Argentina, susceptibles de tributar o tener que ser individualizadas de alguna manera por los entes de contralor. Las claves son asignadas por la Administración Federal de Ingresos Públicos (AFIP), para poder confeccionar el registro o censo de las mismas, para efectos administrativos y tributarios.

ComposiciónEditar

Consta de un total de once (11) cifras: dos dígitos iniciales que indican el tipo global, seguido por ocho dígitos que corresponden, en el caso de personas físicas, al número de Documento Nacional de Identidad, y en el caso de empresas a un número de sociedad asignado por la AFIP, y finalmente un dígito verificador.

Otros nombresEditar

Para quienes trabajan en relación de dependencia, el mismo código toma el nombre de Código Único de Identificación Laboral (CUIL).

Quienes necesitan realizar operaciones que implican el pago de tributos (tal como varios tipos de compraventas registradas), pero que no clasifican como empleados o trabajadores autónomos, también pueden obtener de la misma agencia una "Clave de Identificación" (CDI).

La CUIT como dato personal de carácter públicoEditar

La Clave Única de Identificación Tributaria de las personas físicas es un dato personal, en la medida que vincula a una persona con su identificación tributaria. No obstante, conforme la legislación argentina en materia de datos personales, en particular el artículo 5 de la Ley 25.326 de Protección de Datos Personales, la CUIT es unos de los datos de carácter personal que no requieren el consentimiento de su titular para su tratamiento.[1]​ Al mismo tiempo, la CUIT de los contribuyentes es un dato de acceso público, que de hecho es publicada por la Administración Federal de Ingresos Públicos a través del Padrón de Personas Físicas y Jurídicas.

Procedimiento para obtener la CUITEditar

La CUIT se obtiene en la Administración Federal de Ingresos Públicos, existiendo un trámite para las personas físicas y otro para las personas jurídicas que se describen en el sitio oficial del citado organismo recaudador.[2]​ El trámite debe realizarse ante la Agencia de la AFIP que corresponda al domicilio de la persona o entidad solicitante.

Procedimiento para obtener el dígito verificadorEditar

Tanto la CUIT (Clave Única de Identificación Tributaria) como el CUIL (Código Único de Identificación Laboral) constan de tres partes separados por guion:

En el siguiente ejemplo se toma como CUIT el número ##-12345678-X, donde ## es el tipo, 12345678 es el número de DNI o número de sociedad y X es el dígito verificador.

Tipos:

  • 20, 23, 24 y 27 para Personas Físicas
  • 30, 33 y 34 para Empresas.

El dígito verificador se calcula usando el algoritmo Módulo 11. Para obtenerlo si no lo conocemos o si queremos calcularlo:

  • Se procede a tomar el número de 10 dígitos compuesto por los 2 primeros más los 8 dígitos siguientes, de derecha a izquierda, multiplicando cada dígito por los números que componen la serie numérica 2,3,4,5,6,7; y sumando el resultado de estos productos, como se muestra a continuación (si se ha aplicado la serie hasta el 7 y quedan dígitos por multiplicar, se comienza la serie nuevamente):

En el ejemplo:

8 × 2 = 16
7 × 3 = 21
6 × 4 = 24
5 × 5 = 25
4 × 6 = 24
3 × 7 = 21
2 × 2 = 4
1 × 3 = 3
0 × 4 = 0
2 × 5 = 10

entonces la suma de los productos es:

16+21+24+25+24+21+4+3+0+10 = SUMA_P
  • Al número obtenido por la suma del producto de cada dígito por la serie ya mencionada, se le aplica módulo 11, o sea, se divide por 11 y se determina el resto de la división.

En el ejemplo:

SUMA_MOD11 = SUMA_P módulo 11 

Queda en SUMA_MOD11 el resto de dividir por 11

  • Ahora se hace 11 menos SUMA_MOD11
ONCEMENOS = 11 - SUMA_MOD11
  • Si el resultado es 11, el dígito verificador será 0.
  • Si el resultado es 10, no existe, es un error. Se debe cambiar el tipo a 23 o 33 y recalcular. Algunos algoritmos verifican erróneamente con 9 sin cambiar el tipo, lo cual es una falla de implementación.
Tipo original Nuevo tipo Dígito verificador
20 (Hombre) 23 9
27 (Mujer) 23 4
24 (Repetido) 23 3
30 (Empresa) 33 9
34 (Repetida) 33 3
  • En otro caso el resultado será el dígito verificador.

Ejemplo Macro en Visual Basic MS ExcelEditar

Public Function ValidarCuit(ByVal Cuit As String) As Boolean
    If Len(Cuit) = 11 Then
        Dim Ponderador As Integer
        Dim Acumulado As Integer
        Dim Digito As Integer
        Dim Posicion As Integer

        Ponderador = 2
        Acumulado = 0

        'Recorro la cadena de atrás para adelante
        For Posicion = 10 To 1 Step -1
            'Sumo las multiplicaciones de cada dígito x su ponderador
            Acumulado = Acumulado + Val(Mid$(Cuit, Posicion, 1)) * Ponderador 
            Ponderador = Ponderador + 1

            If Ponderador > 7 Then Ponderador = 2
        Next
    
        Digito = 11 - (Acumulado Mod 11)
        If Digito = 11 Then Digito = 0

        ValidarCuit = (Digito = Right(Cuit, 1))
    Else
        ValidarCuit = False
    End If
End Function

Código BashEditar

Algoritmo en lenguaje Bash
#!/bin/bash

digitos=($(echo $1 | grep -o "[0-9]"))
largo=${#digitos[@]}

if [ "$largo" != 11 ]; then exit 1; fi

acumulado=0

for i in `seq 0 9`
do
  acumulado=$((acumulado + digitos[9 - i] * (2 + (i % 6))))
done
verif=$((11-(acumulado % 11)))

if [ "$verif" = 11 ]; then verif=0; fi

if [ "${digitos[largo - 1]}" != "$verif" ]; then exit 2; fi

exit 0

Código JavaEditar

Algoritmo en lenguaje Java
private boolean validarCuit(String cuit) {
    //Eliminamos todos los caracteres que no son números
    cuit = cuit.replaceAll("[^\\d]", "");
    //Controlamos si son 11 números los que quedaron, si no es el caso, ya devuelve falso
    if (cuit.length() != 11){
        return false;
    }
    //Convertimos la cadena que quedó en una matriz de caracteres
    char[] cuitArray = cuit.toCharArray();
    //Inicializamos una matriz por la cual se multiplicarán cada uno de los dígitos
    Integer[] serie = {5, 4, 3, 2, 7, 6, 5, 4, 3, 2};
    //Creamos una variable auxiliar donde guardaremos los resultados del cálculo del número validador
    Integer aux = 0;
    //Recorremos las matrices de forma simultánea, sumando los productos de la serie por el número en la misma posición
    for (int i=0; i<10; i++){
        aux += Character.getNumericValue(cuitArray[i]) * serie[i];
    }
    //Hacemos como se especifica: 11 menos el resto de de la división de la suma de productos anterior por 11
    aux = 11 - (aux % 11);
    //Si el resultado anterior es 11 el código es 0
    if (aux == 11){
        aux = 0;
    }
    //Si el resultado anterior es 10 el código no tiene que validar, cosa que de todas formas pasa
    //en la siguiente comparación.
    //Devuelve verdadero si son iguales, falso si no lo son
    //(Esta forma esta dada para prevenir errores, en java 6 se puede usar: return aux.equals(Character.getNumericValue(cuitArray[10]));)
    return Objects.equals(Character.getNumericValue(cuitArray[10]), aux);
}

Código JavascriptEditar

function validarCuit(cuit) {

	if(cuit.length != 11) {
		return false;
	}

	var acumulado 	= 0;
	var digitos 	= cuit.split("");
	var digito	= digitos.pop();

	for(var i = 0; i < digitos.length; i++) {
		acumulado += digitos[9 - i] * (2 + (i % 6));
	}

	var verif = 11 - (acumulado % 11);
	if(verif == 11) {
		verif = 0;
	}

	return digito == verif;
}

Código PythonEditar

def es_CUIT_valida(cuit):
    cuit = str(cuit)
    cuit = cuit.replace("-", "")
    cuit = cuit.replace(" ", "")
    cuit = cuit.replace(".", "")
    if len(cuit) != 11:
        return False
    if not cuit.isdigit():
        return False
    base = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
    aux = 0
    for i in range(10):
        aux += int(cuit[i]) * base[i]
    aux = 11 - (aux % 11)
    if aux == 11:
        aux = 0
    if int(cuit[10]) == aux:
        return True
    else:
        return False

Código PHPEditar

public function validarCuit($cuit){
	$cuit = preg_replace('/[^\d]/', '', (string) $cuit);
	$cuit_tipos = [20, 23, 24, 27, 30, 33, 34];

	if (strlen($cuit) != 11) {
		return FALSE;
	}

	$tipo = (int) substr($cuit, 0, 2);

	if (!in_array($tipo, $cuit_tipos, TRUE)) {
	    return FALSE;
    }

	$acumulado = 0;
	$digitos = str_split($cuit); // Convertir en un array
	$digito = array_pop($digitos); // Extraer último elemento del array
	$contador = count($digitos);

	for ($i = 0; $i < $contador; $i++) {
		$acumulado += $digitos[ 9 - $i ] * (2 + ($i % 6));
	}

	$verif = 11 - ($acumulado % 11);

	// Si el resultado es 11, el dígito verificador será 0
	// Sino, será el dígito verificador
	$verif = $verif == 11 ? 0 : $verif;

	return $digito == $verif;
}

Código PL/SQLEditar

PROCEDURE CALCULAR_DV (i_cuit number) AS
    v_dv number;
    v_cuit number;
    begin 
        VALIDAR_CUIT(i_cuit,10);
        
        select mod(substr(i_cuit,1,1)*5+
            substr(i_cuit,2,1)*4+
            substr(i_cuit,3,1)*3+
            substr(i_cuit,4,1)*2+
            substr(i_cuit,5,1)*7+
            substr(i_cuit,6,1)*6+
            substr(i_cuit,7,1)*5+
            substr(i_cuit,8,1)*4+
            substr(i_cuit,9,1)*3+
            substr(i_cuit,10,1)*2,11) 
        into v_dv
        from dual;

    case when (11-v_dv) between 1 and 9 then
            v_cuit := i_cuit || (11-v_dv);
    when v_dv = 1 then
            CASE WHEN substr(i_cuit,1,2) = 27 then
                v_cuit := 23||substr(i_cuit,3,8)||4;
            WHEN substr(i_cuit,1,2) = 20 then
                v_cuit := 23||substr(i_cuit,3,8)||9;
            WHEN substr(i_cuit,1,2) = 24 then
                v_cuit := 23||substr(i_cuit,3,8)||3;
            WHEN substr(i_cuit,1,2) = 30 then
                v_cuit := 33||substr(i_cuit,3,8)||9;
            WHEN substr(i_cuit,1,2) = 34 then
                v_cuit := 33||substr(i_cuit,3,8)||3;
             ELSE
               dbms_output.put_line('El CUIT no se pudo calcular correctamente');
             END CASE;
    else
            v_cuit := i_cuit||0;
    end case;
        
    dbms_output.put_line('El CUIT completo con DV es: ' || v_cuit);
    
    EXCEPTION WHEN OTHERS THEN
        DBMS_OUTPUT.PUT_LINE('Error desconocido: '||SUBSTR(SQLERRM, 1, 200));
    END;
    
PROCEDURE VALIDAR_CUIT(i_cuit number,cant number) AS
BEGIN
    CASE WHEN length(i_cuit) <> cant THEN
        DBMS_OUTPUT.PUT_LINE('El cuit enviado se espera que tenga ' || cant || ' dígitos');
    END CASE;
END;

Código T-SQLEditar

CREATE FUNCTION U_FU_ValidaCUITL
(
	@Cuitl varchar(50)
)
RETURNS int
AS
BEGIN
	
	DECLARE @ResultVar int,
			@TempCuitl varchar(50),
			@factmult varchar(6) ='234567',
			@i int ,
			@j int,
			@suma int

	/*
		Codigo		Valor
		  0			Error 
		  1			OK		  
	*/
	set @ResultVar=0
	if len(@Cuitl)>13
	begin 
		set  @ResultVar=0
	end
	else 
	begin 
		if  len(substring(@Cuitl,1,CHARINDEX('-',@Cuitl)-1))>2 
		begin 
			set  @ResultVar=0
		end
		else 
		begin
			if  len(substring(reverse(@Cuitl),1,CHARINDEX('-',reverse(@Cuitl))-1))>1 
			begin 				
				set  @ResultVar=0
			end 
			else 
			begin 
				set @TempCuitl =reverse(substring(reverse(substring(reverse(@Cuitl), charindex('-',REVERSE(@Cuitl))+1,50)),1,CHARINDEX('-',reverse(substring(reverse(@Cuitl), charindex('-',REVERSE(@Cuitl))+1,50)))-1)+   substring(reverse(substring(reverse(@Cuitl), charindex('-',REVERSE(@Cuitl))+1,50)),charindex('-',reverse(substring(reverse(@Cuitl), charindex('-',REVERSE(@Cuitl))+1,50)))+1,50))

				set @i=1
				set @j=1
				set @suma =0
				while @i<=len (@TempCuitl)
				begin 
					set @suma =@suma+ Cast((substring(@TempCuitl,@i,1)) as int) *Cast((substring(@factmult,@j,1)) as int) 

					 set @i=@i+1
					 set @j=@j+1

					 if @j>6 
						set @j=1
				end 
			end 
		end 
	end 
	
	if Cast(substring(reverse(@Cuitl),1,CHARINDEX('-',reverse(@Cuitl))-1) as int) =11-(@suma % 11)
		set @ResultVar=1

	RETURN @ResultVar
	
	--by CLF_GT

END

Código Visual FoxProEditar

FUNCTION ValidarCUIT(tcCUIT)
  LOCAL lnSuma, llRet
  IF EMPTY(tcCuit)
    llRet = .T.
  ELSE
    IF TYPE('tcCuit') = 'C' AND LEN(tcCuit) = 11
      lnSuma = VAL(SUBS(tcCUIT,10,1)) * 2 + ;
        VAL(SUBS(tcCUIT,9,1)) * 3 + ;
        VAL(SUBS(tcCUIT,8,1)) * 4 + ;
        VAL(SUBS(tcCUIT,7,1)) * 5 + ;
        VAL(SUBS(tcCUIT,6,1)) * 6 + ;
        VAL(SUBS(tcCUIT,5,1)) * 7 + ;
        VAL(SUBS(tcCUIT,4,1)) * 2 + ;
        VAL(SUBS(tcCUIT,3,1)) * 3 + ;
        VAL(SUBS(tcCUIT,2,1)) * 4 + ;
        VAL(SUBS(tcCUIT,1,1)) * 5
      llRet = VAL(SUBS(tcCUIT,11,1)) = ;
        IIF(MOD(lnSuma,11) = 0, 0, 11-MOD(lnSuma,11))
    ELSE
      *-- No es Char o no tiene el largo correcto
      llRet = .F.
    ENDIF
  ENDIF
  RETURN llRet
ENDFUNC

Código GoEditar

func ValidarCUIT(s string) bool {
	// Validar la longitud del input
	if len(s) != 11 {
		return false
	}
	// Validar que s contenga caracteres numéricos únicamente
	if _, err := strconv.ParseFloat(s, 64); err != nil {
		return false
	}
	base := []int{5, 4, 3, 2, 7, 6, 5, 4, 3, 2}
	aux := 0
	for i, digitoBase := range base {
		digitoInput, _ := strconv.Atoi(string(s[i]))
		aux += digitoInput * digitoBase
	}
	aux = 11 - (aux % 11)
	if aux == 11 {
		aux = 0
	}
	ultimoDigito, _ := strconv.Atoi(string(s[10]))
	return ultimoDigito == aux
}

Código C#Editar

public static bool ValidarCUIT(string cuit)
{
    if (string.IsNullOrWhiteSpace(cuit) || cuit.Length != 11 || !cuit.All(Char.IsNumber)) return false;

    var factores = new int[] { 5, 4, 3, 2, 7, 6, 5, 4, 3, 2 };
    var acumulado = 0;

    for (int i = 0; i < factores.Length; i++)
        acumulado += int.Parse(cuit[i].ToString()) * factores[i];

    acumulado = 11 - (acumulado % 11);
    if (acumulado == 11)
        acumulado = 0;
    if (int.Parse(cuit[10].ToString()) != acumulado)
        return false;

    return true;
}

Código RubyEditar

def validar_cuit(cuit) # Usuario ingresa el cuit compuesto por XY-12345678-Z
  cuit = cuit.to_s # Transformo el input en string
  cuit.delete!('-') # Eliminar los guiones, puntos, y, espacios.
  cuit.delete!('.')
  cuit.delete!(' ')

  if cuit.length != 11 # Chequeo que si o si tenga 11 caracteres
    puts "El cuit no cuenta con 11 cifras (tiene #{cuit.length})."
    return false
  end

  unless cuit.scan(/\D/).empty? # Chequeo si tiene algun simbolo no numerico
    puts "El cuit cuenta con caracteres no deseados (#{cuit}). Solo puede tener numeros."
    return false
  end

  base = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2] # Serie de numeros por el cual se hace el calculo
  cuit_array = cuit.split('') # Convierto el string en array.
  last_cuit_number = cuit_array.delete_at(-1)# Elimino Z del cuit
  aux = 0 # creo la variable la cual va a tener el resultado

  cuit_array.zip(base).each do |c_num, b_num| # junto ambos arrays.
    aux += c_num.to_f * b_num # Multiplico la iteracion y lo almaceno en la variable
    puts "Multiplicacion de #{c_num} y #{b_num}"
  end

  divided_aux = aux / 11 # Divido la suma total por 11 (el codigo verificador)
  result = aux.round - (divided_aux.round * 11)
  codigo_verificador = 11 - result # Resultado de codigo verificador
  first_two = cuit_array[0] + cuit_array[1] # Reuno XY

  puts "Result #{result}, codigo_verificador #{codigo_verificador}, last_cuit_number, #{last_cuit_number}"

  if result > 1 && codigo_verificador == last_cuit_number.to_i # Chequeo si el resultado es valido
    puts "El codigo verificador (#{codigo_verificador}) es correcto! "
    return true
  elsif result <= 1 # Caso en el que hay un error de la formula, el codigo verificador no puede ser 10
    case codigo_verificador
    when 9
      if first_two.to_i == 23 || first_two.to_i == 33
        puts "El codigo verificador (9) es correcto" # Digito verificador pasa a ser 9 para hombres/empresas
        return true
      end
    when 4
      if first_two.to_i == 23
        puts "El codigo verificador (4) es correcto" # Digito verificador pasa a ser 4 para mujeres
        return true
      end
    when 3
      if first_two.to_i == 23 || first_two.to_i == 33
        puts "El codigo verificador (3) es correcto" # Digito verificador pasa a ser 3 para empresas/humanos repetidos
        return true
      end
    else
      puts "El cuit ingresado es incorrecto o hay un error en la verificacion, revisar si el ingresado (#{cuit}) es el correcto."
      return false
    end
  else
    puts "El cuit ingresado es incorrecto o hay un error en la verificacion, revisar si el ingresado (#{cuit}) es el correcto."
    return false
  end
end

Véase tambiénEditar

ReferenciasEditar

  1. «Art. 5, Ley 25.326 de Protección de Datos Personales». Consultado el 11 de septiembre de 2012. 
  2. Administración Federal de Ingresos Públicos. «Guía de Trámites de la Administración Federal de Ingresos Públicos». Consultado el 11 de septiembre de 2012. 

Enlaces externosEditar