Argentínska generátor a validátor CUIT/CUIL

Úvod

Argentínske CUIT (Clave Única de Identificación Tributaria) a CUIL (Clave Única de Identificación Laboral) sú jedinečné identifikačné čísla používané v Argentíne na daňové a zamestnanecké účely. Tieto 11-ciferné kódy sú nevyhnutné pre jednotlivcov a podniky na legálne fungovanie v argentínskom hospodárskom systéme. Náš nástroj na generovanie a validáciu CUIT/CUIL poskytuje jednoduchý a efektívny spôsob, ako generovať platné čísla CUIT/CUIL na testovacie účely a overiť existujúce čísla, aby sa zabezpečilo, že zodpovedajú oficiálnemu formátu a overovaciemu algoritmu.

Či už ste vývojár testujúci aplikácie, ktoré spracovávajú argentínske daňové ID, špecialista na QA overujúci funkčnosť systému, alebo jednoducho potrebujete pochopiť, ako tieto identifikačné čísla fungujú, tento nástroj ponúka priamy a jednoduchý spôsob bez zbytočných zložitostí. Nástroj obsahuje dve hlavné funkcie: generátor, ktorý náhodne vytvára platné čísla CUIT/CUIL na základe špecifických parametrov, a validátor, ktorý overuje, či dané číslo CUIT/CUIL dodržiava správny formát a pravidlá výpočtu.

Štruktúra a výpočet CUIT/CUIL

Pochopenie formátu

Platné číslo CUIT/CUIL pozostáva z 11 číslic, ktoré sú zvyčajne zobrazené vo formáte XX-XXXXXXXX-X:

Kód typu (prvé 2 číslice): Indikuje typ subjektu
- 20, 23, 24: Mužské osoby (CUIL)
- 27: Ženské osoby (CUIL)
- 30, 33, 34: Spoločnosti a organizácie (CUIT)
Číslo DNI (prostredných 8 číslic): Pre jednotlivcov je to číslo ich národného identifikačného dokladu (DNI), doplnené o vedúce nuly, ak je to potrebné, aby sa dosiahlo 8 číslic. Pre spoločnosti je to jedinečné pridelené číslo.
Overovacia číslica (posledná číslica): Kontrolná číslica vypočítaná pomocou špecifického algoritmu na overenie celého čísla.

Výpočet overovacej číslice

Overovacia číslica sa vypočíta pomocou nasledujúceho algoritmu:

Vezmite prvých 10 číslic CUIT/CUIL (kód typu + DNI)
Násobte každú číslicu zodpovedajúcou váhou z tejto sekvencie: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
Sčítať všetky výsledné súčiny
Vypočítajte 11 mínus zvyšok z delenia súčtu 11
Ak je výsledok 11, overovacia číslica je 0
Ak je výsledok 10, overovacia číslica je 9
Inak je výsledok overovacia číslica

Matematicky to môže byť vyjadrené ako:

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

Kde:

