Clave Única de Identificación Tributaria

El Código Único 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, susceptibles de tributar. 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.

Índice
Composición
Otros nombres
La CUIT como dato personal de carácter público
Procedimiento para obtener la CUIT
Procedimiento para obtener el dígito verificador
Ejemplo Macro en Visual Basic MS Excel
Código Bash
Código Java
Código Javascript
Código Python
Código PHP
Código PL/SQL
Código T-SQL
Código Visual FoxPro
Código Go
Referencias
Enlaces externos

Composición
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 nombres
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úblico

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 laAdministración Federal de Ingresos Públicosa través del Padrón de Personas Físicas y Jurídicas.

Procedimiento para obtener la CUIT

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 verificador

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:

el tipo,
el número y
el dígito verificador.
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 yX 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 algoritmoMó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 mas 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 modulo 11

Queda en SUMA_MOD11 el resto de dividir por11

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 unafalla 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 Excel

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 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=$((acumulado % 11))
if [ "$verif " = 11 ]; then verif=0; fi

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

exit 0

Código 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 simultanea, 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 Javascript

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 Python

def esCUITValida (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 xrange (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 PHP

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/SQL

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 || ' digitos' );
END CASE;
END;

Código T-SQL

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 FoxPro

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 Go

func ValidarCUIT (s string ) bool {

// Validar la longitud del input
if len(s) != 11 {
return false
}
// Validar que s contenga caracteres numéricos unicamente
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
}

Referencias
 1. «Art. 5, Ley 25.326 de Protección de Datos Personales» (http://www.infoleg.gov.ar/infolegInternet/anexos/60000-649
99/64790/texact.htm). 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»
(http://www.afip.gob.ar/genericos/guiaDeTramites/categoria_list_detail.aspx?id_padre=118) . Consultado el 11 de
septiembre de 2012.

Enlaces externos
Administración Federal de Ingresos Públicos

Consulta a partir de una CUIT (sitio oficial de la AFIP)

Módulo Validador de CUIT paraZend Framework(ZF2)

Obtenido de «https://es.wikipedia.org/w/index.php?title=Clave_Única_de_Identificación_T
ributaria&oldid=113737860»

Esta página se editó por última vez el 4 feb 2019 a las 14:49.

El texto está disponible bajo laLicencia Creative Commons Atribución Compartir Igual 3.0 ; pueden aplicarse cláusulas
adicionales. Al usar este sitio, usted acepta nuestrostérminos de uso y nuestra política de privacidad.
Wikipedia® es una marca registrada de laFundación Wikimedia, Inc., una organización sin ánimo de lucro.