Générateur et Validateur de CUIT/CUIL Argentin

Introduction

Le CUIT argentin (Clave Única de Identificación Tributaria) et le CUIL (Clave Única de Identificación Laboral) sont des numéros d'identification uniques utilisés en Argentine à des fins fiscales et d'emploi, respectivement. Ces codes à 11 chiffres sont essentiels pour les individus et les entreprises afin d'opérer légalement au sein du système économique argentin. Notre outil de Générateur et Validateur de CUIT/CUIL fournit un moyen simple et efficace de générer des numéros de CUIT/CUIL valides à des fins de test et de valider les numéros existants pour s'assurer qu'ils respectent le format officiel et l'algorithme de vérification.

Que vous soyez un développeur testant des applications qui gèrent des identifiants fiscaux argentins, un spécialiste QA vérifiant la fonctionnalité du système, ou que vous ayez simplement besoin de comprendre comment ces numéros d'identification fonctionnent, cet outil offre une solution simple sans complexités inutiles. L'outil propose deux fonctions principales : un générateur qui crée des numéros de CUIT/CUIL valides de manière aléatoire ou sur la base de paramètres spécifiques, et un validateur qui vérifie si un numéro de CUIT/CUIL donné suit le format correct et les règles de calcul.

Structure et Calcul du CUIT/CUIL

Comprendre le Format

Un numéro de CUIT/CUIL valide se compose de 11 chiffres généralement affichés au format XX-XXXXXXXX-X :

Code Type (premiers 2 chiffres) : Indique le type d'entité
- 20, 23, 24 : Individus masculins (CUIL)
- 27 : Individus féminins (CUIL)
- 30, 33, 34 : Entreprises et organisations (CUIT)
Numéro DNI (8 chiffres du milieu) : Pour les individus, il s'agit de leur numéro de document d'identité national (DNI), complété par des zéros devant si nécessaire pour atteindre 8 chiffres. Pour les entreprises, il s'agit d'un numéro unique attribué.
Chiffre de Vérification (dernier chiffre) : Un chiffre de contrôle calculé à l'aide d'un algorithme spécifique pour valider l'ensemble du numéro.

Calcul du Chiffre de Vérification

Le chiffre de vérification est calculé à l'aide de l'algorithme suivant :

Prenez les 10 premiers chiffres du CUIT/CUIL (code type + DNI)
Multipliez chaque chiffre par un poids correspondant de cette séquence : 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
Additionnez tous les produits résultants
Calculez 11 moins le reste de la somme divisée par 11
Si le résultat est 11, le chiffre de vérification est 0
Si le résultat est 10, le chiffre de vérification est 9
Sinon, le résultat est le chiffre de vérification

Mathématiquement, cela peut être exprimé comme :

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

Où :

