CUIT/CUIL Generator & Validator | Argentinsk Skatte-ID-værktøj

Argentinsk CUIT/CUIL Generator og Validator

Introduktion

I Argentinas skatte- og arbejdssystemer vil du konstant støde på to kritiske identifikatorer: CUIT (Clave Única de Identificación Tributaria) og CUIL (Clave Única de Identificación Laboral). Tænk på CUIT som skatte-ID'et for virksomheder og enkeltpersoner, der betaler skat, mens CUIL identificerer arbejdere i det sociale sikringssystem. Begge bruger det samme 11-cifrede format og verificeringsalgoritme, hvilket gør test af applikationer, der håndterer disse numre, særligt vigtige.

Når du udvikler software til det argentinske marked, har du brug for gyldige testdata. Det er her dette værktøj kommer ind i billedet. Du kan generere matematisk korrekte CUIT/CUIL-numre til test uden at bruge rigtige personoplysninger eller validere eksisterende numre for at sikre, at de overholder AFIP's officielle algoritme. Det særligt nyttige er, at værktøjet håndterer både genererings- (oprettelse af gyldige numre efter behov) og valideringssiden (fange formatfejl, ugyldige typekoder og forkerte verificeringstal, før de forårsager produktionsproblemer).

CUIT/CUIL Struktur og Beregning

Forståelse af Formatet

Et gyldigt CUIT/CUIL-nummer består af 11 cifre, som typisk vises i formatet XX-XXXXXXXX-X. Sådan er det opdelt:

1. Typekode (første 2 cifre): Identificerer enheds type

   • 20, 23, 24: Mandlige individer (CUIL)
   • 27: Kvindelige individer (CUIL)
   • 30, 33, 34: Virksomheder og organisationer (CUIT)

2. DNI-nummer (midterste 8 cifre): For individer er dette deres nationale identitetsdokumentnummer (DNI). En almindelig faldgrube: hvis den faktiske DNI har færre end 8 cifre, skal du udfylde med nuller foran. For eksempel bliver DNI 1234567 til 01234567 i CUIT/CUIL. Virksomheder modtager i stedet et unikt tildelt nummer.

3. Verificeringscifre (sidste ciffer): Dette kontrolciffer validerer hele nummeret ved hjælp af en vægtet algoritme. Hvis dette ciffer ikke matcher beregningen, er hele CUIT/CUIL ugyldigt - noget der hyppigt overrasker udviklere, når de manuelt konstruerer testdata.

Verificeringscifre Beregning

Verificeringscifferet bruger en modulo-11 vægtet algoritme. Sådan fungerer det:

1. Tag de første 10 cifre i CUIT/CUIL (typekode + DNI)
2. Multiplicer hvert ciffer med dets tilsvarende vægt: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
3. Summer alle produkter
4. Beregn: 11 minus (sum modulo 11)
5. Håndter grænsetilfælde: hvis resultatet er 11, bruges 0; hvis det er 10, bruges 9

Det, der oftest forvirrer folk, er disse grænsetilfælde i trin 5. Ved test vil du lejlighedsvis få et resultat på 10 eller 11, og glemmer du at kortlægge disse til 9 og 0 henholdsvis, forårsager det valideringsfejl, der kan være vanskelige at debugge, hvis du ikke er opmærksom på denne regel.

Matematisk kan dette udtrykkes som:

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

Hvor:

• $VD$ er verificeringscifferet
• $d_i$ er det $i$-te ciffer i de første 10 cifre
• $w_i$ er den tilsvarende vægt fra sekvensen [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
• Specialtilfælde: hvis $VD = 11$ så $VD = 0$, hvis $VD = 10$ så $VD = 9$

Trinvis Vejledning

Brug af Generatoren

1. Vælg "Generator" fanen øverst i værktøjsgrænsefladen.

2. Vælg en Type Kode fra rullemenuen:

   • 20: Mand (CUIL)
   • 23: Virksomhed (CUIT)
   • 24: Midlertidig Virksomhed (CUIT)
   • 27: Kvinde (CUIL)
   • 30: Selskab (CUIT)
   • 33: Civilforening (CUIT)
   • 34: Fond (CUIT)

3. Indtast et DNI-nummer (valgfrit):

   • Indtast et 8-cifret DNI-nummer i det angivne felt
   • Hvis det efterlades tomt, vil værktøjet bruge et tilfældigt genereret DNI
   • Hvis du indtaster færre end 8 cifre, vil systemet udfylde med foranstillede nuller

4. Generer Tilfældigt DNI (valgfrit):

   • Klik på "Tilfældig" knappen for at generere et tilfældigt 8-cifret DNI-nummer

5. Vis den Genererede CUIT/CUIL:

   • Værktøjet viser automatisk en gyldig CUIT/CUIL baseret på dine input
   • Formatet vil være XX-XXXXXXXX-X med det korrekte verificeringsciffer

6. Kopier Resultatet:

   • Klik på kopiikonet for at kopiere den genererede CUIT/CUIL til din udklipsholder
   • En bekræftelsesmeddelelse vises, når kopieringen er gennemført

Brug af Validatoren

1. Vælg "Validator" fanen øverst i værktøjsgrænsefladen.

2. Indtast CUIT/CUIL til Validering:

   • Indtast CUIT/CUIL i formatet XX-XXXXXXXX-X
   • Værktøjet vil automatisk formatere dit input med bindestreger, mens du skriver
   • Du kan også indtaste nummeret uden bindestreger (XXXXXXXXXXX)

3. Klik på "Valider" Knappen:

   • Værktøjet vil kontrollere formatet, typekoden og verificeringscifrene

4. Vis Validationsresultatet:

   • For gyldige CUIT/CUIL-numre vises en grøn succesmeddelelse
   • For ugyldige numre vises en rød fejlmeddelelse, der forklarer problemet:
     • Ugyldigt format (skal være XX-XXXXXXXX-X)
     • Ugyldig typekode (skal være en af: 20, 23, 24, 27, 30, 33, 34)
     • Ugyldigt verificeringsciffer

5. Yderligere Oplysninger:

   • For gyldige numre viser værktøjet en oversigt over komponenterne:
     • Typekode og dens betydning
     • DNI-nummer
     • Verificeringsciffer

Almindelige Fejl og Bedste Praksis

Når du arbejder med CUIT/CUIL-validering i dine applikationer, så vær opmærksom på disse hyppige faldgruber:

Nul-Padding-problemer: Den mest almindelige fejl, jeg har stødt på, involverer DNI-numre med førende nuller. Når nogen indtaster DNI "1234567", skal din kode behandle det som "01234567" ved CUIT/CUIL-konstruktion. Mange implementeringer konverterer til heltal til behandling, hvilket fjerner førende nuller. Brug strengoperationer med korrekt padding i stedet.

Type-kode Forvirring: Ikke alle to-cifrede tal er gyldige type-koder. Kun 20, 23, 24, 27, 30, 33, 34 fungerer. Jeg har set systemer, der accepterer enhver to-cifret præfiks, hvilket fører til "gyldigt-udseende" numre som 21-12345678-X, der fejler AFIP-validering. Valider altid type-koden før beregning af verificationscifrene.

Køns-antagelser: Type-kode 20 (mand) og 27 (kvinde) er ikke udskiftelige. Hvis du automatisk genererer CUILer baseret på demografiske data, skal du sikre, at din type-kode matcher det faktiske køn registreret hos RENAPER (Argentinas nationale register). Uoverensstemmelser medfører afvisning, når enkeltpersoner forsøger at bruge disse numre med statslige tjenester.

Bindestreg-håndtering: Nogle implementeringer kræver bindestreger, mens andre afviser dem. Bedste praksis: accepter begge formater i inputfelter (med eller uden bindestreger), fjern bindestreger før validering, gem den ubindestregede version i databaser og tilføj kun bindestreger til visningsformål.

Manglende Verifikation: Algoritmevalidering fanger formatfejl, men bekræfter ikke, at CUIT/CUIL er registreret. I produktion skal du validere format først (hurtigt), derefter verificere mod AFIP's database (langsommere men autoritativ). Denne to-trins tilgang fanger stavefejl øjeblikkeligt, mens den stadig sikrer, at nummeret er gyldigt.

Grænsetilfælde-test: Test altid med verificationstal 0 og 9 - disse stammer fra specialtilfælde i algoritmen. Test også DNI'er, der starter med nuller for at sikre, at din padding-logik fungerer korrekt.

Use Cases og Praktiske Anvendelser

Udvikling og Test

Softwareudvikling: Når du bygger applikationer til det argentinske marked, har du brug for testdata, der passerer validering uden at bruge rigtige brugeroplysninger. Her bliver dette kritisk:

• E-handelsplatforme: Betalingsprocessorer og faktureringssystemer kræver gyldige CUIT/CUIL-numre. Under belastningstests kan du have brug for tusindvis af gyldige numre for at simulere realistiske brugerregistreringer.
• Regnskabssoftware: Skatteindberetningsmoduler verificerer CUIT/CUIL-format inden indsendelse til AFIP. Test af disse valideringsregler kræver numre, der passerer checksumalgoritmen.
• HR-administrationssystemer: Lønbehandling og sociale sikringsbidrag afhænger af gyldige CUIL-numre. Et typisk scenarie: du tester medarbejderonboarding-forløb og har brug for at verificere, at ugyldige CUILer udløser passende fejlmeddelelser.
• Bankapplikationer: KYC-processer (Know Your Customer) validerer CUIT/CUIL som en del af kontooprettelsen. I min erfaring dukker grænsetilfælde som type-kode-uoverensstemmelser ofte op under integrationstest.

Databasepopulation: Når du udfylder testdatabaser, sikrer brugen af algoritmisk gyldige CUIT/CUIL-numre, at dine databasebegrænsninger og udløsere fungerer som forventet. Dette er særligt vigtigt ved test af datamigrationsscripts eller ETL-processer, der validerer identifikationsnumre.

Formularvalideringstest: Test både den ideelle vej og fejlbetingelser. Generer gyldige numre for at bekræfte vellykket indsendelse, og modificer derefter verificeringscifferet for at sikre, at din frontend- og backend-validering opfanger fejlen, før den når din database.

API-test: Integrationstests bør bruge gyldige CUIT/CUIL-numre i request-payloads. Dette forhindrer falske negativer, hvor tests mislykkes på grund af ugyldige testdata snarere end faktiske fejl i din API-logik.

QA-automatisering: Parameteriserede tests har fordel af dynamisk CUIT/CUIL-generering. I stedet for at hardcode testværdier, der måske konflikter på tværs af testkørsler, genereres nye gyldige numre for hver testudførelse.

Uddannelsesmæssige Formål

Læring af Valideringsalgoritmer: CUIT/CUIL-verificeringsalgoritmen demonstrerer praktisk anvendelse af modulo-aritmetik og vægtede checksumcifre. Dette samme mønster forekommer i andre identifikationssystemer verden over—kreditkortnumre (Luhn-algoritmen), ISBN-koder og europæiske momsnumre bruger alle lignende vægtede checksummetoder. At forstå, hvordan CUIT/CUIL-validering fungerer, giver indsigt i, hvorfor disse algoritmer eksisterer: de opfanger transskriptionsfejl som ombyttede cifre eller enkeltcifrede fejl.

Undervisning i Datavalidering: Når man træner juniordevelopere i inputvalidering, tilbyder CUIT/CUIL-systemet et virkelighedsnært eksempel, der er mere komplekst end e-mail-validering, men enklere end kryptografisk verificering. Det demonstrerer princippet om forsvar i dybden: formatvalidering (11 cifre), forretningsregelvalidering (gyldige type-koder) og algoritmisk validering (checksumcifre).

International Forretningsudvikling: Hvis du bygger systemer til latinamerikanske markeder, hjælper forståelsen af CUIT/CUIL dig med at forstå lignende systemer i nabolande. Brasilien har CPF/CNPJ, Chile har RUT, og Uruguay har RUT—alle bruger checksumalgoritmer. De mønstre, du lærer her, overføres til disse systemer.

Alternativer og Produktionshensyn

Mens dette værktøj fungerer godt til udvikling og test, har produktionsmiljøer forskellige krav:

Officiel Statslig Validering: For live-applikationer er algoritmisk validering alene ikke nok—du skal verificere, at CUIT/CUIL faktisk er registreret hos AFIP (Administración Federal de Ingresos Públicos). AFIP tilbyder webtjenester til realtidsvalidering, selvom du skal registrere og autentificere dig for at få adgang. Pointen er: et nummer kan være matematisk gyldigt, men ikke officielt tildelt, så implementer altid begge valideringslag i produktionen.

Biblioteker og Pakker: Hvis du integrerer CUIT/CUIL-validering i din kodebase, kan du overveje disse etablerede biblioteker fremfor at lave din egen:

• JavaScript: validar-cuit på npm håndterer validering og formatering
• PHP: afip-php-biblioteket tilbyder både validering og AFIP-webtjenesteintegration
• Python: py-cuit på PyPI implementerer den fulde algoritme

Brug af vedligeholdte biblioteker reducerer risikoen for implementeringsfejl og inkluderer ofte grænsetilfælde, som du måske ville overse i brugerdefineret kode.

Manuel Beregning: Til læreformål eller fejlfinding hjælper manuel gennemgang af algoritmen med at befæste forståelsen. Tag en lommeregner og et eksempel-CUIT/CUIL, og følg derefter den vægtede multiplikationsproces trin for trin.

Enterprise Validerings-tjenester: Store applikationer kan have fordel af tredjepartsvaliderings-API'er, der ikke blot checker format, men også krydshenviser kommercielle databaser. Disse tjenester kan markere inaktive virksomheder, identificere sanktionerede enheder eller levere yderligere metadata om CUIT/CUIL-indehaveren.

CUIT/CUIL-systemets historie

CUIT/CUIL-identifikationssystemet i Argentina har udviklet sig betydeligt siden dets begyndelse:

Oprindelse og implementering

CUIT (Clave Única de Identificación Tributaria) blev første gang introduceret i Argentina i 1970'erne som en del af bestræbelserne på at modernisere skatteopkrævningssystemet. Den Føderale Administration for Offentlige Indtægter (AFIP) implementerede denne entydige identifikator for mere effektivt at spore skatteborgere og reducere skattesvig.

CUIL (Clave Única de Identificación Laboral) blev senere introduceret til specifikt at identificere arbejdstagere i socialsikringssystemet, hvorved der blev skabt en forskel mellem skattemæssig identifikation og arbejdsmæssig identifikation, samtidig med at der blev opretholdt et konsistent format.

Udvikling og digitalisering

I 1990'erne, hvor Argentina gennemgik betydelige økonomiske reformer, blev CUIT/CUIL-systemet stadig vigtigere for at spore økonomisk aktivitet. Systemet blev yderligere digitaliseret, og online verificeringssystemer blev implementeret.

Begyndelsen af 2000'erne så integrationen af CUIT/CUIL-systemet med forskellige digitale statslige tjenester, hvilket gjorde det til en væsentlig komponent i Argentinas e-government-initiativer. Denne periode så også standardiseringen af verificeringsalgoritmen og formatet, som stadig er i brug i dag.

Seneste udviklinger

I de seneste år har AFIP forbedret sikkerheds- og verificeringsprocesserne for CUIT/CUIL-numre ved at implementere mere sofistikerede valideringssystemer og integrere dem med andre statslige databaser. Systemet spiller nu en afgørende rolle i Argentinas bestræbelser på at bekæmpe skattesvig og formalisere økonomien.

I dag bruges CUIT/CUIL ikke kun til skatte- og beskæftigelsesmæssige formål, men også til en bred vifte af aktiviteter, herunder bank, ejendomstransaktioner, forsyningsydelser og online køb, hvilket gør det til en væsentlig identifikator for både enkeltpersoner og virksomheder, der opererer i Argentina.

Implementeringsovervejelser

Ved implementering af CUIT/CUIL-validering i dine egne systemer skal du overveje disse tekniske aspekter:

Algoritme Stabilitet: Den nuværende CUIT/CUIL-verificeringsalgoritme har været uændret siden dens standardisering i 1990'erne. Ifølge AFIP's tekniske dokumentation er modulo-11 vægtet check-ciffer-tilgangen kodificeret i Resolución General 2854/2010 og efterfølgende forskrifter. Denne stabilitet betyder, at implementeringer sjældent behøver opdateringer, men du bør overvåge AFIP-meddelelser for eventuelle regulatoriske ændringer.

Performanceoptimering: Verificeringsalgoritmen er beregningsmæssigt billig - blot 10 multiplikationer, en addition og en modulo-operation. For højtydende systemer, der behandler tusindvis af valideringer pr. sekund, er flaskehalsen typisk netværksventetid ved verificering mod AFIP's database, ikke algoritmen selv. Overvej at cache AFIP-verificeringsresultater med passende TTL'er (typisk 24 timer) for at balancere aktualitet med ydeevne.

Tegnkodning: Når du behandler CUIT/CUIL-data fra eksterne kilder (PDF'er, scannede dokumenter, webscrapning), skal du være opmærksom på tegnkodningsproblemer. Bindestregen kan fremstå som en lang tankestreg (U+2014), en kort tankestreg (U+2013) eller et minustegn (U+2212) i stedet for den standard bindestreg-minus (U+002D). Normaliser disse før validering for at forhindre falske negative resultater.

Internationalisering: Hvis din applikation betjener flere latinamerikanske markeder, skal du bemærke, at Argentinas CUIT/CUIL bruger modulo-11 med specifikke vægte, mens Chiles RUT bruger modulo-11 med forskellige vægte, og Brasiliens CPF/CNPJ bruger modulo-11 med endnu et andet mønster. Antag ikke, at algoritmerne er identiske - hvert lands system har særskilte regler. For en bredere forståelse af check-ciffer-algoritmer, se ISO/IEC 7064-standarden, som formaliserer forskellige modulo-baserede verificeringsordninger.

Databaselagring: Gem CUIT/CUIL-numre uden bindestreger som fast længde CHAR(11) eller som BIGINT, hvis din database understøtter 11-cifrede heltal uden præcisionstab. Tilføj en check-begrænsning, der validerer verificeringscifferet på databaseniveau som en sikkerhedsnet mod korrupte data. Opret indeks på dette felt for effektive opslag, når brugere søger efter CUIT/CUIL.

Kodeeksempler

Python

JavaScript

Java

PHP

<?php

function calculateVerificationDigit($typeCode, $dni) {
    // Konverter til streng og sikr, at DNI er 8 cifre med førende nuller
    $typeCodeStr = (string)$typeCode;
    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
    
    // Kombiner type-kode og DNI
    $digits = $typeCodeStr . $dniStr;
    
    // Vægte for hver position
    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
    
    // Beregn sum af produkter
    $sumProducts = 0;
    for ($i = 0; $i < 10; $i++) {
        $sumProducts += (int)$digits[$i] * $weights[$i];
    }
    
    // Beregn verificationsciffer
    $verificationDigit = 11 - ($sumProducts % 11);
    
    // Specialtilfælde
    if ($verificationDigit == 11) {
        $verificationDigit = 0;
    } else if ($verificationDigit == 10) {
        $verificationDigit = 9;
    }
    
    return $verificationDigit;
}

function generateCuitCuil($typeCode, $dni = null) {
    // Gyldige type-koder
    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
    
    if (!in_array($typeCode, $validTypeCodes)) {
        throw new Exception("Ugyldig type-kode. Skal være en af: " . implode(', ', $validTypeCodes));
    }
    
    // Generer tilfældig DNI, hvis ikke angivet
    if ($dni === null) {
        $dni = rand(10000000, 99999999);
    }
    
    // Beregn verificationsciffer
    $verificationDigit = calculateVerificationDigit($typeCode, $dni);
    
    // Formater CUIT/CUIL
    return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit);
}

function validateCuitCuil($cuitCuil) {
    // Fjern bindestreger, hvis til stede
    $cuitCuilClean = str_replace('-', '', $cuitCuil);
    
    // Kontroller grundlæggende format
    if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
        return ['isValid' => false, 'errorMessage' => 'Ugyldigt format'];
    }
    
    // Udtræk dele
    $typeCode = (int)substr($cuitCuilClean, 0, 2);
    $dni = (int)substr($cuitCuilClean, 2, 8);
    $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
    
    // Valider type-kode
    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
    if (!in_array($typeCode, $validTypeCodes)) {
        return ['isValid' => false, 'errorMessage' => 'Ugyldig type-kode'];
    }
    
    // Beregn og sammenlign verificationsciffer
    $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
    if ($calculatedDigit !== $verificationDigit) {
        return ['isValid' => false, 'errorMessage' => 'Ugyldigt verificationsciffer'];

## Ofte stillede spørgsmål

### Hvad er forskellen mellem CUIT og CUIL?

Her er den praktiske forskel: **CUIT** (Clave Única de Identificación Tributaria) identificerer skattepligtige - både enkeltpersoner og virksomheder, der indgiver skat til AFIP. **CUIL** (Clave Única de Identificación Laboral) identificerer arbejdere i socialsikringssystemet til beskæftigelses- og pensionsformål.

I praksis har mange enkeltpersoner både et CUIL (fra deres første job) og kan senere få et CUIT (hvis de bliver selvstændige eller starter en virksomhed). Numrene bruger identisk formatering og beregningsregler, så fra et valideringssynspunkt håndterer du dem på samme måde. Forskellen har betydning for administrative formål: lønsystemer arbejder typisk med CUIL, mens fakturerings- og skattesystemer bruger CUIT.

### Hvilke typekoder bruges til enkeltpersoner og virksomheder?

For enkeltpersoner:
- 20, 23, 24: Mandlige enkeltpersoner (CUIL)
- 27: Kvindelige enkeltpersoner (CUIL)

For virksomheder og organisationer:
- 30: Selskaber (CUIT)
- 33: Civile foreninger (CUIT)
- 34: Fonde (CUIT)

### Hvordan beregnes kontrolcifret?

Algoritmen bruger vægtet multiplikation: tag hver af de første 10 cifre, multiplicer med vægtene **5, 4, 3, 2, 7, 6, 5, 4, 3, 2**, summer produkterne, og beregn derefter 11 minus (sum modulo 11).

To grænsetilfælde forvirrer folk: når beregningen giver 11, bruges 0 som kontrolcifret; når den giver 10, bruges 9. Disse specialtilfælde eksisterer, fordi kontrolcifret skal være et enkelt ciffer (0-9). Dette er en modulo-11 checksumalgoritme, svarende til den, der bruges i ISBN-10-koder og andre identifikationssystemer verden over.

### Kan jeg bruge dette værktøj til at generere rigtige, officielle CUIT/CUIL-numre?

Nej - dette værktøj genererer matematisk gyldige testdata, men numrene er ikke officielt registreret hos AFIP. Tænk på det som at generere et gyldigt kreditkortnummer ved hjælp af Luhn-algoritmen: det består formatvalidering, men er ikke forbundet med en rigtig konto.

Til officiel CUIT/CUIL-registrering skal enkeltpersoner besøge AFIP med deres DNI, mens virksomheder skal gennemføre virksomhedsregistreringsprocedurer. Værktøjet er udelukkende til udvikling, test og uddannelsesmæssig brug, hvor du har brug for gyldigt udseende data, der ikke vil komme i konflikt med rigtige identifikationsnumre.

### Hvorfor mislykkes min CUIT/CUIL-validering, selvom formatet ser korrekt ud?

Når validering mislykkes trods korrekt formatering, så tjek disse almindelige årsager:

1. **Ugyldig typekode**: Kun 20, 23, 24, 27, 30, 33, 34 er gyldige. Brug af 21, 25 eller andre numre vil fejle.
2. **Forkert kontrolciffer**: Det sidste ciffer skal matche algoritmens beregning. Selv at ændre ét ciffer i DNI-delen kræver genberegning af kontrolcifret.
3. **Formatproblemer**: Skal være nøjagtigt 11 cifre (XX-XXXXXXXX-X). Vær opmærksom på ekstra mellemrum eller manglende førende nuller.
4. **Skjulte tegn**: Kopiering fra PDF'er eller websites kan nogle gange introducere usynlige Unicode-tegn, der ødelægger validering.

Et hurtigt fejlfindingstip: fjern det sidste ciffer og genberegn det manuelt. Hvis det ikke matcher, er det din syndebuk.

### Er bindestreger påkrævet i CUIT/CUIL-numre?

Bindestreger er kun til visningsformatering - de indgår ikke i selve nummeret ved beregning. Når du ser **20-12345678-9**, bekymrer algoritmen sig kun om de 11 cifre: **20123456789**.

De fleste valideringsimplementeringer fjerner bindestreger før behandling, hvilket er grunden til, at vores værktøj accepterer både **20-12345678-9** og **20123456789**. I API'er og databaser vil du typisk gemme den ubundne version og tilføje bindestreger kun ved visning for brugere. Denne tilgang forhindrer, at formateringsinkonsistenser forårsager valideringsfejl.

### Kan et CUIT/CUIL-nummer have færre end 8 cifre i DNI-delen?

DNI-delen skal altid være nøjagtigt 8 cifre - ingen undtagelser. Hvis en persons faktiske DNI har færre cifre (hvilket sker med ældre, lavere nummererede DNI'er), udfyldes der med førende nuller.

For eksempel bliver DNI **1234567** til **01234567** i CUIT/CUIL-strukturen. Dette er en hyppig kilde til fejl ved konvertering mellem DNI og CUIT/CUIL-formater. Jeg har set systemer fejle ved validering, fordi de glemte at udfylde, og behandlede **1234567** som et 7-cifret nummer i stedet for **01234567**. Brug altid nul-udfyldningsfunktioner i din kode i stedet for simpel strengsammenkædning.

### Hvordan kan jeg verificere, om et CUIT/CUIL er officielt registreret i Argentina?

Vores værktøj validerer den matematiske korrekthed - format, typekode og kontrolciffer. Men det kan ikke fortælle dig, om nummeret er faktisk registreret hos AFIP eller tilhører en rigtig person eller virksomhed.

Til officiel verificering bruges [AFIP's webtjenester](https://www.afip.gob.ar/) eller deres "Constancia de Inscripción" opslagsværktøj. AFIP tilbyder API'er til automatisk verificering, selvom du skal registreres som udvikler og autentificeres. I produktionsmiljøer implementeres begge lag: først køres algoritmisk validering (hurtig, fanger stavefejl og formatfejl), derefter verificeres mod AFIP's database (langsommere, men bekræfter, at nummeret er rigtigt og aktivt).

### Kan jeg bruge dette værktøj i min kommercielle applikation?

Ja - CUIT/CUIL-valideringsalgoritmen er en offentlig standard defineret af AFIP, så du kan frit implementere den i kommerciel software. Kodeeksemplerne her er beregnet som referenceimplementeringer.

Til produktionsbrug skal du overveje disse bedste praksisser: implementer korrekt fejlhåndtering for grænsetilfælde, tilføj logning til fejlfinding af valideringsfejl, valider mod AFIP's officielle database (ikke kun algoritmisk validering), og hold din implementering opdateret, hvis AFIP ændrer reglerne (selvom den nuværende algoritme har været stabil i årtier).

### Gemmer værktøjet nogle af de genererede eller validerede CUIT/CUIL-numre?

Nej - al behandling sker i din browser (på klientsiden). Når du genererer eller validerer et CUIT/CUIL, køres beregningen lokalt ved hjælp af JavaScript. Intet sendes til vores servere, og vi logger, gemmer eller sporer ingen numre, du indtaster eller genererer.

Denne klientsidebaserede tilgang sikrer privatliv og betyder også, at værktøjet fungerer offline, så snart siden indlæses. Du kan bekræfte dette ved at åbne din browsers udviklingsværktøjer og se på netværksfanen - du vil se ingen anmodninger sendt ved generering eller validering af numre.

## Referencer

1. AFIP (Administración Federal de Ingresos Públicos). "CUIT/CUIL/CDI." Officiel hjemmeside. [https://www.afip.gob.ar/](https://www.afip.gob.ar/)

2. Ministerio de Trabajo, Empleo y Seguridad Social. "CUIL - Clave Única de Identificación Laboral." [https://www.argentina.gob.ar/trabajo](https://www.argentina.gob.ar/trabajo)

3. ANSES (Administración Nacional de la Seguridad Social). "Få min CUIL." [https://www.anses.gob.ar/](https://www.anses.gob.ar/)

4. Officielt tidsskrift for Den Argentinske Republik. "Generel resolution AFIP 2854/2010: Procedure. Clave Única de Identificación Tributaria (C.U.I.T.)."

5. Skattelov for Den Argentinske Republik. "Identifikation og registrering af skattepligtige."

---

Uanset om du bygger et faktureringssystem, tester medarbejder onboarding-forløb eller lærer om valideringsalgoritmer, tilbyder dette værktøj CUIT/CUIL-generering og -validering, som du har brug for. Generer testdata, der består algoritmisk validering, verificer numre, før de rammer din database, eller udforsk, hvordan check-ciffer-algoritmen fungerer i praksis.