Brasiliansk CNPJ-generator og valideringsværktøj

Introduktion

Det brasilianske CNPJ (Cadastro Nacional da Pessoa Jurídica) er et unikt identifikationsnummer, der tildeles virksomheder og juridiske enheder i Brasilien. Dette brasilianske CNPJ-generator- og valideringsværktøj giver en enkel og effektiv måde at generere gyldige CNPJ-numre til testformål og validere eksisterende CNPJ-numre i henhold til den officielle brasilianske algoritme. Uanset om du er udvikler, der tester applikationer, der håndterer brasilianske virksomhedsdata, en QA-professionel, der opretter testcases, eller nogen, der arbejder med brasilianske virksomhedsoplysninger, gør dette værktøj processen med at arbejde med CNPJ-numre mere strømlinet.

I modsætning til rigtige CNPJ-numre, der officielt udstedes af den brasilianske føderale skatteforvaltning (Receita Federal), er de CNPJs, der genereres af dette værktøj, matematisk gyldige, men ikke registreret til faktiske virksomheder. Dette gør dem perfekte til testsituationer, prøve-data og udviklingsmiljøer, hvor du har brug for korrekt formaterede og gyldige CNPJ-numre uden at bruge rigtige virksomhedsidentifikatorer.

Hvad er et CNPJ?

Et CNPJ (Cadastro Nacional da Pessoa Jurídica) er et 14-cifret identifikationsnummer, der tildeles virksomheder og juridiske enheder af den brasilianske føderale skatteforvaltning. Det fungerer som den brasilianske ækvivalent til et virksomhedsregistreringsnummer eller skatte-ID. Hver virksomhed, der opererer lovligt i Brasilien, skal have et CNPJ, som bruges til:

Skatterapportering og overholdelse
Virksomhedsregistrering hos offentlige myndigheder
Åbning af bankkonti
Udstedelse af fakturaer og kvitteringer
Deltagelse i offentlige udbud
Import og eksport af varer

CNPJ'et er en essentiel identifikator i Brasiliens erhvervsliv og vises på officielle dokumenter, kontrakter og finansielle optegnelser.

CNPJ-struktur og format

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

Strukturen opdeles som følger:

De første 8 cifre (XX.XXX.XXX): Basisnummer tildelt virksomheden
4 cifre efter skråstregen (YYYY): Filialidentifikator (0001 for hovedkontor, andre numre for filialer)
De sidste 2 cifre (ZZ): Kontrolcifre til validering

For eksempel kan et korrekt formateret CNPJ se sådan ud: 12.345.678/0001-95

Kontrolcifrene (de sidste to numre) beregnes ved hjælp af en specifik matematisk algoritme, der validerer CNPJ'ets ægthed. Denne algoritme sikrer, at tilfældigt genererede numre ikke kan bestå validering uden at følge den korrekte beregningsmetode.

Hvordan CNPJ-validering fungerer

CNPJ-valideringsalgoritmen bruger en vægtet beregning til at bestemme kontrolcifrene. Sådan fungerer det:

Beregning af første kontrolciffer

Multiplicer hver af de første 12 cifre med en vægtsekvens: 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
Summer resultaterne af disse multiplikationer
Beregn resten af denne sum divideret med 11
Hvis resten er mindre end 2, er det første kontrolciffer 0; ellers er det 11 minus resten

Beregning af andet kontrolciffer

Multiplicer hver af de første 13 cifre (inklusive det første kontrolciffer) med en vægtsekvens: 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
Summer resultaterne af disse multiplikationer
Beregn resten af denne sum divideret med 11
Hvis resten er mindre end 2, er det andet kontrolciffer 0; ellers er det 11 minus resten

For at et CNPJ skal være gyldigt, skal begge kontrolcifre matche de beregnede værdier.

Hvordan man bruger dette værktøj

Vores brasilianske CNPJ-generator og valideringsværktøj tilbyder to hovedfunktioner: generering af gyldige CNPJs og validering af eksisterende CNPJ-numre.

Generering af et CNPJ