$VD$ je overovacia číslica
$d_i$ je $i$ -tá číslica prvých 10 číslic
$w_i$ je zodpovedajúca váha zo sekvencie [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
Špeciálne prípady: ak $VD = 11$ , potom $VD = 0$ , ak $VD = 10$ , potom $VD = 9$

Krok za krokom návod

Používanie generátora

Vyberte kartu "Generátor" v hornej časti rozhrania nástroja.
Vyberte kód typu z rozbaľovacieho menu:
- 20: Muž (CUIL)
- 23: Podnik (CUIT)
- 24: Dočasný podnik (CUIT)
- 27: Žena (CUIL)
- 30: Korporácia (CUIT)
- 33: Občianske združenie (CUIT)
- 34: Nadácia (CUIT)
Zadajte číslo DNI (voliteľné):
- Zadajte 8-ciferné číslo DNI do poskytnutého poľa
- Ak je ponechané prázdne, nástroj použije náhodne generované DNI
- Ak zadáte menej ako 8 číslic, systém doplní vedúce nuly
Generovať náhodné DNI (voliteľné):
- Kliknite na tlačidlo "Náhodné" na generovanie náhodného 8-ciferného čísla DNI
Zobraziť vygenerované CUIT/CUIL:
- Nástroj automaticky zobrazí platné CUIT/CUIL na základe vašich vstupov
- Formát bude XX-XXXXXXXX-X s správnou overovacou číslicou
Skopírujte výsledok:
- Kliknite na ikonu kopírovania, aby ste skopírovali vygenerované CUIT/CUIL do schránky
- Po úspešnom skopírovaní sa zobrazí potvrdenná správa

Používanie validátora

Vyberte kartu "Validátor" v hornej časti rozhrania nástroja.
Zadajte CUIT/CUIL na overenie:
- Zadajte CUIT/CUIL vo formáte XX-XXXXXXXX-X
- Nástroj automaticky naformátuje váš vstup s pomlčkami, ako píšete
- Môžete tiež zadať číslo bez pomlčiek (XXXXXXXXXXX)
Kliknite na tlačidlo "Overiť":
- Nástroj skontroluje formát, kód typu a overovaciu číslicu
Zobraziť výsledok overenia:
- Pre platné čísla CUIT/CUIL sa zobrazí zelená správa o úspechu
- Pre neplatné čísla sa zobrazí červená chybová správa, ktorá vysvetlí problém:
  - Neplatný formát (musí byť XX-XXXXXXXX-X)
  - Neplatný kód typu (musí byť jeden z: 20, 23, 24, 27, 30, 33, 34)
  - Neplatná overovacia číslica
Ďalšie informácie:
- Pre platné čísla nástroj zobrazuje rozloženie komponentov:
  - Kód typu a jeho význam
  - Číslo DNI
  - Overovacia číslica

Prípadové použitia

Vývoj a testovanie

Softvérový vývoj: Generujte platné čísla CUIT/CUIL na testovanie aplikácií, ktoré spracovávajú argentínske daňové identifikácie, ako sú:
- E-commerce platformy
- Účtovný softvér
- Systémy správy ľudských zdrojov
- Portály vládnych služieb
- Bankové aplikácie
Napĺňanie databázy: Vytvorte realistické testovacie údaje pre systémy, ktoré ukladajú argentínske informácie o používateľoch, čím zabezpečíte, že obmedzenia databázy a validačné pravidlá fungujú správne.
Testovanie validácie formulárov: Testujte validáciu vstupu pre webové formuláre, ktoré zbierajú informácie o CUIT/CUIL, overujúc, že sa správne zobrazujú chybové správy pre neplatné záznamy.
Testovanie API: Generujte platné zaťaženia pre API koncové body, ktoré vyžadujú čísla CUIT/CUIL, čím zabezpečíte, že vaše integračné testy používajú platné údaje.
Automatizácia QA: Zahrňte generovanie CUIT/CUIL do automatizovaných testovacích skriptov na vytvorenie dynamických testovacích prípadov namiesto používania statických testovacích údajov.

Vzdelávacie účely

Učenie sa algoritmov validácie: Pochopte, ako algoritmy kontrolných číslic fungujú v praxi, keď vidíte proces overovania CUIT/CUIL v akcii.
Učenie techník validácie údajov: Použite ako vzdelávací príklad pri učení techník validácie formulárov nových vývojárov.
Pochopenie argentínskych obchodných požiadaviek: Naučte sa o identifikačnom systéme používanom v Argentíne pre medzinárodný obchodný rozvoj.

Alternatívy

Aj keď náš nástroj poskytuje priamy spôsob generovania a validácie čísel CUIT/CUIL, existujú alternatívne prístupy, ktoré by ste mohli zvážiť:

Oficiálna vládna validácia: Pre produkčné prostredia vždy overte čísla CUIT/CUIL proti oficiálnej databáze AFIP (Administración Federal de Ingresos Públicos), keď je to možné.
Knižnice a balíčky: Niekoľko programovacích jazykov má knižnice špecificky navrhnuté na validáciu argentínskych daňových ID:
- JavaScript: validar-cuit npm balík
- PHP: afip-php knižnica
- Python: py-cuit balík
Manuálny výpočet: Pre vzdelávacie účely by ste mohli manuálne vypočítať overovaciu číslicu pomocou algoritmu popísaného vyššie.
Komplexné služby validácie obchodov: Pre podnikové aplikácie zvážte použitie komplexných služieb validácie, ktoré nielenže kontrolujú formát, ale aj overujú existenciu a stav subjektu spojeného s CUIT/CUIL.

História systému CUIT/CUIL

Systém identifikácie CUIT/CUIL v Argentíne sa od svojho vzniku významne vyvinul:

Pôvod a implementácia

CUIT (Clave Única de Identificación Tributaria) bol prvýkrát zavedený v Argentíne v 70. rokoch ako súčasť snáh o modernizáciu systému výberu daní. Federálna správa príjmov (AFIP) implementovala tento jedinečný identifikátor na efektívnejšie sledovanie daňovníkov a zníženie daňových únikov.

CUIL (Clave Única de Identificación Laboral) bol neskôr zavedený na špecifické identifikovanie pracovníkov v systéme sociálneho zabezpečenia, čím sa vytvoril rozdiel medzi daňovou identifikáciou a pracovnou identifikáciou, pričom sa zachoval konzistentný formát.

Evolúcia a digitalizácia

V 90. rokoch, keď Argentína prešla významnými hospodárskymi reformami, sa systém CUIT/CUIL stal čoraz dôležitejším pre sledovanie hospodárskej činnosti. Systém bol ďalej digitalizovaný a implementované boli online overovacie systémy.

Začiatkom 2000-tych rokov došlo k integrácii systému CUIT/CUIL s rôznymi digitálnymi vládnymi službami, čo z neho urobilo nevyhnutnú súčasť argentínskych iniciatív e-governance. Toto obdobie tiež videlo štandardizáciu overovacieho algoritmu a formátu, ktorý zostáva v platnosti dodnes.

Nedávne vývoj

V posledných rokoch AFIP zlepšila bezpečnostné a overovacie procesy pre čísla CUIT/CUIL, implementovaním sofistikovanejších validačných systémov a ich integráciou s inými vládnymi databázami. Systém teraz zohráva kľúčovú úlohu v úsilí Argentíny bojovať proti daňovým únikom a formálne usporiadať ekonomiku.

Dnes sa CUIT/CUIL používa nielen na daňové a zamestnanecké účely, ale aj na široké spektrum aktivít vrátane bankovníctva, transakcií s nehnuteľnosťami, služieb verejných utilít a online nákupov, čo z neho robí nevyhnutný identifikátor pre jednotlivcov aj podniky, ktoré pôsobia v Argentíne.

Kódové príklady

Python

1def calculate_verification_digit(type_code, dni):
2    # Preveďte na reťazec a zabezpečte, aby DNI malo 8 číslic s vedúcimi nulami
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # Spojte kód typu a DNI
7    digits = type_code_str + dni_str
8    
9    # Váhy pre každú pozíciu
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # Vypočítajte súčet súčinov
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # Vypočítajte overovaciu číslicu
16    verification_digit = 11 - (sum_products % 11)
17    
18    # Špeciálne prí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 typov
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í byť jeden z: {valid_type_codes}")
34    
35    # Generujte náhodné DNI, ak nie je poskytnuté
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # Vypočítajte overovaciu číslicu
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    # Odstráňte pomlčky, ak sú prítomné
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # Skontrolujte 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 časti
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    # Overte 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čítajte a porovnajte overovaciu číslicu
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "Neplatná overovacia číslica"
67    
68    return True, "Platný CUIT/CUIL"
69
70# Príklad použitia
71print(generate_cuit_cuil(20, 12345678))  # Generovať pre konkrétne DNI
72print(generate_cuit_cuil(27))  # Generovať s náhodným DNI
73print(validate_cuit_cuil("20-12345678-9"))  # Overiť CUIT/CUIL
74

JavaScript

1function calculateVerificationDigit(typeCode, dni) {
2  // Preveďte na reťazec a zabezpečte, aby DNI malo 8 číslic s vedúcimi nulami
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // Spojte kód typu a DNI
7  const digits = typeCodeStr + dniStr;
8  
9  // Váhy pre každú pozíciu
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // Vypočítajte súčet súčinov
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // Vypočítajte overovaciu číslicu
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // Špeciálne prí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 typov
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í byť jeden z: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // Generujte náhodné DNI, ak nie je poskytnuté
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // Vypočítajte overovaciu číslicu
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  // Odstráňte pomlčky, ak sú prítomné
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // Skontrolujte základný formát
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'Neplatný formát' };
58  }
59  
60  // Extrahujte časti
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  // Overte 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čítajte a porovnajte overovaciu číslicu
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'Neplatná overovacia číslica' };
75  }
76  
77  return { isValid: true };
78}
79
80// Príklad použitia
81console.log(generateCuitCuil(20, 12345678)); // Generovať pre konkrétne DNI
82console.log(generateCuitCuil(27)); // Generovať s náhodným DNI
83console.log(validateCuitCuil("20-12345678-9")); // Overiť 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        // Preveďte na reťazec a zabezpečte, aby DNI malo 8 číslic s vedúcimi nulami
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // Spojte kód typu a DNI
15        String digits = typeCodeStr + dniStr;
16        
17        // Vypočítajte súčet súčinov
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čítajte overovaciu číslicu
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // Špeciálne prí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í byť jeden z: " + VALID_TYPE_CODES);
39        }
40        
41        // Generujte náhodné DNI, ak nie je poskytnuté
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // Vypočítajte overovaciu číslicu
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        // Odstráňte pomlčky, ak sú prítomné
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // Skontrolujte základný formát
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "Neplatný formát");
61        }
62        
63        // Extrahujte časti
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        // Overte kód typu
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "Neplatný kód typu");
71        }
72        
73        // Vypočítajte a porovnajte overovaciu číslicu
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "Neplatná overovacia číslica");
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        // Príklad použitia
102        System.out.println(generateCuitCuil(20, 12345678)); // Generovať pre konkrétne DNI
103        System.out.println(generateCuitCuil(27, null)); // Generovať s náhodným DNI
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Overiť CUIT/CUIL
105    }
106}
107

