Braziliaanse CNPJ Generator en Validator Tool

Inleiding

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.

Wat is een CNPJ?

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:

Belastingrapportage en -naleving
Bedrijfsregistratie bij overheidsinstanties
Het openen van bankrekeningen
Het uitgeven van facturen en kwitanties
Deelname aan overheidsaanbestedingen
Het importeren en exporteren van goederen

De CNPJ is een essentieel identificatienummer in het Braziliaanse bedrijfsleven en verschijnt op officiële documenten, contracten en financiële verslagen.

CNPJ Structuur en Formaat

Een Braziliaanse CNPJ bestaat uit 14 cijfers, meestal geformatteerd als: XX.XXX.XXX/YYYY-ZZ

De structuur is als volgt:

Eerste 8 cijfers (XX.XXX.XXX): Basisnummer toegewezen aan het bedrijf
4 cijfers na de schuine streep (YYYY): Takidentificator (0001 voor hoofdkantoor, andere nummers voor filialen)
Laatste 2 cijfers (ZZ): Controlecijfers voor validatie

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.

Hoe de CNPJ Validatie Werkt

Het CNPJ-validatie-algoritme gebruikt een gewogen berekening om de controlecijfers te bepalen. Zo werkt het:

Berekening van het Eerste Controlecijfer

Vermenigvuldig elk van de eerste 12 cijfers met een gewichtsreeks: 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
Tel de resultaten van deze vermenigvuldigingen op
Bereken de rest van deze som gedeeld door 11
Als de rest kleiner is dan 2, is het eerste controlecijfer 0; anders is het 11 min de rest

Berekening van het Tweede Controlecijfer

Vermenigvuldig elk van de eerste 13 cijfers (inclusief het eerste controlecijfer) met een gewichtsreeks: 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
Tel de resultaten van deze vermenigvuldigingen op
Bereken de rest van deze som gedeeld door 11
Als de rest kleiner is dan 2, is het tweede controlecijfer 0; anders is het 11 min de rest

Om geldig te zijn, moeten beide controlecijfers overeenkomen met de berekende waarden.

Hoe Deze Tool Te Gebruiken

Onze Braziliaanse CNPJ Generator en Validator tool biedt twee hoofd functies: geldige CNPJs genereren en bestaande CNPJ-nummers valideren.

Een CNPJ Genereren

Om een geldige CNPJ voor testdoeleinden te genereren:

Navigeer naar de sectie "CNPJ Generator" van de tool
Klik op de knop "Genereer CNPJ"
Een wiskundig geldige CNPJ verschijnt in de geformatteerde weergave
Gebruik de knop "Kopieer" om de gegenereerde CNPJ naar je klembord te kopiëren

De gegenereerde CNPJ volgt alle wiskundige validatieregels van een echte CNPJ, maar is niet geregistreerd bij de Braziliaanse Federale Belastingdienst.

Een CNPJ Valideren

Om te controleren of een CNPJ wiskundig geldig is:

Navigeer naar de sectie "CNPJ Validator" van de tool
Voer de CNPJ in die je wilt valideren in het invoerveld
- De tool accepteert CNPJs met of zonder opmaak (punten, schuine strepen en koppeltekens)
Klik op de knop "Valideer"
De tool toont of de CNPJ geldig of ongeldig is op basis van het controlecijfer-algoritme

De validator controleert of de CNPJ het juiste formaat volgt en of de controlecijfers overeenkomen met de verwachte waarden volgens het validatie-algoritme.

Gebruiksscenario's

Deze Braziliaanse CNPJ generator en validator tool is bijzonder nuttig in de volgende scenario's:

Softwareontwikkeling en Testen

Testgegevens Aanmaken: Genereer geldige CNPJs voor het vullen van testdatabases zonder echte bedrijfsidentificatoren te gebruiken
Unit Testing: Valideer CNPJ-behandelingsfuncties in je code met bekende geldige en ongeldige voorbeelden
QA Testing: Maak testcases voor formulieren en interfaces die CNPJ-invoer vereisen
Integratietesten: Test systemen die gegevens uitwisselen met Braziliaanse overheidsdiensten of financiële instellingen

Onderwijs en Training

Leren van het CNPJ-formaat: Begrijp hoe Braziliaanse bedrijfsidentificatoren zijn gestructureerd
Studie van Algoritmen: Onderzoek hoe controlecijfervalidatie in de praktijk werkt
Gegevensvalidatietechnieken: Bestudeer voorbeelden van validatievereisten in de echte wereld

Gegevensverwerking

Gegevensopschoning: Valideer CNPJs in bestaande datasets om potentiële fouten te identificeren
Formuliervalidatie: Implementeer client-side of server-side validatie voor CNPJ-invoeren
Gegevensanonimisering: Vervang echte CNPJs door geldige gegenereerde nummers bij het voorbereiden van datasets voor analyse

Internationale Zaken

