Générez des numéros CUIT/CUIL argentins valides pour des tests ou validez ceux existants. Outil simple pour les développeurs travaillant avec les numéros d'identification fiscale et de travail argentins.
Entrez un numéro DNI à 8 chiffres ou utilisez le générateur aléatoire
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.
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é
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.
Le chiffre de vérification est calculé à l'aide de l'algorithme suivant :
Mathématiquement, cela peut être exprimé comme :
Où :
Sélectionnez l'onglet "Générateur" en haut de l'interface de l'outil.
Choisissez un Code Type dans le menu déroulant :
Entrez un Numéro DNI (facultatif) :
Générer un DNI Aléatoire (facultatif) :
Voir le CUIT/CUIL Généré :
Copier le Résultat :
Sélectionnez l'onglet "Validateur" en haut de l'interface de l'outil.
Entrez le CUIT/CUIL à Valider :
Cliquez sur le Bouton "Valider" :
Voir le Résultat de la Validation :
Informations Supplémentaires :
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 :
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.
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.
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 :
validar-cuitafip-phppy-cuitCalcul 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.
Le système d'identification CUIT/CUIL en Argentine a évolué de manière significative depuis sa création :
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.
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.
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.
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
741function 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
841import 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}
1071<?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?>
87Le 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.
Pour les individus :
Pour les entreprises et organisations :
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.
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.
La validation peut échouer pour plusieurs raisons :
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.
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.
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.
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.
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.
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 !
Découvrez plus d'outils qui pourraient être utiles pour votre flux de travail