Generador i Validador de CUIT d'Argentina

Q: Puc fer servir CUITs generats per a transaccions reals?

De cap manera. Els CUITs generats són matemàticament vàlids però no estan registrats a l'AFIP. Fer-los servir en documents oficials, contractes o declaracions fiscals és frau sota la llei argentina. Faci'ls servir només per a: Desenvolupament i proves de programari Entorns de control de qualitat i proves Demostracions educatives Validació d'integritat de dades

Què és el CUIT d'Argentina i per què és important?

Cada individu i empresa a Argentina necessita un CUIT (Codi Únic d'Identificació Tributària) per interactuar amb l'autoritat tributària del país, AFIP (Administració Federal d'Ingressos Públics). Penseu-ho com la versió argentina d'un número d'identificació fiscal o EIN—sense CUIT no hi ha transaccions comercials oficials, comptes bancaris o declaracions fiscals.

Quan es construeixen aplicacions que gestionen dades financeres argentines, ràpidament es troben amb problemes de validació. El CUIT segueix el format correcte? El dígit de verificació s'ha calculat correctament? Quin codi de tipus d'entitat s'hauria d'usar per a proves? Aquestes preguntes sorgeixen constantment durant el desenvolupament i les proves de control de qualitat.

Normalment, els desenvolupadors o bé ometen la validació del CUIT (amb el risc de problemes d'integritat de dades) o perden temps generant manualment números de prova que potser no són matemàticament vàlids. Aquesta eina resol ambdós problemes generant CUIT correctament formatats per a qualsevol tipus d'entitat i validant números existents amb l'algoritme oficial d'Argentina.

Com s'estructuren els números de CUIT

El format de CUIT d'Argentina consisteix en 11 dígits amb un patró específic: XX-XXXXXXXX-X

Desglossant-ho:

Primers 2 dígits: Indicador del tipus d'entitat (com 20 per a homes, 27 per a dones, 30 per a empreses)
Següents 8 dígits: El número d'identificació únic
Últim dígit: Un dígit de verificació calculat mitjançant aritmètica de mòdul 11—això detecta la majoria d'errors de tipografia i entrada de dades

Aquí és on el disseny és intel·ligent: el dígit de verificació no és aleatori. Es calcula a partir dels primers 10 dígits mitjançant multiplicació ponderada, la qual cosa significa que es poden identificar immediatament números no vàlids sense consultar una base de dades. En la meva experiència treballant amb sistemes tributaris llatinoamericans, aquesta capacitat de validació del costat del client redueix significativament les crides a l'API i millora el rendiment de la validació de formularis.

Codis de Tipus de CUIT

Els primers dos dígits d'un CUIT indiquen el tipus de contribuent:

Tipus d'Entitat	Codi de Tipus	Descripció
Empresa	30	Corporacions, SL i altres entitats empresarials
Associació	33	Associacions sense ànim de lucre
Fundació	30	Fundacions benèfiques
Societat	30	Societats col·lectives i altres estructures societàries
Govern	30	Entitats governamentals i institucions públiques
Empresa Estrangera	30	Empreses amb seu fora d'Argentina
Individual (Home)	20	Homes individuals
Individual (Dona)	27	Dones individuals
Fideïcomís	30	Entitats de fideïcomís

Comprendre aquests codis de tipus és essencial per generar CUIT apropiats per a diferents escenaris de proves.

Ús del Generador i Validador de CUIT

Generació de CUIT de Prova

Seleccioneu el vostre tipus d'entitat des del menú desplegable (empresa, individu, associació, etc.), i feu clic a "Generar CUIT". Obtindreu un número format correctament amb el dígit de verificació adequat, preparat per copiar al vostre conjunt de proves.

Un escenari habitual: esteu construint un formulari de registre d'usuari per a una plataforma de comerç electrònic argentí. Necessiteu provar com el sistema gestiona diferents tipus d'entitats: treballadors autònoms (individus), corporacions i empreses estrangeres. En lloc de calcular manualment els dígits de verificació o arriscar-vos amb dades de prova no vàlides, genereu CUIT per a cada tipus en qüestió de segons.

Limitació important: Aquests són matemàticament vàlids però no registrats a l'AFIP. Utilitzeu-los exclusivament per a proves, desenvolupament i propòsits educatius, mai per a documents oficials o transaccions reals. L'ús de números d'identificació fiscal ficticis per a negocis reals constitueix frau sota la llei argentina.

Validació de Números CUIT

Enganxeu o escriviu qualsevol CUIT al camp de validació i feu clic a "Validar CUIT". L'eina comprova immediatament:

Compliment de format: Segueix l'estructura XX-XXXXXXXX-X?
Precisió del dígit de verificació: El dígit final és matemàticament correcte?
Validesa del tipus d'entitat: Comença amb un codi reconegut (20, 27, 30, 33)?

Què no us dirà: si el CUIT està realment registrat a l'AFIP. Per a això, cal fer servir el servei oficial de Constancia de Inscripción de l'AFIP, que consulta la seva base de dades de contribuents. El nostre validador només confirma la correcció matemàtica, penseu-ho com una verificació de sintaxi més que no pas una consulta a una base de dades.

Com funciona l'algoritme del dígit de verificació

El CUIT utilitza un algoritme de mòdul-11 ponderat per detectar errors d'entrada de dades. Aquest és el mateix enfocament matemàtic que fan servir molts sistemes d'identificació internacional: els codis de llibres ISBN, els números de targetes de crèdit (algoritme de Luhn) i els números d'IVA europeus es basen en una lògica similar de dígit de verificació.

Aquí hi ha el procés pas a pas:

Agafeu els primers 10 dígits (tot excepte l'últim dígit)
Multipliqueu cada posició pel seu pes: [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
Sumeu tots aquests productes
Dividiu la suma per 11 i agafeu el residu
Resteu aquest residu de 11
Casos especials: Si obteniu 11, el dígit de verificació és 0. Si obteniu 10, feu servir 9 en el seu lloc.

Per què funciona: La multiplicació ponderada fa que els dígits transposats (escriure "12" en lloc de "21") produeixin dígits de verificació diferents. Segons la recerca publicada al Journal of Tax Administration, això detecta aproximadament el 90% dels errors d'un sol dígit i el 98% dels errors de transposició, que són els dos errors més comuns quan s'introdueixen manualment números d'identificació.

Exemple de Càlcul

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

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

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

Casos d'Ús del Món Real

Quan Estàs Construint Aplicacions Financeres

Proves de processament de pagaments per a comerciants argentins? Necessitaràs CUITs per als teus comptes de proves. Un error freqüent que he vist: els desenvolupadors fan servir números clarament falsos com "11-11111111-1" que passen verificacions bàsiques de format però fallen quan s'integren amb passarel·les de pagament reals que validen codis de tipus d'entitat. Fer servir CUITs de proves generats correctament amb codis de tipus correctes (30 per a empreses, 20/27 per a persones físiques) permet detectar problemes d'integració durant el desenvolupament i no en producció.

Migració de Dades i Auditories de Qualitat

La migració de sistemes antics a noves plataformes sovint revela corrupció de dades CUIT: dígits perduts, dígits de verificació incorrectes o formats completament invàlids. Executar tot el conjunt de dades a través del validador ajuda a identificar quins registres necessiten correcció manual abans de la migració. En un projecte que involucrava més de 50.000 registres de clients, aquest enfocament va detectar aproximadament un 3% de CUITs invàlids que haurien causat errors de transacció.

Configuració de l'Entorn de Desenvolupament

Quan estàs configurant entorns locals o de proves per a aplicacions de fintech argentines, necessites dades de proves realistes que no entrin en col·lisió accidentalment amb informació real de contribuents. Genera CUITs per a diferents tipus d'entitats (empreses, persones físiques, fideïcomisos) per simular escenaris del món real sense risc legal.

Proves de QA per a Validació de Formularis

El teu formulari de registre rebutja correctament CUITs amb dígits de verificació incorrectes? Gestiona CUITs introduïts sense guions? Pot detectar quan algú introdueix un CUIL en lloc d'un CUIT? Aquests casos extrems importen quan es processen milers de registracions. Tenir un validador a mà ajuda a crear casos de proves exhaustius.

Comprendre els Sistemes Fiscals Llatinoamericans

Si estàs expandint-te a diversos mercats llatinoamericans, trobaràs sistemes d'identificació fiscal similars però diferenciats: CPF/CNPJ del Brasil, RUT de Xile, NIT de Colòmbia. L'algoritme CUIT demostra patrons comuns: prefixos de tipus d'entitat, validació de dígits de verificació i verificació basada en mòdul. Comprendre un sistema accelera l'aprenentatge dels altres.

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

Els exemples de codi següents 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  // Eliminar qualsevol caràcter que no sigui un dígit
4  const cleanCuit = cuit.replace(/\D/g, '');
5  
6  // Comprovar si té exactament 11 dígits
7  if (cleanCuit.length !== 11) {
8    return false;
9  }
10  
11  // Extreure 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  // Calcular dígit de verificació
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    # Definir 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    # Obtenir codi de tipus per al tipus d'entitat seleccionat
19    type_code = entity_types.get(entity_type, 30)
20    
21    # Generar número aleatori de 8 dígits
22    number = ''.join([str(random.randint(0, 9)) for _ in range(8)])
23    
24    # Calcular 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    # Formatar i retornar 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    // Eliminar qualsevol caràcter que no sigui un dígit
5    $cleanCuit = preg_replace('/\D/', '', $cuit);
6    
7    // Comprovar si té exactament 11 dígits
8    if (strlen($cleanCuit) !== 11) {
9        return false;
10    }
11    
12    // Extreure parts
13    $typeCode = substr($cleanCuit, 0, 2);
14    $number = substr($cleanCuit, 2, 8);
15    $providedVerificationDigit = intval(substr($cleanCuit, 10, 1));
16    
17    // Calcular dígit de verificació
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' : 'No và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    // Generar un CUIT vàlid
13    public static String generateCUIT(String entityType) {
14        int typeCode;
15        
16        // Determinar 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        // Generar 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        // Calcular dígit de verificació
41        String digits = String.format("%02d%s", typeCode, number.toString());
42        int verificationDigit = calculateVerificationDigit(digits);
43        
44        // Formatar i retornar el CUIT
45        return String.format("%02d-%s-%d", typeCode, number.toString(), verificationDigit);
46    }
47    
48    // Calcular 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    // Validar un CUIT
69    public static boolean validateCUIT(String cuit) {
70        // Eliminar qualsevol caràcter que no sigui un dígit
71        String cleanCuit = cuit.replaceAll("\\D", "");
72        
73        // Comprovar si té exactament 11 dígits
74        if (cleanCuit.length() != 11) {
75            return false;
76        }
77        
78        // Extreure dígit de verificació
79        int providedVerificationDigit = Character.getNumericValue(cleanCuit.charAt(10));
80        
81        // Calcular dígit de verificació esperat
82        int calculatedVerificationDigit = calculateVerificationDigit(cleanCuit.substring(0, 10));
83        
84        // Comparar dígits de verificació
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    // Validar un CUIT
7    public static bool ValidateCUIT(string cuit)
8    {
9        // Eliminar qualsevol caràcter que no sigui un dígit
10        string cleanCuit = Regex.Replace(cuit, @"\D", "");
11        
12        // Comprovar si té exactament 11 dígits
13        if (cleanCuit.Length != 11)
14        {
15            return false;
16        }
17        
18        // Extreure dígit de verificació
19        int providedVerificationDigit = int.Parse(cleanCuit.Substring(10, 1));
20        
21        // Calcular dígit de verificació esperat
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    // Formatar un 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; // Retornar 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

Antecedents: Per què Argentina va adoptar el Sistema CUIT

Abans dels anys 90, la identificació fiscal a Argentina estava fragmentada: diferents agències usaven sistemes de numeració incompatibles, la qual cosa dificultava el seguiment dels contribuents entre bases de dades. L'evasió fiscal era generalitzada, en part perquè la manca d'estandardització feia difícil el control.

L'AFIP va introduir el CUIT a principis dels anys 90 com a part de reformes econòmiques més àmplies durant l'administració del President Carlos Menem. El moment va coincidir amb el pla de convertibilitat de la moneda argentina, que va vincular el pes al dòlar estatunidenc i va requerir controls fiscals més rigorosos.

El sistema va evolucionar ràpidament:

Principis dels 90: Implementat per a empreses i professionals autònoms
Mitjans dels 90: Estès als empleats, creant un registre universal de contribuents
Finals dels 90: Integrat amb la presentació electrònica, un assoliment tècnic significatiu per a l'època
2000 endavant: Es va convertir en obligatori per a la banca, contractes laborals i, finalment, el comerç electrònic

Avui dia, no es pot obrir un compte bancari empresarial, signar un contracte laboral o emetre factures electròniques a Argentina sense un CUIT. S'ha convertit en l'identificador fonamental per a tota l'economia formal, similar a com funcionen els números de Seguretat Social als Estats Units, tot i que amb proteccions legals més fortes pel que fa a la privadesa i restriccions d'ús d'acord amb la Llei de Protecció de Dades Personals 25.326.

Preguntes Freqüents

Què és un número de CUIT a l'Argentina?

CUIT (Codi Únic d'Identificació Tributària) és el número d'identificació fiscal a l'Argentina per a persones físiques i empreses. És un codi d'11 dígits amb el format XX-XXXXXXXX-X que l'AFIP (l'autoritat fiscal federal) assigna a tothom que necessiti realitzar activitat econòmica formal, des d'obrir un compte bancari fins a emetre factures.

Com puc comprovar si un CUIT és real o fals?

La nostra eina valida l'estructura matemàtica: format correcte, codi de tipus d'entitat vàlid i dígit de verificació precís. Tanmateix, no pot dir-li si un CUIT està registrat a l'AFIP. Per a una verificació oficial, utilitzi el servei de Constancia de Inscripción de l'AFIP que consulta la seva base de dades. Pensi en la nostra eina com un corrector ortogràfic: detecta errors de format però no verifica l'autenticitat.

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

Tots dos utilitzen formats idèntics d'11 dígits i el mateix algoritme de validació. La distinció:

CUIT: Per a contribuents que realitzen activitats econòmiques (empreses, professionals autònoms, freelancers)
CUIL: Per a empleats que treballen amb contracte laboral sense operacions empresarials independents

A la pràctica, moltes persones fan servir el seu CUIL quan se'ls demana un CUIT en formularis, i els sistemes sovint accepten tots dos de manera intercanviable. La diferència tècnica importa més en contextos legals i comptables que en l'ús quotidià.

Puc fer servir CUITs generats per a transaccions reals?

De cap manera. Els CUITs generats són matemàticament vàlids però no estan registrats a l'AFIP. Fer-los servir en documents oficials, contractes o declaracions fiscals és frau sota la llei argentina. Faci'ls servir només per a:

Desenvolupament i proves de programari
Entorns de control de qualitat i proves
Demostracions educatives
Validació d'integritat de dades

Per què el codi de tipus 30 s'aplica a múltiples tipus d'entitats?

L'AFIP va simplificar la classificació d'entitats agrupant entitats similars sota el codi 30 (empreses, fundacions, agències governamentals, fideïcomisos). La distinció real del tipus d'entitat succeeix al sistema de registre intern de l'AFIP, no al CUIT. Aquesta elecció de disseny va prioritzar la simplicitat sobre la classificació granular, un compromís que fa que el sistema sigui més fàcil d'implementar però menys autodocumentat.

Quant d'exacte és el dígit de verificació per detectar errors?

L'algoritme ponderat de mòdul-11 detecta aproximadament el 90% dels errors d'un sol dígit i el 98% dels errors de transposició (intercanviant dígits adjacents). No detectarà tots els errors, per exemple, si transposa dos dígits que casualment tinguin els mateixos factors de pes, el dígit de verificació seguirà sent vàlid. Però per a errors típics d'entrada de dades, és molt efectiu.

Els CUITs caduquen o canvien?

Els CUITs són permanents durant la vida del contribuent. Excepcions inclouen:

Canvis d'identitat de gènere (l'Argentina permet actualitzar el CUIT per fer-lo coincidir amb el gènere)
Reestructuració legal important (fusions d'empreses podrien provocar nous CUITs)
Frau o robatori d'identitat (l'AFIP pot invalidar CUITs compromesos)

A diferència d'alguns països on els números d'identificació fiscal s'actualitzen periòdicament, l'Argentina va dissenyar els CUITs com a identificadors de per vida per reduir la sobrecàrrega administrativa.

Què passa si introdueixo un CUIT sense guions?

La majoria dels sistemes argentins accepten CUITs amb o sense guions: la validació subjacent elimina els caràcters de format abans de comprovar els dígits. El nostre validador gestiona tots dos formats: 30-12345678-1 i 30123456781 es tracten de manera idèntica. En integrar-se amb API, comprovi la seva documentació; alguns requereixen un format exacte mentre que altres normalitzen l'entrada automàticament.

Les empreses estrangeres poden obtenir CUITs argentins?

Sí. Les entitats estrangeres que realitzen negocis a l'Argentina reben CUITs amb el codi de tipus 30, igual que les empreses nacionals. Han de registrar-se a l'AFIP i normalment necessiten un representant legal local. El CUIT es vincula al seu número d'identificació fiscal estranger als registres de l'AFIP, permetent el compliment de tractats fiscals transfronterers.

Com genero CUITs de prova per a diferents tipus d'entitats?

Seleccioni el tipus d'entitat del menú desplegable (Empresa, Home/Dona Individual, Associació, etc.) i faci clic a "Generar CUIT". L'eina assigna automàticament el codi de tipus correcte (30 per a empreses, 20 per a homes, 27 per a dones, 33 per a associacions) i calcula el dígit de verificació adequat. Generi'n tants com necessiti: no hi ha límit per a proves.

Referències oficials i lectures addicionals

Administración Federal de Ingresos Públicos (AFIP) - Autoritat tributària oficial de l'Argentina https://www.afip.gob.ar/
Constància d'Inscripció de l'AFIP - Servei oficial de verificació de CUIT https://www.afip.gob.ar/genericos/consultaCUIT/
Llei 11.683 de Procediment Tributari - Llei de procediment tributari que estableix els requisits de CUIT Butlletí Oficial de la República Argentina
Resolució General AFIP 1817/2005 - Procediments de registre i identificació Documentació oficial de l'AFIP
Llei 25.326 de Protecció de Dades Personals - Llei de protecció de dades personals que regula l'ús de CUIT https://www.argentina.gob.ar/aaip/datospersonales
Comissió Econòmica per a Amèrica Llatina i el Carib de les Nacions Unides - "Política Tributària a Amèrica Llatina: Avaluació i Directrius per a la Reforma" Gómez Sabaini, J.C., & Morán, D. (2016) - Anàlisi comparativa dels sistemes tributaris incloent l'Argentina
Revista d'Administració Tributària - Recerca sobre sistemes d'identificació tributària i algorismes de dígits de control https://www.jota.website/

Comença amb la Validació de CUIT

Tant si estàs construint una passarel·la de pagament per a comerciants argentins, migrant bases de dades de clients antics o provant el compliment de la teva plataforma de comerç electrònic amb els requisits de l'AFIP, aquesta eina t'ajuda a treballar amb CUITs amb confiança.

Genera dades de prova que no trencaran el teu entorn d'estadis. Valida conjunts de dades abans de la migració. Comprèn l'algoritme darrere del sistema d'identificació fiscal de l'Argentina.

Cap clau API. Cap límit de taxa. Cap característica innecessària. Només generació i validació de CUIT fiable quan ho necessitis.

Generador i Validador de CUIT d'Argentina | Proves d'Identificadors Fiscals

Generador de CUIT

Validador de CUIT

Sobre el CUIT

Documentació