CUIT/CUIL Generator & Validator | Argentinsk skatte-ID-verktyg

Argentinsk CUIT/CUIL-generator och validering

Introduktion

I Argentinas skatte- och arbetsystem stöter du ständigt på två kritiska identifierare: CUIT (Clave Única de Identificación Tributaria) och CUIL (Clave Única de Identificación Laboral). Tänk på CUIT som skatte-ID för företag och individer som betalar skatt, medan CUIL identifierar arbetstagare i socialförsäkringssystemet. Båda använder samma 11-siffriga format och verifieringsalgoritm, vilket gör testning av applikationer som hanterar dessa nummer särskilt viktigt.

När du utvecklar programvara för den argentinska marknaden behöver du giltiga testdata. Det är där detta verktyg kommer in. Du kan generera matematiskt korrekta CUIT/CUIL-nummer för testning utan att använda riktiga personuppgifter, eller validera befintliga nummer för att säkerställa att de överensstämmer med AFIP:s officiella algoritm. Det som är särskilt användbart är att verktyget hanterar både genererings- (skapa giltiga nummer på begäran) och valideringssidan (fånga formatfel, ogiltiga typkoder och felaktiga verifieringssiffror innan de orsakar produktionsproblem).

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. Här är hur det bryts ner:

1. Typkod (första 2 siffrorna): Identifierar enhetstypen

   • 20, 23, 24: Manliga individer (CUIL)
   • 27: Kvinnliga individer (CUIL)
   • 30, 33, 34: Företag och organisationer (CUIT)

2. DNI-nummer (mellansta 8 siffrorna): För individer är detta deras nationella identitetsdokumentnummer (DNI). Ett vanligt misstag: om det faktiska DNI har färre än 8 siffror måste du fylla på med inledande nollor. Till exempel blir DNI 1234567 01234567 i CUIT/CUIL. Företag får ett unikt tilldelat nummer istället.

3. Verifieringssiffra (sista siffran): Denna kontrollsiffra validerar hela numret med hjälp av en viktad algoritm. Om denna siffra inte matchar beräkningen är hela CUIT/CUIL ogiltigt—något som ofta överraskar utvecklare när de manuellt konstruerar testdata.

Beräkning av verifieringssiffra

Verifieringssiffran använder en modulo-11 viktad algoritm. Så här fungerar det:

1. Ta de första 10 siffrorna i CUIT/CUIL (typkod + DNI)
2. Multiplicera varje siffra med sin motsvarande vikt: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
3. Summera alla produkter
4. Beräkna: 11 minus (summa modulo 11)
5. Hantera gränsfall: om resultatet är 11, använd 0; om det är 10, använd 9

