Argentinsk CUIT/CUIL Generator och Validator

Introduktion

Den argentinska CUIT (Clave Única de Identificación Tributaria) och CUIL (Clave Única de Identificación Laboral) är unika identifieringsnummer som används i Argentina för skatte- och anställningsändamål. Dessa 11-siffriga koder är avgörande för individer och företag att verka lagligt inom det argentinska ekonomiska systemet. Vårt CUIT/CUIL Generator och Validator-verktyg erbjuder ett enkelt och effektivt sätt att generera giltiga CUIT/CUIL-nummer för teständamål och validera befintliga nummer för att säkerställa att de följer det officiella formatet och verifieringsalgoritmen.

Oavsett om du är utvecklare som testar applikationer som hanterar argentinska skatte-ID, en QA-specialist som verifierar systemfunktionalitet, eller helt enkelt behöver förstå hur dessa identifieringsnummer fungerar, erbjuder detta verktyg en rak lösning utan onödiga komplikationer. Verktyget har två primära funktioner: en generator som skapar giltiga CUIT/CUIL-nummer slumpmässigt eller baserat på specifika parametrar, och en validator som verifierar om ett givet CUIT/CUIL-nummer följer rätt format och beräkningsregler.

CUIT/CUIL Struktur och Beräkning

Förstå Formatet

Ett giltigt CUIT/CUIL-nummer består av 11 siffror som vanligtvis visas i formatet XX-XXXXXXXX-X:

Typkod (de första 2 siffrorna): Indikerar enhetstyp
- 20, 23, 24: Manliga individer (CUIL)
- 27: Kvinnliga individer (CUIL)
- 30, 33, 34: Företag och organisationer (CUIT)
DNI-nummer (de mittersta 8 siffrorna): För individer är detta deras nationella identitetsdokumentnummer (DNI), fyllt med ledande nollor om det behövs för att nå 8 siffror. För företag är detta ett unikt tilldelat nummer.
Verifieringssiffra (den sista siffran): En kontrollsiffra som beräknas med en specifik algoritm för att validera hela numret.

Beräkning av Verifieringssiffra

Verifieringssiffran beräknas med följande algoritm:

Ta de första 10 siffrorna av CUIT/CUIL (typkod + DNI)
Multiplicera varje siffra med en motsvarande vikt från denna sekvens: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
Summera alla resulterande produkter
Beräkna 11 minus resten av summan dividerad med 11
Om resultatet är 11, är verifieringssiffran 0
Om resultatet är 10, är verifieringssiffran 9
Annars är resultatet verifieringssiffran

Matematiskt kan detta uttryckas som:

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

Där:

$VD$ är verifieringssiffran
$d_i$ är den $i$ :te siffran av de första 10 siffrorna
$w_i$ är den motsvarande vikten från sekvensen [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
Särskilda fall: om $VD = 11$ då $VD = 0$ , om $VD = 10$ då $VD = 9$

Steg-för-Steg Guide

Använda Generatorn

Välj fliken "Generator" högst upp i verktygsgränssnittet.
Välj en Typkod från rullgardinsmenyn:
- 20: Man (CUIL)
- 23: Företag (CUIT)
- 24: Tillfälligt företag (CUIT)
- 27: Kvinna (CUIL)
- 30: Bolag (CUIT)
- 33: Civilförening (CUIT)
- 34: Stiftelse (CUIT)
Ange ett DNI-nummer (valfritt):
- Skriv in ett 8-siffrigt DNI-nummer i det angivna fältet
- Om det lämnas tomt kommer verktyget att använda ett slumpmässigt genererat DNI
- Om du anger färre än 8 siffror kommer systemet att fylla med ledande nollor
Generera Slumptal DNI (valfritt):
- Klicka på knappen "Slumptal" för att generera ett slumpmässigt 8-siffrigt DNI-nummer
Se det Genererade CUIT/CUIL:
- Verktyget visar automatiskt ett giltigt CUIT/CUIL baserat på dina inmatningar
- Formatet kommer att vara XX-XXXXXXXX-X med rätt verifieringssiffra
Kopiera Resultatet:
- Klicka på kopieringsikonen för att kopiera det genererade CUIT/CUIL till ditt urklipp
- Ett bekräftelsemeddelande visas när det har kopierats framgångsrikt

Använda Validatorn

Välj fliken "Validator" högst upp i verktygsgränssnittet.
Ange CUIT/CUIL att Validera:
- Skriv in CUIT/CUIL i formatet XX-XXXXXXXX-X
- Verktyget kommer automatiskt att formatera din inmatning med bindestreck när du skriver
- Du kan också ange numret utan bindestreck (XXXXXXXXXXX)
Klicka på "Validera"-knappen:
- Verktyget kommer att kontrollera formatet, typkoden och verifieringssiffran
Se Valideringsresultatet:
- För giltiga CUIT/CUIL-nummer kommer ett grönt framgångsmeddelande att visas
- För ogiltiga nummer kommer ett rött felmeddelande att förklara problemet:
  - Ogiltigt format (måste vara XX-XXXXXXXX-X)
  - Ogiltig typkod (måste vara en av: 20, 23, 24, 27, 30, 33, 34)
  - Ogiltig verifieringssiffra
Ytterligare Information:
- För giltiga nummer visar verktyget en uppdelning av komponenterna:
  - Typkod och dess betydelse
  - DNI-nummer
  - Verifieringssiffra

Användningsfall

Utveckling och Testning

Programvaruutveckling: Generera giltiga CUIT/CUIL-nummer för att testa applikationer som hanterar argentinska skatteidentifieringar, såsom:
- E-handelsplattformar
- Bokföringsprogram
- HR-hanteringssystem
- Statliga tjänsteportaler
- Bankapplikationer
Databasfyllning: Skapa realistiska testdata för system som lagrar argentinsk användarinformation, vilket säkerställer att databasbegränsningar och valideringsregler fungerar korrekt.
Formulärvalideringstestning: Testa inmatningsvalidering för webbformulär som samlar in CUIT/CUIL-information, vilket verifierar att rätt felmeddelanden visas för ogiltiga inmatningar.
API-testning: Generera giltiga payloads för API-slutpunkter som kräver CUIT/CUIL-nummer, vilket säkerställer att dina integrationstester använder giltiga data.
QA Automation: Integrera CUIT/CUIL-generering i automatiserade testskript för att skapa dynamiska testfall istället för att använda statiska testdata.

Utbildningssyften

Lära sig Valideringsalgoritmer: Förstå hur kontrollsifferalgoritmer fungerar i praktiken genom att se CUIT/CUIL-verifieringsprocessen i aktion.
Undervisa Data Validering: Använd som ett utbildningsexempel när du lär ut formulärvalideringstekniker till nya utvecklare.
Förstå Argentinska Affärskrav: Lär dig om identifieringssystemet som används i Argentina för internationell affärsutveckling.

Alternativ

Även om vårt verktyg erbjuder ett enkelt sätt att generera och validera CUIT/CUIL-nummer, finns det alternativa tillvägagångssätt som du kan överväga:

Officiell Regeringsvalidering: För produktionsmiljöer, validera alltid CUIT/CUIL-nummer mot den officiella AFIP (Administración Federal de Ingresos Públicos) databasen när det är möjligt.
Bibliotek och Paket: Flera programmeringsspråk har bibliotek som är specifikt utformade för argentinsk skatte-ID-validering:
- JavaScript: validar-cuit npm-paket
- PHP: afip-php bibliotek
- Python: py-cuit paket
Manuell Beräkning: För utbildningssyften kan du beräkna verifieringssiffran manuellt med hjälp av algoritmen som beskrivs tidigare.
Omfattande Affärsvalideringstjänster: För företagsapplikationer, överväg att använda omfattande valideringstjänster som inte bara kontrollerar formatet utan också verifierar existensen och statusen för enheten kopplad till CUIT/CUIL.

Historik om CUIT/CUIL Systemet

CUIT/CUIL identifieringssystemet i Argentina har utvecklats avsevärt sedan sin början:

Ursprunget och Implementering

CUIT (Clave Única de Identificación Tributaria) introducerades först i Argentina på 1970-talet som en del av ansträngningarna att modernisera skatteinsamlingssystemet. Den federala administrationsmyndigheten för offentliga inkomster (AFIP) implementerade denna unika identifierare för att spåra skattebetalare mer effektivt och minska skatteflykt.

CUIL (Clave Única de Identificación Laboral) introducerades senare för att specifikt identifiera arbetare i det sociala trygghetssystemet, vilket skapade en distinktion mellan skatteidentifiering och arbetsidentifiering samtidigt som man behöll ett konsekvent format.

Utveckling och Digitalisering

Under 1990-talet, när Argentina genomgick betydande ekonomiska reformer, blev CUIT/CUIL-systemet allt viktigare för att spåra ekonomisk aktivitet. Systemet digitaliserades ytterligare, och onlineverifieringssystem implementerades.

I början av 2000-talet sågs integrationen av CUIT/CUIL-systemet med olika digitala statliga tjänster, vilket gjorde det till en avgörande komponent i Argentinas e-regeringsinitiativ. Denna period såg också standardiseringen av verifieringsalgoritmen och formatet som fortfarande används idag.

Senaste Utvecklingar

Under de senaste åren har AFIP förbättrat säkerhets- och verifieringsprocesserna för CUIT/CUIL-nummer, implementerat mer sofistikerade valideringssystem och integrerat dem med andra statliga databaser. Systemet spelar nu en avgörande roll i Argentinas strävan att bekämpa skatteflykt och formalisera ekonomin.

Idag används CUIT/CUIL inte bara för skatte- och anställningsändamål utan också för en rad aktiviteter inklusive bankverksamhet, fastighetstransaktioner, nyttjande av tjänster och onlineköp, vilket gör det till en avgörande identifierare för både individer och företag som verkar i Argentina.

Kodexempel

Python

1def calculate_verification_digit(type_code, dni):
2    # Konvertera till sträng och säkerställ att DNI är 8 siffror med ledande nollor
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # Kombinera typkod och DNI
7    digits = type_code_str + dni_str
8    
9    # Vikter för varje position
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # Beräkna summan av produkterna
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # Beräkna verifieringssiffran
16    verification_digit = 11 - (sum_products % 11)
17    
18    # Särskilda fall
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    # Giltiga typkoder
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"Ogiltig typkod. Måste vara en av: {valid_type_codes}")
34    
35    # Generera slumpmässigt DNI om det inte anges
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # Beräkna verifieringssiffran
40    verification_digit = calculate_verification_digit(type_code, dni)
41    
42    # Formatera CUIT/CUIL
43    return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46    # Ta bort bindestreck om de finns
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # Kontrollera grundläggande format
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "Ogiltigt format"
52    
53    # Extrahera delar
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    # Validera typkod
59    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60    if type_code not in valid_type_codes:
61        return False, "Ogiltig typkod"
62    
63    # Beräkna och jämför verifieringssiffran
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "Ogiltig verifieringssiffra"
67    
68    return True, "Giltig CUIT/CUIL"
69
70# Exempelanvändning
71print(generate_cuit_cuil(20, 12345678))  # Generera för specifik DNI
72print(generate_cuit_cuil(27))  # Generera med slumpmässig DNI
73print(validate_cuit_cuil("20-12345678-9"))  # Validera en CUIT/CUIL
74

