🛠️

Whiz Tools

Build • Create • Innovate

Gerador e Validador de CUIT/CUIL Argentino

Gere números de CUIT/CUIL argentinos válidos para testes ou valide os existentes. Ferramenta simples para desenvolvedores que trabalham com números de identificação fiscal e trabalhista argentinos.

Gerador de CUIT/CUIL

Digite um número de DNI de 8 dígitos ou use o gerador aleatório

CUIT/CUIL Gerado

📚

Documentação

Gerador e Validador de CUIT/CUIL Argentino

Introdução

O CUIT (Clave Única de Identificação Tributária) e o CUIL (Clave Única de Identificação Laboral) argentinos são números de identificação únicos usados na Argentina para fins fiscais e de emprego, respectivamente. Esses códigos de 11 dígitos são essenciais para indivíduos e empresas operarem legalmente dentro do sistema econômico argentino. Nossa ferramenta de Gerador e Validador de CUIT/CUIL fornece uma maneira simples e eficiente de gerar números de CUIT/CUIL válidos para fins de teste e validar números existentes para garantir que estejam em conformidade com o formato oficial e o algoritmo de verificação.

Se você é um desenvolvedor testando aplicativos que manipulam IDs fiscais argentinos, um especialista em QA verificando a funcionalidade do sistema, ou simplesmente precisa entender como esses números de identificação funcionam, esta ferramenta oferece uma solução direta sem complexidades desnecessárias. A ferramenta possui duas funções principais: um gerador que cria números de CUIT/CUIL válidos aleatoriamente ou com base em parâmetros específicos, e um validador que verifica se um determinado número de CUIT/CUIL segue as regras de formato e cálculo corretas.

Estrutura e Cálculo do CUIT/CUIL

Entendendo o Formato

Um número de CUIT/CUIL válido consiste em 11 dígitos normalmente exibidos no formato XX-XXXXXXXX-X:

  1. Código do Tipo (primeiros 2 dígitos): Indica o tipo de entidade

    • 20, 23, 24: Indivíduos do sexo masculino (CUIL)
    • 27: Indivíduos do sexo feminino (CUIL)
    • 30, 33, 34: Empresas e organizações (CUIT)

  2. Número do DNI (8 dígitos do meio): Para indivíduos, este é o número do documento de identidade nacional (DNI), preenchido com zeros à esquerda, se necessário, para alcançar 8 dígitos. Para empresas, este é um número único atribuído.

  3. Dígito de Verificação (último dígito): Um dígito de verificação calculado usando um algoritmo específico para validar todo o número.

Cálculo do Dígito de Verificação

O dígito de verificação é calculado usando o seguinte algoritmo:

  1. Pegue os primeiros 10 dígitos do CUIT/CUIL (código do tipo + DNI)
  2. Multiplique cada dígito por um peso correspondente desta sequência: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
  3. Some todos os produtos resultantes
  4. Calcule 11 menos o resto da soma dividido por 11
  5. Se o resultado for 11, o dígito de verificação é 0
  6. Se o resultado for 10, o dígito de verificação é 9
  7. Caso contrário, o resultado é o dígito de verificação

Matematicamente, isso pode ser expresso como:

VD=11−((∑i=110di×wi) mod 11)VD = 11 - ((\sum_{i=1}^{10} d_i \times w_i) \bmod 11)