For at generere et gyldigt CNPJ til testformål:

Naviger til "CNPJ-generator"-sektionen af værktøjet
Klik på knappen "Generer CNPJ"
Et matematisk gyldigt CNPJ vises i det formaterede display
Brug knappen "Kopier" til at kopiere det genererede CNPJ til din udklipsholder

Det genererede CNPJ vil følge alle de matematiske valideringsregler for et rigtigt CNPJ, men er ikke registreret hos den brasilianske føderale skatteforvaltning.

Validering af et CNPJ

For at tjekke, om et CNPJ er matematisk gyldigt:

Naviger til "CNPJ-validerings"-sektionen af værktøjet
Indtast det CNPJ, du ønsker at validere, i inputfeltet
- Værktøjet accepterer CNPJs med eller uden formatering (punkter, skråstreger og bindestreger)
Klik på knappen "Valider"
Værktøjet viser, om CNPJ'et er gyldigt eller ugyldigt baseret på kontrolcifferalgoritmen

Valideringsværktøjet tjekker, om CNPJ'et følger det korrekte format, og om kontrolcifrene matcher de forventede værdier i henhold til valideringsalgoritmen.

Anvendelsestilfælde

Dette brasilianske CNPJ-generator- og valideringsværktøj er særligt nyttigt i følgende scenarier:

Softwareudvikling og testning

Oprettelse af testdata: Generer gyldige CNPJs til at befolke testdatabaser uden at bruge rigtige virksomhedsidentifikatorer
Enhedstestning: Valider CNPJ-håndteringsfunktioner i din kode med kendte gyldige og ugyldige eksempler
QA-testning: Opret testcases til formularer og grænseflader, der kræver CNPJ-input
Integrationstestning: Test systemer, der udveksler data med brasilianske offentlige tjenester eller finansielle institutioner

Uddannelse og træning

Lære CNPJ-formatet: Forstå, hvordan brasilianske virksomhedsidentifikatorer er struktureret
Studie af algoritmer: Undersøg, hvordan kontrolciffer-validering fungerer i praksis
Data valideringsteknikker: Studer virkelige eksempler på krav til datavalidering

Databehandling

Datarenser: Valider CNPJs i eksisterende datasæt for at identificere potentielle fejl
Formularvalidering: Implementer klient- eller server-side validering for CNPJ-input
Dataanonymisering: Erstat rigtige CNPJs med gyldige genererede, når du forbereder datasæt til analyse

International forretning

Forberedelse til markedindtræden: Forstå brasilianske krav til virksomhedsidentifikation
Dokumentforberedelse: Sikre korrekt formatering ved forberedelse af forretningsdokumenter til Brasilien
Overholdelseskontrol: Bekræft, at indsamlede CNPJ-numre i det mindste er matematisk gyldige

Alternativer

Mens vores værktøj giver en simpel, browserbaseret løsning til generering og validering af CNPJs, er der flere alternativer afhængigt af dine specifikke behov:

Programmeringsbiblioteker

For udviklere, der integrerer CNPJ-validering direkte i applikationer, er der flere sprog-specifikke biblioteker tilgængelige:

JavaScript: cpf_cnpj.js, validator.js
Python: python-cnpj, validate-docbr
PHP: brazilianutils, respect/validation
Java: caelum-stella, commons-validator
Ruby: cpf_cnpj, brazilian-rails

Disse biblioteker tilbyder ofte yderligere funktionalitet som formatering, parsing og validering af andre brasilianske dokumenter.

API-tjenester

For applikationer, der kræver validering uden at implementere algoritmen:

Brasilianske regerings-API'er (kræver registrering)
Kommercielle validerings-API'er, der inkluderer CNPJ-tjek
Virksomhedsinformationsservices, der validerer mod den officielle database

Manuel beregning

Til uddannelsesmæssige formål eller engangsvalideringer kan du manuelt anvende algoritmen:

Uddrag de første 12 cifre af CNPJ'et
Udfør de vægtede beregninger som beskrevet tidligere
Sammenlign de beregnede kontrolcifre med de faktiske kontrolcifre

