Cómo validar un número de CUIT con una API

Si estás construyendo un producto que atiende a usuarios o empresas argentinas, inevitablemente vas a encontrarte con el CUIT. Ya sea que estés procesando facturas, dando de alta empresas o integrándote con AFIP (la autoridad tributaria de Argentina), validar un CUIT es una de las primeras cosas que tu backend necesita hacer de forma confiable. Un CUIT malformado puede causar errores en presentaciones impositivas, pagos rechazados y problemas de compliance. En esta guía vamos a recorrer qué es un CUIT, cómo funciona su estructura, el algoritmo del dígito verificador, los errores más comunes que enfrentan los desarrolladores, y cómo validar CUITs programáticamente usando la API Validate de Normadata.

¿Qué es un CUIT?

El CUIT (Clave Única de Identificación Tributaria) es el número de identificación tributaria único de Argentina. Lo emite AFIP y se asigna a cada individuo, empresa y persona jurídica que participa en el sistema impositivo del país. Pensalo como el equivalente argentino del EIN de Estados Unidos o el RFC de México. Toda empresa registrada en Argentina tiene un CUIT, y los individuos que trabajan formalmente también reciben uno. Lo vas a ver en facturas, recibos de impuestos, documentos de nómina y registros de cuentas bancarias. A diferencia del DNI (el documento nacional de identidad), el CUIT incluye un prefijo de tipo y un dígito de verificación, lo que permite validarlo algorítmicamente sin necesidad de consultar una base de datos externa.

Estructura y formato del CUIT

Un CUIT es un número de 11 dígitos escrito en el formato XX-XXXXXXXX-X, dividido en tres partes: un prefijo de tipo de dos dígitos, un cuerpo de ocho dígitos (generalmente el número de DNI de la persona) y un dígito verificador. El prefijo de tipo indica el tipo de entidad:

• 20 — Persona física masculina
• 23 — Persona física masculina (alternativo, se usa cuando 20 produce un dígito verificador inválido)
• 24 — Persona física masculina (segunda alternativa)
• 27 — Persona física femenina
• 30 — Empresa o persona jurídica
• 33 — Persona jurídica (alternativo)
• 34 — Persona jurídica (segunda alternativa)

Por ejemplo, un CUIT como 20-12345678-5 nos dice que pertenece a una persona física masculina (prefijo 20), con DNI 12345678 y un dígito verificador de 5. El cuerpo de ocho dígitos es típicamente el número de DNI para personas físicas o un número secuencial asignado por AFIP para empresas. El número completo siempre tiene 11 dígitos sin separadores cuando se transmite electrónicamente, aunque se muestra habitualmente con guiones para facilitar la lectura.

El algoritmo del dígito verificador

El último dígito de un CUIT es un dígito de verificación calculado usando un algoritmo de módulo 11 con pesos fijos. Esto te permite detectar errores de tipeo y transcripción sin necesidad de consultar ningún servicio externo. Así funciona el algoritmo:

1. Escribí los primeros 10 dígitos del CUIT.
2. Asigná los siguientes pesos a cada posición: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2.
3. Multiplicá cada dígito por su peso correspondiente.
4. Sumá todos los productos.
5. Calculá el resto: suma módulo 11.
6. Restá el resto de 11 para obtener el dígito verificador.
7. Si el resultado es 11, el dígito verificador es 0. Si el resultado es 10, el dígito verificador es 9 (o el CUIT es inválido dependiendo del prefijo utilizado).

Por ejemplo, dados los primeros 10 dígitos 20-29883741, multiplicás cada dígito por su peso (2x5, 0x4, 2x3, 9x2, 8x7, 8x6, 3x5, 7x4, 4x3, 1x2), sumás los productos (10+0+6+18+56+48+15+28+12+2 = 195), calculás 195 mod 11 = 8, luego 11-8 = 3. El CUIT completo sería 20-31456789-4. Si el dígito verificador que calculaste no coincide con el dígito 11 proporcionado, el CUIT es inválido.

Errores comunes de validación

Cuando validás CUITs en producción, los desarrolladores frecuentemente se encuentran con varios problemas que pueden causar rechazos falsos o bugs silenciosos:

• Ceros iniciales en el cuerpo del DNI — Algunos números de DNI tienen menos de 8 dígitos y deben rellenarse con ceros. Si tu parser elimina ceros iniciales, el cálculo del dígito verificador va a fallar.
• Manejo de guiones — Los CUITs se almacenan con y sin guiones en distintos sistemas. Siempre normalizá eliminando guiones y espacios antes de validar.
• Suposiciones sobre el prefijo de tipo — No asumas que el prefijo 20 es siempre masculino o que 30 es siempre empresa. Los prefijos alternativos (23, 24, 33, 34) existen específicamente para casos donde el prefijo principal produce un dígito verificador inválido.
• Tipos string vs numérico — Siempre tratá los CUITs como strings, nunca como enteros. Convertir a número elimina ceros iniciales y produce resultados incorrectos.
• Confundir CUIT con CUIL — El CUIL (Clave Única de Identificación Laboral) usa el mismo formato y algoritmo. Funcionalmente son intercambiables para validación, pero sirven distintos propósitos en sistemas gubernamentales.

Validando con la API de Normadata

En lugar de implementar el algoritmo del dígito verificador vos mismo y mantener lógica de casos especiales, podés validar CUITs con una sola llamada a la API del endpoint Validate de Normadata. La API normaliza la entrada, verifica el formato y el checksum, y devuelve metadatos estructurados incluyendo el tipo de entidad y el valor formateado. Acá van ejemplos en distintos lenguajes:

curl -X POST https://api.normadata.io/v1/validate/tax-ids \
 -H "X-API-Key: nd_your_key_here" \
 -H "Content-Type: application/json" \
 -d {
 "value": "20-31456789-4",
 "country": "AR",
 "type": "cuit"
 }

import requests

response = requests.post(
 "https://api.normadata.io/v1/validate/tax-ids",
 headers={"X-API-Key": "nd_your_key_here"},
 json={
 "value": "20-31456789-4",
 "country": "AR",
 "type": "cuit"
 }
)
data = response.json()
print(data["valid"]) # True

const response = await fetch("https://api.normadata.io/v1/validate/tax-ids", {
 method: "POST",
 headers: {
 "X-API-Key": "nd_your_key_here",
 "Content-Type": "application/json"
 },
 body: JSON.stringify({
 value: "20-31456789-4",
 country: "AR",
 type: "cuit"
 })
});
const data = await response.json();
console.log(data.valid); // true

{
 "valid": true,
 "country": "AR",
 "type": "cuit",
 "value": {
 "raw": "20298837413",
 "formatted": "20-31456789-4"
 },
 "metadata": {
 "prefix": "20",
 "entity_type": "persona_fisica_masculino",
 "dni": "29883741",
 "check_digit": "3"
 }
}

{
 "valid": false,
 "country": "AR",
 "type": "cuit",
 "value": {
 "raw": "20298837419",
 "formatted": "20-29883741-9"
 },
 "error": {
 "code": "err_validation_failed",
 "message": "Check digit mismatch. Expected 3, received 9."
 }
}

Próximos pasos

Ahora que entendés cómo funciona la validación de CUIT, podés integrarla en tu flujo de onboarding, sistema de facturación o pipeline de compliance. La API Validate de Normadata maneja no solo CUITs sino también CBUs (números de cuenta bancaria), DNIs y otros identificadores argentinos — además de tax IDs de 8 otros países sudamericanos usando la misma API consistente. Mirá la página de cobertura para ver la lista completa de identificadores soportados, o andá a la documentación de la API para empezar a hacer requests.