PHP

1<?php
2
3function calculateVerificationDigit($typeCode, $dni) {
4    // Preveďte na reťazec a zabezpečte, aby DNI malo 8 číslic s vedúcimi nulami
5    $typeCodeStr = (string)$typeCode;
6    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
7    
8    // Spojte kód typu a DNI
9    $digits = $typeCodeStr . $dniStr;
10    
11    // Váhy pre každú pozíciu
12    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
13    
14    // Vypočítajte súčet súčinov
15    $sumProducts = 0;
16    for ($i = 0; $i < 10; $i++) {
17        $sumProducts += (int)$digits[$i] * $weights[$i];
18    }
19    
20    // Vypočítajte overovaciu číslicu
21    $verificationDigit = 11 - ($sumProducts % 11);
22    
23    // Špeciálne prí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 typov
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í byť jeden z: " . implode(', ', $validTypeCodes));
39    }
40    
41    // Generujte náhodné DNI, ak nie je poskytnuté
42    if ($dni === null) {
43        $dni = rand(10000000, 99999999);
44    }
45    
46    // Vypočítajte overovaciu číslicu
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    // Odstráňte pomlčky, ak sú prítomné
55    $cuitCuilClean = str_replace('-', '', $cuitCuil);
56    
57    // Skontrolujte základný formát
58    if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
59        return ['isValid' => false, 'errorMessage' => 'Neplatný formát'];
60    }
61    
62    // Extrahujte časti
63    $typeCode = (int)substr($cuitCuilClean, 0, 2);
64    $dni = (int)substr($cuitCuilClean, 2, 8);
65    $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
66    
67    // Overte 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čítajte a porovnajte overovaciu číslicu
74    $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
75    if ($calculatedDigit !== $verificationDigit) {
76        return ['isValid' => false, 'errorMessage' => 'Neplatná overovacia číslica'];
77    }
78    
79    return ['isValid' => true];
80}
81
82// Príklad použitia
83echo generateCuitCuil(20, 12345678) . "\n"; // Generovať pre konkrétne DNI
84echo generateCuitCuil(27) . "\n"; // Generovať s náhodným DNI
85var_dump(validateCuitCuil("20-12345678-9")); // Overiť CUIT/CUIL
86?>
87