Onde:

  • VDVD é o dígito de verificação
  • did_i é o ii-ésimo dígito dos primeiros 10 dígitos
  • wiw_i é o peso correspondente da sequência [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
  • Casos especiais: se VD=11VD = 11 então VD=0VD = 0, se VD=10VD = 10 então VD=9VD = 9

Guia Passo a Passo

Usando o Gerador

  1. Selecione a aba "Gerador" na parte superior da interface da ferramenta.

  2. Escolha um Código do Tipo no menu suspenso:

    • 20: Masculino (CUIL)
    • 23: Empresa (CUIT)
    • 24: Empresa Temporária (CUIT)
    • 27: Feminino (CUIL)
    • 30: Corporação (CUIT)
    • 33: Associação Civil (CUIT)
    • 34: Fundação (CUIT)

  3. Insira um Número de DNI (opcional):

    • Digite um número de DNI de 8 dígitos no campo fornecido
    • Se deixado em branco, a ferramenta usará um DNI gerado aleatoriamente
    • Se você inserir menos de 8 dígitos, o sistema preencherá com zeros à esquerda

  4. Gerar DNI Aleatório (opcional):

    • Clique no botão "Aleatório" para gerar um número de DNI de 8 dígitos aleatório

  5. Visualize o CUIT/CUIL Gerado:

    • A ferramenta exibe automaticamente um CUIT/CUIL válido com base em suas entradas
    • O formato será XX-XXXXXXXX-X com o dígito de verificação correto

  6. Copie o Resultado:

    • Clique no ícone de copiar para copiar o CUIT/CUIL gerado para sua área de transferência
    • Uma mensagem de confirmação aparecerá quando copiado com sucesso

Usando o Validador

  1. Selecione a aba "Validador" na parte superior da interface da ferramenta.

  2. Insira o CUIT/CUIL para Validar:

    • Digite o CUIT/CUIL no formato XX-XXXXXXXX-X
    • A ferramenta formatará automaticamente sua entrada com hífens enquanto você digita
    • Você também pode inserir o número sem hífens (XXXXXXXXXXX)

  3. Clique no botão "Validar":

    • A ferramenta verificará o formato, o código do tipo e o dígito de verificação

  4. Visualize o Resultado da Validação:

    • Para números de CUIT/CUIL válidos, uma mensagem de sucesso em verde aparecerá
    • Para números inválidos, uma mensagem de erro em vermelho explicará o problema:
      • Formato inválido (deve ser XX-XXXXXXXX-X)
      • Código do tipo inválido (deve ser um dos: 20, 23, 24, 27, 30, 33, 34)
      • Dígito de verificação inválido

  5. Informações Adicionais:

    • Para números válidos, a ferramenta exibe uma análise dos componentes:
      • Código do tipo e seu significado
      • Número do DNI
      • Dígito de verificação

Casos de Uso

Desenvolvimento e Testes

  1. Desenvolvimento de Software: Gere números de CUIT/CUIL válidos para testar aplicativos que lidam com identificação fiscal argentina, como:

    • Plataformas de e-commerce
    • Software de contabilidade
    • Sistemas de gestão de RH
    • Portais de serviços governamentais
    • Aplicativos bancários

  2. População de Banco de Dados: Crie dados de teste realistas para sistemas que armazenam informações de usuários argentinos, garantindo que as restrições e regras de validação do banco de dados funcionem corretamente.

  3. Teste de Validação de Formulários: Teste a validação de entrada para formulários da web que coletam informações de CUIT/CUIL, verificando se mensagens de erro apropriadas aparecem para entradas inválidas.

  4. Teste de API: Gere cargas úteis válidas para endpoints de API que requerem números de CUIT/CUIL, garantindo que seus testes de integração usem dados válidos.

  5. Automação de QA: Incorpore a geração de CUIT/CUIL em scripts de teste automatizados para criar casos de teste dinâmicos em vez de usar dados de teste estáticos.

Fins Educacionais

  1. Aprendendo Algoritmos de Validação: Entenda como os algoritmos de dígitos de verificação funcionam na prática, vendo o processo de verificação do CUIT/CUIL em ação.

  2. Ensinando Validação de Dados: Use como um exemplo educacional ao ensinar técnicas de validação de formulários para novos desenvolvedores.

  3. Entendendo Requisitos Empresariais Argentinos: Aprenda sobre o sistema de identificação usado na Argentina para desenvolvimento de negócios internacionais.

Alternativas

Embora nossa ferramenta forneça uma maneira direta de gerar e validar números de CUIT/CUIL, existem abordagens alternativas que você pode considerar:

  1. Validação Oficial do Governo: Para ambientes de produção, sempre valide números de CUIT/CUIL contra o banco de dados oficial da AFIP (Administración Federal de Ingressos Públicos) quando possível.

  2. Bibliotecas e Pacotes: Várias linguagens de programação possuem bibliotecas especificamente projetadas para validação de ID fiscal argentino:

    • JavaScript: pacote npm validar-cuit
    • PHP: biblioteca afip-php
    • Python: pacote py-cuit

  3. Cálculo Manual: Para fins educacionais, você pode calcular o dígito de verificação manualmente usando o algoritmo descrito anteriormente.

  4. Serviços de Validação Empresarial Abrangentes: Para aplicativos empresariais, considere usar serviços de validação abrangentes que não apenas verifiquem o formato, mas também confirmem a existência e o status da entidade associada ao CUIT/CUIL.

História do Sistema CUIT/CUIL

O sistema de identificação CUIT/CUIL na Argentina evoluiu significativamente desde sua criação:

Origens e Implementação

O CUIT (Clave Única de Identificação Tributária) foi introduzido pela primeira vez na Argentina na década de 1970 como parte dos esforços para modernizar o sistema de arrecadação de impostos. A Administração Federal de Receita Pública (AFIP) implementou este identificador único para rastrear contribuintes de maneira mais eficiente e reduzir a evasão fiscal.

O CUIL (Clave Única de Identificação Laboral) foi introduzido posteriormente para identificar especificamente os trabalhadores no sistema de seguridade social, criando uma distinção entre identificação fiscal e identificação laboral, mantendo um formato consistente.

Evolução e Digitalização

Na década de 1990, à medida que a Argentina passava por reformas econômicas significativas, o sistema CUIT/CUIL tornou-se cada vez mais importante para rastrear a atividade econômica. O sistema foi ainda mais digitalizado, e sistemas de verificação online foram implementados.

O início dos anos 2000 viu a integração do sistema CUIT/CUIL com vários serviços digitais do governo, tornando-se um componente essencial das iniciativas de governo eletrônico da Argentina. Este período também viu a padronização do algoritmo de verificação e do formato que permanece em uso até hoje.

Desenvolvimentos Recentes

Nos últimos anos, a AFIP aprimorou os processos de segurança e verificação para números de CUIT/CUIL, implementando sistemas de validação mais sofisticados e integrando-os com outros bancos de dados governamentais. O sistema agora desempenha um papel crucial nos esforços da Argentina para combater a evasão fiscal e formalizar a economia.

Hoje, o CUIT/CUIL é usado não apenas para fins fiscais e de emprego, mas também para uma ampla gama de atividades, incluindo transações bancárias, compra de propriedades, serviços públicos e compras online, tornando-se um identificador essencial para indivíduos e empresas que operam na Argentina.

Exemplos de Código

Python

1def calculate_verification_digit(type_code, dni):
2    # Converter para string e garantir que o DNI tenha 8 dígitos com zeros à esquerda
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # Combinar código do tipo e DNI
7    digits = type_code_str + dni_str
8    
9    # Pesos para cada posição
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # Calcular soma dos produtos
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # Calcular dígito de verificação
16    verification_digit = 11 - (sum_products % 11)
17    
18    # Casos especiais
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    # Códigos de tipo válidos
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"Código do tipo inválido. Deve ser um dos: {valid_type_codes}")
34    
35    # Gerar DNI aleatório se não fornecido
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # Calcular dígito de verificação
40    verification_digit = calculate_verification_digit(type_code, dni)
41    
42    # Formatar CUIT/CUIL
43    return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46    # Remover hífens se presentes
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # Verificar formato básico
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "Formato inválido"
52    
53    # Extrair partes
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    # Validar código do tipo
59    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60    if type_code not in valid_type_codes:
61        return False, "Código do tipo inválido"
62    
63    # Calcular e comparar dígito de verificação
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "Dígito de verificação inválido"
67    
68    return True, "CUIT/CUIL válido"
69
70# Exemplo de uso
71print(generate_cuit_cuil(20, 12345678))  # Gerar para DNI específico
72print(generate_cuit_cuil(27))  # Gerar com DNI aleatório
73print(validate_cuit_cuil("20-12345678-9"))  # Validar um CUIT/CUIL
74

