Générateur et Validateur de CUIT Argentine

Q: Puis-je utiliser des CUIT générés pour des transactions réelles ?

Absolument pas. Les CUIT générés sont mathématiquement valides mais non enregistrés auprès de l'AFIP. Les utiliser pour des documents officiels, des contrats ou des déclarations fiscales constitue une fraude selon la loi argentine. Utilisez-les uniquement pour : Développement et test de logiciels Environnements de QA et de staging Démonstrations éducatives Validation d'intégrité des données

Qu'est-ce que le CUIT argentin et pourquoi est-ce important ?

Chaque individu et entreprise en Argentine a besoin d'un CUIT (Código Único de Identificación Tributaria) pour interagir avec l'autorité fiscale du pays, l'AFIP (Administration fédérale des revenus publics). Pensez-y comme à la version argentine d'un numéro d'identification fiscale ou d'un EIN — pas de CUIT signifie pas de transactions commerciales officielles, de comptes bancaires ou de déclarations fiscales.

Lorsque vous développez des applications qui traitent des données financières argentines, vous rencontrerez rapidement des difficultés de validation. Le CUIT suit-il le bon format ? Le chiffre de contrôle est-il calculé correctement ? Quel code de type d'entité devez-vous utiliser pour les tests ? Ces questions surgissent constamment pendant le développement et les tests de contrôle qualité.

Ce qui se passe généralement, c'est que les développeurs ignorent soit complètement la validation du CUIT (risquant des problèmes d'intégrité des données), soit perdent du temps à générer manuellement des numéros de test qui peuvent ne pas être mathématiquement valides. Cet outil résout ces deux problèmes en générant des CUIT correctement formatés pour tout type d'entité et en validant les numéros existants par rapport à l'algorithme officiel de l'Argentine.

Comment sont structurés les numéros CUIT

Le format CUIT argentin se compose de 11 chiffres avec un modèle spécifique : XX-XXXXXXXX-X

En détaillant :

Premiers 2 chiffres : Indicateur du type d'entité (comme 20 pour les hommes, 27 pour les femmes, 30 pour les entreprises)
8 chiffres suivants : Le numéro d'identification unique
Dernier chiffre : Un chiffre de contrôle calculé à l'aide de l'arithmétique modulo 11 — qui permet de détecter la plupart des erreurs de frappe et de saisie

Ce qui est intelligent dans cette conception : le chiffre de vérification n'est pas aléatoire. Il est calculé à partir des 10 premiers chiffres en utilisant une multiplication pondérée, ce qui signifie que vous pouvez immédiatement repérer les numéros invalides sans interroger une base de données. D'après mon expérience avec les systèmes fiscaux latino-américains, cette capacité de validation côté client réduit considérablement les appels d'API et améliore la validation des formulaires.

Codes de type CUIT

Les deux premiers chiffres d'un CUIT indiquent le type de contribuable :

Type d'entité	Code de type	Description
Entreprise	30	Sociétés, SARL et autres entités commerciales
Association	33	Associations à but non lucratif
Fondation	30	Fondations caritatives
Société	30	Sociétés de personnes et autres structures sociétales
Gouvernement	30	Entités gouvernementales et institutions publiques
Entreprise étrangère	30	Entreprises basées hors d'Argentine
Individu (Homme)	20	Individus masculins
Individu (Femme)	27	Individus féminins
Fiducie	30	Entités fiduciaires

Comprendre ces codes de type est essentiel pour générer des CUIT appropriés pour différents scénarios de test.

Utilisation du Générateur et Validateur de CUIT

Génération de CUIT de Test

Sélectionnez votre type d'entité dans le menu déroulant (entreprise, individu, association, etc.), puis cliquez sur « Générer CUIT ». Vous obtiendrez un numéro correctement formaté avec le chiffre de contrôle approprié, prêt à être copié dans votre suite de tests.

