Genereer geldige Braziliaanse CNPJ-nummers en valideer bestaande met deze eenvoudige tool die is ontworpen voor ontwikkelaars en testers die werken met Braziliaanse bedrijfs-ID's.
Genereer een geldig Braziliaans CNPJ-nummer voor testdoeleinden.
Controleer of een Braziliaans CNPJ-nummer geldig is.
De Braziliaanse CNPJ (Cadastro Nacional da Pessoa Jurídica) is een uniek identificatienummer dat aan bedrijven en rechtspersonen in Brazilië wordt toegewezen. Deze Braziliaanse CNPJ generator en validator tool biedt een eenvoudige, efficiënte manier om geldige CNPJ-nummers te genereren voor testdoeleinden en bestaande CNPJ-nummers te valideren volgens het officiële Braziliaanse algoritme. Of je nu een ontwikkelaar bent die applicaties test die met Braziliaanse bedrijfsgegevens omgaan, een QA-professional die testcases maakt, of iemand die met Braziliaanse bedrijfsinformatie werkt, deze tool stroomlijnt het proces van het werken met CNPJ-nummers.
In tegenstelling tot echte CNPJ-nummers die officieel worden uitgegeven door de Braziliaanse Federale Belastingdienst (Receita Federal), zijn de door deze tool gegenereerde CNPJs wiskundig geldig maar niet geregistreerd op daadwerkelijke bedrijven. Dit maakt ze perfect voor testsituaties, voorbeeldgegevens en ontwikkelomgevingen waar je correct geformatteerde en geldige CNPJ-nummers nodig hebt zonder echte bedrijfsidentificatoren te gebruiken.
Een CNPJ (Cadastro Nacional da Pessoa Jurídica) is een 14-cijferig identificatienummer dat aan bedrijven en rechtspersonen door de Braziliaanse Federale Belastingdienst wordt toegewezen. Het dient als het Braziliaanse equivalent van een bedrijfsregistratienummer of belasting-ID. Elk bedrijf dat legaal in Brazilië opereert, moet een CNPJ hebben, dat wordt gebruikt voor:
De CNPJ is een essentieel identificatienummer in het Braziliaanse bedrijfsleven en verschijnt op officiële documenten, contracten en financiële verslagen.
Een Braziliaanse CNPJ bestaat uit 14 cijfers, meestal geformatteerd als: XX.XXX.XXX/YYYY-ZZ
De structuur is als volgt:
Bijvoorbeeld, een correct geformatteerde CNPJ kan eruitzien als: 12.345.678/0001-95
De controlecijfers (de laatste twee nummers) worden berekend met behulp van een specifiek wiskundig algoritme dat de authenticiteit van de CNPJ valideert. Dit algoritme zorgt ervoor dat willekeurig gegenereerde nummers niet kunnen slagen voor validatie zonder de juiste rekenmethode te volgen.
Het CNPJ-validatie-algoritme gebruikt een gewogen berekening om de controlecijfers te bepalen. Zo werkt het:
Om geldig te zijn, moeten beide controlecijfers overeenkomen met de berekende waarden.
Onze Braziliaanse CNPJ Generator en Validator tool biedt twee hoofd functies: geldige CNPJs genereren en bestaande CNPJ-nummers valideren.
Om een geldige CNPJ voor testdoeleinden te genereren:
De gegenereerde CNPJ volgt alle wiskundige validatieregels van een echte CNPJ, maar is niet geregistreerd bij de Braziliaanse Federale Belastingdienst.
Om te controleren of een CNPJ wiskundig geldig is:
De validator controleert of de CNPJ het juiste formaat volgt en of de controlecijfers overeenkomen met de verwachte waarden volgens het validatie-algoritme.
Deze Braziliaanse CNPJ generator en validator tool is bijzonder nuttig in de volgende scenario's:
Hoewel onze tool een eenvoudige, browsergebaseerde oplossing biedt voor het genereren en valideren van CNPJs, zijn er verschillende alternatieven afhankelijk van je specifieke behoeften:
Voor ontwikkelaars die CNPJ-validatie rechtstreeks in applicaties willen integreren, zijn er verschillende taal-specifieke bibliotheken beschikbaar:
cpf_cnpj.js, validator.jspython-cnpj, validate-docbrbrazilianutils, respect/validationcaelum-stella, commons-validatorcpf_cnpj, brazilian-railsDeze bibliotheken bieden vaak extra functionaliteit zoals opmaak, parseren en validatie van andere Braziliaanse documenten.
Voor applicaties die validatie vereisen zonder het algoritme te implementeren:
Voor educatieve doeleinden of eenmalige validaties kun je het algoritme handmatig toepassen:
Handmatige berekening is echter foutgevoelig en inefficiënt voor regelmatig gebruik.
De CNPJ-generator en validator in deze tool zijn geïmplementeerd met behulp van JavaScript, waardoor deze snel is en volledig in je browser kan draaien zonder je gegevens naar een server te verzenden. Hier is hoe de kernfuncties werken:
1function generateCNPJ() {
2 // Genereer de eerste 12 cijfers willekeurig
3 const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4
5 // Bereken het eerste controlecijfer
6 const firstCheckDigit = calculateCheckDigit(digits);
7 digits.push(firstCheckDigit);
8
9 // Bereken het tweede controlecijfer
10 const secondCheckDigit = calculateCheckDigit(digits);
11 digits.push(secondCheckDigit);
12
13 // Formatteer de 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 // Verwijder niet-numerieke tekens
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Controleer of het de juiste lengte heeft
6 if (cleanCNPJ.length !== 14) return false;
7
8 // Controleer op bekende ongeldige patronen (allezelfde cijfers)
9 if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10
11 // Zet om naar een array van cijfers
12 const digits = cleanCNPJ.split('').map(Number);
13
14 // Controleer het eerste verificatiecijfer
15 const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16 if (digits[12] !== expectedFirstDigit) return false;
17
18 // Controleer het tweede verificatiecijfer
19 const expectedSecondDigit = calculateCheckDigit(digits.slice(0, 13));
20 if (digits[13] !== expectedSecondDigit) return false;
21
22 return true;
23}
241function formatCNPJ(cnpj) {
2 // Verwijder niet-numerieke tekens
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Formatteer op basis van lengte
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}
18Deze kernfuncties kunnen in andere programmeertalen worden geïmplementeerd volgens dezelfde logica. Hier zijn voorbeelden in Python en 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 # Genereer de eerste 12 cijfers willekeurig
15 digits = [random.randint(0, 9) for _ in range(12)]
16
17 # Bereken het eerste controlecijfer
18 first_check = calculate_check_digit(digits)
19 digits.append(first_check)
20
21 # Bereken het tweede controlecijfer
22 second_check = calculate_check_digit(digits)
23 digits.append(second_check)
24
25 # Formatteer de 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 # Verwijder niet-numerieke tekens
31 cnpj = ''.join(filter(str.isdigit, cnpj))
32
33 # Controleer lengte
34 if len(cnpj) != 14:
35 return False
36
37 # Controleer of alle cijfers hetzelfde zijn
38 if len(set(cnpj)) == 1:
39 return False
40
41 # Zet om naar lijst van gehele getallen
42 digits = [int(d) for d in cnpj]
43
44 # Valideer het eerste controlecijfer
45 first_check = calculate_check_digit(digits[:12])
46 if digits[12] != first_check:
47 return False
48
49 # Valideer het tweede controlecijfer
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 // Genereer de eerste 12 cijfers willekeurig
10 for (int i = 0; i < 12; i++) {
11 digits[i] = random.nextInt(10);
12 }
13
14 // Bereken het eerste controlecijfer
15 digits[12] = calculateCheckDigit(digits, 12);
16
17 // Bereken het tweede controlecijfer
18 digits[13] = calculateCheckDigit(digits, 13);
19
20 // Formatteer de 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 // Verwijder niet-numerieke tekens
45 cnpj = cnpj.replaceAll("\\D", "");
46
47 // Controleer lengte
48 if (cnpj.length() != 14) {
49 return false;
50 }
51
52 // Controleer of alle cijfers hetzelfde zijn
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 // Zet om naar array van gehele getallen
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 // Valideer het eerste controlecijfer
71 int firstCheck = calculateCheckDigit(digits, 12);
72 if (digits[12] != firstCheck) {
73 return false;
74 }
75
76 // Valideer het tweede controlecijfer
77 int secondCheck = calculateCheckDigit(digits, 13);
78 if (digits[13] != secondCheck) {
79 return false;
80 }
81
82 return true;
83 }
84}
85Bij het gebruik van deze CNPJ-generator en validator tool, houd rekening met de volgende overwegingen:
Een CNPJ is het nationale registratienummer voor bedrijven en rechtspersonen in Brazilië. Het wordt gebruikt voor belastingdoeleinden, bedrijfsregistratie, het openen van bankrekeningen en het identificeren van bedrijven in officiële transacties.
Nee. De CNPJs die door deze tool worden gegenereerd zijn wiskundig geldig volgens het controlecijfer-algoritme, maar ze zijn niet geregistreerd bij de Braziliaanse Federale Belastingdienst en behoren niet tot echte bedrijven.
Nee. Om een legitieme CNPJ voor een bedrijf te verkrijgen, moet je je registreren bij de Braziliaanse Federale Belastingdienst (Receita Federal) volgens de officiële procedure. Gegenereerde CNPJs zijn alleen voor testdoeleinden.
Om te verifiëren of een CNPJ geregistreerd is op een daadwerkelijk bedrijf, moet je de database van de Braziliaanse Federale Belastingdienst raadplegen. Onze tool controleert alleen of een CNPJ wiskundig geldig is, niet of deze officieel geregistreerd is.
CNPJs met allemaal dezelfde cijfers (zoals 11.111.111/1111-11) worden automatisch als ongeldig beschouwd, zelfs als ze wiskundig slagen voor het controlecijfer-algoritme. Dit is een regel die is vastgesteld door de Braziliaanse Federale Belastingdienst.
Nee. Alle verwerking vindt plaats in je browser, en we slaan geen van de CNPJs op die je genereert of valideert.
De huidige versie van de tool genereert één CNPJ tegelijk. Voor bulk generatie kun je overwegen een van de programmeerbibliotheken te gebruiken die in de sectie Alternatieven worden genoemd.
Dit is het officiële formaat dat door de Braziliaanse autoriteiten vereist is. De specifieke groepering helpt bij het identificeren van verschillende componenten van de CNPJ, zoals het basisnummer en de takidentificator.
Je kunt het validatie-algoritme implementeren in je favoriete programmeertaal met behulp van de codevoorbeelden die in de sectie Technische Implementatie zijn gegeven, of een van de bibliotheken gebruiken die in de sectie Alternatieven worden genoemd.
Ja. Overheidsinstanties in Brazilië hebben specifieke CNPJ-patronen. Bijvoorbeeld, federale overheidsinstanties beginnen vaak met specifieke cijfers. Onze generator creëert willekeurige CNPJs en genereert geen CNPJs voor overheidsinstanties.
Onze Braziliaanse CNPJ Generator en Validator tool maakt het werken met deze identificatienummers eenvoudig en efficiënt. Of je nu applicaties test, voorbeeldgegevens voorbereidt of bestaande CNPJs valideert, deze tool biedt een eenvoudige oplossing zonder de complexiteit van API-integraties of geavanceerde configuraties.
Genereer nu je eerste geldige CNPJ of valideer een bestaande met onze eenvoudige interface!
Ontdek meer tools die handig kunnen zijn voor uw workflow