Generatore e Validatore CUIT/CUIL Argentino

Introduzione

Il CUIT argentino (Clave Única de Identificación Tributaria) e il CUIL (Clave Única de Identificación Laboral) sono numeri di identificazione unici utilizzati in Argentina per scopi fiscali e lavorativi, rispettivamente. Questi codici di 11 cifre sono essenziali per individui e aziende per operare legalmente all'interno del sistema economico argentino. Il nostro strumento Generatore e Validatore CUIT/CUIL offre un modo semplice ed efficiente per generare numeri CUIT/CUIL validi per scopi di test e validare numeri esistenti per garantire che siano conformi al formato ufficiale e all'algoritmo di verifica.

Sia che tu sia uno sviluppatore che testa applicazioni che gestiscono ID fiscali argentini, uno specialista QA che verifica la funzionalità del sistema, o semplicemente abbia bisogno di capire come funzionano questi numeri di identificazione, questo strumento offre una soluzione diretta senza complessità inutili. Lo strumento presenta due funzioni principali: un generatore che crea numeri CUIT/CUIL validi in modo casuale o basato su parametri specifici, e un validatore che verifica se un dato numero CUIT/CUIL segue il formato corretto e le regole di calcolo.

Struttura e Calcolo del CUIT/CUIL

Comprendere il Formato

Un numero CUIT/CUIL valido consiste in 11 cifre tipicamente visualizzate nel formato XX-XXXXXXXX-X:

Codice di Tipo (prime 2 cifre): Indica il tipo di entità
- 20, 23, 24: Individui maschi (CUIL)
- 27: Individui femmine (CUIL)
- 30, 33, 34: Aziende e organizzazioni (CUIT)
Numero DNI (8 cifre centrali): Per gli individui, questo è il loro numero di documento d'identità nazionale (DNI), riempito con zeri iniziali se necessario per raggiungere 8 cifre. Per le aziende, questo è un numero assegnato unico.
Cifra di Verifica (ultima cifra): Una cifra di controllo calcolata utilizzando un algoritmo specifico per convalidare l'intero numero.

Calcolo della Cifra di Verifica

La cifra di verifica viene calcolata utilizzando il seguente algoritmo:

Prendere le prime 10 cifre del CUIT/CUIL (codice di tipo + DNI)
Moltiplicare ogni cifra per un peso corrispondente da questa sequenza: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
Sommare tutti i prodotti risultanti
Calcolare 11 meno il resto della somma diviso per 11
Se il risultato è 11, la cifra di verifica è 0
Se il risultato è 10, la cifra di verifica è 9
Altrimenti, il risultato è la cifra di verifica

Matematicamente, questo può essere espresso come:

$VD = 11 - ((\sum_{i=1}^{10} d_i \times w_i) \bmod 11)$

Dove:

$VD$ è la cifra di verifica
$d_i$ è la $i$ -esima cifra delle prime 10 cifre
$w_i$ è il peso corrispondente della sequenza [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
Casi speciali: se $VD = 11$ allora $VD = 0$ , se $VD = 10$ allora $VD = 9$

Guida Passo-Passo

Utilizzo del Generatore

Seleziona la scheda "Generatore" nella parte superiore dell'interfaccia dello strumento.
Scegli un Codice di Tipo dal menu a discesa:
- 20: Maschio (CUIL)
- 23: Azienda (CUIT)
- 24: Azienda Temporanea (CUIT)
- 27: Femmina (CUIL)
- 30: Corporazione (CUIT)
- 33: Associazione Civile (CUIT)
- 34: Fondazione (CUIT)
Inserisci un Numero DNI (opzionale):
- Immetti un numero DNI di 8 cifre nel campo fornito
- Se lasciato vuoto, lo strumento utilizzerà un DNI generato casualmente
- Se inserisci meno di 8 cifre, il sistema riempirà con zeri iniziali
Genera un DNI Casuale (opzionale):
- Clicca sul pulsante "Casuale" per generare un numero DNI di 8 cifre casuale
Visualizza il CUIT/CUIL Generato:
- Lo strumento visualizza automaticamente un CUIT/CUIL valido in base ai tuoi input
- Il formato sarà XX-XXXXXXXX-X con la corretta cifra di verifica
Copia il Risultato:
- Clicca sull'icona di copia per copiare il CUIT/CUIL generato negli appunti
- Apparirà un messaggio di conferma quando copiato con successo

Utilizzo del Validatore

Seleziona la scheda "Validatore" nella parte superiore dell'interfaccia dello strumento.
Inserisci il CUIT/CUIL da Validare:
- Immetti il CUIT/CUIL nel formato XX-XXXXXXXX-X
- Lo strumento formatterà automaticamente il tuo input con trattini mentre digiti
- Puoi anche inserire il numero senza trattini (XXXXXXXXXXX)
Clicca sul Pulsante "Valida":
- Lo strumento controllerà il formato, il codice di tipo e la cifra di verifica
Visualizza il Risultato della Validazione:
- Per numeri CUIT/CUIL validi, apparirà un messaggio di successo verde
- Per numeri non validi, apparirà un messaggio di errore rosso che spiega il problema:
  - Formato non valido (deve essere XX-XXXXXXXX-X)
  - Codice di tipo non valido (deve essere uno di: 20, 23, 24, 27, 30, 33, 34)
  - Cifra di verifica non valida
Informazioni Aggiuntive:
- Per numeri validi, lo strumento visualizza un'analisi dei componenti:
  - Codice di tipo e il suo significato
  - Numero DNI
  - Cifra di verifica

Casi d'Uso

Sviluppo e Test

Sviluppo Software: Genera numeri CUIT/CUIL validi per testare applicazioni che gestiscono identificazioni fiscali argentine, come:
- Piattaforme di e-commerce
- Software di contabilità
- Sistemi di gestione delle risorse umane
- Portali di servizi governativi
- Applicazioni bancarie
Popolamento Database: Crea dati di test realistici per sistemi che memorizzano informazioni sugli utenti argentini, garantendo che le restrizioni del database e le regole di validazione funzionino correttamente.
Test di Validazione dei Moduli: Testa la validazione dell'input per i moduli web che raccolgono informazioni CUIT/CUIL, verificando che appaiano messaggi di errore appropriati per voci non valide.
Test API: Genera payload validi per endpoint API che richiedono numeri CUIT/CUIL, garantendo che i tuoi test di integrazione utilizzino dati validi.
Automazione QA: Integra la generazione di CUIT/CUIL negli script di test automatizzati per creare casi di test dinamici piuttosto che utilizzare dati di test statici.

Scopi Educativi

Apprendere Algoritmi di Validazione: Comprendere come funzionano gli algoritmi di controllo nella pratica vedendo il processo di verifica del CUIT/CUIL in azione.
Insegnare la Validazione dei Dati: Utilizza come esempio educativo quando insegni tecniche di validazione dei moduli a nuovi sviluppatori.
Comprendere i Requisiti Aziendali Argentini: Impara sul sistema di identificazione utilizzato in Argentina per lo sviluppo commerciale internazionale.

Alternative

Sebbene il nostro strumento fornisca un modo semplice per generare e validare numeri CUIT/CUIL, ci sono approcci alternativi che potresti considerare:

Validazione Ufficiale del Governo: Per ambienti di produzione, valida sempre i numeri CUIT/CUIL contro il database ufficiale dell'AFIP (Administración Federal de Ingresos Públicos) quando possibile.
Librerie e Pacchetti: Diversi linguaggi di programmazione hanno librerie specificamente progettate per la validazione degli ID fiscali argentini:
- JavaScript: pacchetto npm validar-cuit
- PHP: libreria afip-php
- Python: pacchetto py-cuit
Calcolo Manuale: Per scopi educativi, potresti calcolare manualmente la cifra di verifica utilizzando l'algoritmo descritto in precedenza.
Servizi di Validazione Aziendale Completi: Per applicazioni aziendali, considera l'uso di servizi di validazione completi che non solo controllano il formato ma verificano anche l'esistenza e lo stato dell'entità associata al CUIT/CUIL.

Storia del Sistema CUIT/CUIL

Il sistema di identificazione CUIT/CUIL in Argentina è evoluto significativamente dalla sua nascita:

Origini e Implementazione

Il CUIT (Clave Única de Identificación Tributaria) è stato introdotto per la prima volta in Argentina negli anni '70 come parte degli sforzi per modernizzare il sistema di riscossione fiscale. L'Amministrazione Federale delle Entrate Pubbliche (AFIP) ha implementato questo identificatore unico per monitorare i contribuenti in modo più efficiente e ridurre l'evasione fiscale.

Il CUIL (Clave Única de Identificación Laboral) è stato introdotto successivamente per identificare specificamente i lavoratori nel sistema di sicurezza sociale, creando una distinzione tra identificazione fiscale e identificazione lavorativa mantenendo un formato coerente.

Evoluzione e Digitalizzazione

Negli anni '90, mentre l'Argentina subiva significative riforme economiche, il sistema CUIT/CUIL divenne sempre più importante per monitorare l'attività economica. Il sistema è stato ulteriormente digitalizzato e sono stati implementati sistemi di verifica online.

All'inizio degli anni 2000, il sistema CUIT/CUIL è stato integrato con vari servizi governativi digitali, rendendolo un componente essenziale delle iniziative di e-government dell'Argentina. Questo periodo ha visto anche la standardizzazione dell'algoritmo di verifica e del formato che rimane in uso oggi.

Sviluppi Recenti

Negli ultimi anni, l'AFIP ha migliorato i processi di sicurezza e verifica per i numeri CUIT/CUIL, implementando sistemi di validazione più sofisticati e integrandoli con altri database governativi. Il sistema gioca ora un ruolo cruciale negli sforzi dell'Argentina per combattere l'evasione fiscale e formalizzare l'economia.

Oggi, il CUIT/CUIL è utilizzato non solo per scopi fiscali e lavorativi, ma anche per una vasta gamma di attività tra cui transazioni bancarie, acquisti di proprietà, servizi pubblici e acquisti online, rendendolo un identificatore essenziale per individui e aziende che operano in Argentina.

Esempi di Codice

Python

1def calculate_verification_digit(type_code, dni):
2    # Convert to string and ensure DNI is 8 digits with leading zeros
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # Combine type code and DNI
7    digits = type_code_str + dni_str
8    
9    # Weights for each position
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # Calculate sum of products
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # Calculate verification digit
16    verification_digit = 11 - (sum_products % 11)
17    
18    # Special cases
19    if verification_digit == 11:
20        verification_digit = 0
21    elif verification_digit == 10:
22        verification_digit = 9
23    
24    return verification_digit
25
26def generate_cuit_cuil(type_code, dni=None):
27    import random
28    
29    # Valid type codes
30    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
31    
32    if type_code not in valid_type_codes:
33        raise ValueError(f"Codice di tipo non valido. Deve essere uno di: {valid_type_codes}")
34    
35    # Generate random DNI if not provided
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # Calculate verification digit
40    verification_digit = calculate_verification_digit(type_code, dni)
41    
42    # Format CUIT/CUIL
43    return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46    # Remove hyphens if present
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # Check basic format
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "Formato non valido"
52    
53    # Extract parts
54    type_code = int(cuit_cuil_clean[0:2])
55    dni = int(cuit_cuil_clean[2:10])
56    verification_digit = int(cuit_cuil_clean[10])
57    
58    # Validate type code
59    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60    if type_code not in valid_type_codes:
61        return False, "Codice di tipo non valido"
62    
63    # Calculate and compare verification digit
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "Cifra di verifica non valida"
67    
68    return True, "CUIT/CUIL valido"
69
70# Example usage
71print(generate_cuit_cuil(20, 12345678))  # Generate for specific DNI
72print(generate_cuit_cuil(27))  # Generate with random DNI
73print(validate_cuit_cuil("20-12345678-9"))  # Validate a CUIT/CUIL
74

JavaScript

1function calculateVerificationDigit(typeCode, dni) {
2  // Convert to string and ensure DNI is 8 digits with leading zeros
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // Combine type code and DNI
7  const digits = typeCodeStr + dniStr;
8  
9  // Weights for each position
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // Calculate sum of products
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // Calculate verification digit
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // Special cases
22  if (verificationDigit === 11) {
23    verificationDigit = 0;
24  } else if (verificationDigit === 10) {
25    verificationDigit = 9;
26  }
27  
28  return verificationDigit;
29}
30
31function generateCuitCuil(typeCode, dni) {
32  // Valid type codes
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`Codice di tipo non valido. Deve essere uno di: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // Generate random DNI if not provided
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // Calculate verification digit
45  const verificationDigit = calculateVerificationDigit(typeCode, dni);
46  
47  // Format CUIT/CUIL
48  return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52  // Remove hyphens if present
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // Check basic format
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'Formato non valido' };
58  }
59  
60  // Extract parts
61  const typeCode = parseInt(cuitCuilClean.substring(0, 2));
62  const dni = parseInt(cuitCuilClean.substring(2, 10));
63  const verificationDigit = parseInt(cuitCuilClean.substring(10, 11));
64  
65  // Validate type code
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'Codice di tipo non valido' };
69  }
70  
71  // Calculate and compare verification digit
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'Cifra di verifica non valida' };
75  }
76  
77  return { isValid: true };
78}
79
80// Example usage
81console.log(generateCuitCuil(20, 12345678)); // Generate for specific DNI
82console.log(generateCuitCuil(27)); // Generate with random DNI
83console.log(validateCuitCuil("20-12345678-9")); // Validate a CUIT/CUIL
84

Java

1import java.util.Arrays;
2import java.util.List;
3import java.util.Random;
4
5public class CuitCuilUtils {
6    private static final List<Integer> VALID_TYPE_CODES = Arrays.asList(20, 23, 24, 27, 30, 33, 34);
7    private static final int[] WEIGHTS = {5, 4, 3, 2, 7, 6, 5, 4, 3, 2};
8    
9    public static int calculateVerificationDigit(int typeCode, int dni) {
10        // Convert to string and ensure DNI is 8 digits with leading zeros
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // Combine type code and DNI
15        String digits = typeCodeStr + dniStr;
16        
17        // Calculate sum of products
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // Calculate verification digit
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // Special cases
27        if (verificationDigit == 11) {
28            verificationDigit = 0;
29        } else if (verificationDigit == 10) {
30            verificationDigit = 9;
31        }
32        
33        return verificationDigit;
34    }
35    
36    public static String generateCuitCuil(int typeCode, Integer dni) {
37        if (!VALID_TYPE_CODES.contains(typeCode)) {
38            throw new IllegalArgumentException("Codice di tipo non valido. Deve essere uno di: " + VALID_TYPE_CODES);
39        }
40        
41        // Generate random DNI if not provided
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // Calculate verification digit
48        int verificationDigit = calculateVerificationDigit(typeCode, dni);
49        
50        // Format CUIT/CUIL
51        return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52    }
53    
54    public static ValidationResult validateCuitCuil(String cuitCuil) {
55        // Remove hyphens if present
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // Check basic format
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "Formato non valido");
61        }
62        
63        // Extract parts
64        int typeCode = Integer.parseInt(cuitCuilClean.substring(0, 2));
65        int dni = Integer.parseInt(cuitCuilClean.substring(2, 10));
66        int verificationDigit = Integer.parseInt(cuitCuilClean.substring(10, 11));
67        
68        // Validate type code
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "Codice di tipo non valido");
71        }
72        
73        // Calculate and compare verification digit
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "Cifra di verifica non valida");
77        }
78        
79        return new ValidationResult(true, null);
80    }
81    
82    public static class ValidationResult {
83        private final boolean isValid;
84        private final String errorMessage;
85        
86        public ValidationResult(boolean isValid, String errorMessage) {
87            this.isValid = isValid;
88            this.errorMessage = errorMessage;
89        }
90        
91        public boolean isValid() {
92            return isValid;
93        }
94        
95        public String getErrorMessage() {
96            return errorMessage;
97        }
98    }
99    
100    public static void main(String[] args) {
101        // Example usage
102        System.out.println(generateCuitCuil(20, 12345678)); // Generate for specific DNI
103        System.out.println(generateCuitCuil(27, null)); // Generate with random DNI
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Validate a CUIT/CUIL
105    }
106}
107

PHP

1<?php
2
3function calculateVerificationDigit($typeCode, $dni) {
4    // Convert to string and ensure DNI is 8 digits with leading zeros
5    $typeCodeStr = (string)$typeCode;
6    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
7    
8    // Combine type code and DNI
9    $digits = $typeCodeStr . $dniStr;
10    
11    // Weights for each position
12    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
13    
14    // Calculate sum of products
15    $sumProducts = 0;
16    for ($i = 0; $i < 10; $i++) {
17        $sumProducts += (int)$digits[$i] * $weights[$i];
18    }
19    
20    // Calculate verification digit
21    $verificationDigit = 11 - ($sumProducts % 11);
22    
23    // Special cases
24    if ($verificationDigit == 11) {
25        $verificationDigit = 0;
26    } else if ($verificationDigit == 10) {
27        $verificationDigit = 9;
28    }
29    
30    return $verificationDigit;
31}
32
33function generateCuitCuil($typeCode, $dni = null) {
34    // Valid type codes
35    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
36    
37    if (!in_array($typeCode, $validTypeCodes)) {
38        throw new Exception("Codice di tipo non valido. Deve essere uno di: " . implode(', ', $validTypeCodes));
39    }
40    
41    // Generate random DNI if not provided
42    if ($dni === null) {
43        $dni = rand(10000000, 99999999);
44    }
45    
46    // Calculate verification digit
47    $verificationDigit = calculateVerificationDigit($typeCode, $dni);
48    
49    // Format CUIT/CUIL
50    return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit);
51}
52
53function validateCuitCuil($cuitCuil) {
54    // Remove hyphens if present
55    $cuitCuilClean = str_replace('-', '', $cuitCuil);
56    
57    // Check basic format
58    if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
59        return ['isValid' => false, 'errorMessage' => 'Formato non valido'];
60    }
61    
62    // Extract parts
63    $typeCode = (int)substr($cuitCuilClean, 0, 2);
64    $dni = (int)substr($cuitCuilClean, 2, 8);
65    $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
66    
67    // Validate type code
68    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
69    if (!in_array($typeCode, $validTypeCodes)) {
70        return ['isValid' => false, 'errorMessage' => 'Codice di tipo non valido'];
71    }
72    
73    // Calculate and compare verification digit
74    $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
75    if ($calculatedDigit !== $verificationDigit) {
76        return ['isValid' => false, 'errorMessage' => 'Cifra di verifica non valida'];
77    }
78    
79    return ['isValid' => true];
80}
81
82// Example usage
83echo generateCuitCuil(20, 12345678) . "\n"; // Generate for specific DNI
84echo generateCuitCuil(27) . "\n"; // Generate with random DNI
85var_dump(validateCuitCuil("20-12345678-9")); // Validate a CUIT/CUIL
86?>
87

Domande Frequenti

Qual è la differenza tra CUIT e CUIL?

Il CUIT (Clave Única de Identificación Tributaria) è utilizzato per scopi di identificazione fiscale ed è assegnato sia a individui che a entità legali che devono pagare tasse in Argentina. Il CUIL (Clave Única de Identificación Laboral) è specificamente per i lavoratori ed è utilizzato per scopi lavorativi e di sicurezza sociale. Sebbene condividano lo stesso formato e algoritmo di calcolo, servono a scopi amministrativi diversi.

Quali codici di tipo sono utilizzati per gli individui e quali per le aziende?

Per gli individui:

20, 23, 24: Individui maschi (CUIL)
27: Individui femmine (CUIL)

Per le aziende e le organizzazioni:

30: Corporazioni (CUIT)
33: Associazioni Civili (CUIT)
34: Fondazioni (CUIT)

Come viene calcolata la cifra di verifica?

La cifra di verifica viene calcolata utilizzando un algoritmo di somma pesata. Ciascuna delle prime 10 cifre viene moltiplicata per un peso corrispondente (5, 4, 3, 2, 7, 6, 5, 4, 3, 2), e i risultati vengono sommati. La cifra di verifica è 11 meno il resto quando questa somma è divisa per 11. Casi speciali: se il risultato è 11, la cifra di verifica è 0; se il risultato è 10, la cifra di verifica è 9.

Posso utilizzare questo strumento per generare numeri CUIT/CUIL reali e ufficiali?

No, questo strumento è progettato per scopi di test e educativi solo. I numeri generati sono matematicamente validi secondo l'algoritmo CUIT/CUIL ma non sono ufficialmente registrati presso le autorità fiscali argentine (AFIP). Per la registrazione ufficiale del CUIT/CUIL, individui e aziende devono seguire le procedure legali appropriate attraverso l'AFIP.

Perché la mia validazione CUIT/CUIL fallisce anche se il formato sembra corretto?

La validazione può fallire per diversi motivi:

Il codice di tipo non è uno dei codici validi (20, 23, 24, 27, 30, 33, 34)
La cifra di verifica non corrisponde al valore calcolato in base all'algoritmo
Il formato è errato (deve essere XX-XXXXXXXX-X)
Ci sono caratteri non numerici nell'input (a parte i trattini)

I trattini sono richiesti nei numeri CUIT/CUIL?

Sebbene i numeri CUIT/CUIL siano comunemente scritti e visualizzati con trattini (XX-XXXXXXXX-X), i trattini non fanno parte del numero reale ai fini del calcolo. Il nostro validatore accetta entrambi i formati (con o senza trattini) e convaliderà correttamente entrambi i formati.

Può un numero CUIT/CUIL avere meno di 8 cifre nella parte DNI?

No, la parte DNI deve sempre essere esattamente di 8 cifre. Se il DNI effettivo ha meno cifre, deve essere riempito con zeri iniziali per raggiungere 8 cifre. Ad esempio, se il DNI di qualcuno è 1234567, nel CUIT/CUIL sarà rappresentato come 01234567.

Come posso verificare se un CUIT/CUIL è ufficialmente registrato in Argentina?

Per verificare se un CUIT/CUIL è ufficialmente registrato e attivo, dovresti utilizzare il sito web ufficiale dell'AFIP (Administración Federal de Ingresos Públicos) o i servizi. Il nostro strumento verifica solo la validità matematica del numero, non il suo stato di registrazione ufficiale.

Posso utilizzare questo strumento nella mia applicazione commerciale?

Sì, puoi integrare l'algoritmo e la logica dimostrati in questo strumento nelle tue applicazioni commerciali. L'algoritmo di validazione CUIT/CUIL è uno standard pubblico. Tuttavia, per ambienti di produzione, ti consigliamo di implementare una corretta gestione degli errori e di considerare una validazione aggiuntiva contro fonti ufficiali quando necessario.

Questo strumento memorizza alcuni dei numeri CUIT/CUIL generati o convalidati?

No, questo strumento non memorizza alcuna delle informazioni inserite o generate. Tutto il processamento avviene lato client nel tuo browser e nessun dato viene inviato o memorizzato sui nostri server. Questo garantisce la privacy e la sicurezza di qualsiasi informazione tu inserisca.

Riferimenti

AFIP (Administración Federal de Ingresos Públicos). "CUIT/CUIL/CDI." Sito Ufficiale. https://www.afip.gob.ar/
Ministero del Lavoro, dell'Occupazione e della Sicurezza Sociale. "CUIL - Clave Única de Identificación Laboral." https://www.argentina.gob.ar/trabajo
ANSES (Administración Nacional de la Seguridad Social). "Ottenere il mio CUIL." https://www.anses.gob.ar/
Bollettino Ufficial della Repubblica Argentina. "Risoluzione Generale AFIP 2854/2010: Procedura. Clave Única de Identificación Tributaria (C.U.I.T.)."
Codice Fiscale della Repubblica Argentina. "Identificazione e Registrazione dei Contribuenti."

Pronto a generare o convalidare numeri CUIT/CUIL argentini? Prova il nostro strumento ora e semplifica il tuo processo di test!

Strumento di generazione e validazione CUIT/CUIL argentino

Generatore CUIT/CUIL

CUIT/CUIL Generato

Documentazione