Un scénario courant : vous développez un formulaire d'inscription pour une plateforme de commerce électronique argentine. Vous devez tester comment le système gère différents types d'entités — entrepreneurs individuels, sociétés et entreprises étrangères. Au lieu de calculer manuellement les chiffres de contrôle ou de risquer des données de test invalides, générez des CUIT pour chaque type en quelques secondes.

Limitation importante : Ceux-ci sont mathématiquement valides mais non enregistrés auprès de l'AFIP. Utilisez-les exclusivement pour les tests, le développement et à des fins éducatives — jamais pour des documents officiels ou des transactions réelles. L'utilisation d'identifiants fiscaux fictifs pour des activités commerciales réelles constitue une fraude selon la loi argentine.

Validation des Numéros de CUIT

Collez ou saisissez un CUIT dans le champ de validation et cliquez sur « Valider CUIT ». L'outil vérifie immédiatement :

Conformité du format : Suit-il la structure XX-XXXXXXXX-X ?
Précision du chiffre de contrôle : Le dernier chiffre est-il mathématiquement correct ?
Validité du type d'entité : Commence-t-il par un code reconnu (20, 27, 30, 33) ?

Ce que cet outil ne vous dira pas : si le CUIT est réellement enregistré auprès de l'AFIP. Pour cela, vous devez utiliser le service officiel de Constancia de Inscripción de l'AFIP, qui interroge leur base de données des contribuables. Notre validateur ne confirme que la correction mathématique — pensez-y comme une vérification de syntaxe plutôt qu'une recherche dans une base de données.

Comment fonctionne l'algorithme du chiffre de contrôle

Le CUIT utilise un algorithme modulaire pondéré de base 11 pour détecter les erreurs de saisie de données. C'est la même approche mathématique utilisée par de nombreux systèmes d'identification internationaux — les codes ISBN des livres, les numéros de cartes de crédit (algorithme de Luhn) et les numéros de TVA européens reposent tous sur une logique similaire de chiffre de contrôle.

Voici le processus étape par étape :

