Spring til indhold
🛠️
Whiz Tools

CNPJ Generator & Validator - Brasiliansk Forretnings-ID-værktøj

Generer gyldige CNPJ-numre til test eller validér brasilianske forretnings-ID'er øjeblikkeligt. Gratis værktøj med check-ciffer-verificering for udviklere, der arbejder med Cadastro Nacional da Pessoa Jurídica.

Brasiliansk CNPJ Generator og Validator

CNPJ Generator

Generer et gyldigt brasiliansk CNPJ-nummer til testformål.

CNPJ Validator

Tjek om et brasiliansk CNPJ-nummer er gyldigt.

Indlæsningsberegner...
📚

Dokumentation

Forståelse af brasilianske CNPJ-numre

CNPJ (Cadastro Nacional da Pessoa Jurídica) er Brasiliens version af et selskabsskatte-ID - et 14-cifret nummer, der identificerer hver juridisk virksomhedsenhed i landet. Hvis du bygger software, der håndterer brasilianske virksomhedsdata, vil du hurtigt støde på disse numre i registreringsformularer, fakturaer og API-integrationer.

Her er det, der gør dette værktøj praktisk: det genererer matematisk gyldige CNPJs til test uden at bruge rigtige virksomhedsidentifikatorer. Når du opretter en testdatabase med 1.000 poster eller debugger en valideringsrutine kl. 2 om natten, har du brug for CNPJs, der består algoritmiske tjek, men ikke utilsigtet matcher faktiske virksomheder. Det er præcis det, dette genererer.

De numre, der er oprettet her, følger den officielle Receita Federal (brasiliansk føderalt skattevæsen) valideringsalgoritme. De har korrekte kontrolcifre og korrekt formatering - de er blot ikke registreret i myndighedernes database. Tænk på dem som syntaktisk korrekte testdata, der ikke vil skabe overholdelsesmæssige problemer i dit udviklingsmiljø.

Hvad er en CNPJ og hvorfor den er vigtig

En CNPJ fungerer som Brasiliens virksomhedsidentifikator - svarende til et EIN i USA eller et selskabsregistreringsnummer i UK. Hver forretningsenhed, der opererer lovligt i Brasilien, skal have et, udstedt af Receita Federal (Føderale Skattemyndighed).

Du vil støde på CNPJs, når:

  • Behandling af betalinger: Brasilianske betalingsgateways kræver CNPJ-validering for handelskonto
  • Skattemæssig overholdelse: Hver faktura udstedt i Brasilien skal indeholde et gyldigt CNPJ
  • Virksomhedsregistrering: Statslige myndigheder bruger CNPJs til at spore juridiske enheder på tværs af systemer
  • Bankforretninger: Åbning af virksomhedskonti eller behandling af internationale overførsler
  • Import/eksport: Tolddokumentation kræver CNPJ-verificering
  • Statslige kontrakter: Offentlige udbudssystemer validerer CNPJs før accept af bud

Ud fra min erfaring med brasilianske e-handelplatforme er et af de mest almindelige integrationspunkter betalingsstrømmen, hvor brugere indtaster deres CNPJ til virksomhedskøb. Din valideringslogik skal fange formateringsfejl, før betalingsprocessoren gør det - ellers vil du se mislykkede transaktioner, som kunne have været forhindret.

CNPJ-struktur og format

Et CNPJ består af 14 cifre formateret som: XX.XXX.XXX/YYYY-ZZ

Nedbrydning af strukturen:

  1. Første 8 cifre (XX.XXX.XXX): Det grundlæggende registreringsnummer, der entydigt tildeles virksomheden
  2. Næste 4 cifre (/YYYY): Filial- eller etableringsidentifikator—/0001 angiver hovedkontor, mens /0002, /0003 repræsenterer filialer
  3. Sidste 2 cifre (-ZZ): Verificationstal beregnet gennem en vægtet algoritme

Eksempel: 12.345.678/0001-95