$VD$ est le chiffre de vérification
$d_i$ est le $i$ -ème chiffre des 10 premiers chiffres
$w_i$ est le poids correspondant de la séquence [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
Cas spéciaux : si $VD = 11$ alors $VD = 0$ , si $VD = 10$ alors $VD = 9$

Guide Étape par Étape

Utilisation du Générateur

Sélectionnez l'onglet "Générateur" en haut de l'interface de l'outil.
Choisissez un Code Type dans le menu déroulant :
- 20 : Masculin (CUIL)
- 23 : Entreprise (CUIT)
- 24 : Entreprise Temporaire (CUIT)
- 27 : Féminin (CUIL)
- 30 : Société (CUIT)
- 33 : Association Civile (CUIT)
- 34 : Fondation (CUIT)
Entrez un Numéro DNI (facultatif) :
- Saisissez un numéro DNI à 8 chiffres dans le champ prévu
- Si laissé vide, l'outil utilisera un DNI généré aléatoirement
- Si vous entrez moins de 8 chiffres, le système complétera avec des zéros devant
Générer un DNI Aléatoire (facultatif) :
- Cliquez sur le bouton "Aléatoire" pour générer un numéro DNI à 8 chiffres aléatoire
Voir le CUIT/CUIL Généré :
- L'outil affiche automatiquement un CUIT/CUIL valide basé sur vos entrées
- Le format sera XX-XXXXXXXX-X avec le chiffre de vérification correct
Copier le Résultat :
- Cliquez sur l'icône de copie pour copier le CUIT/CUIL généré dans votre presse-papiers
- Un message de confirmation apparaîtra lorsque la copie sera réussie

Utilisation du Validateur

Sélectionnez l'onglet "Validateur" en haut de l'interface de l'outil.
Entrez le CUIT/CUIL à Valider :
- Saisissez le CUIT/CUIL au format XX-XXXXXXXX-X
- L'outil formate automatiquement votre saisie avec des tirets au fur et à mesure que vous tapez
- Vous pouvez également entrer le numéro sans tirets (XXXXXXXXXXX)
Cliquez sur le Bouton "Valider" :
- L'outil vérifiera le format, le code type et le chiffre de vérification
Voir le Résultat de la Validation :
- Pour les numéros CUIT/CUIL valides, un message de succès vert apparaîtra
- Pour les numéros invalides, un message d'erreur rouge expliquera le problème :
  - Format invalide (doit être XX-XXXXXXXX-X)
  - Code type invalide (doit être l'un de : 20, 23, 24, 27, 30, 33, 34)
  - Chiffre de vérification invalide
Informations Supplémentaires :
- Pour les numéros valides, l'outil affiche une répartition des composants :
  - Code type et sa signification
  - Numéro DNI
  - Chiffre de vérification

Cas d'Utilisation

Développement et Test

Développement de Logiciels : Générer des numéros CUIT/CUIL valides pour tester des applications qui gèrent des identifiants fiscaux argentins, tels que :
- Plateformes de commerce électronique
- Logiciels de comptabilité
- Systèmes de gestion des ressources humaines
- Portails de services gouvernementaux
- Applications bancaires
Population de Base de Données : Créer des données de test réalistes pour des systèmes qui stockent des informations utilisateur argentines, en s'assurant que les contraintes de base de données et les règles de validation fonctionnent correctement.
Test de Validation de Formulaire : Tester la validation des entrées pour les formulaires Web qui collectent des informations de CUIT/CUIL, en vérifiant que des messages d'erreur appropriés apparaissent pour les entrées invalides.
Test d'API : Générer des charges utiles valides pour les points de terminaison API qui nécessitent des numéros de CUIT/CUIL, en s'assurant que vos tests d'intégration utilisent des données valides.
Automatisation QA : Intégrer la génération de CUIT/CUIL dans des scripts de test automatisés pour créer des cas de test dynamiques plutôt que d'utiliser des données de test statiques.

Objectifs Éducatifs

Apprentissage des Algorithmes de Validation : Comprendre comment fonctionnent les algorithmes de chiffre de contrôle en pratique en voyant le processus de vérification du CUIT/CUIL en action.
Enseigner la Validation des Données : Utiliser comme exemple éducatif lors de l'enseignement des techniques de validation de formulaire aux nouveaux développeurs.
Comprendre les Exigences Commerciales Argentines : Apprendre sur le système d'identification utilisé en Argentine pour le développement commercial international.

Alternatives

Bien que notre outil fournisse un moyen simple de générer et de valider des numéros de CUIT/CUIL, il existe des approches alternatives que vous pourriez envisager :

Validation Officielle par le Gouvernement : Pour les environnements de production, validez toujours les numéros de CUIT/CUIL contre la base de données officielle de l'AFIP (Administración Federal de Ingresos Públicos) lorsque cela est possible.
Bibliothèques et Packages : Plusieurs langages de programmation disposent de bibliothèques spécifiquement conçues pour la validation des identifiants fiscaux argentins :
- JavaScript : package npm validar-cuit
- PHP : bibliothèque afip-php
- Python : package py-cuit
Calcul Manuel : À des fins éducatives, vous pourriez calculer le chiffre de vérification manuellement à l'aide de l'algorithme décrit précédemment.
Services de Validation Commerciale Complets : Pour les applications d'entreprise, envisagez d'utiliser des services de validation complets qui vérifient non seulement le format mais aussi l'existence et le statut de l'entité associée au CUIT/CUIL.

Histoire du Système CUIT/CUIL

Le système d'identification CUIT/CUIL en Argentine a évolué de manière significative depuis sa création :

Origines et Mise en Œuvre

Le CUIT (Clave Única de Identificación Tributaria) a été introduit pour la première fois en Argentine dans les années 1970 dans le cadre des efforts de modernisation du système de collecte des impôts. L'Administration Fédérale des Revenus Publics (AFIP) a mis en place cet identifiant unique pour suivre les contribuables plus efficacement et réduire l'évasion fiscale.

Le CUIL (Clave Única de Identificación Laboral) a été introduit plus tard pour identifier spécifiquement les travailleurs dans le système de sécurité sociale, créant une distinction entre l'identification fiscale et l'identification du travail tout en maintenant un format cohérent.

Évolution et Digitalisation

Dans les années 1990, alors que l'Argentine subissait d'importantes réformes économiques, le système CUIT/CUIL est devenu de plus en plus important pour le suivi de l'activité économique. Le système a été davantage digitalisé, et des systèmes de vérification en ligne ont été mis en œuvre.

Le début des années 2000 a vu l'intégration du système CUIT/CUIL avec divers services gouvernementaux numériques, faisant de lui un élément essentiel des initiatives de gouvernement électronique de l'Argentine. Cette période a également vu la normalisation de l'algorithme de vérification et du format qui restent en usage aujourd'hui.

Développements Récents

Ces dernières années, l'AFIP a renforcé les processus de sécurité et de vérification des numéros de CUIT/CUIL, mettant en œuvre des systèmes de validation plus sophistiqués et les intégrant à d'autres bases de données gouvernementales. Le système joue désormais un rôle crucial dans les efforts de l'Argentine pour lutter contre l'évasion fiscale et formaliser l'économie.

Aujourd'hui, le CUIT/CUIL est utilisé non seulement à des fins fiscales et d'emploi, mais aussi pour une large gamme d'activités, y compris les transactions bancaires, les transactions immobilières, les services publics et les achats en ligne, en faisant un identifiant essentiel pour les individus et les entreprises opérant en Argentine.

Exemples de Code

Python

1def calculate_verification_digit(type_code, dni):
2    # Convertir en chaîne et s'assurer que le DNI a 8 chiffres avec des zéros devant
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # Combiner le code type et le DNI
7    digits = type_code_str + dni_str
8    
9    # Poids pour chaque position
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # Calculer la somme des produits
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # Calculer le chiffre de vérification
16    verification_digit = 11 - (sum_products % 11)
17    
18    # Cas spéciaux
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    # Codes types valides
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"Code type invalide. Doit être l'un de : {valid_type_codes}")
34    
35    # Générer un DNI aléatoire si non fourni
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # Calculer le chiffre de vérification
40    verification_digit = calculate_verification_digit(type_code, dni)
41    
42    # Formater le CUIT/CUIL
43    return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46    # Supprimer les tirets si présents
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # Vérifier le format de base
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "Format invalide"
52    
53    # Extraire les parties
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    # Valider le code type
59    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60    if type_code not in valid_type_codes:
61        return False, "Code type invalide"
62    
63    # Calculer et comparer le chiffre de vérification
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "Chiffre de vérification invalide"
67    
68    return True, "CUIT/CUIL valide"
69
70# Exemple d'utilisation
71print(generate_cuit_cuil(20, 12345678))  # Générer pour un DNI spécifique
72print(generate_cuit_cuil(27))  # Générer avec un DNI aléatoire
73print(validate_cuit_cuil("20-12345678-9"))  # Valider un CUIT/CUIL
74

JavaScript

1function calculateVerificationDigit(typeCode, dni) {
2  // Convertir en chaîne et s'assurer que le DNI a 8 chiffres avec des zéros devant
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // Combiner le code type et le DNI
7  const digits = typeCodeStr + dniStr;
8  
9  // Poids pour chaque position
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // Calculer la somme des produits
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // Calculer le chiffre de vérification
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // Cas spéciaux
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  // Codes types valides
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`Code type invalide. Doit être l'un de : ${validTypeCodes.join(', ')}`);
37  }
38  
39  // Générer un DNI aléatoire si non fourni
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // Calculer le chiffre de vérification
45  const verificationDigit = calculateVerificationDigit(typeCode, dni);
46  
47  // Formater le CUIT/CUIL
48  return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52  // Supprimer les tirets si présents
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // Vérifier le format de base
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'Format invalide' };
58  }
59  
60  // Extraire les parties
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  // Valider le code type
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'Code type invalide' };
69  }
70  
71  // Calculer et comparer le chiffre de vérification
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'Chiffre de vérification invalide' };
75  }
76  
77  return { isValid: true };
78}
79
80// Exemple d'utilisation
81console.log(generateCuitCuil(20, 12345678)); // Générer pour un DNI spécifique
82console.log(generateCuitCuil(27)); // Générer avec un DNI aléatoire
83console.log(validateCuitCuil("20-12345678-9")); // Valider un 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        // Convertir en chaîne et s'assurer que le DNI a 8 chiffres avec des zéros devant
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // Combiner le code type et le DNI
15        String digits = typeCodeStr + dniStr;
16        
17        // Calculer la somme des produits
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // Calculer le chiffre de vérification
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // Cas spéciaux
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("Code type invalide. Doit être l'un de : " + VALID_TYPE_CODES);
39        }
40        
41        // Générer un DNI aléatoire si non fourni
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // Calculer le chiffre de vérification
48        int verificationDigit = calculateVerificationDigit(typeCode, dni);
49        
50        // Formater le CUIT/CUIL
51        return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52    }
53    
54    public static ValidationResult validateCuitCuil(String cuitCuil) {
55        // Supprimer les tirets si présents
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // Vérifier le format de base
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "Format invalide");
61        }
62        
63        // Extraire les parties
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        // Valider le code type
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "Code type invalide");
71        }
72        
73        // Calculer et comparer le chiffre de vérification
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "Chiffre de vérification invalide");
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        // Exemple d'utilisation
102        System.out.println(generateCuitCuil(20, 12345678)); // Générer pour un DNI spécifique
103        System.out.println(generateCuitCuil(27, null)); // Générer avec un DNI aléatoire
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Valider un CUIT/CUIL
105    }
106}
107