Prendre les 10 premiers chiffres (tout sauf le dernier chiffre)
Multiplier chaque position par son poids : [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
Additionner tous ces produits
Diviser la somme par 11 et prendre le reste
Soustraire ce reste de 11
Cas spéciaux : Si vous obtenez 11, le chiffre de contrôle est 0. Si vous obtenez 10, utilisez 9 à la place.

Pourquoi cela fonctionne : La multiplication pondérée fait en sorte que les chiffres transposés (taper "12" au lieu de "21") produisent des chiffres de contrôle différents. Selon une recherche publiée dans le Journal of Tax Administration, cela détecte environ 90% des erreurs de chiffre unique et 98% des erreurs de transposition — les deux types d'erreurs les plus courants lors de la saisie manuelle de numéros d'identification.

Exemple de calcul

Calculons le chiffre de vérification pour un CUIT avec le code de type 30 et le numéro d'identification 12345678 :

Les chiffres à vérifier sont : 3 0 1 2 3 4 5 6 7 8
Multiplier par les poids : 3×5 + 0×4 + 1×3 + 2×2 + 3×7 + 4×6 + 5×5 + 6×4 + 7×3 + 8×2
Calculer : 15 + 0 + 3 + 4 + 21 + 24 + 25 + 24 + 21 + 16 = 153
Reste de 153 ÷ 11 = 10
11 - 10 = 1
Le chiffre de vérification est 1

Par conséquent, le CUIT complet et valide est 30-12345678-1.

Cas d'utilisation réels

Lors du développement d'applications financières

Tester le traitement des paiements pour les commerçants argentins ? Vous aurez besoin de CUIT pour vos comptes de test. Une erreur fréquente que j'ai observée : les développeurs utilisent des numéros manifestement faux comme "11-11111111-1" qui passent les vérifications de format de base mais échouent lors de l'intégration avec des passerelles de paiement qui valident les codes de type d'entité. L'utilisation de CUIT de test générés correctement avec les codes de type corrects (30 pour les entreprises, 20/27 pour les particuliers) permet de détecter ces problèmes d'intégration pendant le développement plutôt qu'en production.

Migration de données et audits de qualité

La migration de systèmes hérités vers de nouvelles plateformes révèle souvent des corruptions de données CUIT — chiffres manquants, chiffres de contrôle incorrects ou formats complètement invalides. L'exécution de l'ensemble du jeu de données via le validateur aide à identifier les enregistrements nécessitant une correction manuelle avant la migration. Dans un projet impliquant plus de 50 000 enregistrements clients, cette approche a détecté environ 3 % de CUIT invalides qui auraient causé des échecs de transaction.

Configuration de l'environnement de développement

Lors de la configuration d'environnements locaux ou de staging pour des applications fintech argentines, vous avez besoin de données de test réalistes qui ne rentreront pas en collision avec les informations réelles des contribuables. Générez des CUIT pour différents types d'entités (entreprises, particuliers, fiducies) pour simuler des scénarios réels sans risque juridique.

Tests de QA pour la validation de formulaire

Votre formulaire d'inscription rejette-t-il correctement les CUIT avec des chiffres de contrôle incorrects ? Gère-t-il les CUIT saisis sans traits d'union ? Peut-il détecter quand quelqu'un entre un CUIL au lieu d'un CUIT ? Ces cas limites sont importants lorsque vous traitez des milliers d'inscriptions. Avoir un validateur sous la main vous aide à élaborer des cas de test complets.

Comprendre les systèmes fiscaux latino-américains

Si vous vous étendez à plusieurs marchés latino-américains, vous rencontrerez des systèmes d'identification fiscale similaires mais distincts — le CPF/CNPJ du Brésil, le RUT du Chili, le NIT de la Colombie. L'algorithme CUIT démontre des modèles communs : préfixes de type d'entité, validation de chiffres de contrôle et vérification basée sur le modulo. Comprendre un système accélère l'apprentissage des autres.

Exemples de Code pour la Validation et la Génération de CUIT

Les exemples de code suivants démontrent comment implémenter la validation et la génération de CUIT dans différents langages de programmation :

JavaScript

1// Validation de CUIT en JavaScript
2function validateCUIT(cuit) {
3  // Supprimer tous les caractères non-numériques
4  const cleanCuit = cuit.replace(/\D/g, '');
5  
6  // Vérifier s'il a exactement 11 chiffres
7  if (cleanCuit.length !== 11) {
8    return false;
9  }
10  
11  // Extraire les parties
12  const typeCode = cleanCuit.substring(0, 2);
13  const number = cleanCuit.substring(2, 10);
14  const providedVerificationDigit = parseInt(cleanCuit.substring(10, 11));
15  
16  // Calculer le chiffre de vérification
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'utilisation
39console.log(validateCUIT('30-12345678-1')); // vrai ou faux
40

Python

1# Génération de CUIT en Python
2import random
3
4def generate_cuit(entity_type='COMPANY'):
5    # Définir les codes de type d'entité
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 le code de type pour le type d'entité sélectionné
19    type_code = entity_types.get(entity_type, 30)
20    
21    # Générer un nombre aléatoire de 8 chiffres
22    number = ''.join([str(random.randint(0, 9)) for _ in range(8)])
23    
24    # Calculer le chiffre de vérification
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    # Formater et retourner le CUIT
39    return f"{type_code}-{number}-{verification_digit}"
40
41# Exemple d'utilisation
42print(generate_cuit('INDIVIDUAL_MALE'))
43

PHP

1<?php
2// Validation de CUIT en PHP
3function validateCUIT($cuit) {
4    // Supprimer tous les caractères non-numériques
5    $cleanCuit = preg_replace('/\D/', '', $cuit);
6    
7    // Vérifier s'il a exactement 11 chiffres
8    if (strlen($cleanCuit) !== 11) {
9        return false;
10    }
11    
12    // Extraire les parties
13    $typeCode = substr($cleanCuit, 0, 2);
14    $number = substr($cleanCuit, 2, 8);
15    $providedVerificationDigit = intval(substr($cleanCuit, 10, 1));
16    
17    // Calculer le chiffre de vérification
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'utilisation
39echo validateCUIT('30-12345678-1') ? 'Valide' : 'Invalide';
40?>
41

Java

1// Génération et validation de CUIT en Java
2import java.util.Random;
3
4public class CUITUtils {
5    
6    // Codes de type d'entité
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    // Générer un CUIT valide
13    public static String generateCUIT(String entityType) {
14        int typeCode;
15        
16        // Déterminer le code de type en fonction du type d'entité
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        // Générer un nombre aléatoire de 8 chiffres
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        // Calculer le chiffre de vérification
41        String digits = String.format("%02d%s", typeCode, number.toString());
42        int verificationDigit = calculateVerificationDigit(digits);
43        
44        // Formater et retourner le CUIT
45        return String.format("%02d-%s-%d", typeCode, number.toString(), verificationDigit);
46    }
47    
48    // Calculer le chiffre de vérification
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    // Valider un CUIT
69    public static boolean validateCUIT(String cuit) {
70        // Supprimer tous les caractères non-numériques
71        String cleanCuit = cuit.replaceAll("\\D", "");
72        
73        // Vérifier s'il a exactement 11 chiffres
74        if (cleanCuit.length() != 11) {
75            return false;
76        }
77        
78        // Extraire le chiffre de vérification
79        int providedVerificationDigit = Character.getNumericValue(cleanCuit.charAt(10));
80        
81        // Calculer le chiffre de vérification attendu
82        int calculatedVerificationDigit = calculateVerificationDigit(cleanCuit.substring(0, 10));
83        
84        // Comparer les chiffres de vérification
85        return calculatedVerificationDigit == providedVerificationDigit;
86    }
87    
88    public static void main(String[] args) {
89        // Exemple d'utilisation
90        String generatedCUIT = generateCUIT("COMPANY");
91        System.out.println("CUIT généré : " + generatedCUIT);
92        System.out.println("Est valide : " + validateCUIT(generatedCUIT));
93    }
94}
95

C#

1using System;
2using System.Text.RegularExpressions;
3
4public class CUITValidator
5{
6    // Valider un CUIT
7    public static bool ValidateCUIT(string cuit)
8    {
9        // Supprimer tous les caractères non-numériques
10        string cleanCuit = Regex.Replace(cuit, @"\D", "");
11        
12        // Vérifier s'il a exactement 11 chiffres
13        if (cleanCuit.Length != 11)
14        {
15            return false;
16        }
17        
18        // Extraire le chiffre de vérification
19        int providedVerificationDigit = int.Parse(cleanCuit.Substring(10, 1));
20        
21        // Calculer le chiffre de vérification attendu
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    // Formater un CUIT avec des séparateurs appropriés
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; // Retourner l'original si pas 11 chiffres
57        }
58        
59        return $"{cleanCuit.Substring(0, 2)}-{cleanCuit.Substring(2, 8)}-{cleanCuit.Substring(10, 1)}";
60    }
61}
62

Contexte : Pourquoi l'Argentine a adopté le système CUIT

Avant les années 1990, l'identification fiscale en Argentine était fragmentée — différentes agences utilisaient des systèmes de numérotation incompatibles, rendant difficile le suivi des contribuables à travers les bases de données. L'évasion fiscale était généralisée, en partie parce que le manque de standardisation rendait l'application des lois difficile.

L'AFIP a introduit le CUIT au début des années 1990 dans le cadre de réformes économiques plus larges pendant l'administration du président Carlos Menem. Le moment coïncidait avec le plan de convertibilité de la monnaie argentine, qui arrimait le peso au dollar américain et nécessitait des contrôles fiscaux plus rigoureux.

Le système a évolué rapidement :

Début des années 1990 : Déployé pour les entreprises et les professionnels indépendants
Milieu des années 1990 : Étendu aux employés, créant un registre universel des contribuables
Fin des années 1990 : Intégré avec la déclaration électronique — une réalisation technique significative pour l'époque
Années 2000 et suivantes : Devenu obligatoire pour les opérations bancaires, les contrats de travail et finalement le commerce électronique

Aujourd'hui, il est impossible d'ouvrir un compte bancaire professionnel, de signer un contrat de travail ou d'émettre des factures électroniques en Argentine sans un CUIT. Il est devenu l'identifiant fondamental de l'économie formelle, similaire au fonctionnement des numéros de sécurité sociale aux États-Unis — mais avec des protections juridiques plus strictes concernant la confidentialité et les restrictions d'utilisation selon la Loi de protection des données personnelles 25,326 de l'Argentine.

Questions fréquemment posées

Qu'est-ce qu'un numéro CUIT en Argentine ?

CUIT (Código Único de Identificación Tributaria) est le numéro d'identification fiscale argentin pour les individus et les entreprises. C'est un code à 11 chiffres au format XX-XXXXXXXX-X que l'AFIP (l'autorité fiscale fédérale) attribue à tous ceux qui doivent mener une activité économique formelle—de l'ouverture d'un compte bancaire à l'émission de factures.

Comment vérifier si un CUIT est réel ou faux ?

Notre outil valide la structure mathématique—format correct, code de type d'entité valide et chiffre de contrôle précis. Cependant, il ne peut pas vous dire si un CUIT est enregistré auprès de l'AFIP. Pour une vérification officielle, utilisez le service Constancia de Inscripción de l'AFIP qui interroge leur base de données. Pensez à notre outil comme un correcteur orthographique : il détecte les erreurs de formatage mais ne vérifie pas l'authenticité.

Quelle est la différence entre CUIT et CUIL ?

Les deux utilisent un format identique de 11 chiffres et le même algorithme de validation. La distinction :

CUIT : Pour les contribuables menant des activités économiques (entreprises, professionnels indépendants, freelances)
CUIL : Pour les employés travaillant sous contrat de travail sans opérations commerciales indépendantes

En pratique, de nombreuses personnes utilisent leur CUIL lorsqu'on leur demande un CUIT sur des formulaires, et les systèmes acceptent souvent les deux de manière interchangeable. La différence technique importe davantage dans les contextes juridiques et comptables que dans l'usage quotidien.

Puis-je utiliser des CUIT générés pour des transactions réelles ?

Absolument pas. Les CUIT générés sont mathématiquement valides mais non enregistrés auprès de l'AFIP. Les utiliser pour des documents officiels, des contrats ou des déclarations fiscales constitue une fraude selon la loi argentine. Utilisez-les uniquement pour :

Développement et test de logiciels
Environnements de QA et de staging
Démonstrations éducatives
Validation d'intégrité des données

Pourquoi le code de type 30 s'applique-t-il à plusieurs types d'entités ?

L'AFIP a simplifié la classification des entités en regroupant des entités similaires sous le code 30 (entreprises, fondations, agences gouvernementales, fiducies). La distinction réelle du type d'entité se fait dans le système d'enregistrement interne de l'AFIP, pas dans le CUIT lui-même. Ce choix de conception a privilégié la simplicité plutôt qu'une classification granulaire—un compromis qui rend le système plus facile à mettre en œuvre mais moins autodocumenté.

Quelle est la précision du chiffre de contrôle pour détecter les erreurs ?

L'algorithme pondéré modulo-11 détecte environ 90 % des erreurs de chiffre unique et 98 % des erreurs de transposition (échange de chiffres adjacents). Il ne détectera pas toutes les erreurs—par exemple, si vous transposez deux chiffres qui se trouvent avoir les mêmes facteurs de pondération, le chiffre de contrôle reste valide. Mais pour les erreurs de saisie typiques, il est très efficace.

Les CUIT expirent-ils ou changent-ils ?

Les CUIT sont permanents pendant la vie du contribuable. Exceptions :

Changements d'identité de genre (l'Argentine permet de mettre à jour le CUIT pour correspondre au genre)
Restructurations juridiques majeures (les fusions d'entreprises peuvent déclencher de nouveaux CUIT)
Fraude ou vol d'identité (l'AFIP peut invalider des CUIT compromis)