JavaScript

1function calculateVerificationDigit(typeCode, dni) {
2  // Converter para string e garantir que o DNI tenha 8 dígitos com zeros à esquerda
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // Combinar código do tipo e DNI
7  const digits = typeCodeStr + dniStr;
8  
9  // Pesos para cada posição
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // Calcular soma dos produtos
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // Calcular dígito de verificação
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // Casos especiais
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  // Códigos de tipo válidos
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`Código do tipo inválido. Deve ser um dos: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // Gerar DNI aleatório se não fornecido
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // Calcular dígito de verificação
45  const verificationDigit = calculateVerificationDigit(typeCode, dni);
46  
47  // Formatar CUIT/CUIL
48  return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52  // Remover hífens se presentes
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // Verificar formato básico
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'Formato inválido' };
58  }
59  
60  // Extrair partes
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  // Validar código do tipo
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'Código do tipo inválido' };
69  }
70  
71  // Calcular e comparar dígito de verificação
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'Dígito de verificação inválido' };
75  }
76  
77  return { isValid: true };
78}
79
80// Exemplo de uso
81console.log(generateCuitCuil(20, 12345678)); // Gerar para DNI específico
82console.log(generateCuitCuil(27)); // Gerar com DNI aleatório
83console.log(validateCuitCuil("20-12345678-9")); // Validar um 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        // Converter para string e garantir que o DNI tenha 8 dígitos com zeros à esquerda
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // Combinar código do tipo e DNI
15        String digits = typeCodeStr + dniStr;
16        
17        // Calcular soma dos produtos
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // Calcular dígito de verificação
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // Casos especiais
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("Código do tipo inválido. Deve ser um dos: " + VALID_TYPE_CODES);
39        }
40        
41        // Gerar DNI aleatório se não fornecido
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // Calcular dígito de verificação
48        int verificationDigit = calculateVerificationDigit(typeCode, dni);
49        
50        // Formatar CUIT/CUIL
51        return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52    }
53    
54    public static ValidationResult validateCuitCuil(String cuitCuil) {
55        // Remover hífens se presentes
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // Verificar formato básico
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "Formato inválido");
61        }
62        
63        // Extrair partes
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        // Validar código do tipo
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "Código do tipo inválido");
71        }
72        
73        // Calcular e comparar dígito de verificação
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "Dígito de verificação inválido");
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        // Exemplo de uso
102        System.out.println(generateCuitCuil(20, 12345678)); // Gerar para DNI específico
103        System.out.println(generateCuitCuil(27, null)); // Gerar com DNI aleatório
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Validar um CUIT/CUIL
105    }
106}
107

PHP

1<?php
2
3function calculateVerificationDigit($typeCode, $dni) {
4    // Converter para string e garantir que o DNI tenha 8 dígitos com zeros à esquerda
5    $typeCodeStr = (string)$typeCode;
6    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
7    
8    // Combinar código do tipo e DNI
9    $digits = $typeCodeStr . $dniStr;
10    
11    // Pesos para cada posição
12    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
13    
14    // Calcular soma dos produtos
15    $sumProducts = 0;
16    for ($i = 0; $i < 10; $i++) {
17        $sumProducts += (int)$digits[$i] * $weights[$i];
18    }
19    
20    // Calcular dígito de verificação
21    $verificationDigit = 11 - ($sumProducts % 11);
22    
23    // Casos especiais
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    // Códigos de tipo válidos
35    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
36    
37    if (!in_array($typeCode, $validTypeCodes)) {
38        throw new Exception("Código do tipo inválido. Deve ser um dos: " . implode(', ', $validTypeCodes));
39    }
40    
41    // Gerar DNI aleatório se não fornecido
42    if ($dni === null) {
43        $dni = rand(10000000, 99999999);
44    }
45    
46    // Calcular dígito de verificação
47    $verificationDigit = calculateVerificationDigit($typeCode, $dni);
48    
49    // Formatar CUIT/CUIL
50    return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit);
51}
52
53function validateCuitCuil($cuitCuil) {
54    // Remover hífens se presentes
55    $cuitCuilClean = str_replace('-', '', $cuitCuil);
56    
57    // Verificar formato básico
58    if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
59        return ['isValid' => false, 'errorMessage' => 'Formato inválido'];
60    }
61    
62    // Extrair partes
63    $typeCode = (int)substr($cuitCuilClean, 0, 2);
64    $dni = (int)substr($cuitCuilClean, 2, 8);
65    $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
66    
67    // Validar código do tipo
68    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
69    if (!in_array($typeCode, $validTypeCodes)) {
70        return ['isValid' => false, 'errorMessage' => 'Código do tipo inválido'];
71    }
72    
73    // Calcular e comparar dígito de verificação
74    $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
75    if ($calculatedDigit !== $verificationDigit) {
76        return ['isValid' => false, 'errorMessage' => 'Dígito de verificação inválido'];
77    }
78    
79    return ['isValid' => true];
80}
81
82// Exemplo de uso
83echo generateCuitCuil(20, 12345678) . "\n"; // Gerar para DNI específico
84echo generateCuitCuil(27) . "\n"; // Gerar com DNI aleatório
85var_dump(validateCuitCuil("20-12345678-9")); // Validar um CUIT/CUIL
86?>
87

Perguntas Frequentes

Qual é a diferença entre CUIT e CUIL?

CUIT (Clave Única de Identificação Tributária) é usado para fins de identificação fiscal e é atribuído tanto a indivíduos quanto a entidades jurídicas que precisam pagar impostos na Argentina. CUIL (Clave Única de Identificação Laboral) é especificamente para trabalhadores e é usado para fins laborais e de seguridade social. Embora compartilhem o mesmo formato e algoritmo de cálculo, servem a propósitos administrativos diferentes.

Quais códigos de tipo são usados para indivíduos e quais para empresas?

Para indivíduos:

  • 20, 23, 24: Indivíduos do sexo masculino (CUIL)
  • 27: Indivíduos do sexo feminino (CUIL)

Para empresas e organizações:

  • 30: Corporações (CUIT)
  • 33: Associações Civis (CUIT)
  • 34: Fundações (CUIT)

Como é calculado o dígito de verificação?

O dígito de verificação é calculado usando um algoritmo de soma ponderada. Cada um dos primeiros 10 dígitos é multiplicado por um peso correspondente (5, 4, 3, 2, 7, 6, 5, 4, 3, 2), e os resultados são somados. O dígito de verificação é 11 menos o resto quando essa soma é dividida por 11. Casos especiais: se o resultado for 11, o dígito de verificação é 0; se o resultado for 10, o dígito de verificação é 9.

Posso usar esta ferramenta para gerar números de CUIT/CUIL reais e oficiais?

Não, esta ferramenta é projetada para fins de teste e educacionais apenas. Os números gerados são matematicamente válidos de acordo com o algoritmo CUIT/CUIL, mas não estão oficialmente registrados junto às autoridades fiscais argentinas (AFIP). Para registro oficial de CUIT/CUIL, indivíduos e empresas devem seguir os procedimentos legais adequados através da AFIP.

Por que a validação do meu CUIT/CUIL falha, mesmo que o formato pareça correto?

A validação pode falhar por várias razões:

  1. O código do tipo não é um dos códigos válidos (20, 23, 24, 27, 30, 33, 34)
  2. O dígito de verificação não corresponde ao valor calculado com base no algoritmo
  3. O formato está incorreto (deve ser XX-XXXXXXXX-X)
  4. Existem caracteres não numéricos na entrada (além dos hífens)

Os hífens são obrigatórios nos números de CUIT/CUIL?

Embora os números de CUIT/CUIL sejam comumente escritos e exibidos com hífens (XX-XXXXXXXX-X), os hífens não fazem parte do número real para fins de cálculo. Nosso validador aceita ambos os formatos (com ou sem hífens) e validará corretamente qualquer um dos formatos.

Um número de CUIT/CUIL pode ter menos de 8 dígitos na parte do DNI?

Não, a parte do DNI deve ter sempre exatamente 8 dígitos. Se o DNI real tiver menos dígitos, ele deve ser preenchido com zeros à esquerda para alcançar 8 dígitos. Por exemplo, se o DNI de alguém for 1234567, no CUIT/CUIL ele seria representado como 01234567.

Como posso verificar se um CUIT/CUIL está oficialmente registrado na Argentina?

Para verificar se um CUIT/CUIL está oficialmente registrado e ativo, você deve usar o site ou serviços oficiais da AFIP (Administración Federal de Ingressos Públicos). Nossa ferramenta apenas verifica a validade matemática do número, não seu status oficial de registro.

Posso usar esta ferramenta em meu aplicativo comercial?

Sim, você pode integrar o algoritmo e a lógica demonstrados nesta ferramenta em seus aplicativos comerciais. O algoritmo de validação de CUIT/CUIL é um padrão público. No entanto, para ambientes de produção, recomendamos implementar um tratamento de erros adequado e considerar validações adicionais contra fontes oficiais quando necessário.

Esta ferramenta armazena algum dos números de CUIT/CUIL gerados ou validados?

Não, esta ferramenta não armazena nenhuma das informações inseridas ou geradas. Todo o processamento é feito no lado do cliente em seu navegador, e nenhum dado é enviado ou armazenado em nossos servidores. Isso garante a privacidade e a segurança de qualquer informação que você insira.

Referências

  1. AFIP (Administración Federal de Ingressos Públicos). "CUIT/CUIL/CDI." Site Oficial. https://www.afip.gob.ar/

  2. Ministério do Trabalho, Emprego e Segurança Social. "CUIL - Clave Única de Identificação Laboral." https://www.argentina.gob.ar/trabajo

  3. ANSES (Administración Nacional de la Seguridad Social). "Obter meu CUIL." https://www.anses.gob.ar/

  4. Boletim Oficial da República Argentina. "Resolução Geral AFIP 2854/2010: Procedimento. Clave Única de Identificação Tributária (C.U.I.T.)."

  5. Código Fiscal da República Argentina. "Identificação e Registro de Contribuintes."

Pronto para gerar ou validar números de CUIT/CUIL argentinos? Experimente nossa ferramenta agora e simplifique seu processo de teste!

🔗

Ferramentas Relacionadas

Descubra mais ferramentas que podem ser úteis para seu fluxo de trabalho

Gerador e Validador de CUIT da Argentina para Fins de Teste

Experimente esta ferramenta

Gerador e Validador de CBU Argentino | Códigos Bancários

Experimente esta ferramenta

Ferramenta Geradora e Validadora de IBAN para Testes e Verificação

Experimente esta ferramenta

Gerador e Validador de CNPJ Brasileiro para Testes

Experimente esta ferramenta

Gerador e Validador de CLABE Mexicana para Testes de Software

Experimente esta ferramenta

Calculadora de Perímetro Molhado para Canais e Tubos

Experimente esta ferramenta

Gerador de CPF Válido para Testes e Desenvolvimento de Software

Experimente esta ferramenta

Gerador de CUIDs: Identificadores Únicos e Escaláveis

Experimente esta ferramenta

Gerador de RFC Mexicano para Testes | Crie Códigos de Identificação Fiscal Válidos

Experimente esta ferramenta