Gere números de CUIT válidos da Argentina (códigos de identificação fiscal) e valide os existentes com esta ferramenta simples projetada para cenários de teste. Sem recursos complexos, apenas geração e validação de CUIT de forma direta.
Uma ferramenta simples para gerar e validar códigos de identificação fiscal argentinos (CUIT) para fins de teste.
Formato: XX-XXXXXXXX-X
CUIT (Código Único de Identificação Tributária) é o código de identificação fiscal utilizado na Argentina para indivíduos e entidades legais.
O CUIT (Código Único de Identificação Tributária) é o Código de Identificação Tributária Único da Argentina, um identificador crítico para todos os contribuintes no sistema tributário argentino. Este código numérico essencial serve como o principal identificador para indivíduos e entidades legais ao interagir com a AFIP (Administração Federal de Receitas Públicas) e realizar operações comerciais em toda a Argentina. Nossa ferramenta Gerador e Validador de CUIT da Argentina fornece uma solução simples e eficiente para gerar CUITs matematicamente válidos para fins de teste e validar números de CUIT existentes.
Se você é um desenvolvedor testando aplicativos que processam informações fiscais argentinas, um especialista em QA verificando a integridade dos dados ou um analista de negócios preparando conjuntos de dados de teste, esta ferramenta simplifica o processo de trabalho com números de CUIT sem a complexidade de integrações de API ou recursos desnecessários.
O CUIT argentino segue um formato específico que consiste em 11 dígitos dispostos da seguinte forma:
1XX-XXXXXXXX-X
2Esse formato padronizado pode ser dividido em três componentes distintos:
Os dois primeiros dígitos de um CUIT indicam o tipo de contribuinte:
| Tipo de Entidade | Código do Tipo | Descrição |
|---|---|---|
| Empresa | 30 | Corporações, LLCs e outras entidades comerciais |
| Associação | 33 | Associações sem fins lucrativos |
| Fundação | 30 | Fundações de caridade |
| Sociedade | 30 | Parcerias e outras estruturas de sociedade |
| Governo | 30 | Entidades governamentais e instituições públicas |
| Empresa Estrangeira | 30 | Empresas com sede fora da Argentina |
| Indivíduo (Masculino) | 20 | Indivíduos do sexo masculino |
| Indivíduo (Feminino) | 27 | Indivíduos do sexo feminino |
| Trust | 30 | Entidades de trust |
Entender esses códigos de tipo é essencial para gerar CUITs apropriados para diferentes cenários de teste.
Nossa ferramenta oferece duas funções principais: gerar CUITs válidos e validar os existentes. Veja como usar cada recurso de forma eficaz:
O gerador cria CUITs aleatórios, mas matematicamente válidos, que seguem o algoritmo oficial usado pela AFIP. Esses CUITs são perfeitos para testar sistemas que exigem formatos de CUIT válidos, embora não estejam registrados em bancos de dados oficiais.
O validador verifica tanto o formato quanto a validade matemática do CUIT, verificando se o dígito de verificação corresponde ao valor calculado com base nos dígitos anteriores.
O dígito de verificação (o último dígito) de um CUIT é calculado usando um algoritmo específico projetado para detectar erros comuns na entrada de dados. Entender esse algoritmo ajuda a explicar como nossa ferramenta valida os CUITs:
Vamos calcular o dígito de verificação para um CUIT com código de tipo 30 e número de identificação 12345678:
Portanto, o CUIT completo e válido é 30-12345678-1.
A ferramenta Gerador e Validador de CUIT da Argentina serve a múltiplos propósitos práticos em diferentes contextos profissionais:
Os seguintes exemplos de código demonstram como implementar a validação e geração de CUIT em várias linguagens de programação:
1// Validação de CUIT em JavaScript
2function validateCUIT(cuit) {
3 // Remove quaisquer caracteres não numéricos
4 const cleanCuit = cuit.replace(/\D/g, '');
5
6 // Verifica se tem exatamente 11 dígitos
7 if (cleanCuit.length !== 11) {
8 return false;
9 }
10
11 // Extrai partes
12 const typeCode = cleanCuit.substring(0, 2);
13 const number = cleanCuit.substring(2, 10);
14 const providedVerificationDigit = parseInt(cleanCuit.substring(10, 11));
15
16 // Calcula dígito de verificação
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// Exemplo de uso
39console.log(validateCUIT('30-12345678-1')); // true ou false
401# Geração de CUIT em Python
2import random
3
4def generate_cuit(entity_type='COMPANY'):
5 # Definir códigos de tipo de entidade
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 # Obter código do tipo para o tipo de entidade selecionado
19 type_code = entity_types.get(entity_type, 30)
20
21 # Gerar número aleatório de 8 dígitos
22 number = ''.join([str(random.randint(0, 9)) for _ in range(8)])
23
24 # Calcular dígito de verificação
25 multipliers = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
26 digits = f"{type_code}{number}"
27
28 sum_products = sum(int(digits[i]) * multipliers[i] for i in range(10))
29 remainder = sum_products % 11
30
31 if remainder == 0:
32 verification_digit = 0
33 elif remainder == 1:
34 verification_digit = 9
35 else:
36 verification_digit = 11 - remainder
37
38 # Formatar e retornar o CUIT
39 return f"{type_code}-{number}-{verification_digit}"
40
41# Exemplo de uso
42print(generate_cuit('INDIVIDUAL_MALE'))
431<?php
2// Validação de CUIT em PHP
3function validateCUIT($cuit) {
4 // Remove quaisquer caracteres não numéricos
5 $cleanCuit = preg_replace('/\D/', '', $cuit);
6
7 // Verifica se tem exatamente 11 dígitos
8 if (strlen($cleanCuit) !== 11) {
9 return false;
10 }
11
12 // Extrai partes
13 $typeCode = substr($cleanCuit, 0, 2);
14 $number = substr($cleanCuit, 2, 8);
15 $providedVerificationDigit = intval(substr($cleanCuit, 10, 1));
16
17 // Calcula dígito de verificação
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// Exemplo de uso
39echo validateCUIT('30-12345678-1') ? 'Válido' : 'Inválido';
40?>
411// Geração e Validação de CUIT em Java
2import java.util.Random;
3
4public class CUITUtils {
5
6 // Códigos de tipo de entidade
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 // Gera um CUIT válido
13 public static String generateCUIT(String entityType) {
14 int typeCode;
15
16 // Determina o código do tipo com base no tipo de entidade
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 // Gera número aleatório de 8 dígitos
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 // Calcula dígito de verificação
41 String digits = String.format("%02d%s", typeCode, number.toString());
42 int verificationDigit = calculateVerificationDigit(digits);
43
44 // Formatar e retornar o CUIT
45 return String.format("%02d-%s-%d", typeCode, number.toString(), verificationDigit);
46 }
47
48 // Calcula dígito de verificação
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 // Valida um CUIT
69 public static boolean validateCUIT(String cuit) {
70 // Remove quaisquer caracteres não numéricos
71 String cleanCuit = cuit.replaceAll("\\D", "");
72
73 // Verifica se tem exatamente 11 dígitos
74 if (cleanCuit.length() != 11) {
75 return false;
76 }
77
78 // Extrai dígito de verificação
79 int providedVerificationDigit = Character.getNumericValue(cleanCuit.charAt(10));
80
81 // Calcula dígito de verificação esperado
82 int calculatedVerificationDigit = calculateVerificationDigit(cleanCuit.substring(0, 10));
83
84 // Compara dígitos de verificação
85 return calculatedVerificationDigit == providedVerificationDigit;
86 }
87
88 public static void main(String[] args) {
89 // Exemplo de uso
90 String generatedCUIT = generateCUIT("COMPANY");
91 System.out.println("CUIT Gerado: " + generatedCUIT);
92 System.out.println("É válido: " + validateCUIT(generatedCUIT));
93 }
94}
951using System;
2using System.Text.RegularExpressions;
3
4public class CUITValidator
5{
6 // Valida um CUIT
7 public static bool ValidateCUIT(string cuit)
8 {
9 // Remove quaisquer caracteres não numéricos
10 string cleanCuit = Regex.Replace(cuit, @"\D", "");
11
12 // Verifica se tem exatamente 11 dígitos
13 if (cleanCuit.Length != 11)
14 {
15 return false;
16 }
17
18 // Extrai dígito de verificação
19 int providedVerificationDigit = int.Parse(cleanCuit.Substring(10, 1));
20
21 // Calcula dígito de verificação esperado
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 // Formata um CUIT com separadores adequados
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; // Retorna original se não tiver 11 dígitos
57 }
58
59 return $"{cleanCuit.Substring(0, 2)}-{cleanCuit.Substring(2, 8)}-{cleanCuit.Substring(10, 1)}";
60 }
61}
62O sistema de CUIT foi estabelecido na Argentina no início dos anos 1990 como parte de uma iniciativa mais ampla de reforma tributária destinada a modernizar a infraestrutura fiscal do país e reduzir a evasão fiscal. A Administração Federal de Receitas Públicas (AFIP), a autoridade fiscal da Argentina, implementou o CUIT como um sistema de identificação padronizado para todos os contribuintes.
Antes da introdução do CUIT, a Argentina usava vários sistemas de identificação inconsistentes para diferentes tipos de contribuintes, tornando a administração tributária ineficiente e criando oportunidades para a não conformidade. O CUIT unificou esses sistemas em um único identificador verificável que poderia ser usado em todas as atividades relacionadas a impostos.
Marcos importantes na evolução do sistema de CUIT incluem:
O CUIT se tornou um elemento essencial dos sistemas econômicos e financeiros da Argentina, servindo não apenas para fins fiscais, mas também para bancário, emprego, segurança social e transações comerciais.
Um CUIT (Código Único de Identificação Tributária) é o Código de Identificação Tributária Único da Argentina atribuído a indivíduos e entidades legais para fins fiscais. Consiste em 11 dígitos no formato XX-XXXXXXXX-X, onde os dois primeiros dígitos indicam o tipo de entidade, os oito dígitos do meio são um número de identificação e o último dígito é um dígito de verificação.
Um CUIT válido deve:
Nossa ferramenta validadora de CUIT pode verificar instantaneamente se um CUIT atende a esses critérios.
Embora semelhantes em formato, CUIT e CUIL servem a propósitos diferentes:
Ambos seguem o mesmo formato e algoritmo de verificação, mas são usados em contextos diferentes.
Não. Os CUITs gerados por esta ferramenta são matematicamente válidos, mas não estão registrados no banco de dados oficial da AFIP. Eles devem ser usados apenas para fins de teste, desenvolvimento ou educacionais. Usar CUITs fictícios em documentos ou transações oficiais pode constituir fraude.
A AFIP atribuiu o mesmo código de tipo (30) a vários tipos de entidades, incluindo empresas, fundações e entidades governamentais. Isso faz parte do sistema de classificação oficial e não afeta a validade do CUIT. O tipo específico de entidade é determinado por informações adicionais de registro nos sistemas da AFIP.
Os CUITs são identificadores permanentes que geralmente não mudam ao longo da vida de um indivíduo ou entidade. No entanto, em alguns casos específicos, como mudanças de status legal ou reassignment de gênero, um novo CUIT pode ser atribuído.
Sim, mas não através da nossa ferramenta. A AFIP fornece um serviço oficial chamado "Constância de Inscrição" em seu site, onde você pode verificar se um CUIT está oficialmente registrado e ativo. Nossa ferramenta apenas valida a correção matemática de um CUIT.
Erros comuns incluem:
Nosso validador ajuda a identificar esses problemas verificando tanto a validade do formato quanto a matemática.
Nossa ferramenta permite que você selecione entre vários tipos de entidades antes de gerar um CUIT. Basta escolher o tipo de entidade apropriado no menu suspenso e clicar em "Gerar CUIT". A ferramenta usará automaticamente o código de tipo correto para sua seleção.
Não, nossa ferramenta não impõe limites ao número de CUITs que você pode gerar ou validar. Ela foi projetada para conveniência em cenários de teste e educacionais onde você pode precisar de múltiplos CUITs válidos.
Administração Federal de Receitas Públicas (AFIP). "Identificação Tributária." https://www.afip.gob.ar/
Ministério da Economia da República Argentina. "Sistema Tributário Argentino." https://www.argentina.gob.ar/economia
Lei 11.683 de Procedimento Tributário. Boletim Oficial da República Argentina.
Resolução Geral AFIP 1817/2005. "Procedimentos de inscrição e registramento."
Chicote, J. (2018). "Sistemas de Identificação Tributária na América Latina: Uma Análise Comparativa." Journal of Tax Administration, 4(1), 88-106.
Gómez Sabaini, J.C., & Morán, D. (2016). "Política Fiscal na América Latina: Avaliação e Diretrizes para Reforma." Comissão Econômica para a América Latina e o Caribe (CEPAL).
A ferramenta Gerador e Validador de CUIT da Argentina fornece uma solução direta e eficiente para trabalhar com códigos de identificação tributária argentinos em ambientes de teste e desenvolvimento. Ao entender a estrutura, formato e algoritmo de verificação dos CUITs, os usuários podem garantir a integridade dos dados e a conformidade com os padrões de identificação tributária da Argentina.
Seja você um desenvolvedor de software que interage com sistemas financeiros argentinos, testando rotinas de validação de dados ou simplesmente aprendendo sobre sistemas de identificação tributária internacionais, nossa ferramenta oferece a funcionalidade necessária sem complexidade desnecessária.
Experimente gerar um CUIT agora ou valide um existente para vivenciar a simplicidade e eficácia de nossa ferramenta em primeira mão.
Descubra mais ferramentas que podem ser úteis para o seu fluxo de trabalho