Generer gyldige brasilianske CNPJ-numre og valider eksisterende med dette enkle værktøj designet til udviklere og testere, der arbejder med brasilianske virksomheds-ID'er.
Generer et gyldigt brasiliansk CNPJ-nummer til testformål.
Tjek om et brasiliansk CNPJ-nummer er gyldigt.
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.
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:
CNPJ'et er en essentiel identifikator i Brasiliens erhvervsliv og vises på officielle dokumenter, kontrakter og finansielle optegnelser.
Et brasiliansk CNPJ består af 14 cifre, typisk formateret som: XX.XXX.XXX/YYYY-ZZ
Strukturen opdeles som følger:
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.
CNPJ-valideringsalgoritmen bruger en vægtet beregning til at bestemme kontrolcifrene. Sådan fungerer det:
For at et CNPJ skal være gyldigt, skal begge kontrolcifre matche de beregnede værdier.
Vores brasilianske CNPJ-generator og valideringsværktøj tilbyder to hovedfunktioner: generering af gyldige CNPJs og validering af eksisterende CNPJ-numre.
For at generere et gyldigt CNPJ til testformål:
Det genererede CNPJ vil følge alle de matematiske valideringsregler for et rigtigt CNPJ, men er ikke registreret hos den brasilianske føderale skatteforvaltning.
For at tjekke, om et CNPJ er matematisk gyldigt:
Valideringsværktøjet tjekker, om CNPJ'et følger det korrekte format, og om kontrolcifrene matcher de forventede værdier i henhold til valideringsalgoritmen.
Dette brasilianske CNPJ-generator- og valideringsværktøj er særligt nyttigt i følgende scenarier:
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:
For udviklere, der integrerer CNPJ-validering direkte i applikationer, er der flere sprog-specifikke biblioteker tilgængelige:
cpf_cnpj.js, validator.jspython-cnpj, validate-docbrbrazilianutils, respect/validationcaelum-stella, commons-validatorcpf_cnpj, brazilian-railsDisse biblioteker tilbyder ofte yderligere funktionalitet som formatering, parsing og validering af andre brasilianske dokumenter.
For applikationer, der kræver validering uden at implementere algoritmen:
Til uddannelsesmæssige formål eller engangsvalideringer kan du manuelt anvende algoritmen:
Men manuel beregning er fejlbehæftet og ineffektiv til regelmæssig brug.
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:
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}
291function 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}
241function 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}
18Disse centrale funktioner kan implementeres i andre programmeringssprog ved at følge den samme logik. Her er eksempler i Python og Java:
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
551import 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}
85Når du bruger dette CNPJ-generator- og valideringsværktøj, skal du holde følgende overvejelser i tankerne:
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.
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.
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.
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.
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.
Nej. Al behandling sker i din browser, og vi gemmer eller transmitterer ikke nogen af de CNPJs, du genererer eller validerer.
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.
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.
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.
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.
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!
Opdag flere værktøjer, der måske kan være nyttige for din arbejdsgang.