Často kladené otázky

Aký je rozdiel medzi CUIT a CUIL?

CUIT (Clave Única de Identificación Tributaria) sa používa na daňovú identifikáciu a je pridelený jednotlivcom aj právnickým osobám, ktoré musia platiť dane v Argentíne. CUIL (Clave Única de Identificación Laboral) je špecificky určený pre pracovníkov a používa sa na pracovné a sociálne zabezpečenie. Hoci zdieľajú rovnaký formát a algoritmus výpočtu, slúžia rôznym administratívnym účelom.

Ktoré kódy typov sa používajú pre jednotlivcov a ktoré pre spoločnosti?

Pre jednotlivcov:

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

Pre spoločnosti a organizácie:

30: Korporácie (CUIT)
33: Občianske združenia (CUIT)
34: Nadácie (CUIT)

Ako sa vypočítava overovacia číslica?

Overovacia číslica sa vypočítava pomocou algoritmu váženého súčtu. Každá z prvých 10 číslic sa násobí zodpovedajúcou váhou (5, 4, 3, 2, 7, 6, 5, 4, 3, 2) a výsledky sa sčítajú. Overovacia číslica je 11 mínus zvyšok, keď je tento súčet delený 11. Špeciálne prípady: ak je výsledok 11, overovacia číslica je 0; ak je výsledok 10, overovacia číslica je 9.