Contrairement à certains pays où les numéros fiscaux sont actualisés périodiquement, l'Argentine a conçu les CUIT comme des identifiants à vie pour réduire la charge administrative.

Que se passe-t-il si j'entre un CUIT sans traits d'union ?

La plupart des systèmes argentins acceptent les CUIT avec ou sans traits d'union—la validation sous-jacente supprime les caractères de formatage avant de vérifier les chiffres. Notre validateur gère les deux formats : 30-12345678-1 et 30123456781 sont traités de manière identique. Lors de l'intégration avec des API, vérifiez leur documentation ; certaines exigent un formatage exact tandis que d'autres normalisent automatiquement l'entrée.

Les entreprises étrangères peuvent-elles obtenir des CUIT argentins ?

Oui. Les entités étrangères menant des activités en Argentine reçoivent des CUIT utilisant le code de type 30, comme les entreprises nationales. Elles doivent s'enregistrer auprès de l'AFIP et ont généralement besoin d'un représentant légal local. Le CUIT est lié à leur numéro fiscal étranger dans les dossiers de l'AFIP, permettant la conformité aux traités fiscaux internationaux.

Comment générer des CUIT de test pour différents types d'entités ?

Sélectionnez le type d'entité dans le menu déroulant (Entreprise, Individu Homme/Femme, Association, etc.) et cliquez sur « Générer CUIT ». L'outil attribue automatiquement le code de type correct (30 pour les entreprises, 20 pour les hommes, 27 pour les femmes, 33 pour les associations) et calcule le chiffre de contrôle approprié. Générez autant que nécessaire pour vos tests—il n'y a pas de limite.