Det som oftast förvirrar folk är just dessa gränsfall i steg 5. När du testar får du ibland ett resultat på 10 eller 11, och att glömma bort att mappa dessa till 9 respektive 0 orsakar valideringsfel som kan vara svåra att felsöka om du inte är medveten om denna regel.

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 motsvarande vikt från sekvensen [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
• Specialfall: om $VD = 11$ då $VD = 0$, om $VD = 10$ då $VD = 9$

Steg-för-steg-guide

Använda generatorn

1. Välj fliken "Generator" längst upp i verktygets gränssnitt.

2. Välj en typkod från rullgardinsmenyn:

   • 20: Man (CUIL)
   • 23: Företag (CUIT)
   • 24: Tillfälligt företag (CUIT)
   • 27: Kvinna (CUIL)
   • 30: Aktiebolag (CUIT)
   • 33: Civilförening (CUIT)
   • 34: Stiftelse (CUIT)

3. Ange ett DNI-nummer (valfritt):

   • Mata 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 på med inledande nollor

4. Generera slumpmässigt DNI (valfritt):

   • Klicka på knappen "Slumpmässig" för att generera ett slumpmässigt 8-siffrigt DNI-nummer

5. Visa genererad CUIT/CUIL:

   • Verktyget visar automatiskt en giltig CUIT/CUIL baserat på dina inmatningar
   • Formatet kommer att vara XX-XXXXXXXX-X med rätt verifieringssiffra

6. Kopiera resultatet:

   • Klicka på kopieringsikonen för att kopiera den genererade CUIT/CUIL till urklipp
   • Ett bekräftelsemeddelande visas när kopieringen är slutförd

Använda validatorn

1. Välj fliken "Validator" längst upp i verktygets gränssnitt.

2. Ange CUIT/CUIL att validera:

   • Mata in CUIT/CUIL i formatet XX-XXXXXXXX-X
   • Verktyget formaterar automatiskt din inmatning med bindestreck när du skriver
   • Du kan också ange numret utan bindestreck (XXXXXXXXXXX)

3. Klicka på knappen "Validera":

   • Verktyget kontrollerar format, typkod och verifieringssiffra

4. Visa valideringsresultatet:

   • För giltiga CUIT/CUIL-nummer visas ett grönt framgångsmeddelande
   • För ogiltiga nummer visas ett rött felmeddelande som förklarar 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

5. Ytterligare information:

   • För giltiga nummer visar verktyget en uppdelning av komponenterna:
     • Typkod och dess betydelse
     • DNI-nummer
     • Verifieringssiffra

Vanliga misstag och bästa praxis

När du arbetar med CUIT/CUIL-validering i dina applikationer, var uppmärksam på dessa vanliga fallgropar:

Nollutfyllnadsproblem: Det vanligaste felet jag har stött på handlar om DNI-nummer med inledande nollor. När någon anger DNI "1234567" behöver din kod behandla det som "01234567" för CUIT/CUIL-konstruktion. Många implementationer konverterar till heltal för bearbetning, vilket tar bort inledande nollor. Använd strängoperationer med korrekt utfyllnad istället.

Typkodförvirring: Inte alla tvåsiffriga nummer är giltiga typkoder. Endast 20, 23, 24, 27, 30, 33, 34 fungerar. Jag har sett system som accepterar valfri tvåsiffrig prefix, vilket leder till "giltigt utseende" nummer som 21-12345678-X som misslyckas med AFIP-validering. Validera alltid typkoden innan du beräknar verifieringssiffran.

Könsmissuppfattningar: Typkod 20 (man) och 27 (kvinna) är inte utbytbara. Om du automatiskt genererar CUILer baserat på demografiska data, se till att din typkod matchar det kön som är registrerat hos RENAPER (Argentinas nationella register). Felaktigheter leder till avvisande när individer försöker använda dessa nummer med statliga tjänster.

Bindestreckhantering: Vissa implementationer kräver bindestreck medan andra avvisar dem. Bästa praxis: acceptera båda format i inmatningsfält (med eller utan bindestreck), ta bort bindestreck före validering, lagra den obundna versionen i databaser och lägg endast till bindestreck för visningsändamål.

Saknad verifiering: Algoritmsvalidering fångar formatfel men bekräftar inte att CUIT/CUIL är registrerad. I produktionsmiljö, validera format först (snabbt), verifiera sedan mot AFIP:s databas (långsammare men auktoritativt). Detta tvåstegsangreppssätt fångar stavfel omedelbart samtidigt som det säkerställer att numret är verkligt.

Gränsfallstestning: Testa alltid med verifieringssiffror 0 och 9 - dessa resultera från specialfall i algoritmen. Testa också DNI:er som börjar med nollor för att säkerställa att din utfyllnadslogik fungerar korrekt.

Användningsfall och praktiska tillämpningar

Utveckling och testning

Mjukvaruutveckling: När du bygger applikationer för den argentinska marknaden behöver du testdata som klarar validering utan att använda riktiga användaruppgifter. Här blir detta kritiskt:

• E-handelplattformar: Betalningsprocessorer och faktureringssystem kräver giltiga CUIT/CUIL-nummer. Under belastningstester kan du behöva tusentals giltiga nummer för att simulera realistiska användarregistreringar.
• Redovisningsprogram: Skatterapporteringsmoduler verifierar CUIT/CUIL-format innan inlämning till AFIP. Testning av dessa valideringsregler kräver nummer som klarar kontrollsiffrans algoritm.
• HR-hanteringssystem: Lönehantering och socialförsäkringsavgifter är beroende av giltiga CUIL-nummer. Ett vanligt scenario: du testar anställningsflöden och behöver verifiera att ogiltiga CUIL-nummer utlöser lämpliga felmeddelanden.
• Bankapplikationer: KYC-processer (Know Your Customer) validerar CUIT/CUIL som en del av kontoöppningen. Enligt min erfarenhet dyker gränsfallsscenarier som typkodsmatchningsfel ofta upp under integrationstestning.

Databaspopulering: När du seedar testdatabaser säkerställer användning av algoritmiskt giltiga CUIT/CUIL-nummer att dina databasbegränsningar och utlösare fungerar som förväntat. Detta är särskilt viktigt när du testar datamigrationsscript eller ETL-processer som validerar identifikationsnummer.

Formulärvalideringstestning: Testa både den lyckade vägen och felförhållanden. Generera giltiga nummer för att bekräfta lyckad inskickning, modifiera sedan verifieringssiffran för att säkerställa att din frontend- och backend-validering fångar felet innan det når din databas.

API-testning: Integrationstester bör använda giltiga CUIT/CUIL-nummer i begärandeinnehållet. Detta förhindrar falska negativa resultat där tester misslyckas på grund av ogiltig testdata snarare än faktiska buggar i din API-logik.

QA-automatisering: Parametriserade tester gynnas av dynamisk CUIT/CUIL-generering. Istället för att hårdkoda testvärden som kan konfliktera mellan testkörningar, generera nya giltiga nummer för varje testexekvering.

Utbildningssyfte

Lära sig valideringsalgoritmer: CUIT/CUIL-verifieringsalgoritmen visar praktisk tillämpning av modulo-aritmetik och viktade kontrollsiffror. Samma mönster förekommer i andra identifieringssystem världen över—kreditkortnummer (Luhn-algoritm), ISBN-koder och europeiska momsnummer använder liknande viktade kontrollsummeansatser. Att förstå hur CUIT/CUIL-validering fungerar ger insikt i varför dessa algoritmer finns: de fångar upp avskrivningsfel som omkastade siffror eller enstaka siffermisstag.

Undervisa datavalidering: När du utbildar juniora utvecklare i inmatningsvalidering erbjuder CUIT/CUIL-systemet ett verkligt exempel som är mer komplext än e-postvalidering men enklare än kryptografisk verifiering. Det demonstrerar principen om försvar på djupet: formatvalidering (11 siffror), affärsregelvalidering (giltiga typkoder) och algoritmisk validering (kontrollsiffra).

Internationell affärsutveckling: Om du bygger system för latinamerikanska marknader hjälper förståelsen av CUIT/CUIL dig att förstå liknande system i grannländerna. Brasilien har CPF/CNPJ, Chile har RUT, och Uruguay har RUT—alla använder kontrollsiffersalgoritmer. De mönster du lär dig här överförs till dessa system.

Alternativ och produktionsöverväganden

Medan detta verktyg fungerar bra för utveckling och testning har produktionsmiljöer olika krav:

Officiell statlig validering: För live-applikationer räcker algoritmisk validering inte—du behöver verifiera att CUIT/CUIL faktiskt är registrerat hos AFIP (Administración Federal de Ingresos Públicos). AFIP tillhandahåller webbtjänster för realtidsvalidering, även om du behöver registrera och autentisera dig för att komma åt dem. Kruxet: ett nummer kan vara matematiskt giltigt men inte officiellt tilldelat, så implementera alltid båda valideringsnivåerna i produktionen.

Bibliotek och paket: Om du integrerar CUIT/CUIL-validering i din kodbas, överväg dessa etablerade bibliotek snarare än att skapa din egen:

• JavaScript: validar-cuit på npm hanterar validering och formatering
• PHP: afip-php-biblioteket tillhandahåller både validering och AFIP-webbtjänsteintegrering
• Python: py-cuit på PyPI implementerar hela algoritmen

Att använda underhållna bibliotek minskar risken för implementeringsfel och inkluderar ofta gränsfallsscenarier som du kan missa i anpassad kod.

Manuell beräkning: I utbildningssyfte eller för felsökning hjälper det att arbeta igenom algoritmen för hand. Ta fram en kalkylator och ett exempel-CUIT/CUIL, följ sedan den viktade multiplikationsprocessen steg för steg.

Företagsvalideringstjänster: Storskaliga applikationer kan dra nytta av tredjepartsvaliterings-API:er som inte bara kontrollerar format utan också korshänvisar mot kommersiella databaser. Dessa tjänster kan flagga inaktiva företag, identifiera sanktionerade enheter eller tillhandahålla ytterligare metadata om CUIT/CUIL-innehavaren.

CUIT/CUIL-systemets historia

CUIT/CUIL-identifieringssystemet i Argentina har utvecklats avsevärt sedan dess tillkomst:

Ursprung 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. Federala skattemyndigheten (AFIP) implementerade denna unika identifierare för att spåra skattebetalare mer effektivt och minska skattefusk.

CUIL (Clave Única de Identificación Laboral) introducerades senare för att specifikt identifiera arbetstagare i socialförsäkringssystemet, vilket skapade en åtskillnad mellan skatteidentifiering och arbetsidentifiering samtidigt som ett konsekvent format bibehölls.

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 online-verifieringssystem implementerades.

I början av 2000-talet skedde en integration av CUIT/CUIL-systemet med olika digitala statliga tjänster, vilket gjorde det till en väsentlig del av Argentinas e-förvaltningsinitiativ. Under denna period standardiserades även verifieringsalgoritmen och formatet som fortfarande används idag.

Senaste utvecklingen

Under de senaste åren har AFIP förbättrat säkerhets- och verifieringsprocesserna för CUIT/CUIL-nummer genom att implementera mer sofistikerade valideringssystem och integrera dem med andra statliga databaser. Systemet spelar nu en avgörande roll i Argentinas ansträngningar att bekämpa skattefusk och formalisera ekonomin.

Idag används CUIT/CUIL inte bara för skatte- och sysselsättningsändamål utan också för ett brett spektrum av aktiviteter, inklusive bankverksamhet, fastighetsaffärer, samhällstjänster och onlineköp, vilket gör den till en väsentlig identifierare för både individer och företag som verkar i Argentina.

Implementeringsöverväganden

Vid implementering av CUIT/CUIL-validering i egna system, överväg dessa tekniska aspekter:

Algoritmstabilitet: Den nuvarande CUIT/CUIL-verifieringsalgoritmen har förblivit oförändrad sedan dess standardisering på 1990-talet. Enligt AFIP:s tekniska dokumentation är modulo-11-viktad checksiffra kodifierad i Resolución General 2854/2010 och efterföljande föreskrifter. Denna stabilitet innebär att implementeringar sällan behöver uppdateringar, men du bör övervaka AFIP:s meddelanden om eventuella regeländringar.

Prestandaoptimering: Verifieringsalgoritmen är beräkningsmässigt billig—bara 10 multiplikationer, en addition och en modulo-operation. För system med hög genomströmning som bearbetar tusentals valideringar per sekund är flaskhalsen vanligtvis nätverksfördröjning vid verifiering mot AFIP:s databas, inte algoritmen själv. Överväg att cacha AFIP-verifieringsresultat med lämpliga TTL:er (vanligtvis 24 timmar) för att balansera aktualitet med prestanda.

Teckenkodning: Vid bearbetning av CUIT/CUIL-data från externa källor (PDF:er, skannade dokument, webbskrapning), var uppmärksam på problem med teckenkodning. Bindestreck kan visas som em dash (U+2014), en dash (U+2013) eller minustecken (U+2212) istället för standard bindestreck-minus (U+002D). Normalisera dessa innan validering för att förhindra falska negativa resultat.

Internationalisering: Om din applikation betjänar flera latinamerikanska marknader, notera att Argentinas CUIT/CUIL använder modulo-11 med specifika vikter, medan Chiles RUT använder modulo-11 med olika vikter, och Brasiliens CPF/CNPJ använder modulo-11 med ännu ett annat mönster. Anta inte att algoritmerna är identiska—varje lands system har distinkta regler. För en bredare förståelse av checksiffersalgoritmer, se ISO/IEC 7064-standarden som formaliserar olika modulo-baserade verifieringsscheman.

Databaslagring: Lagra CUIT/CUIL-nummer utan bindestreck som fast längd CHAR(11) eller som BIGINT om din databas stöder 11-siffriga heltal utan precisionstapp. Lägg till en kontrollbegränsning som validerar verifieringssiffran på databasnivå som ett säkerhetsnät mot korrupterade data. Skapa index på detta fält för effektiva sökningar när användare söker efter CUIT/CUIL.

Kodexempel

Python

JavaScript

Java

PHP

<?php

function calculateVerificationDigit($typeCode, $dni) {
    // Konvertera till sträng och säkerställ att DNI är 8 siffror med inledande nollor
    $typeCodeStr = (string)$typeCode;
    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
    
    // Kombinera typkod och DNI
    $digits = $typeCodeStr . $dniStr;
    
    // Vikter för varje position
    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
    
    // Beräkna summan av produkter
    $sumProducts = 0;
    for ($i = 0; $i < 10; $i++) {
        $sumProducts += (int)$digits[$i] * $weights[$i];
    }
    
    // Beräkna verifieringssiffra
    $verificationDigit = 11 - ($sumProducts % 11);
    
    // Specialfall
    if ($verificationDigit == 11) {
        $verificationDigit = 0;
    } else if ($verificationDigit == 10) {
        $verificationDigit = 9;
    }
    
    return $verificationDigit;
}

function generateCuitCuil($typeCode, $dni = null) {
    // Giltiga typkoder
    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
    
    if (!in_array($typeCode, $validTypeCodes)) {
        throw new Exception("Ogiltig typkod. Måste vara en av: " . implode(', ', $validTypeCodes));
    }
    
    // Generera slumpmässig DNI om ingen anges
    if ($dni === null) {
        $dni = rand(10000000, 99999999);
    }
    
    // Beräkna verifieringssiffra
    $verificationDigit = calculateVerificationDigit($typeCode, $dni);
    
    // Formatera CUIT/CUIL
    return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit);
}