Men manuel beregning er fejlbehæftet og ineffektiv til regelmæssig brug.

Teknisk implementering

CNPJ-generatoren og -valideringen i dette værktøj er implementeret ved hjælp af JavaScript, hvilket gør det hurtigt og i stand til at køre helt i din browser uden at sende dine data til en server. Her er hvordan de centrale funktioner fungerer:

CNPJ-genereringsalgoritme

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 kontrolciffer
6  const firstCheckDigit = calculateCheckDigit(digits);
7  digits.push(firstCheckDigit);
8  
9  // Beregn andet kontrolciffer
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-valideringsalgoritme

1function validateCNPJ(cnpj) {
2  // Fjern ikke-numeriske tegn
3  const cleanCNPJ = cnpj.replace(/\D/g, '');
4  
5  // Tjek om det har den korrekte længde
6  if (cleanCNPJ.length !== 14) return false;
7  
8  // Tjek 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  // Tjek første kontrolciffer
15  const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16  if (digits[12] !== expectedFirstDigit) return false;
17  
18  // Tjek andet kontrolciffer
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 centrale funktioner kan implementeres i andre programmeringssprog ved at følge den samme logik. Her er eksempler i Python og Java:

Python-implementering

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 de første 12 cifre tilfældigt
15    digits = [random.randint(0, 9) for _ in range(12)]
16    
17    # Beregn første kontrolciffer
18    first_check = calculate_check_digit(digits)
19    digits.append(first_check)
20    
21    # Beregn andet kontrolciffer
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    # Tjek længde
34    if len(cnpj) != 14:
35        return False
36    
37    # Tjek 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 kontrolciffer
45    first_check = calculate_check_digit(digits[:12])
46    if digits[12] != first_check:
47        return False
48    
49    # Valider andet kontrolciffer
50    second_check = calculate_check_digit(digits[:13])
51    if digits[13] != second_check:
52        return False
53    
54    return True
55

Java-implementering

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 de 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 kontrolciffer
15        digits[12] = calculateCheckDigit(digits, 12);
16        
17        // Beregn andet kontrolciffer
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        // Tjek længde
48        if (cnpj.length() != 14) {
49            return false;
50        }
51        
52        // Tjek 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 kontrolciffer
71        int firstCheck = calculateCheckDigit(digits, 12);
72        if (digits[12] != firstCheck) {
73            return false;
74        }
75        
76        // Valider andet kontrolciffer
77        int secondCheck = calculateCheckDigit(digits, 13);
78        if (digits[13] != secondCheck) {
79            return false;
80        }
81        
82        return true;
83    }
84}
85

Vigtige overvejelser

Når du bruger dette CNPJ-generator- og valideringsværktøj, skal du holde følgende overvejelser i tankerne:

Juridiske og etiske overvejelser

Ikke til svindel: Genererede CNPJs bør aldrig bruges til svigagtige formål eller misrepræsentation
Kun til test: Disse CNPJs er kun til test- og udviklingsformål
Ikke registreret: Genererede CNPJs er matematisk gyldige, men ikke registreret hos brasilianske myndigheder
Ingen real-world gyldighed: De kan ikke bruges til faktisk virksomhedsregistrering eller skatteformål

Tekniske begrænsninger

Ingen virksomhedsoplysninger: Genererede CNPJs indeholder ikke rigtige virksomhedssektor koder eller lokalitetsoplysninger
Ingen databaseverificering: Valideren tjekker kun matematisk gyldighed, ikke registreringsstatus
Formatvariationer: Selvom værktøjet håndterer almindelige formateringsvariationer, kan nogle systemer kræve specifikke formater

Sikkerhedsovervejelser

Klient-side behandling: Al behandling sker i din browser; ingen data sendes til servere
Ingen datalagring: Genererede CNPJs gemmes ikke eller logges
Ingen personlige data: Værktøjet håndterer eller behandler ikke nogen personlige oplysninger

Ofte stillede spørgsmål

Hvad bruges et CNPJ til i Brasilien?

