Generátor a validátor argentinského CUIT/CUIL

Úvod

Argentinský CUIT (Clave Única de Identificación Tributaria) a CUIL (Clave Única de Identificación Laboral) jsou jedinečné identifikační čísla používaná v Argentině pro daňové a pracovní účely. Tyto 11-místné kódy jsou nezbytné pro jednotlivce a podniky, aby mohly legálně fungovat v argentinském hospodářském systému. Náš nástroj pro generování a validaci CUIT/CUIL poskytuje jednoduchý a efektivní způsob, jak generovat platná čísla CUIT/CUIL pro testovací účely a validovat existující čísla, aby se zajistilo, že odpovídají oficiálnímu formátu a validačnímu algoritmu.

Ať už jste vývojář testující aplikace, které zpracovávají argentinské daňové ID, specialista na QA ověřující funkčnost systému, nebo jednoduše potřebujete pochopit, jak tato identifikační čísla fungují, tento nástroj nabízí přímočaré řešení bez zbytečných složitostí. Nástroj má dvě hlavní funkce: generátor, který vytváří platná čísla CUIT/CUIL náhodně nebo na základě specifických parametrů, a validátor, který ověřuje, zda dané číslo CUIT/CUIL odpovídá správnému formátu a pravidlům výpočtu.

Struktura a výpočet CUIT/CUIL

Pochopení formátu

Platné číslo CUIT/CUIL se skládá z 11 číslic, které jsou obvykle zobrazeny ve formátu XX-XXXXXXXX-X:

Kód typu (první 2 číslice): Označuje typ entity
- 20, 23, 24: Mužské osoby (CUIL)
- 27: Ženské osoby (CUIL)
- 30, 33, 34: Společnosti a organizace (CUIT)
Číslo DNI (prostředních 8 číslic): Pro jednotlivce je to jejich číslo národního identifikačního dokumentu (DNI), které je v případě potřeby doplněno o vedoucí nuly, aby dosáhlo 8 číslic. Pro společnosti je to jedinečné přidělené číslo.
Kontrolní číslice (poslední číslice): Kontrolní číslice vypočtená pomocí specifického algoritmu pro validaci celého čísla.

Výpočet kontrolní číslice

Kontrolní číslice se vypočítá pomocí následujícího algoritmu:

Vezměte prvních 10 číslic CUIT/CUIL (kód typu + DNI)
Vynásobte každou číslici odpovídající váhou z této sekvence: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
Sečtěte všechny výsledné součiny
Vypočítejte 11 minus zbytek součtu děleného 11
Pokud je výsledek 11, kontrolní číslice je 0
Pokud je výsledek 10, kontrolní číslice je 9
Jinak je výsledek kontrolní číslicí

Matematicky lze toto vyjádřit jako:

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

Kde:

$VD$ je kontrolní číslice
$d_i$ je $i$ -tá číslice prvních 10 číslic
$w_i$ je odpovídající váha ze sekvence [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
Zvláštní případy: pokud $VD = 11$ , pak $VD = 0$ , pokud $VD = 10$ , pak $VD = 9$

Krok za krokem

Použití generátoru

Vyberte kartu "Generátor" v horní části rozhraní nástroje.
Vyberte kód typu z rozbalovacího menu:
- 20: Muž (CUIL)
- 23: Podnik (CUIT)
- 24: Dočasný podnik (CUIT)
- 27: Žena (CUIL)
- 30: Korporace (CUIT)
- 33: Občanská asociace (CUIT)
- 34: Nadace (CUIT)
Zadejte číslo DNI (volitelné):
- Zadejte 8-místné číslo DNI do poskytnutého pole
- Pokud je ponecháno prázdné, nástroj použije náhodně vygenerované DNI
- Pokud zadáte méně než 8 číslic, systém je doplní o vedoucí nuly
Generovat náhodné DNI (volitelné):
- Klikněte na tlačítko "Náhodné" pro vygenerování náhodného 8-místného čísla DNI
Zobrazte vygenerované CUIT/CUIL:
- Nástroj automaticky zobrazí platné CUIT/CUIL na základě vašich vstupů
- Formát bude XX-XXXXXXXX-X se správnou kontrolní číslicí
Zkopírujte výsledek:
- Klikněte na ikonu kopírování, abyste zkopírovali vygenerované CUIT/CUIL do schránky
- Po úspěšném zkopírování se zobrazí potvrzovací zpráva

Použití validátoru

Vyberte kartu "Validátor" v horní části rozhraní nástroje.
Zadejte CUIT/CUIL k validaci:
- Zadejte CUIT/CUIL ve formátu XX-XXXXXXXX-X
- Nástroj automaticky formátuje váš vstup s pomlčkami, jak píšete
- Můžete také zadat číslo bez pomlček (XXXXXXXXXXX)
Klikněte na tlačítko "Validovat":
- Nástroj zkontroluje formát, kód typu a kontrolní číslici
Zobrazte výsledek validace:
- U platných čísel CUIT/CUIL se zobrazí zelená úspěšná zpráva
- U neplatných čísel se zobrazí červená chybová zpráva, která vysvětlí problém:
  - Neplatný formát (musí být XX-XXXXXXXX-X)
  - Neplatný kód typu (musí být jeden z: 20, 23, 24, 27, 30, 33, 34)
  - Neplatná kontrolní číslice
Další informace:
- U platných čísel nástroj zobrazuje rozpis komponent:
  - Kód typu a jeho význam
  - Číslo DNI
  - Kontrolní číslice

Případy použití

Vývoj a testování

Vývoj softwaru: Generujte platná čísla CUIT/CUIL pro testování aplikací, které zpracovávají argentinské daňové identifikace, například:
- E-commerce platformy
- Účetní software
- Systémy správy lidských zdrojů
- Portály vládních služeb
- Bankovní aplikace
Naplnění databáze: Vytvořte realistická testovací data pro systémy, které ukládají argentinské uživatelské informace, aby se zajistilo, že pravidla pro omezení databáze a validaci fungují správně.
Testování validace formulářů: Otestujte validaci vstupu pro webové formuláře, které shromažďují informace o CUIT/CUIL, a ověřte, že se správné chybové zprávy objevují pro neplatné záznamy.
Testování API: Generujte platné payloady pro API koncové body, které vyžadují čísla CUIT/CUIL, a zajistěte, že vaše integrační testy používají platná data.
Automatizace QA: Zahrňte generování CUIT/CUIL do automatizovaných testovacích skriptů pro vytváření dynamických testovacích případů namísto použití statických testovacích dat.

Vzdělávací účely

Učení validačních algoritmů: Pochopte, jak kontrolní algoritmy fungují v praxi tím, že uvidíte proces validace CUIT/CUIL v akci.
Učení technik validace dat: Použijte jako vzdělávací příklad při výuce technik validace formulářů novým vývojářům.
Pochopení požadavků argentinského podnikání: Naučte se o identifikačním systému používaném v Argentině pro mezinárodní obchodní rozvoj.

Alternativy

Zatímco náš nástroj poskytuje přímočarý způsob generování a validace čísel CUIT/CUIL, existují alternativní přístupy, které můžete zvážit:

Oficiální vládní validace: Pro produkční prostředí vždy validujte čísla CUIT/CUIL proti oficiální databázi AFIP (Administración Federal de Ingresos Públicos), kdykoli je to možné.
Knihovny a balíčky: Některé programovací jazyky mají knihovny speciálně navržené pro validaci argentinských daňových ID:
- JavaScript: validar-cuit npm balíček
- PHP: afip-php knihovna
- Python: py-cuit balíček
Ruční výpočet: Pro vzdělávací účely můžete ručně vypočítat kontrolní číslici pomocí výše popsaného algoritmu.
Komplexní služby validace podnikání: Pro podnikové aplikace zvažte použití komplexních validačních služeb, které nejen kontrolují formát, ale také ověřují existenci a stav entity spojené s CUIT/CUIL.

Historie systému CUIT/CUIL

Systém identifikace CUIT/CUIL v Argentině se od svého vzniku výrazně vyvinul:

Původ a implementace

CUIT (Clave Única de Identificación Tributaria) byl poprvé zaveden v Argentině v 70. letech jako součást snah o modernizaci systému výběru daní. Federální správa příjmů (AFIP) tento jedinečný identifikátor zavedla, aby efektivněji sledovala daňové poplatníky a snížila daňové úniky.

CUIL (Clave Única de Identificación Laboral) byl později zaveden k identifikaci pracovníků ve systému sociálního zabezpečení, čímž se vytvořil rozdíl mezi daňovou identifikací a pracovní identifikací, přičemž byl zachován konzistentní formát.

Vývoj a digitalizace

V 90. letech, kdy Argentina prošla významnými ekonomickými reformami, se systém CUIT/CUIL stal stále důležitějším pro sledování ekonomické činnosti. Systém byl dále digitalizován a byly implementovány online validační systémy.

Začátkem 2000. let došlo k integraci systému CUIT/CUIL s různými digitálními vládními službami, což z něj učinilo nezbytnou součást argentinských iniciativ e-governmentu. Toto období také přineslo standardizaci validačního algoritmu a formátu, který se používá dodnes.

Nedávné události

V posledních letech AFIP zlepšila bezpečnostní a validační procesy pro čísla CUIT/CUIL, implementovala sofistikovanější validační systémy a integrovala je s dalšími vládními databázemi. Systém nyní hraje klíčovou roli v argentinských snahách o boj proti daňovým únikům a formalizaci ekonomiky.

Dnes se CUIT/CUIL používá nejen pro daňové a pracovní účely, ale také pro širokou škálu činností, včetně bankovnictví, transakcí s nemovitostmi, služeb utilit a online nákupů, což z něj činí nezbytný identifikátor pro jednotlivce i podniky působící v Argentině.

Příklady kódu

Python

1def calculate_verification_digit(type_code, dni):
2    # Převeďte na řetězec a zajistěte, aby DNI mělo 8 číslic s vedoucími nulami
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # Kombinujte kód typu a DNI
7    digits = type_code_str + dni_str
8    
9    # Váhy pro každou pozici
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # Vypočítejte součet součinů
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # Vypočítejte kontrolní číslici
16    verification_digit = 11 - (sum_products % 11)
17    
18    # Zvláštní případy
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    # Platné kódy typu
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"Neplatný kód typu. Musí být jeden z: {valid_type_codes}")
34    
35    # Vygenerujte náhodné DNI, pokud není poskytnuto
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # Vypočítejte kontrolní číslici
40    verification_digit = calculate_verification_digit(type_code, dni)
41    
42    # Formát CUIT/CUIL
43    return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46    # Odstraňte pomlčky, pokud jsou přítomny
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # Zkontrolujte základní formát
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "Neplatný formát"
52    
53    # Extrahujte části
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    # Ověřte kód typu
59    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60    if type_code not in valid_type_codes:
61        return False, "Neplatný kód typu"
62    
63    # Vypočítejte a porovnejte kontrolní číslici
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "Neplatná kontrolní číslice"
67    
68    return True, "Platný CUIT/CUIL"
69
70# Příklad použití
71print(generate_cuit_cuil(20, 12345678))  # Generujte pro konkrétní DNI
72print(generate_cuit_cuil(27))  # Generujte s náhodným DNI
73print(validate_cuit_cuil("20-12345678-9"))  # Ověřte CUIT/CUIL
74