Voorbereiding op Markttoegang: Begrijp de vereisten voor Braziliaanse bedrijfsidentificatie
Documentvoorbereiding: Zorg voor de juiste opmaak bij het voorbereiden van bedrijfsdocumenten voor Brazilië
Nalevingscontrole: Controleer of verzamelde CNPJ-nummers in ieder geval wiskundig geldig zijn

Alternatieven

Hoewel onze tool een eenvoudige, browsergebaseerde oplossing biedt voor het genereren en valideren van CNPJs, zijn er verschillende alternatieven afhankelijk van je specifieke behoeften:

Programmeerbibliotheken

Voor ontwikkelaars die CNPJ-validatie rechtstreeks in applicaties willen integreren, zijn er verschillende taal-specifieke bibliotheken beschikbaar:

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

Deze bibliotheken bieden vaak extra functionaliteit zoals opmaak, parseren en validatie van andere Braziliaanse documenten.

API-diensten

Voor applicaties die validatie vereisen zonder het algoritme te implementeren:

Braziliaanse overheids-API's (registratie vereist)
Commerciële validatie-API's die CNPJ-controle omvatten
Bedrijfsinformatiediensten die valideren tegen de officiële database

Handmatige Berekening

Voor educatieve doeleinden of eenmalige validaties kun je het algoritme handmatig toepassen:

Haal de eerste 12 cijfers van de CNPJ
Voer de gewogen berekeningen uit zoals eerder beschreven
Vergelijk de berekende controlecijfers met de werkelijke controlecijfers

Handmatige berekening is echter foutgevoelig en inefficiënt voor regelmatig gebruik.

Technische Implementatie

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:

CNPJ Generatie Algoritme

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}
29

CNPJ Validatie Algoritme

1function 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}
24

CNPJ Formatteringsfunctie

1function 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}
18

Deze kernfuncties kunnen in andere programmeertalen worden geïmplementeerd volgens dezelfde logica. Hier zijn voorbeelden in Python en Java:

Python Implementatie

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
55

Java Implementatie

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        // 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}
85

Belangrijke Overwegingen

Bij het gebruik van deze CNPJ-generator en validator tool, houd rekening met de volgende overwegingen:

Juridische en Ethische Overwegingen

Niet voor Fraude: Gegenereerde CNPJs mogen nooit voor frauduleuze doeleinden of misrepresentatie worden gebruikt
Alleen voor Testen: Deze CNPJs zijn alleen voor test- en ontwikkelingsdoeleinden
Niet Geregistreerd: Gegenereerde CNPJs zijn wiskundig geldig maar niet geregistreerd bij de Braziliaanse autoriteiten
Geen Werkelijke Geldigheid: Ze kunnen niet worden gebruikt voor daadwerkelijke bedrijfsregistratie of belastingdoeleinden

Technische Beperkingen

Geen Bedrijfsinformatie: Gegenereerde CNPJs bevatten geen echte bedrijfssectorcodes of locatie-informatie
Geen Databaseverificatie: De validator controleert alleen de wiskundige geldigheid, niet de registratiestatus
Format Variaties: Hoewel de tool veelvoorkomende opmaakvariaties behandelt, kunnen sommige systemen specifieke formaten vereisen

Beveiligingsoverwegingen

Client-Side Verwerking: Alle verwerking vindt plaats in je browser; er worden geen gegevens naar servers verzonden
Geen Gegevensopslag: Gegenereerde CNPJs worden niet opgeslagen of gelogd
Geen Persoonlijke Gegevens: De tool verwerkt of behandelt geen persoonlijke informatie

Veelgestelde Vragen

Waarvoor wordt een CNPJ in Brazilië gebruikt?

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.

Zijn de CNPJs die door deze tool worden gegenereerd echt?

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.

Kan ik gegenereerde CNPJs voor mijn bedrijf gebruiken?

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.

Hoe kan ik controleren of een CNPJ tot een echt bedrijf behoort?

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.

Waarom weigert de validator een CNPJ met allemaal dezelfde cijfers?

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.

Slaat de tool de CNPJs op die ik genereer of valideer?

Nee. Alle verwerking vindt plaats in je browser, en we slaan geen van de CNPJs op die je genereert of valideert.

Kan ik meerdere CNPJs tegelijk genereren?

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.

Waarom is het formaat XX.XXX.XXX/XXXX-XX belangrijk?

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.

Hoe valideer ik een CNPJ programmatig?

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.

Zijn er speciale CNPJs voor overheidsinstanties?

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.

Referenties

Braziliaanse Federale Belastingdienst (Receita Federal do Brasil) - Officiële Website
"CNPJ - Cadastro Nacional da Pessoa Jurídica" - Wikipedia
Braziliaans Burgerlijk Wetboek (Wet nr. 10.406/2002) - Juridisch kader voor rechtspersonen in Brazilië
Braziliaanse Normatieve Instructie voor Bedrijfsregistratie (IN RFB nr. 1863/2018) - Regels voor CNPJ-registratie

Probeer Het Nu

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!

Braziliaanse CNPJ Generator en Validator Tool voor Testen

Braziliaanse CNPJ Generator en Validator

CNPJ Generator

CNPJ Validator

Documentatie