Det interessante ved filialidentifikatoren: når en virksomhed åbner flere lokationer, får hver de samme første 8 cifre, men et anderledes filnalnummer. Så hvis en detailkæde har 50 butikker, vil de have CNPJ'er, der ender med /0001 til /0050, alle med samme grundlæggende nummer. Dette gør det nemt at identificere, at flere CNPJ'er tilhører samme moderorganisation.

Kontrolcifrene er ikke tilfældige—de beregnes ved hjælp af en modulus-11-algoritme med specifikke vægtsekvenser. Dette designvalg, som er almindeligt i brasilianske administrative dokumenter, gør det matematisk vanskeligt at forfalske gyldige numre eller utilsigtet oprette gyldige numre gennem tastefejl.

Hvordan CNPJ-validering faktisk fungerer

Valideringsalgoritmen bruger en vægtet modulus-11-beregning. Her er logikken bag den:

Første kontrolciffer-beregning

  1. Tag de første 12 cifre og multiplicer hver med vægte: 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. Summer alle produkterne
  3. Divider summen med 11 og find resten
  4. Hvis resten < 2, er kontrolcifferet 0; ellers er det 11 - resten

Anden kontrolciffer-beregning

  1. Tag de første 13 cifre (inklusive første kontrolciffer) og multiplicer med vægte: 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. Summer alle produkterne
  3. Divider med 11 og find resten
  4. Hvis resten < 2, er kontrolcifferet 0; ellers er det 11 - resten

Hvorfor denne tilgang virker: Det vægtede multiplikationssystem skaber en unik sammenhæng mellem alle 12 grundcifre og de resulterende kontrolcifre. Ændring af blot et enkelt ciffer i grundnummeret producerer forskellige kontrolcifre, hvilket fanger almindelige overføringsfejl som at bytte om på to cifre (skrive 12.345 i stedet for 12.354).

En praktisk bemærkning: CNPJs med alle identiske cifre (som 11.111.111/1111-11) er automatisk ugyldige, selv hvis de består den matematiske kontrol. Receita Federal udelukker udtrykkelig disse mønstre for at forhindre trivielle tilfælde.

Sådan bruges CNPJ-generatoren og -validatoren

Generering af test-CNPJs

Har du brug for en gyldig CNPJ til din testdatabase? Sådan gør du:

  1. Klik på "Generer CNPJ"
  2. Værktøjet opretter et matematisk gyldigt nummer med det samme
  3. Klik på "Kopier" for at gemme det i udklipsholderen
  4. Indsæt det i dine testformularer, databasefrø eller enhedstest

Hver genereret CNPJ består alle algoritmiske valideringstjek, men er ikke registreret hos Receita Federal. Det betyder, at du frit kan bruge dem i udvikling uden at bekymre dig om utilsigtet at bruge en rigtig virksomheds identifikator.

Validering af CNPJ-numre

Har du en CNPJ, som du skal verificere? Validatoren klarer det:

  1. Indsæt eller skriv CNPJ'en i inputfeltet
  2. Vær ikke bekymret for formattering—det virker med 12345678000195 eller 12.345.678/0001-95
  3. Klik på "Validér"
  4. Få øjeblikkelig feedback om, hvorvidt checkcifre er korrekte

Hvad validatoren tjekker: korrekt længde (14 cifre), korrekte beregninger af checkcifre og udelukkelse af ugyldige mønstre som ens cifre. Hvad den ikke tjekker: hvorvidt CNPJ'en er registreret i den offentlige database—det kræver direkte forespørgsel hos Receita Federal.

Reelle Use Cases for CNPJ Generator og Validator

Softwareudvikling og Test

Database seeding: Når du opretter et staging-miljø med realistiske testdata, har du brug for dusinvis eller hundredvis af gyldige CNPJs. Manuelt at oprette disse er besværligt, og brug af rigtige virksomhedsidentifikatorer rejser privatlivsproblemer. Genererede CNPJs løser begge problemer.

Unit testing grænsetilfælde: Din validerings-funktion skal afvise 00.000.000/0000-00, men acceptere 11.222.333/0001-81. At have en generator giver dig hurtigt mulighed for at oprette både gyldige og bevidst ugyldige testtilfælde for at verificere, at din logik håndterer grænseforhold korrekt.