JavaScript

1function calculateVerificationDigit(typeCode, dni) {
2  // Převeďte na řetězec a zajistěte, aby DNI mělo 8 číslic s vedoucími nulami
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // Kombinujte kód typu a DNI
7  const digits = typeCodeStr + dniStr;
8  
9  // Váhy pro každou pozici
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // Vypočítejte součet součinů
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // Vypočítejte kontrolní číslici
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // Zvláštní případy
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  // Platné kódy typu
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`Neplatný kód typu. Musí být jeden z: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // Vygenerujte náhodné DNI, pokud není poskytnuto
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // Vypočítejte kontrolní číslici
45  const verificationDigit = calculateVerificationDigit(typeCode, dni);
46  
47  // Formát CUIT/CUIL
48  return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52  // Odstraňte pomlčky, pokud jsou přítomny
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // Zkontrolujte základní formát
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'Neplatný formát' };
58  }
59  
60  // Extrahujte části
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  // Ověřte kód typu
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'Neplatný kód typu' };
69  }
70  
71  // Vypočítejte a porovnejte kontrolní číslici
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'Neplatná kontrolní číslice' };
75  }
76  
77  return { isValid: true };
78}
79
80// Příklad použití
81console.log(generateCuitCuil(20, 12345678)); // Generujte pro konkrétní DNI
82console.log(generateCuitCuil(27)); // Generujte s náhodným DNI
83console.log(validateCuitCuil("20-12345678-9")); // Ověřte 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        // Převeďte na řetězec a zajistěte, aby DNI mělo 8 číslic s vedoucími nulami
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // Kombinujte kód typu a DNI
15        String digits = typeCodeStr + dniStr;
16        
17        // Vypočítejte součet součinů
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // Vypočítejte kontrolní číslici
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // Zvláštní případy
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("Neplatný kód typu. Musí být jeden z: " + VALID_TYPE_CODES);
39        }
40        
41        // Vygenerujte náhodné DNI, pokud není poskytnuto
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // Vypočítejte kontrolní číslici
48        int verificationDigit = calculateVerificationDigit(typeCode, dni);
49        
50        // Formát CUIT/CUIL
51        return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52    }
53    
54    public static ValidationResult validateCuitCuil(String cuitCuil) {
55        // Odstraňte pomlčky, pokud jsou přítomny
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // Zkontrolujte základní formát
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "Neplatný formát");
61        }
62        
63        // Extrahujte části
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        // Ověřte kód typu
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "Neplatný kód typu");
71        }
72        
73        // Vypočítejte a porovnejte kontrolní číslici
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "Neplatná kontrolní číslice");
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        // Příklad použití
102        System.out.println(generateCuitCuil(20, 12345678)); // Generujte pro konkrétní DNI
103        System.out.println(generateCuitCuil(27, null)); // Generujte s náhodným DNI
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Ověřte CUIT/CUIL
105    }
106}
107

PHP

1<?php
2
3function calculateVerificationDigit($typeCode, $dni) {
4    // Převeďte na řetězec a zajistěte, aby DNI mělo 8 číslic s vedoucími nulami
5    $typeCodeStr = (string)$typeCode;
6    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
7    
8    // Kombinujte kód typu a DNI
9    $digits = $typeCodeStr . $dniStr;
10    
11    // Váhy pro každou pozici
12    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
13    
14    // Vypočítejte součet součinů
15    $sumProducts = 0;
16    for ($i = 0; $i < 10; $i++) {
17        $sumProducts += (int)$digits[$i] * $weights[$i];
18    }
19    
20    // Vypočítejte kontrolní číslici
21    $verificationDigit = 11 - ($sumProducts % 11);
22    
23    // Zvláštní případy
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    // Platné kódy typu
35    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
36    
37    if (!in_array($typeCode, $validTypeCodes)) {
38        throw new Exception("Neplatný kód typu. Musí být jeden z: " . implode(', ', $validTypeCodes));
39    }
40    
41    // Vygenerujte náhodné DNI, pokud není poskytnuto
42    if ($dni === null) {
43        $dni = rand(10000000, 99999999);
44    }
45    
46    // Vypočítejte kontrolní číslici
47    $verificationDigit = calculateVerificationDigit($typeCode, $dni);
48    
49    // Formát CUIT/CUIL
50    return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit);
51}
52
53function validateCuitCuil($cuitCuil) {
54    // Odstraňte pomlčky, pokud jsou přítomny
55    $cuitCuilClean = str_replace('-', '', $cuitCuil);
56    
57    // Zkontrolujte základní formát
58    if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
59        return ['isValid' => false, 'errorMessage' => 'Neplatný formát'];
60    }
61    
62    // Extrahujte části
63    $typeCode = (int)substr($cuitCuilClean, 0, 2);
64    $dni = (int)substr($cuitCuilClean, 2, 8);
65    $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
66    
67    // Ověřte kód typu
68    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
69    if (!in_array($typeCode, $validTypeCodes)) {
70        return ['isValid' => false, 'errorMessage' => 'Neplatný kód typu'];
71    }
72    
73    // Vypočítejte a porovnejte kontrolní číslici
74    $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
75    if ($calculatedDigit !== $verificationDigit) {
76        return ['isValid' => false, 'errorMessage' => 'Neplatná kontrolní číslice'];
77    }
78    
79    return ['isValid' => true];
80}
81
82// Příklad použití
83echo generateCuitCuil(20, 12345678) . "\n"; // Generujte pro konkrétní DNI
84echo generateCuitCuil(27) . "\n"; // Generujte s náhodným DNI
85var_dump(validateCuitCuil("20-12345678-9")); // Ověřte CUIT/CUIL
86?>
87

Často kladené otázky

Jaký je rozdíl mezi CUIT a CUIL?

CUIT (Clave Única de Identificación Tributaria) se používá pro daňovou identifikaci a je přidělen jak jednotlivcům, tak právnickým osobám, které musí platit daně v Argentině. CUIL (Clave Única de Identificación Laboral) je specificky pro pracovníky a používá se pro pracovní a sociální zabezpečení. Ačkoli mají stejný formát a výpočetní algoritmus, slouží různým administrativním účelům.

Které kódy typu se používají pro jednotlivce a které pro společnosti?

Pro jednotlivce:

20, 23, 24: Mužské osoby (CUIL)
27: Ženské osoby (CUIL)

Pro společnosti a organizace:

30: Korporace (CUIT)
33: Občanská asociace (CUIT)
34: Nadace (CUIT)

Jak se vypočítává kontrolní číslice?

Kontrolní číslice se vypočítává pomocí váženého součtového algoritmu. Každá z prvních 10 číslic se násobí odpovídající váhou (5, 4, 3, 2, 7, 6, 5, 4, 3, 2) a výsledky se sečtou. Kontrolní číslice je 11 minus zbytek, když je tento součet dělen 11. Zvláštní případy: pokud je výsledek 11, kontrolní číslice je 0; pokud je výsledek 10, kontrolní číslice je 9.

Mohu tento nástroj použít k generování skutečných, oficiálních čísel CUIT/CUIL?

Ne, tento nástroj je určen pouze pro testovací a vzdělávací účely. Vygenerovaná čísla jsou matematicky platná podle algoritmu CUIT/CUIL, ale nejsou oficiálně registrována u argentinských daňových úřadů (AFIP). Pro oficiální registraci CUIT/CUIL musí jednotlivci a společnosti dodržovat správné právní postupy prostřednictvím AFIP.

Proč moje validace CUIT/CUIL selhává, i když formát vypadá správně?

Validace může selhat z několika důvodů:

Kód typu není jedním z platných kódů (20, 23, 24, 27, 30, 33, 34)
Kontrolní číslice se neshoduje s vypočítanou hodnotou podle algoritmu
Formát je nesprávný (mělo by to být XX-XXXXXXXX-X)
Vstupu jsou přítomny nečíselné znaky (kromě pomlček)

Jsou pomlčky v číslech CUIT/CUIL povinné?

Ačkoli jsou čísla CUIT/CUIL běžně psána a zobrazována s pomlčkami (XX-XXXXXXXX-X), pomlčky nejsou součástí skutečného čísla pro účely výpočtu. Náš validátor přijímá oba formáty (s nebo bez pomlček) a správně ověří jakýkoli formát.

Může mít číslo CUIT/CUIL méně než 8 číslic v části DNI?

Ne, část DNI musí mít vždy přesně 8 číslic. Pokud má skutečné DNI méně číslic, musí být doplněno o vedoucí nuly, aby dosáhlo 8 číslic. Například, pokud je něčí DNI 1234567, bude v CUIT/CUIL reprezentováno jako 01234567.

Jak mohu ověřit, zda je CUIT/CUIL oficiálně registrováno v Argentině?

Chcete-li ověřit, zda je CUIT/CUIL oficiálně registrováno a aktivní, měli byste použít oficiální webové stránky nebo služby AFIP (Administración Federal de Ingresos Públicos). Náš nástroj pouze ověřuje matematickou platnost čísla, nikoli jeho oficiální registrační stav.

Mohu tento nástroj použít ve své komerční aplikaci?

Ano, můžete integrovat algoritmus a logiku, které jsou demonstrovány v tomto nástroji, do svých komerčních aplikací. Algoritmus validace CUIT/CUIL je veřejný standard. Nicméně pro produkční prostředí doporučujeme implementovat řádné zpracování chyb a zvážit další validaci proti oficiálním zdrojům, kdykoli je to nutné.

Ukládá nástroj nějaká vygenerovaná nebo validovaná čísla CUIT/CUIL?

Ne, tento nástroj neukládá žádné informace zadané nebo vygenerované. Všechny zpracování probíhají na straně klienta ve vašem prohlížeči a žádná data nejsou odesílána ani ukládána na naše servery. To zajišťuje soukromí a bezpečnost jakýchkoli informací, které zadáte.

Odkazy

AFIP (Administración Federal de Ingresos Públicos). "CUIT/CUIL/CDI." Oficiální web. 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). "Získat moje CUIL." https://www.anses.gob.ar/
Boletín Oficial de la República Argentina. "Rozhodnutí Generálního ředitelství AFIP 2854/2010: Postup. Clave Única de Identificación Tributaria (C.U.I.T.)."
Daňový kodex Argentinské republiky. "Identifikace a registrace daňových poplatníků."

Jste připraveni generovat nebo validovat argentinská čísla CUIT/CUIL? Vyzkoušejte náš nástroj nyní a zjednodušte svůj testovací proces!

Nástroj pro generování a validaci argentinského CUIT/CUIL

Generátor CUIT/CUIL

Vygenerovaný CUIT/CUIL

Dokumentace