JavaScript

1function calculateVerificationDigit(typeCode, dni) {
2  // Konvertera till sträng och säkerställ att DNI är 8 siffror med ledande nollor
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // Kombinera typkod och DNI
7  const digits = typeCodeStr + dniStr;
8  
9  // Vikter för varje position
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // Beräkna summan av produkterna
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // Beräkna verifieringssiffran
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // Särskilda fall
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  // Giltiga typkoder
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`Ogiltig typkod. Måste vara en av: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // Generera slumpmässigt DNI om det inte anges
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // Beräkna verifieringssiffran
45  const verificationDigit = calculateVerificationDigit(typeCode, dni);
46  
47  // Formatera CUIT/CUIL
48  return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52  // Ta bort bindestreck om de finns
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // Kontrollera grundläggande format
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'Ogiltigt format' };
58  }
59  
60  // Extrahera delar
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  // Validera typkod
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'Ogiltig typkod' };
69  }
70  
71  // Beräkna och jämför verifieringssiffran
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'Ogiltig verifieringssiffra' };
75  }
76  
77  return { isValid: true };
78}
79
80// Exempelanvändning
81console.log(generateCuitCuil(20, 12345678)); // Generera för specifik DNI
82console.log(generateCuitCuil(27)); // Generera med slumpmässig DNI
83console.log(validateCuitCuil("20-12345678-9")); // Validera en 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        // Konvertera till sträng och säkerställ att DNI är 8 siffror med ledande nollor
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // Kombinera typkod och DNI
15        String digits = typeCodeStr + dniStr;
16        
17        // Beräkna summan av produkterna
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // Beräkna verifieringssiffran
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // Särskilda fall
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("Ogiltig typkod. Måste vara en av: " + VALID_TYPE_CODES);
39        }
40        
41        // Generera slumpmässigt DNI om det inte anges
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // Beräkna verifieringssiffran
48        int verificationDigit = calculateVerificationDigit(typeCode, dni);
49        
50        // Formatera CUIT/CUIL
51        return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52    }
53    
54    public static ValidationResult validateCuitCuil(String cuitCuil) {
55        // Ta bort bindestreck om de finns
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // Kontrollera grundläggande format
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "Ogiltigt format");
61        }
62        
63        // Extrahera delar
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        // Validera typkod
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "Ogiltig typkod");
71        }
72        
73        // Beräkna och jämför verifieringssiffran
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "Ogiltig verifieringssiffra");
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        // Exempelanvändning
102        System.out.println(generateCuitCuil(20, 12345678)); // Generera för specifik DNI
103        System.out.println(generateCuitCuil(27, null)); // Generera med slumpmässig DNI
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Validera en CUIT/CUIL
105    }
106}
107

PHP

1<?php
2
3function calculateVerificationDigit($typeCode, $dni) {
4    // Konvertera till sträng och säkerställ att DNI är 8 siffror med ledande nollor
5    $typeCodeStr = (string)$typeCode;
6    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
7    
8    // Kombinera typkod och DNI
9    $digits = $typeCodeStr . $dniStr;
10    
11    // Vikter för varje position
12    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
13    
14    // Beräkna summan av produkterna
15    $sumProducts = 0;
16    for ($i = 0; $i < 10; $i++) {
17        $sumProducts += (int)$digits[$i] * $weights[$i];
18    }
19    
20    // Beräkna verifieringssiffran
21    $verificationDigit = 11 - ($sumProducts % 11);
22    
23    // Särskilda fall
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    // Giltiga typkoder
35    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
36    
37    if (!in_array($typeCode, $validTypeCodes)) {
38        throw new Exception("Ogiltig typkod. Måste vara en av: " . implode(', ', $validTypeCodes));
39    }
40    
41    // Generera slumpmässigt DNI om det inte anges
42    if ($dni === null) {
43        $dni = rand(10000000, 99999999);
44    }
45    
46    // Beräkna verifieringssiffran
47    $verificationDigit = calculateVerificationDigit($typeCode, $dni);
48    
49    // Formatera CUIT/CUIL
50    return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit);
51}
52
53function validateCuitCuil($cuitCuil) {
54    // Ta bort bindestreck om de finns
55    $cuitCuilClean = str_replace('-', '', $cuitCuil);
56    
57    // Kontrollera grundläggande format
58    if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
59        return ['isValid' => false, 'errorMessage' => 'Ogiltigt format'];
60    }
61    
62    // Extrahera delar
63    $typeCode = (int)substr($cuitCuilClean, 0, 2);
64    $dni = (int)substr($cuitCuilClean, 2, 8);
65    $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
66    
67    // Validera typkod
68    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
69    if (!in_array($typeCode, $validTypeCodes)) {
70        return ['isValid' => false, 'errorMessage' => 'Ogiltig typkod'];
71    }
72    
73    // Beräkna och jämför verifieringssiffran
74    $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
75    if ($calculatedDigit !== $verificationDigit) {
76        return ['isValid' => false, 'errorMessage' => 'Ogiltig verifieringssiffra'];
77    }
78    
79    return ['isValid' => true];
80}
81
82// Exempelanvändning
83echo generateCuitCuil(20, 12345678) . "\n"; // Generera för specifik DNI
84echo generateCuitCuil(27) . "\n"; // Generera med slumpmässig DNI
85var_dump(validateCuitCuil("20-12345678-9")); // Validera en CUIT/CUIL
86?>
87

Vanliga Frågor

Vad är skillnaden mellan CUIT och CUIL?

CUIT (Clave Única de Identificación Tributaria) används för skatteidentifieringsändamål och tilldelas både individer och juridiska enheter som behöver betala skatt i Argentina. CUIL (Clave Única de Identificación Laboral) är specifikt för arbetstagare och används för arbets- och socialförsäkringsändamål. Även om de delar samma format och beräkningsalgoritm, tjänar de olika administrativa ändamål.

Vilka typkoder används för individer och vilka för företag?

För individer:

20, 23, 24: Manliga individer (CUIL)
27: Kvinnliga individer (CUIL)

För företag och organisationer:

30: Bolag (CUIT)
33: Civilföreningar (CUIT)
34: Stiftelser (CUIT)

Hur beräknas verifieringssiffran?

Verifieringssiffran beräknas med en viktad summalgoritm. Varje av de första 10 siffrorna multipliceras med en motsvarande vikt (5, 4, 3, 2, 7, 6, 5, 4, 3, 2), och resultaten summeras. Verifieringssiffran är 11 minus resten när denna summa divideras med 11. Särskilda fall: om resultatet är 11, är verifieringssiffran 0; om resultatet är 10, är verifieringssiffran 9.

Kan jag använda detta verktyg för att generera riktiga, officiella CUIT/CUIL-nummer?

Nej, detta verktyg är avsett för test- och utbildningsändamål endast. De nummer som genereras är matematiskt giltiga enligt CUIT/CUIL-algoritmen men är inte officiellt registrerade hos de argentinska skattemyndigheterna (AFIP). För officiell CUIT/CUIL-registrering måste individer och företag följa de korrekta lagliga procedurerna genom AFIP.

Varför misslyckas min CUIT/CUIL-validering även om formatet ser korrekt ut?

Valideringen kan misslyckas av flera skäl:

Typkoden är inte en av de giltiga koderna (20, 23, 24, 27, 30, 33, 34)
Verifieringssiffran matchar inte det beräknade värdet baserat på algoritmen
Formatet är felaktigt (ska vara XX-XXXXXXXX-X)
Det finns icke-numeriska tecken i inmatningen (förutom bindestreck)

Är bindestreck nödvändiga i CUIT/CUIL-nummer?

Även om CUIT/CUIL-nummer vanligtvis skrivs och visas med bindestreck (XX-XXXXXXXX-X), är bindestrecken inte en del av det faktiska numret för beräkningsändamål. Vår validator accepterar båda formaten (med eller utan bindestreck) och kommer att validera antingen format korrekt.

Kan ett CUIT/CUIL-nummer ha färre än 8 siffror i DNI-delen?

Nej, DNI-delen måste alltid vara exakt 8 siffror. Om det faktiska DNI har färre siffror måste det fyllas med ledande nollor för att nå 8 siffror. Till exempel, om någons DNI är 1234567, skulle det i CUIT/CUIL representeras som 01234567.

Hur kan jag verifiera om en CUIT/CUIL är officiellt registrerad i Argentina?

För att verifiera om en CUIT/CUIL är officiellt registrerad och aktiv, bör du använda den officiella AFIP (Administración Federal de Ingresos Públicos) webbplatsen eller tjänster. Vårt verktyg verifierar endast den matematiska giltigheten av numret, inte dess officiella registreringsstatus.

Kan jag använda detta verktyg i min kommersiella applikation?

Ja, du kan integrera algoritmen och logiken som demonstreras i detta verktyg i dina kommersiella applikationer. CUIT/CUIL-valideringsalgoritmen är en offentlig standard. För produktionsmiljöer rekommenderar vi dock att implementera korrekt felhantering och överväga ytterligare validering mot officiella källor när det är nödvändigt.

Lagrar verktyget några av de genererade eller validerade CUIT/CUIL-nummer?

Nej, detta verktyg lagrar ingen av den information som anges eller genereras. All bearbetning sker på klientsidan i din webbläsare, och ingen data skickas till eller lagras på våra servrar. Detta säkerställer integriteten och säkerheten för all information du anger.

Referenser

AFIP (Administración Federal de Ingresos Públicos). "CUIT/CUIL/CDI." Officiell webbplats. 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). "Obtener mi CUIL." https://www.anses.gob.ar/
Boletín Oficial de la República Argentina. "Resolución General AFIP 2854/2010: Procedimiento. Clave Única de Identificación Tributaria (C.U.I.T.)."
Código Fiscal de la República Argentina. "Identificación y Registro de Contribuyentes."

Redo att generera eller validera argentinska CUIT/CUIL-nummer? Prova vårt verktyg nu och förenkla din testprocess!

Argentinsk CUIT/CUIL-generator och valideringsverktyg

CUIT/CUIL-generator

Genererat CUIT/CUIL

Dokumentation