QA regressionstest: Når man tester registreringsformularer eller B2B-checkout-forløb, har QA-teams brug for friske testdata til hver kørsel. Et almindeligt problem, jeg har set: testmiljøer forurenes med de samme 5-6 CNPJs, der bruges gentagne gange, hvilket skjuler fejl, der kun vises med specifikke cifermønstre.

API integrationstest: Hvis du integrerer med brasilianske betalingsprocessorer som PagSeguro eller Mercado Pago, kræver deres sandkasse-miljøer ofte gyldig CNPJ-formatering. Matematikken skal være korrekt, selvom du ikke rammer produktionsdatabaser.

Databehandling og Validering

Rensning af importerede data: Du har modtaget en CSV med 10.000 brasilianske virksomhedsposter. Før behandling skal du identificere, hvilke CNPJs der er fejlformede. Ved at køre dem gennem validatoren markeres poster med stavefejl, afkortning eller forkerte kontrolcifre - hvilket sparer timer med efterfølgende fejlsøgning.

Klient-side formvalidering: At fange ugyldige CNPJs før indsendelse forbedrer brugeroplevelsen. Ingen vil udfylde en 20-felts registreringsformular for blot at få en fejl ved indsendelse, fordi de har byttet om på to cifre i deres CNPJ.

Data anonymisering til analyse: Når du forbereder produktionsdata til deling med analysehold eller eksterne partnere, skal du erstatte rigtige CNPJs med gyldige, men falske. Dette opretholder referentiel integritet i dit datasæt samtidig med, at det beskytter faktiske virksomhedsidentiteter.

Internationale Forretningsoperationer

Forståelse af brasilianske krav: Hvis du udvider til det brasilianske marked, vil du støde på CNPJ-krav i kontrakter, fakturaer og forsendelsesdokumentation. At have et værktøj til at eksperimentere med formatet hjælper dig med at forstå, hvad dine systemer skal håndtere.

Tredjepartsintegrationsspecifikationer: Når du gennemgår API-dokumentation fra brasilianske SaaS-udbydere, vil du ofte se CNPJ-felter i payload-eksempler. At kunne generere gyldige testværdier hjælper dig med hurtigere at prototype integrationer.

Alternative CNPJ Validerings Metoder

Programmeringsbiblioteker

Hvis du har brug for CNPJ-validering integreret i din applikationslogik, implementerer disse biblioteker check-ciffer algoritmen:

Disse biblioteker håndterer typisk formatteringering og validering for flere brasilianske dokumenttyper (CPF, CNPJ,v etc.).

Officielle Verificerings-API'er

Til produktionssystemer der har brug for at verificere faktisk virksomretering Federalderalbetjening: Consulta CNPJ API tillader verificering mod den officielle database (kræver korrekt autorisation og hastighedsbegrænsning))Djepartsdataleverandører**: Tjenester som Serasa Experian og Boa Vista SCPC tilbyder kommercielle API'er der returnerer virksomhedsdetaljer, registreringsstatus og kreditoplysninger

Bemærk: Disse tjenester tjekker faktisk registrering, ikke kunnot Du haveve korrekt og foAPI-omkbykosnigner til produktion.ionsbrug.

Hvornår man bruger hver tilgang

Brug denne browser-værktøj når: Du har brug for hurtig validering uden at installere afhængigheder, generere testdata til demonstrationer eller lære hvordan CNPJ-validering fungerer.

Brug etbibliotek når: Du bygger en applikation der har brugentsfor klient- eller server-side validering som en del af formularprocessering.

Brug en officiel API når: Du har brug for at verificere at et CNPJ svarer til en reel, aktiv forretningsenhed med aktuel registreringsstatus.

Tekniske implementeringsdetaljer

Dette værktøj kører helt i din browser ved hjælp af JavaScript—ingen serveranmodninger, ingen data forlader din maskine. Her er hvordan algoritmerne fungerer under motorhjelmen, med kode du kan tilpasse til dine egne projekter:

CNPJ Generationsalgoritme

1function generateCNPJ() {
2  // Generer de første 12 cifre tilfældigt
3  const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4  
5  // Beregn første kontrolcifre
6  const firstCheckDigit = calculateCheckDigit(digits);
7  digits.push(firstCheckDigit);
8  
9  // Beregn andet kontrolcifre
10  const secondCheckDigit = calculateCheckDigit(digits);
11  digits.push(secondCheckDigit);
12  
13  // Formater CNPJ
14  return formatCNPJ(digits.join(''));
15}
16
17function calculateCheckDigit(digits) {
18  const weights = digits.length < 13 
19    ? [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2] 
20    : [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
21  
22  const sum = digits.reduce((acc, digit, index) => {
23    return acc + digit * weights[index];
24  }, 0);
25  
26  const remainder = sum % 11;
27  return remainder < 2 ? 0 : 11 - remainder;
28}
29

CNPJ Validationsalgoritme

1function validateCNPJ(cnpj) {
2  // Fjern ikke-numeriske tegn
3  const cleanCNPJ = cnpj.replace(/\D/g, '');
4  
5  // Kontroller om den har den korrekte længde
6  if (cleanCNPJ.length !== 14) return false;
7  
8  // Kontroller for kendte ugyldige mønstre (alle samme cifre)
9  if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10  
11  // Konverter til array af cifre
12  const digits = cleanCNPJ.split('').map(Number);
13  
14  // Kontroller første verificeringscifre
15  const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16  if (digits[12] !== expectedFirstDigit) return false;
17  
18  // Kontroller andet verificeringscifre
19  const expectedSecondDigit = calculateCheckDigit(digits.slice(0, 13));
20  if (digits[13] !== expectedSecondDigit) return false;
21  
22  return true;
23}
24

CNPJ Formateringsfunktion

1function formatCNPJ(cnpj) {
2  // Fjern ikke-numeriske tegn
3  const cleanCNPJ = cnpj.replace(/\D/g, '');
4  
5  // Formater baseret på længde
6  if (cleanCNPJ.length <= 2) {
7    return cleanCNPJ;
8  } else if (cleanCNPJ.length <= 5) {
9    return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2)}`;
10  } else if (cleanCNPJ.length <= 8) {
11    return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2, 5)}.${cleanCNPJ.slice(5)}`;
12  } else if (cleanCNPJ.length <= 12) {
13    return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2, 5)}.${cleanCNPJ.slice(5, 8)}/${cleanCNPJ.slice(8)}`;
14  } else {
15    return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2, 5)}.${cleanCNPJ.slice(5, 8)}/${cleanCNPJ.slice(8, 12)}-${cleanCNPJ.slice(12, 14)}`;
16  }
17}
18

Disse kernefunktioner kan implementeres i andre programmeringssprog ved at følge samme logik. Her er eksempler i Python og Java:

Python Implementation

