Generador i validador de CUIT d'Argentina per a fins de prova

Genera números de CUIT argentins vàlids (còdigs d'identificació fiscal) i valida els existents amb aquesta eina senzilla dissenyada per a escenaris de prova. Sense característiques complexes, només generació i validació de CUIT de manera directa.

Generador i validador de CUIT d'Argentina

Una eina senzilla per generar i validar codis d'identificació fiscal argentins (CUIT) per a fins de prova.

Sobre el CUIT

El CUIT (Codi Únic d'Identificació Tributària) és el codi d'identificació fiscal utilitzat a Argentina per a individus i entitats legals.

El format és XX-XXXXXXXX-X on X són dígits.
Els dos primers dígits indiquen el tipus d'entitat (20 per a individus masculins, 27 per a individus femenins, 30 per a empreses, etc.).
L'últim dígit és un dígit de verificació calculat mitjançant un algoritme específic basat en els dígits anteriors.

📚

Documentació

Generador i Validador de CUIT d'Argentina

Introducció al CUIT d'Argentina

El CUIT (Codi Únic d'Identificació Tributària) és el Codi d'Identificació Tributària Únic d'Argentina, un identificador crític per a tots els contribuents en el sistema tributari argentí. Aquest codi numèric essencial serveix com a identificador principal per a individus i entitats legals quan interactuen amb l'AFIP (Administració Federal de Renda Pública) i realitzen operacions comercials a tot Argentina. La nostra eina Generador i Validador de CUIT d'Argentina proporciona una solució senzilla i eficient per a generar CUIT matemàticament vàlids per a fins de prova i validar números de CUIT existents.

Ja siguis un desenvolupador provant aplicacions que processen informació tributària argentina, un especialista en QA verificant la integritat de les dades, o un analista de negocis preparant conjunts de dades de prova, aquesta eina simplifica el procés de treballar amb números de CUIT sense la complexitat de les integracions d'API o funcions innecessàries.

Entenent l'Estructura i el Format del CUIT

El CUIT argentí segueix un format específic que consisteix en 11 dígits disposats com:

1XX-XXXXXXXX-X
2

Aquest format estàndard es pot desglossar en tres components distintius:

Codi de Tipus (Primeres 2 xifres): Identifica el tipus d'entitat o individu
Número d'Identificació (8 xifres del mig): Seqüència única assignada a l'entitat
Dígits de Verificació (Última xifra): Dígit de control calculat que valida la integritat del CUIT

Codis de Tipus de CUIT

Les dues primeres xifres d'un CUIT indiquen el tipus de contribuent:

Tipus d'Entitat	Codi de Tipus	Descripció
Empresa	30	Corporacions, SRLs i altres entitats comercials
Associació	33	Associacions sense ànim de lucre
Fundació	30	Fundacions benèfiques
Societat	30	Societats i altres estructures de societat
Govern	30	Entitats governamentals i institucions públiques
Empresa Estrangera	30	Empreses amb seu fora d'Argentina
Individu (Masculí)	20	Individus masculins
Individu (Femení)	27	Individus femenins
Fideicomís	30	Entitats de fideicomís

Entendre aquests codis de tipus és essencial per a generar CUIT adequats per a diferents escenaris de prova.

Com Utilitzar el Generador i Validador de CUIT d'Argentina

La nostra eina ofereix dues funcions principals: generar CUIT vàlids i validar els existents. Aquí tens com utilitzar cadascuna de les funcions de manera efectiva:

Generant CUIT Vàlids

Navega a la secció "Generador de CUIT" de l'eina
Selecciona el tipus d'entitat apropiat de les opcions disponibles
Fes clic al botó "Generar CUIT"
L'eina mostrarà un CUIT matemàticament vàlid amb el format correcte i el dígit de verificació
Utilitza el botó "Copia" per copiar el CUIT generat al teu portapapers per a la seva utilització en les proves

El generador crea CUIT aleatoris però matemàticament vàlids que segueixen l'algoritme oficial utilitzat per l'AFIP. Aquests CUIT són perfectes per a provar sistemes que requereixen formats de CUIT vàlids, tot i que no estan registrats en bases de dades oficials.

Validant CUIT Existents

Ves a la secció "Validador de CUIT" de l'eina
Introduïu el CUIT que desitges validar al camp d'entrada (format: XX-XXXXXXXX-X)
Fes clic al botó "Valida CUIT"
L'eina verificarà instantàniament si el CUIT és matemàticament vàlid
Els resultats mostraran "CUIT Vàlid ✓" o "CUIT Invàlid ✗"

El validador comprova tant el format com la validesa matemàtica del CUIT verificant que el dígit de verificació coincideixi amb el valor calculat basat en els dígits anteriors.

L'Algoritme de Verificació del CUIT

El dígit de verificació (l'últim dígit) d'un CUIT es calcula mitjançant un algoritme específic dissenyat per detectar errors comuns en l'entrada de dades. Entendre aquest algoritme ajuda a explicar com la nostra eina valida els CUIT:

Procés de Verificació Pas a Pas

Pren les primeres 10 xifres del CUIT (excloent el dígit de verificació)
Multiplica cada dígit per un factor de pes corresponent d'aquesta seqüència: [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
Suma tots els productes resultants
Calcula el residu quan es divideix la suma per 11
Resta el residu de 11
Si el resultat és 11, el dígit de verificació és 0
Si el resultat és 10, el dígit de verificació és 9
En cas contrari, el resultat és el dígit de verificació

Exemple de Càlcul

Calculem el dígit de verificació per un CUIT amb codi de tipus 30 i número d'identificació 12345678:

Els dígits a verificar són: 3 0 1 2 3 4 5 6 7 8
Multiplica per pesos: 3×5 + 0×4 + 1×3 + 2×2 + 3×7 + 4×6 + 5×5 + 6×4 + 7×3 + 8×2
Calcula: 15 + 0 + 3 + 4 + 21 + 24 + 25 + 24 + 21 + 16 = 153
Remainder of 153 ÷ 11 = 10
11 - 10 = 1
El dígit de verificació és 1

Per tant, el CUIT vàlid complet és 30-12345678-1.

Aplicacions i Casos d'Ús

L'eina Generador i Validador de CUIT d'Argentina serveix a múltiples propòsits pràctics en diferents contextos professionals:

Desenvolupament de Programari i Proves

Proves de Base de Dades: Genera CUIT vàlids per a omplir bases de dades de prova amb dades realistes de contribuents argentins
Validació de Formularis: Prova la validació d'entrada per a formularis que requereixen la introducció de CUIT
Proves d'Integració d'API: Verifica sistemes que interactuen amb APIs tributàries o financeres argentines
Proves de Casos Límit: Prova com els sistemes gestionen diferents tipus d'entitats i casos límit

Assegurança de Qualitat de Dades

Validació de Dades: Verifica ràpidament si un conjunt de dades conté números de CUIT vàlids
Neteja de Dades: Identifica CUIT invàlids en conjunts de dades existents
Generació de Dades: Crea conjunts de dades sintètics amb identificadors tributaris argentins vàlids
Validació d'Importació/Exportació: Verifica la integritat del CUIT en la transferència de dades entre sistemes

Aplicacions Empresarials i Administratives

Preparació de Documents: Assegura que els CUIT estiguin correctament formats en documents empresarials
Configuració d'Entorns de Prova: Crea entorns de prova realistes per a aplicacions financeres o tributàries
Materials de Formació: Genera exemples de CUIT per a materials de formació sense utilitzar informació real de contribuents

Propòsits Educatius

Aprendre sobre Sistemes Tributaris: Entendre com funciona la identificació tributària argentina
Estudi d'Algoritmes: Examinar l'algoritme de verificació com a exemple de sistemes de dígits de control
Formació en Compliment: Formar al personal sobre el reconeixement i la validació de formats de CUIT adequats

Exemples de Codi per a la Validació i Generació de CUIT

Els següents exemples de codi demostren com implementar la validació i generació de CUIT en diversos llenguatges de programació:

JavaScript

1// Validació de CUIT en JavaScript
2function validateCUIT(cuit) {
3  // Remove any non-digit characters
4  const cleanCuit = cuit.replace(/\D/g, '');
5  
6  // Check if it has exactly 11 digits
7  if (cleanCuit.length !== 11) {
8    return false;
9  }
10  
11  // Extract parts
12  const typeCode = cleanCuit.substring(0, 2);
13  const number = cleanCuit.substring(2, 10);
14  const providedVerificationDigit = parseInt(cleanCuit.substring(10, 11));
15  
16  // Calculate verification digit
17  const multipliers = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
18  let sum = 0;
19  
20  for (let i = 0; i < 10; i++) {
21    sum += parseInt(cleanCuit[i]) * multipliers[i];
22  }
23  
24  const remainder = sum % 11;
25  let calculatedVerificationDigit;
26  
27  if (remainder === 0) {
28    calculatedVerificationDigit = 0;
29  } else if (remainder === 1) {
30    calculatedVerificationDigit = 9;
31  } else {
32    calculatedVerificationDigit = 11 - remainder;
33  }
34  
35  return calculatedVerificationDigit === providedVerificationDigit;
36}
37
38// Exemple d'ús
39console.log(validateCUIT('30-12345678-1')); // true o false
40

Python

1# Generació de CUIT en Python
2import random
3
4def generate_cuit(entity_type='COMPANY'):
5    # Defineix codis de tipus d'entitat
6    entity_types = {
7        'COMPANY': 30,
8        'ASSOCIATION': 33,
9        'FOUNDATION': 30,
10        'SOCIETY': 30,
11        'GOVERNMENT': 30,
12        'FOREIGN_COMPANY': 30,
13        'INDIVIDUAL_MALE': 20,
14        'INDIVIDUAL_FEMALE': 27,
15        'TRUST': 30
16    }
17    
18    # Obteniu el codi de tipus per al tipus d'entitat seleccionat
19    type_code = entity_types.get(entity_type, 30)
20    
21    # Genera un número aleatori de 8 dígits
22    number = ''.join([str(random.randint(0, 9)) for _ in range(8)])
23    
24    # Calcula el dígit de verificació
25    multipliers = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
26    digits = f"{type_code}{number}"
27    
28    sum_products = sum(int(digits[i]) * multipliers[i] for i in range(10))
29    remainder = sum_products % 11
30    
31    if remainder == 0:
32        verification_digit = 0
33    elif remainder == 1:
34        verification_digit = 9
35    else:
36        verification_digit = 11 - remainder
37    
38    # Format i retorna el CUIT
39    return f"{type_code}-{number}-{verification_digit}"
40
41# Exemple d'ús
42print(generate_cuit('INDIVIDUAL_MALE'))
43

PHP

1<?php
2// Validació de CUIT en PHP
3function validateCUIT($cuit) {
4    // Remove any non-digit characters
5    $cleanCuit = preg_replace('/\D/', '', $cuit);
6    
7    // Check if it has exactly 11 digits
8    if (strlen($cleanCuit) !== 11) {
9        return false;
10    }
11    
12    // Extract parts
13    $typeCode = substr($cleanCuit, 0, 2);
14    $number = substr($cleanCuit, 2, 8);
15    $providedVerificationDigit = intval(substr($cleanCuit, 10, 1));
16    
17    // Calculate verification digit
18    $multipliers = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
19    $sum = 0;
20    
21    for ($i = 0; $i < 10; $i++) {
22        $sum += intval($cleanCuit[$i]) * $multipliers[$i];
23    }
24    
25    $remainder = $sum % 11;
26    
27    if ($remainder === 0) {
28        $calculatedVerificationDigit = 0;
29    } elseif ($remainder === 1) {
30        $calculatedVerificationDigit = 9;
31    } else {
32        $calculatedVerificationDigit = 11 - $remainder;
33    }
34    
35    return $calculatedVerificationDigit === $providedVerificationDigit;
36}
37
38// Exemple d'ús
39echo validateCUIT('30-12345678-1') ? 'Vàlid' : 'Invàlid';
40?>
41

Java

1// Generació i Validació de CUIT en Java
2import java.util.Random;
3
4public class CUITUtils {
5    
6    // Codis de tipus d'entitat
7    private static final int COMPANY_CODE = 30;
8    private static final int ASSOCIATION_CODE = 33;
9    private static final int INDIVIDUAL_MALE_CODE = 20;
10    private static final int INDIVIDUAL_FEMALE_CODE = 27;
11    
12    // Genera un CUIT vàlid
13    public static String generateCUIT(String entityType) {
14        int typeCode;
15        
16        // Determina el codi de tipus basat en el tipus d'entitat
17        switch (entityType.toUpperCase()) {
18            case "INDIVIDUAL_MALE":
19                typeCode = INDIVIDUAL_MALE_CODE;
20                break;
21            case "INDIVIDUAL_FEMALE":
22                typeCode = INDIVIDUAL_FEMALE_CODE;
23                break;
24            case "ASSOCIATION":
25                typeCode = ASSOCIATION_CODE;
26                break;
27            case "COMPANY":
28            default:
29                typeCode = COMPANY_CODE;
30                break;
31        }
32        
33        // Genera un número aleatori de 8 dígits
34        Random random = new Random();
35        StringBuilder number = new StringBuilder();
36        for (int i = 0; i < 8; i++) {
37            number.append(random.nextInt(10));
38        }
39        
40        // Calcula el dígit de verificació
41        String digits = String.format("%02d%s", typeCode, number.toString());
42        int verificationDigit = calculateVerificationDigit(digits);
43        
44        // Format i retorna el CUIT
45        return String.format("%02d-%s-%d", typeCode, number.toString(), verificationDigit);
46    }
47    
48    // Calcula el dígit de verificació
49    private static int calculateVerificationDigit(String digits) {
50        int[] multipliers = {5, 4, 3, 2, 7, 6, 5, 4, 3, 2};
51        int sum = 0;
52        
53        for (int i = 0; i < 10; i++) {
54            sum += Character.getNumericValue(digits.charAt(i)) * multipliers[i];
55        }
56        
57        int remainder = sum % 11;
58        
59        if (remainder == 0) {
60            return 0;
61        } else if (remainder == 1) {
62            return 9;
63        } else {
64            return 11 - remainder;
65        }
66    }
67    
68    // Valida un CUIT
69    public static boolean validateCUIT(String cuit) {
70        // Remove any non-digit characters
71        String cleanCuit = cuit.replaceAll("\\D", "");
72        
73        // Check if it has exactly 11 digits
74        if (cleanCuit.length() != 11) {
75            return false;
76        }
77        
78        // Extract verification digit
79        int providedVerificationDigit = Character.getNumericValue(cleanCuit.charAt(10));
80        
81        // Calculate expected verification digit
82        int calculatedVerificationDigit = calculateVerificationDigit(cleanCuit.substring(0, 10));
83        
84        // Compare verification digits
85        return calculatedVerificationDigit == providedVerificationDigit;
86    }
87    
88    public static void main(String[] args) {
89        // Exemple d'ús
90        String generatedCUIT = generateCUIT("COMPANY");
91        System.out.println("CUIT Generat: " + generatedCUIT);
92        System.out.println("És vàlid: " + validateCUIT(generatedCUIT));
93    }
94}
95

C#

1using System;
2using System.Text.RegularExpressions;
3
4public class CUITValidator
5{
6    // Valida un CUIT
7    public static bool ValidateCUIT(string cuit)
8    {
9        // Remove any non-digit characters
10        string cleanCuit = Regex.Replace(cuit, @"\D", "");
11        
12        // Check if it has exactly 11 digits
13        if (cleanCuit.Length != 11)
14        {
15            return false;
16        }
17        
18        // Extract verification digit
19        int providedVerificationDigit = int.Parse(cleanCuit.Substring(10, 1));
20        
21        // Calculate expected verification digit
22        int[] multipliers = { 5, 4, 3, 2, 7, 6, 5, 4, 3, 2 };
23        int sum = 0;
24        
25        for (int i = 0; i < 10; i++)
26        {
27            sum += int.Parse(cleanCuit.Substring(i, 1)) * multipliers[i];
28        }
29        
30        int remainder = sum % 11;
31        int calculatedVerificationDigit;
32        
33        if (remainder == 0)
34        {
35            calculatedVerificationDigit = 0;
36        }
37        else if (remainder == 1)
38        {
39            calculatedVerificationDigit = 9;
40        }
41        else
42        {
43            calculatedVerificationDigit = 11 - remainder;
44        }
45        
46        return calculatedVerificationDigit == providedVerificationDigit;
47    }
48    
49    // Format a CUIT amb separadors adequats
50    public static string FormatCUIT(string cuit)
51    {
52        string cleanCuit = Regex.Replace(cuit, @"\D", "");
53        
54        if (cleanCuit.Length != 11)
55        {
56            return cuit; // Retorna l'original si no té 11 dígits
57        }
58        
59        return $"{cleanCuit.Substring(0, 2)}-{cleanCuit.Substring(2, 8)}-{cleanCuit.Substring(10, 1)}";
60    }
61}
62

Història del CUIT a Argentina

El sistema de CUIT es va establir a Argentina a principis dels anys 90 com a part d'una iniciativa de reforma tributària més àmplia destinada a modernitzar la infraestructura fiscal del país i reduir l'evasió fiscal. L'Administració Federal de Renda Pública (AFIP), l'autoritat tributària d'Argentina, va implementar el CUIT com un sistema d'identificació unificat per a tots els contribuents.

Abans de la introducció del CUIT, Argentina utilitzava diversos sistemes d'identificació inconsistents per a diferents tipus de contribuents, cosa que feia que l'administració tributària fos ineficient i creava oportunitats per a la no conformitat. El CUIT va unificar aquests sistemes en un únic identificador verificable que es podia utilitzar en totes les activitats relacionades amb els impostos.

Alguns fets clau en l'evolució del sistema de CUIT inclouen:

Principis dels anys 90: Implementació inicial del sistema de CUIT per a empreses i autònoms
Mitjans dels anys 90: Extensió del sistema per cobrir tots els contribuents, incloent-hi els empleats
Finals dels anys 90: Integració del CUIT amb sistemes de presentació electrònica d'impostos
Anys 2000: Implementació de sistemes de verificació en línia per a la validació de CUIT
Anys 2010: Més integració amb serveis fiscals digitals i requisits de facturació electrònica

El CUIT s'ha convertit en un element essencial dels sistemes econòmics i financers d'Argentina, servint no només per a fins fiscals sinó també per a la banca, l'ocupació, la seguretat social i les transaccions comercials.

Preguntes Freqüents

Què és un número de CUIT?

Un CUIT (Codi Únic d'Identificació Tributària) és el Codi d'Identificació Tributària Únic d'Argentina assignat a individus i entitats legals per a fins fiscals. Consisteix en 11 dígits en el format XX-XXXXXXXX-X, on les dues primeres xifres indiquen el tipus d'entitat, les vuit xifres del mig són un número d'identificació i l'última xifra és un dígit de verificació.

Com puc saber si un CUIT és vàlid?

Un CUIT vàlid ha de:

Seguir el format XX-XXXXXXXX-X
Tenir un dígit de verificació que coincideixi amb el valor calculat basat en els dígits anteriors
Començar amb un codi de tipus d'entitat vàlid (per exemple, 20, 27, 30, 33)

La nostra eina de validador de CUIT pot verificar instantàniament si un CUIT compleix aquests criteris.

Quina és la diferència entre CUIT i CUIL?

Encara que són similars en format, CUIT i CUIL serveixen a diferents propòsits:

CUIT (Codi Únic d'Identificació Tributària) s'utilitza per a contribuents que realitzen activitats econòmiques
CUIL (Codi Únic d'Identificació Laboral) s'assigna a empleats que no tenen activitats econòmiques independents

Ambdós segueixen el mateix format i algoritme de verificació, però s'utilitzen en diferents contextos.

Puc utilitzar els CUIT generats per a fins oficials?

No. Els CUIT generats per aquesta eina són matemàticament vàlids però no estan registrats a la base de dades oficial de l'AFIP. Han de ser utilitzats només per a proves, desenvolupament o fins educatius. Utilitzar CUIT ficticis per a documents o transaccions oficials pot constituir frau.

Per què alguns tipus d'entitats comparteixen el mateix codi de tipus?

L'AFIP ha assignat el mateix codi de tipus (30) a diversos tipus d'entitats, incloent empreses, fundacions i entitats governamentals. Aquesta és part del sistema de classificació oficial i no afecta la validesa del CUIT. El tipus d'entitat específic es determina per informació addicional d'inscripció als sistemes de l'AFIP.

Amb quina freqüència canvien els CUIT?

Els CUIT són identificadors permanents que generalment no canvien al llarg de la vida d'un individu o entitat. No obstant això, en alguns casos específics com canvis d'estatus legal o reasignació de gènere, es pot assignar un nou CUIT.

Es pot validar un CUIT contra registres oficials de l'AFIP?

Sí, però no a través de la nostra eina. L'AFIP proporciona un servei oficial anomenat "Constància d'Inscripció" al seu lloc web on pots verificar si un CUIT està registrat oficialment i actiu. La nostra eina només valida la correcció matemàtica d'un CUIT.

Quins són els errors comuns en l'entrada de CUIT?

Els errors comuns inclouen:

Transposició de dígits (per exemple, 12 en comptes de 21)
Falta o excés de dígits
Format incorrecte (falta de guions)
Ús de codis de tipus d'entitat incorrectes
Errors de càlcul en el dígit de verificació

El nostre validador ajuda a identificar aquests problemes comprovant tant el format com la validesa matemàtica.

Com genero CUIT per a tipus d'entitat específics?

La nostra eina et permet seleccionar entre diversos tipus d'entitats abans de generar un CUIT. Simplement tria el tipus d'entitat apropiat del menú desplegable i fes clic a "Generar CUIT". L'eina utilitzarà automàticament el codi de tipus correcte per a la teva selecció.

Hi ha un límit en quant a quants CUIT puc generar o validar?

No, la nostra eina no imposa cap límit en el nombre de CUIT que pots generar o validar. Està dissenyada per a la comoditat en escenaris de prova i educatius on pots necessitar múltiples CUIT vàlids.

Referències

Administració Federal d'Ingressos Públics (AFIP). "Identificació Tributària." https://www.afip.gob.ar/
Ministeri d'Economia de la República Argentina. "Sistema Tributari Argentí." https://www.argentina.gob.ar/economia
Llei 11.683 de Procediment Tributari. Butlletí Oficial de la República Argentina.
Resolució General AFIP 1817/2005. "Procediments d'inscripció i registració."
Chicote, J. (2018). "Sistemes d'Identificació Tributària a Llatinoamèrica: Una Anàlisi Comparativa." Journal of Tax Administration, 4(1), 88-106.
Gómez Sabaini, J.C., & Morán, D. (2016). "Política Fiscal a Llatinoamèrica: Avaluació i Directrius per a la Reforma." Comissió Econòmica per a Amèrica Llatina i el Carib (CEPAL).

Conclusió

L'eina Generador i Validador de CUIT d'Argentina proporciona una solució senzilla i eficient per a treballar amb codis d'identificació tributària argentins en entorns de prova i desenvolupament. Entenent l'estructura, el format i l'algoritme de verificació dels CUIT, els usuaris poden assegurar la integritat de les dades i el compliment dels estàndards d'identificació tributària argentins.

Ja siguis desenvolupant programari que s'interfaci amb sistemes financers argentins, provant rutines de validació de dades, o simplement aprenent sobre sistemes d'identificació tributària internacionals, la nostra eina ofereix la funcionalitat que necessites sense complexitat innecessària.

Prova a generar un CUIT ara o valida'n un existent per experimentar la simplicitat i l'efectivitat de la nostra eina de primera mà.

💬

Comentaris

💬

Fes clic a la notificació de comentaris per començar a donar comentaris sobre aquesta eina

🔗

Eines relacionades

Descobreix més eines que podrien ser útils per al teu flux de treball