PHP

1<?php
2
3function calculateVerificationDigit($typeCode, $dni) {
4    // Convertir en chaîne et s'assurer que le DNI a 8 chiffres avec des zéros devant
5    $typeCodeStr = (string)$typeCode;
6    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
7    
8    // Combiner le code type et le DNI
9    $digits = $typeCodeStr . $dniStr;
10    
11    // Poids pour chaque position
12    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
13    
14    // Calculer la somme des produits
15    $sumProducts = 0;
16    for ($i = 0; $i < 10; $i++) {
17        $sumProducts += (int)$digits[$i] * $weights[$i];
18    }
19    
20    // Calculer le chiffre de vérification
21    $verificationDigit = 11 - ($sumProducts % 11);
22    
23    // Cas spéciaux
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    // Codes types valides
35    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
36    
37    if (!in_array($typeCode, $validTypeCodes)) {
38        throw new Exception("Code type invalide. Doit être l'un de : " . implode(', ', $validTypeCodes));
39    }
40    
41    // Générer un DNI aléatoire si non fourni
42    if ($dni === null) {
43        $dni = rand(10000000, 99999999);
44    }
45    
46    // Calculer le chiffre de vérification
47    $verificationDigit = calculateVerificationDigit($typeCode, $dni);
48    
49    // Formater le CUIT/CUIL
50    return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit);
51}
52
53function validateCuitCuil($cuitCuil) {
54    // Supprimer les tirets si présents
55    $cuitCuilClean = str_replace('-', '', $cuitCuil);
56    
57    // Vérifier le format de base
58    if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
59        return ['isValid' => false, 'errorMessage' => 'Format invalide'];
60    }
61    
62    // Extraire les parties
63    $typeCode = (int)substr($cuitCuilClean, 0, 2);
64    $dni = (int)substr($cuitCuilClean, 2, 8);
65    $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
66    
67    // Valider le code type
68    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
69    if (!in_array($typeCode, $validTypeCodes)) {
70        return ['isValid' => false, 'errorMessage' => 'Code type invalide'];
71    }
72    
73    // Calculer et comparer le chiffre de vérification
74    $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
75    if ($calculatedDigit !== $verificationDigit) {
76        return ['isValid' => false, 'errorMessage' => 'Chiffre de vérification invalide'];
77    }
78    
79    return ['isValid' => true];
80}
81
82// Exemple d'utilisation
83echo generateCuitCuil(20, 12345678) . "\n"; // Générer pour un DNI spécifique
84echo generateCuitCuil(27) . "\n"; // Générer avec un DNI aléatoire
85var_dump(validateCuitCuil("20-12345678-9")); // Valider un CUIT/CUIL
86?>
87