1import random
2
3def calculate_check_digit(digits):
4    weights = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2] if len(digits) < 13 else [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
5    
6    total = 0
7    for i in range(len(digits)):
8        total += digits[i] * weights[i]
9    
10    remainder = total % 11
11    return 0 if remainder < 2 else 11 - remainder
12
13def generate_cnpj():
14    # Generer første 12 cifre tilfældigt
15    digits = [random.randint(0, 9) for _ in range(12)]
16    
17    # Beregn første kontrolcifre
18    first_check = calculate_check_digit(digits)
19    digits.append(first_check)
20    
21    # Beregn andet kontrolcifre
22    second_check = calculate_check_digit(digits)
23    digits.append(second_check)
24    
25    # Formater CNPJ
26    cnpj = ''.join(map(str, digits))
27    return f"{cnpj[:2]}.{cnpj[2:5]}.{cnpj[5:8]}/{cnpj[8:12]}-{cnpj[12:]}"
28
29def validate_cnpj(cnpj):
30    # Fjern ikke-numeriske tegn
31    cnpj = ''.join(filter(str.isdigit, cnpj))
32    
33    # Kontroller længde
34    if len(cnpj) != 14:
35        return False
36    
37    # Kontroller om alle cifre er de samme
38    if len(set(cnpj)) == 1:
39        return False
40    
41    # Konverter til liste af heltal
42    digits = [int(d) for d in cnpj]
43    
44    # Valider første kontrolcifre
45    first_check = calculate_check_digit(digits[:12])
46    if digits[12] != first_check:
47        return False
48    
49    # Valider andet kontrolcifre
50    second_check = calculate_check_digit(digits[:13])
51    if digits[13] != second_check:
52        return False
53    
54    return True
55

Java Implementation

1import java.util.Random;
2
3public class CNPJUtils {
4    
5    public static String generateCNPJ() {
6        Random random = new Random();
7        int[] digits = new int[14];
8        
9        // Generer første 12 cifre tilfældigt
10        for (int i = 0; i < 12; i++) {
11            digits[i] = random.nextInt(10);
12        }
13        
14        // Beregn første kontrolcifre
15        digits[12] = calculateCheckDigit(digits, 12);
16        
17        // Beregn andet kontrolcifre
18        digits[13] = calculateCheckDigit(digits, 13);
19        
20        // Formater CNPJ
21        return String.format("%02d.%03d.%03d/%04d-%02d",
22                digits[0] * 10 + digits[1],
23                digits[2] * 100 + digits[3] * 10 + digits[4],
24                digits[5] * 100 + digits[6] * 10 + digits[7],
25                digits[8] * 1000 + digits[9] * 100 + digits[10] * 10 + digits[11],
26                digits[12] * 10 + digits[13]);
27    }
28    
29    private static int calculateCheckDigit(int[] digits, int length) {
30        int[] weights = length < 13 
31            ? new int[]{5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2}
32            : new int[]{6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2};
33        
34        int sum = 0;
35        for (int i = 0; i < length; i++) {
36            sum += digits[i] * weights[i];
37        }
38        
39        int remainder = sum % 11;
40        return remainder < 2 ? 0 : 11 - remainder;
41    }
42    
43    public static boolean validateCNPJ(String cnpj) {
44        // Fjern ikke-numeriske tegn
45        cnpj = cnpj.replaceAll("\\D", "");
46        
47        // Kontroller længde
48        if (cnpj.length() != 14) {
49            return false;
50        }
51        
52        // Kontroller om alle cifre er de samme
53        boolean allDigitsSame = true;
54        for (int i = 1; i < cnpj.length(); i++) {
55            if (cnpj.charAt(i) != cnpj.charAt(0)) {
56                allDigitsSame = false;
57                break;
58            }
59        }
60        if (allDigitsSame) {
61            return false;
62        }
63        
64        // Konverter til array af heltal
65        int[] digits = new int[14];
66        for (int i = 0; i < 14; i++) {
67            digits[i] = Character.getNumericValue(cnpj.charAt(i));
68        }
69        
70        // Valider første kontrolcifre
71        int firstCheck = calculateCheckDigit(digits, 12);
72        if (digits[12] != firstCheck) {
73            return false;
74        }
75        
76        // Valider andet kontrolcifre
77        int secondCheck = calculateCheckDigit(digits, 13);
78        if (digits[13] != secondCheck) {
79            return false;
80        }
81        
82        return true;
83    }
84}
85

Vigtige begrænsninger og overvejelser

Hvad dette værktøj kan og ikke kan

Hvad det validerer: Matematisk korrekthed - hvorvidt kontrolcifre matcher algoritmens beregning.

Hvad det ikke validerer: Om CNPJ'en er registreret hos Receita Federal, om den tilhører en aktiv virksomhed, eller om den er forbundet med det firmanavn, du forventer.

Tænk på det som stavekontrol versus faktakontrol. Dette værktøj fortæller dig, om en CNPJ er "stavet" korrekt ifølge matematiske regler, men det kan ikke fortælle dig, om nummeret svarer til en reel, aktiv forretningsenhed.

Lovlig og etisk brug

Genererede CNPJs er kun til test og udvikling. De er matematisk gyldige, men ikke registreret hos brasilianske myndigheder, hvilket betyder:

  • ✅ Sikker at bruge til: Udfyldning af testdatabaser, unit testing af valideringslogik, QA-miljøer, kodeeksempler i dokumentation
  • ❌ Aldrig brug til: Skatteangivelse, virksomhedsregistrering, kontraktunderskrivelse, behandling af reelle transaktioner eller foregøgling af virksomhedsidentitet

Brug af en falsk CNPJ til officielle formål er ikke blot uetisk - det er ulovligt efter brasiliansk lovgivning og kan resultere i bedragerianklagelser.

Tekniske begrænsninger at kende

Tilfældig generering har konsekvenser: Værktøjet genererer de første 12 cifre tilfældigt. Rigtige CNPJs udstedt af Receita Federal følger interne mønstre relateret til registreringsdato, regionalt kontor og virksomhedstype. Genererede numre vil ikke matche disse mønstre, hvilket sofistikerede valideringssystemer muligvis vil markere.

Ingen semantisk validering: Et gyldigt CNPJ-format betyder ikke en gyldig forretningskontekst. For eksempel har statslige enheder specifikke CNPJ-intervaller - denne generator kan tilfældigt skabe en, men den ville ikke være meningsfuld.

Formatbehandling: Validatoren accepterer forskellige inputformater (12345678000195, 12.345.678/0001-95), men nogle ældre systemer forventer nøjagtigt formattering. Test altid med dine specifikke integrationskrav.

Privatliv og sikkerhed

Al behandling sker client-side i din browser. Ingen CNPJs, du genererer eller validerer, sendes til servere, logges eller gemmes. Værktøjet anmoder ikke om, behandler eller processerer personlige oplysninger.

Ofte stillede spørgsmål om CNPJ-validering

Hvad er forskellen mellem validering og verificering af en CNPJ?

Validering tjekker, om nummeret er matematisk korrekt - korrekt format, korrekte kontrolcifre, ingen ugyldige mønstre. Dette værktøj udfører validering.

Verificering tjekker, om CNPJ'en er registreret hos et faktisk selskab i Receita Federal-databasen. Verificering kræver forespørgsel i den statslige database og er ikke noget, dette værktøj gør.

Du kan have en perfekt gyldig CNPJ, som ikke er verificeret (som testnumrene dette værktøj genererer), eller en ugyldig CNPJ, der tilhører et rigtigt selskab (fordi nogen har lavet en stavefejl ved indtastningen).

Kan jeg bruge genererede CNPJs til produktionstestning?

Det afhænger af, hvad du mener med "produktionstestning". De er fine til staging-miljøer, belastningstestning og pre-launch QA. Men hvis "produktionstestning" betyder test med rigtige transaktioner, rigtige statslige API'er eller rigtige finansielle systemer - så nej, du har brug for faktiske registrerede CNPJs.

En sikrere tilgang: brug genererede CNPJs i isolerede testmiljøer, og skift så til et lille sæt rigtige test-selskabs-CNPJs (dem du kontrollerer) ved test af produktionsintegrationer.

Hvorfor afviser validatoren 11.111.111/1111-11?

Selvom en CNPJ med identiske cifre matematisk kan producere gyldige kontrolcifre, udelukker Receita Federal udtrykkelig disse mønstre. Det er en forretningsregel, ikke en matematisk. Det samme gælder for sekventielle mønstre i nogle valideringssystemer.

Dette svarer til, hvordan mange systemer afviser adgangskoder som "password123" selv om de opfylder længdekravene - de er teknisk gyldige, men praktisk uacceptable.

Hvordan håndterer jeg CNPJ-validering i forskellige lokaler?

Brasilianske virksomheder, der driver international forretning, fjerner nogle gange formateringstegnene ved indtastning af CNPJs i udenlandske systemer. Din valideringslogik bør fjerne ikke-numeriske tegn før kontrol:

1const cleanCNPJ = input.replace(/\D/g, ''); // Fjern alt undtagen cifre
2

Acceptér 12.345.678/0001-95, 12345678000195 og 12 345 678 0001 95 som ækvivalente input.

Hvad med CNPJ vs CPF-validering?

CPF (Cadastro de Pessoas Físicas) er Brasiliens individuelle skatte-ID, mens CNPJ er for virksomheder. De bruger forskellige kontrolcifre-algoritmer og længder (CPF har 11 cifre, CNPJ har 14). Hvis du bygger en brasiliansk app, der håndterer begge, har du brug for separate valideringsfunktioner - selvom mange biblioteker understøtter begge formater.

Et almindeligt mønster: lad brugere indtaste enten CPF eller CNPJ i samme felt, og identificer derefter typen baseret på længden efter fjernelse af formateringstegn.

Virker dette for udenlandske virksomheder, der opererer i Brasilien?

Udenlandske virksomheder, der opererer i Brasilien, skal også anskaffe CNPJs fra Receita Federal. Deres CNPJs følger samme format og valideringsregler som indenlandske virksomheder. Der er ingen speciel "udenlandsk virksomhed" CNPJ-format.

Dog kan udenlandske virksomheder have yderligere dokumentationskrav og forskellige registreringsprocesser - konsultér en brasiliansk forretningsadvokat for specifikke detaljer.

Kan jeg forespørge den statslige database for at verificere CNPJ-registrering?

Ja, Receita Federal giver offentlig adgang til at verificere grundlæggende CNPJ-oplysninger gennem deres Consulta Pública CNPJ service. Du kan manuelt slå CNPJs op eller, med behørig autorisation, bruge deres API'er til programmatisk adgang.

Bemærk, at intensiv brug kræver registrering, og der er hastighedsgrænser for at forhindre misbrug.

Hvor ofte ændres CNPJs?

CNPJs er permanente identifikatorer, der ikke ændres, når et selskab skifter navn, adresse eller ejerstruktur. Men hvis et selskab lukker og senere genregistreres, kan det modtage en ny CNPJ. Filialnumre (den /XXXX-del) kan tilføjes, efterhånden som virksomheder åbner nye lokationer, men det grundlæggende 8-cifrede nummer forbliver konstant.

Referencer og yderligere ressourcer

Officielle statslige kilder

  1. Receita Federal do Brasil - Officiel Portal - Den brasilianske føderale skatteservices officielle hjemmeside med CNPJ-registrerings- og verificeringstjenester
  2. Consulta Pública CNPJ - Offentlig CNPJ-opslag - Officiel statslig tjeneste til at verificere CNPJ-registreringsstatus
  3. Normativ Instruktion RFB Nr. 1863/2018 - Juridiske forskrifter, der styrer CNPJ-registrering og -brug i Brasilien

Tekniske standarder og dokumentation

  1. Modulær aritmetiske algoritmer - Beregningen af kontrolcifre bruger modulo 11-aritmetik, en standardtilgang til validering af cifre
  2. ISO/IEC 7064 - International standard for kontrolciffersystemer, der har påvirket den brasilianske dokumentvalideringsdesign
  3. Brasiliansk civillovbog (Lov Nr. 10.406/2002) - Juridisk ramme, der definerer forretningsenhedsklassifikationer, der kræver CNPJ-registrering

Udviklingsressourcer

  1. NPM-pakkeregister - npmjs.com - Repository for JavaScript-biblioteker, herunder brasilianske dokumentvalidatorer
  2. PyPI (Python Package Index) - pypi.org - Python-biblioteker til CNPJ-validering og brasiliansk dokumentbehandling
  3. GitHub - Open source-implementeringer af CNPJ-validering i flere programmeringssprog

Start Generering og Validering af CNPJs

Uanset om du bygger en brasiliansk e-handelsplatform, tester betalingsintegrationer med Mercado Pago eller blot har brug for at forstå, hvordan CNPJ-validering fungerer, giver dette værktøj dig øjeblikkelig adgang til både genererings- og valideringsmuligheder.

Ingen installation, ingen API-nøgler, ingen kompliceret opsætning. Åbn blot din browser og begynd at arbejde med gyldige brasilianske virksomhedsidentifikatorer.