Môžem tento nástroj použiť na generovanie reálnych, oficiálnych čísel CUIT/CUIL?

Nie, tento nástroj je navrhnutý na testovacie a vzdelávacie účely. Čísla generované sú matematicky platné podľa algoritmu CUIT/CUIL, ale nie sú oficiálne registrované u argentínskych daňových úradov (AFIP). Pre oficiálnu registráciu CUIT/CUIL musia jednotlivci a spoločnosti dodržiavať správne právne postupy prostredníctvom AFIP.

Prečo moje overenie CUIT/CUIL zlyhá, aj keď formát vyzerá správne?

Overenie môže zlyhať z niekoľkých dôvodov:

Kód typu nie je jedným z platných kódov (20, 23, 24, 27, 30, 33, 34)
Overovacia číslica sa nezhoduje s vypočítanou hodnotou na základe algoritmu
Formát je nesprávny (mal by byť XX-XXXXXXXX-X)
V zázname sú nečíselné znaky (okrem pomlčiek)

Sú pomlčky potrebné v číslach CUIT/CUIL?

Hoci sa čísla CUIT/CUIL bežne píšu a zobrazujú s pomlčkami (XX-XXXXXXXX-X), pomlčky nie sú súčasťou skutočného čísla na účely výpočtu. Náš validátor akceptuje oba formáty (s alebo bez pomlčiek) a správne overí ktorýkoľvek formát.

Môže mať číslo CUIT/CUIL menej ako 8 číslic v časti DNI?

Nie, časť DNI musí mať vždy presne 8 číslic. Ak má skutočné DNI menej číslic, musí byť doplnené o vedúce nuly, aby dosiahlo 8 číslic. Napríklad, ak je DNI niekoho 1234567, v CUIT/CUIL by bolo reprezentované ako 01234567.

Ako môžem overiť, či je CUIT/CUIL oficiálne registrované v Argentíne?

Na overenie, či je CUIT/CUIL oficiálne registrované a aktívne, by ste mali použiť oficiálnu webovú stránku alebo služby AFIP (Administración Federal de Ingresos Públicos). Náš nástroj iba overuje matematickú platnosť čísla, nie jeho oficiálny registračný stav.

Môžem tento nástroj použiť vo svojej komerčnej aplikácii?

Áno, môžete integrovať algoritmus a logiku, ktoré sú demonštrované v tomto nástroji, do svojich komerčných aplikácií. Algoritmus validácie CUIT/CUIL je verejný štandard. Odporúčame však implementovať správne spracovanie chýb a zvážiť ďalšie overenie proti oficiálnym zdrojom, keď je to potrebné.

Ukladá nástroj akékoľvek vygenerované alebo overené čísla CUIT/CUIL?

Nie, tento nástroj neukladá žiadne z informácií zadaných alebo generovaných. Všetko spracovanie sa vykonáva na strane klienta vo vašom prehliadači a žiadne údaje nie sú odosielané ani ukladané na našich serveroch. To zabezpečuje súkromie a bezpečnosť akýchkoľvek informácií, ktoré zadáte.

Odkazy

AFIP (Administración Federal de Ingresos Públicos). "CUIT/CUIL/CDI." Oficiálna webová stránka. https://www.afip.gob.ar/
Ministerstvo práce, zamestnania a sociálneho zabezpečenia. "CUIL - Clave Única de Identificación Laboral." https://www.argentina.gob.ar/trabajo
ANSES (Administración Nacional de la Seguridad Social). "Získajte svoj CUIL." https://www.anses.gob.ar/
Oficiálny vestník Argentínskej republiky. "Rozhodnutie generálneho riaditeľstva AFIP 2854/2010: Postup. Clave Única de Identificación Tributaria (C.U.I.T.)."
Daňový kód Argentínskej republiky. "Identifikácia a registrácia daňovníkov."

Ste pripravení generovať alebo overiť argentínske čísla CUIT/CUIL? Vyskúšajte náš nástroj teraz a zjednodušte svoj proces testovania!

Generátor a validátor CUIT/CUIL v Argentíne

Generátor CUIT/CUIL

Vygenerovaný CUIT/CUIL

Dokumentácia