Questions Fréquemment Posées

Quelle est la différence entre CUIT et CUIL ?

Le CUIT (Clave Única de Identificación Tributaria) est utilisé à des fins d'identification fiscale et est attribué aux individus et aux entités juridiques qui doivent payer des impôts en Argentine. Le CUIL (Clave Única de Identificación Laboral) est spécifiquement destiné aux travailleurs et est utilisé à des fins de travail et de sécurité sociale. Bien qu'ils partagent le même format et l'algorithme de calcul, ils servent des objectifs administratifs différents.

Quels codes types sont utilisés pour les individus et lesquels pour les entreprises ?

Pour les individus :

20, 23, 24 : Individus masculins (CUIL)
27 : Individus féminins (CUIL)

Pour les entreprises et organisations :

30 : Sociétés (CUIT)
33 : Associations Civiles (CUIT)
34 : Fondations (CUIT)

Comment le chiffre de vérification est-il calculé ?

Le chiffre de vérification est calculé à l'aide d'une somme pondérée. Chacun des 10 premiers chiffres est multiplié par un poids correspondant (5, 4, 3, 2, 7, 6, 5, 4, 3, 2), et les résultats sont additionnés. Le chiffre de vérification est 11 moins le reste lorsque cette somme est divisée par 11. Cas spéciaux : si le résultat est 11, le chiffre de vérification est 0 ; si le résultat est 10, le chiffre de vérification est 9.