function validateCuitCuil($cuitCuil) {
    // Ta bort bindestreck om de finns
    $cuitCuilClean = str_replace('-', '', $cuitCuil);
    
    // Kontrollera grundformat
    if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
        return ['isValid' => false, 'errorMessage' => 'Ogiltigt format'];
    }
    
    // Extrahera delar
    $typeCode = (int)substr($cuitCuilClean, 0, 2);
    $dni = (int)substr($cuitCuilClean, 2, 8);
    $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
    
    // Validera typkod
    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
    if (!in_array($typeCode, $validTypeCodes)) {
        return ['isValid' => false, 'errorMessage' => 'Ogiltig typkod'];
    }
    
    // Beräkna och jämför verifieringssiffra
    $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
    if ($calculatedDigit !== $verificationDigit) {

## Vanliga frågor

### Vad är skillnaden mellan CUIT och CUIL?

Här är den praktiska skillnaden: **CUIT** (Clave Única de Identificación Tributaria) identifierar skattebetalare—både individer och företag som lämnar in skatter till AFIP. **CUIL** (Clave Única de Identificación Laboral) identifierar arbetstagare i socialförsäkringssystemet för anställning och pensionering.

I praktiken har många individer både ett CUIL (från deras första jobb) och kan senare få ett CUIT (om de blir egenföretagare eller startar ett företag). Numren använder identisk formatering och beräkningsregler, så ur valideringssynpunkt hanterar man dem på samma sätt. Skillnaden är viktig för administrativa ändamål: lönesystem arbetar vanligtvis med CUIL, medan fakturerings- och skattesystem använder CUIT.

### Vilka typkoder används för individer respektive företag?

För individer:
- 20, 23, 24: Manliga individer (CUIL)
- 27: Kvinnliga individer (CUIL)

För företag och organisationer:
- 30: Aktiebolag (CUIT)
- 33: Civila föreningar (CUIT)
- 34: Stiftelser (CUIT)

### Hur beräknas kontrollsiffran?

Algoritmen använder viktad multiplikation: ta var och en av de första 10 siffrorna, multiplicera med vikterna **5, 4, 3, 2, 7, 6, 5, 4, 3, 2**, summera produkterna, och sedan beräkna 11 minus (summa modulo 11).

Två specialfall kan förvirra folk: när beräkningen ger 11, använd 0 som kontrollsiffra; när den ger 10, använd 9. Dessa specialfall finns eftersom kontrollsiffran måste vara en enda siffra (0-9). Detta är en modulo-11 kontrollsiffersalgoritm, liknande den som används i ISBN-10-koder och andra identifieringssystem världen över.

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

Nej—detta verktyg genererar matematiskt giltiga testdata, men numren är inte officiellt registrerade hos AFIP. Tänk på det som att generera ett giltigt kreditkortsnummer med Luhn-algoritmen: det klarar formatvalidering, men är inte kopplat till ett riktigt konto.

För officiell CUIT/CUIL-registrering måste individer besöka AFIP med sitt DNI, medan företag måste slutföra bolagsregistreringsprocedurer. Verktyget är strikt för utveckling, testning och utbildningsändamål där du behöver giltigt utseende data som inte kommer att konfliktera med riktiga identifieringsnummer.

### Varför misslyckas min CUIT/CUIL-validering trots att formatet ser korrekt ut?

När validering misslyckas trots korrekt formatering, kontrollera dessa vanliga orsaker:

1. **Ogiltig typkod**: Endast 20, 23, 24, 27, 30, 33, 34 är giltiga. Användning av 21, 25 eller andra nummer kommer att misslyckas.
2. **Felaktig kontrollsiffra**: Den sista siffran måste matcha algoritmens beräkning. Även att ändra en siffra i DNI-delen kräver omberäkning av kontrollsiffran.
3. **Formatproblem**: Måste vara exakt 11 siffror (XX-XXXXXXXX-X). Se upp för extra mellanslag eller saknade inledande nollor.
4. **Dolda tecken**: Kopiering och inklistring från PDF:er eller webbplatser kan ibland introducera osynliga Unicode-tecken som bryter validering.

Ett snabbt felsöknings-tips: ta bort den sista siffran och beräkna om den manuellt. Om den inte matchar, är det där problemet ligger.

### Krävs bindestreck i CUIT/CUIL-nummer?

Bindestreck är endast för visningsformatering—de ingår inte i det faktiska numret för beräkningsändamål. När du ser **20-12345678-9**, bryr sig algoritmen bara om de 11 siffrorna: **20123456789**.

De flesta valideringsimplementationer tar bort bindestreck innan bearbetning, vilket är varför vårt verktyg accepterar både **20-12345678-9** och **20123456789**. I API:er och databaser lagrar du vanligtvis den obundna versionen och lägger till bindestreck endast när du visar för användare. Detta tillvägagångssätt förhindrar att formateringsinkonsekvent orsakar valideringsfel.

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

DNI-delen måste alltid vara exakt 8 siffror—inga undantag. Om någons faktiska DNI har färre siffror (vilket händer med äldre, lägre numrerade DNI:er), fyller du på med inledande nollor.

Till exempel blir DNI **1234567** till **01234567** i CUIT/CUIL-strukturen. Detta är en vanlig källa till buggar när man konverterar mellan DNI och CUIT/CUIL-format. Jag har sett system misslyckas med validering eftersom de glömt att fylla på, och behandlar **1234567** som ett 7-siffrigt nummer istället för **01234567**. Använd alltid nollpåfyllningsfunktioner i din kod snarare än enkel strängsammansättning.

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

Vårt verktyg validerar den matematiska korrektheten—format, typkod och kontrollsiffra. Men det kan inte avgöra om numret faktiskt är registrerat hos AFIP eller tillhör en verklig person eller ett verkligt företag.

För officiell verifiering, använd [AFIP:s webbtjänster](https://www.afip.gob.ar/) eller deras "Constancia de Inscripción" sökverktyg. AFIP erbjuder API:er för automatiserad verifiering, även om du behöver registrera dig som utvecklare och autentisera. I produktionsmiljöer, implementera båda lagren: kör först algoritmisk validering (snabb, fångar stavfel och formatfel), och verifiera sedan mot AFIP:s databas (långsammare, men bekräftar att numret är verkligt och aktivt).

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

Ja—CUIT/CUIL-valideringsalgoritmen är en offentlig standard definierad av AFIP, så du kan fritt implementera den i kommersiell programvara. Kodexemplen här är avsedda som referensimplementationer.

För produktionsanvändning, överväg dessa bästa praxis: implementera korrekt felhantering för specialfall, lägg till loggning för felsökning av valideringsfel, validera mot AFIP:s officiella databas (inte bara algoritmisk validering), och håll din implementation uppdaterad om AFIP ändrar reglerna (även om den nuvarande algoritmen har varit stabil i årtionden).

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

Nej—all bearbetning sker i din webbläsare (klientsidan). När du genererar eller validerar en CUIT/CUIL, körs beräkningen lokalt med JavaScript. Ingenting skickas till våra servrar, och vi loggar, lagrar eller spårar inga nummer du matar in eller genererar.

Detta klientsidiga tillvägagångssätt säkerställer integritet och innebär också att verktyget fungerar offline när sidan har laddats. Du kan verifiera detta genom att öppna din webbläsares utvecklarverktyg och titta på nätverksfliken—du kommer att se inga förfrågningar skickas när du genererar eller validerar nummer.

## Referenser

1. AFIP (Federal Administration of Public Revenue). "CUIT/CUIL/CDI." Officiell webbplats. [https://www.afip.gob.ar/](https://www.afip.gob.ar/)

2. Arbets-, sysselsättnings- och socialförsäkringsdepartementet. "CUIL - Unik Arbetsidentifikationsnyckel." [https://www.argentina.gob.ar/trabajo](https://www.argentina.gob.ar/trabajo)

3. ANSES (Nationell Administration för Social Trygghet). "Erhåll min CUIL." [https://www.anses.gob.ar/](https://www.anses.gob.ar/)

4. Officiell tidning för Argentinska Republiken. "Generell resolution AFIP 2854/2010: Förfarande. Unik Skatteidentifikationsnyckel (C.U.I.T.)."

5. Skattelag för Argentinska Republiken. "Identifiering och registrering av skattebetalare."

---

Oavsett om du bygger ett faktureringssystem, testar anställningsflöden eller lär dig om valideringsalgoritmer, tillhandahåller detta verktyg CUIT/CUIL-generering och validering som du behöver. Generera testdata som klarar algoritmisk validering, verifiera nummer innan de når din databas eller utforska hur kontrollsiffrans algoritm fungerar i praktiken.