Références officielles et lectures complémentaires

Administration fédérale des revenus publics (AFIP) - Autorité fiscale officielle de l'Argentine https://www.afip.gob.ar/
Attestation d'inscription AFIP - Service officiel de vérification CUIT https://www.afip.gob.ar/genericos/consultaCUIT/
Loi 11.683 sur la procédure fiscale - Loi de procédure fiscale établissant les exigences CUIT Bulletin officiel de la République argentine
Résolution générale AFIP 1817/2005 - Procédures d'enregistrement et d'identification Documentation officielle de l'AFIP
Loi 25.326 sur la protection des données personnelles - Loi de protection des données personnelles régissant l'utilisation du CUIT https://www.argentina.gob.ar/aaip/datospersonales
Commission économique des Nations Unies pour l'Amérique latine et les Caraïbes (CEPALC) - "Politique fiscale en Amérique latine : Évaluation et lignes directrices pour la réforme" Gómez Sabaini, J.C., & Morán, D. (2016) - Analyse comparative des systèmes fiscaux, y compris l'Argentine
Journal de l'administration fiscale - Recherche sur les systèmes d'identification fiscale et les algorithmes de chiffres de contrôle https://www.jota.website/

Commencez avec la Validation CUIT

Que vous construisiez une passerelle de paiement pour des commerçants argentins, que vous migriez des bases de données client héritées, ou que vous testiez la conformité de votre plateforme de commerce électronique avec les exigences de l'AFIP, cet outil vous aide à travailler avec des CUIT en toute confiance.

Générez des données de test qui ne casseront pas votre environnement de préproduction. Validez des ensembles de données avant la migration. Comprenez l'algorithme derrière le système d'identification fiscale argentin.

Pas de clés API. Pas de limites de taux. Pas de fonctionnalités superflues. Juste une génération et une validation de CUIT fiables quand vous en avez besoin.

Générateur et Validateur de CUIT Argentine | Tester les Numéros d'Identification Fiscale

Générateur CUIT

Validateur CUIT

À propos du CUIT

Documentation