Puis-je utiliser cet outil pour générer de vrais numéros de CUIT/CUIL officiels ?

Non, cet outil est conçu uniquement pour des fins de test et éducatives. Les numéros générés sont mathématiquement valides selon l'algorithme CUIT/CUIL mais ne sont pas officiellement enregistrés auprès des autorités fiscales argentines (AFIP). Pour l'enregistrement officiel de CUIT/CUIL, les individus et les entreprises doivent suivre les procédures légales appropriées via l'AFIP.

Pourquoi la validation de mon CUIT/CUIL échoue-t-elle même si le format semble correct ?

La validation peut échouer pour plusieurs raisons :

Le code type n'est pas l'un des codes valides (20, 23, 24, 27, 30, 33, 34)
Le chiffre de vérification ne correspond pas à la valeur calculée selon l'algorithme
Le format est incorrect (doit être XX-XXXXXXXX-X)
Il y a des caractères non numériques dans l'entrée (à part les tirets)

Les tirets sont-ils nécessaires dans les numéros CUIT/CUIL ?

Bien que les numéros CUIT/CUIL soient généralement écrits et affichés avec des tirets (XX-XXXXXXXX-X), les tirets ne font pas partie du numéro réel à des fins de calcul. Notre validateur accepte les deux formats (avec ou sans tirets) et validera correctement l'un ou l'autre format.

Un CUIT/CUIL peut-il avoir moins de 8 chiffres dans la portion DNI ?

Non, la portion DNI doit toujours avoir exactement 8 chiffres. Si le DNI réel a moins de chiffres, il doit être complété par des zéros devant pour atteindre 8 chiffres. Par exemple, si le DNI d'une personne est 1234567, dans le CUIT/CUIL, il serait représenté comme 01234567.

Comment puis-je vérifier si un CUIT/CUIL est officiellement enregistré en Argentine ?

Pour vérifier si un CUIT/CUIL est officiellement enregistré et actif, vous devez utiliser le site Web ou les services de l'AFIP (Administración Federal de Ingresos Públicos). Notre outil ne vérifie que la validité mathématique du numéro, pas son statut d'enregistrement officiel.

Puis-je utiliser cet outil dans mon application commerciale ?

Oui, vous pouvez intégrer l'algorithme et la logique démontrés dans cet outil dans vos applications commerciales. L'algorithme de validation CUIT/CUIL est une norme publique. Cependant, pour les environnements de production, nous recommandons de mettre en œuvre un traitement d'erreur approprié et de considérer une validation supplémentaire contre des sources officielles lorsque cela est nécessaire.

L'outil stocke-t-il des numéros CUIT/CUIL générés ou validés ?

Non, cet outil ne stocke aucune des informations saisies ou générées. Tous les traitements sont effectués côté client dans votre navigateur, et aucune donnée n'est envoyée ou stockée sur nos serveurs. Cela garantit la confidentialité et la sécurité de toute information que vous saisissez.

Références

AFIP (Administración Federal de Ingresos Públicos). "CUIT/CUIL/CDI." Site officiel. https://www.afip.gob.ar/
Ministerio de Trabajo, Empleo y Seguridad Social. "CUIL - Clave Única de Identificación Laboral." https://www.argentina.gob.ar/trabajo
ANSES (Administración Nacional de la Seguridad Social). "Obtenir mon CUIL." https://www.anses.gob.ar/
Boletín Oficial de la República Argentina. "Résolution Générale AFIP 2854/2010 : Procédure. Clave Única de Identificación Tributaria (C.U.I.T.)."
Código Fiscal de la République Argentina. "Identification et Enregistrement des Contribuables."

Prêt à générer ou valider des numéros CUIT/CUIL argentins ? Essayez notre outil maintenant et simplifiez votre processus de test !

Outil de génération et de validation de CUIT/CUIL argentin

Générateur de CUIT/CUIL

CUIT/CUIL généré

Documentation