Et CNPJ er det nationale registreringsnummer for virksomheder og juridiske enheder i Brasilien. Det bruges til skatteformål, virksomhedsregistrering, åbning af bankkonti og identifikation af virksomheder i officielle transaktioner.

Er de CNPJs, der genereres af dette værktøj, rigtige?

Nej. De CNPJs, der genereres af dette værktøj, er matematisk gyldige i henhold til kontrolcifferalgoritmen, men de er ikke registreret hos den brasilianske føderale skatteforvaltning og tilhører ikke rigtige virksomheder.

Kan jeg bruge genererede CNPJs til min virksomhed?

Nej. For at få et legitimt CNPJ til en virksomhed skal du registrere dig hos den brasilianske føderale skatteforvaltning (Receita Federal) i henhold til den officielle proces. Genererede CNPJs er kun til testformål.

Hvordan kan jeg se, om et CNPJ tilhører en rigtig virksomhed?

For at verificere, om et CNPJ er registreret til en faktisk virksomhed, skal du konsultere den brasilianske føderale skatteforvaltnings database. Vores værktøj tjekker kun, om et CNPJ er matematisk gyldigt, ikke om det er officielt registreret.

Hvorfor afviser valideringsværktøjet et CNPJ med alle de samme cifre?

CNPJs med alle de samme cifre (som 11.111.111/1111-11) betragtes automatisk som ugyldige, selvom de matematisk passerer kontrolcifferalgoritmen. Dette er en regel fastsat af den brasilianske føderale skatteforvaltning.

Gemmer værktøjet de CNPJs, jeg genererer eller validerer?

Nej. Al behandling sker i din browser, og vi gemmer eller transmitterer ikke nogen af de CNPJs, du genererer eller validerer.

Kan jeg generere flere CNPJs ad gangen?

Den nuværende version af værktøjet genererer én CNPJ ad gangen. For massegenerering kan du overveje at bruge et af de programmeringsbiblioteker, der er nævnt i afsnittet Alternativer.

Hvorfor er formatet XX.XXX.XXX/XXXX-XX vigtigt?

Dette er det officielle format, der kræves af brasilianske myndigheder. Den specifikke gruppering hjælper med at identificere forskellige komponenter af CNPJ'et, såsom basisnummeret og filialidentifikatoren.

Hvordan validerer jeg et CNPJ programmatisk?

Du kan implementere valideringsalgoritmen i dit foretrukne programmeringssprog ved hjælp af kodeeksemplerne, der er angivet i afsnittet Teknisk implementering, eller bruge et af de biblioteker, der er nævnt i afsnittet Alternativer.

Er der særlige CNPJs for offentlige enheder?

Ja. Offentlige enheder i Brasilien har specifikke CNPJ-mønstre. For eksempel starter føderale offentlige enheder ofte med specifikke cifre. Vores generator skaber tilfældige CNPJs og genererer ikke specifikt CNPJs for offentlige enheder.

Referencer

Brasiliansk føderal skatteforvaltning (Receita Federal do Brasil) - Officiel hjemmeside
"CNPJ - Cadastro Nacional da Pessoa Jurídica" - Wikipedia
Brasiliansk civilret (Lov nr. 10.406/2002) - Juridisk ramme for erhvervsenheder i Brasilien
Brasiliansk virksomhedsregistreringsnormativ instruktion (IN RFB nr. 1863/2018) - Regler for CNPJ-registrering

Prøv det nu

Vores brasilianske CNPJ-generator og valideringsværktøj gør arbejdet med disse identifikationsnumre enkelt og effektivt. Uanset om du tester applikationer, forbereder prøve-data eller validerer eksisterende CNPJs, giver dette værktøj en ligetil løsning uden kompleksiteten ved API-integrationer eller avancerede konfigurationer.

Generer dit første gyldige CNPJ nu eller valider et eksisterende ved hjælp af vores enkle grænseflade!

Brasiliansk CNPJ-generator og -valideringsværktøj til testning

Brasiliansk CNPJ Generator og Validator

CNPJ Generator

CNPJ Validator

Dokumentation