Naar inhoud springen
🛠️
Whiz Tools

CNPJ Generator & Validator - Braziliaans Bedrijfs-ID-hulpmiddel

Genereer geldige CNPJ-nummers voor testen of valideer direct Braziliaanse bedrijfs-ID's. Gratis hulpmiddel met controlegetallen verificatie voor ontwikkelaars die werken met Cadastro Nacional da Pessoa Jurídica.

Braziliaanse CNPJ Generator en Validator

CNPJ Generator

Genereer een geldig Braziliaans CNPJ-nummer voor testdoeleinden.

CNPJ Validator

Controleer of een Braziliaans CNPJ-nummer geldig is.

Laadcalculator...
📚

Documentatie

Het begrijpen van Braziliaanse CNPJ-nummers

De CNPJ (Cadastro Nacional da Pessoa Jurídica) is de Braziliaanse versie van een bedrijfsbelasting-ID—een 14-cijferig nummer dat elke juridische bedrijfsentiteit in het land identificeert. Als je software ontwikkelt die Braziliaanse bedrijfsgegevens verwerkt, zul je deze nummers snel tegenkomen in registratieformulieren, facturen en API-integraties.

Hier is wat deze tool praktisch maakt: het genereert wiskundig geldige CNPJs voor testen zonder echte bedrijfsidentificatoren te gebruiken. Wanneer je een testdatabase met 1.000 records opzet of een validatieroutine aan het debuggen bent om 2 uur 's nachts, heb je CNPJs nodig die algoritmische controles doorstaan maar niet per ongeluk overeenkomen met daadwerkelijke bedrijven. Dat is precies wat dit genereert.

De gegenereerde nummers volgen het officiële Receita Federal (Braziliaanse Federale Belastingdienst) validatiealgoritme. Ze hebben correcte controletekens en juiste opmaak—ze zijn gewoon niet geregistreerd in de overheidsdatabase. Beschouw ze als syntactisch correcte testgegevens die geen nalevingsproblemen zullen veroorzaken in je ontwikkelomgeving.

Wat is een CNPJ en Waarom Het Belangrijk Is

Een CNPJ fungeert als Brazilië's bedrijfsidentificatie—vergelijkbaar met een EIN in de Verenigde Staten of een Bedrijfsregistratienummer in het Verenigd Koninkrijk. Elke bedrijfsentiteit die legaal in Brazilië opereert, moet er een hebben, uitgegeven door de Receita Federal (Federale Belastingdienst).

U zult CNPJs tegenkomen bij:

  • Betalingsverwerking: Braziliaanse betaalgateways vereisen CNPJ-validatie voor merchantaccounts
  • Belastingcompliance: Elke factuur die in Brazilië wordt uitgegeven, moet een geldige CNPJ bevatten
  • Bedrijfsregistratie: Overheidsinstanties gebruiken CNPJs om rechtspersonen over systemen heen bij te houden
  • Bankoperaties: Het openen van zakelijke rekeningen of het verwerken van internationale overmakingen
  • Import/export: Douanedocumentatie vereist CNPJ-verificatie
  • Overheidscontracten: Systemen voor openbare aanbestedingen valideren CNPJs voordat biedingen worden geaccepteerd

Uit mijn ervaring met Braziliaanse e-commerce platforms is een van de meest voorkomende integratiepunten de checkout-flow waarbij gebruikers hun CNPJ invoeren voor zakelijke aankopen. Uw validatielogica moet opmaakfouten onderscheppen voordat de betalingsverwerker dat doet—anders zult u mislukte transacties zien die hadden kunnen worden voorkomen.

CNPJ-structuur en -indeling

Een CNPJ bestaat uit 14 cijfers met de indeling: XX.XXX.XXX/YYYY-ZZ

De structuur uitgelegd:

  1. Eerste 8 cijfers (XX.XXX.XXX): Het basis registratienummer dat uniek aan het bedrijf wordt toegewezen
  2. Volgende 4 cijfers (/YYYY): Filiaal- of vestigingsidentificatie—/0001 geeft het hoofdkantoor aan, terwijl /0002, /0003 filiaallocaties vertegenwoordigen
  3. Laatste 2 cijfers (-ZZ): Verificatiecijfers berekend via een gewogen algoritme

Voorbeeld: 12.345.678/0001-95

Interessant aan de filiaalidentificatie: wanneer een bedrijf meerdere locaties opent, krijgen deze dezelfde eerste 8 cijfers maar een ander filiaalnummer. Als een winkelketen 50 winkels heeft, zullen ze CNPJs hebben die eindigen op /0001 tot /0050, allemaal met hetzelfde basisnummer. Dit maakt het gemakkelijk om te herkennen dat meerdere CNPJs tot dezelfde moederorganisatie behoren.

De controletekens zijn niet willekeurig—ze worden berekend met behulp van een modulus-11-algoritme met specifieke gewichtreeksen. Deze ontwerpkeuze, gebruikelijk in Braziliaanse administratieve documenten, maakt het wiskundig moeilijk om geldige nummers te vervalsen of per ongeluk geldige nummers te maken door typefouten.

Hoe CNPJ-validatie werkelijk werkt

Het validatie-algoritme gebruikt een gewogen modulus-11-berekening. Hier is de logica erachter:

Eerste Controlegetal Berekening

  1. Neem de eerste 12 cijfers en vermenigvuldig elk met gewichten: 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. Som alle producten
  3. Deel de som door 11 en verkrijg de rest
  4. Als rest < 2, is het controlegetal 0; anders is het 11 - rest

Tweede Controlegetal Berekening

  1. Neem de eerste 13 cijfers (inclusief het eerste controlegetal) en vermenigvuldig met gewichten: 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. Som alle producten
  3. Deel door 11 en verkrijg de rest
  4. Als rest < 2, is het controlegetal 0; anders is het 11 - rest

Waarom deze aanpak werkt: Het gewogen vermenigvuldigingssysteem creëert een unieke relatie tussen alle 12 basisgetallen en de resulterende controlegetallen. Het veranderen van zelfs een enkel cijfer in het basisnummer produceert verschillende controlegetallen, wat veelvoorkomende overschrijvingsfouten zoals het verwisselen van twee cijfers (typen 12.345 in plaats van 12.354) onderschept.

Een praktische opmerking: CNPJs met allemaal identieke cijfers (zoals 11.111.111/1111-11) zijn automatisch ongeldig, zelfs als ze de wiskundige controle doorstaan. De Receita Federal sluit deze patronen expliciet uit om triviale gevallen te voorkomen.

Hoe gebruik je de CNPJ-generator en -validator

CNPJ's genereren voor testen

Heb je een geldige CNPJ nodig voor je testdatabase? Zo werkt het:

  1. Klik op "CNPJ genereren"
  2. De tool maakt direct een wiskundig geldig nummer
  3. Klik op "Kopiëren" om het naar je klembord te kopiëren
  4. Plak het in je testformulieren, database seeds of unit tests

Elke gegenereerde CNPJ doorstaat alle algoritmische validatiecontroles maar is niet geregistreerd bij de Receita Federal. Dit betekent dat je ze vrij kunt gebruiken in de ontwikkeling zonder je zorgen te maken over het per ongeluk gebruiken van de identificatie van een echt bedrijf.

CNPJ-nummers valideren

Heb je een CNPJ die je wilt verifiëren? De validator doet het werk:

  1. Plak of typ de CNPJ in het invoerveld
  2. Maak je geen zorgen over de opmaak—het werkt met 12345678000195 of 12.345.678/0001-95
  3. Klik op "Valideren"
  4. Ontvang direct feedback over de juistheid van de controletekens

Wat de validator controleert: juiste lengte (14 cijfers), correcte berekening van controletekens en uitsluiting van ongeldige patronen zoals cijfers die allemaal hetzelfde zijn. Wat het niet controleert: of de CNPJ is geregistreerd in de overheidsdatabase—dat vereist rechtstreekse raadpleging van de Receita Federal.

Praktische gebruiksgevallen voor CNPJ Generator en Validator

Softwareontwikkeling en Testen

Database seeding: Bij het opzetten van een staging-omgeving met realistische testgegevens heb je tientallen of honderden geldige CNPJs nodig. Het handmatig maken hiervan is tijdrovend, en het gebruik van echte bedrijfsidentificatoren roept privacyzorgen op. Gegenereerde CNPJs lossen beide problemen op.

Unit testing randgevallen: Je validatiefunctie moet 00.000.000/0000-00 afwijzen maar 11.222.333/0001-81 accepteren. Een generator stelt je in staat om snel zowel geldige als opzettelijk ongeldige testgevallen te maken om te verifiëren of je logica grensvoorwaarden correct afhandelt.

QA regressietesten: Bij het testen van registratieformulieren of B2B-afrekenprocedures hebben QA-teams verse testgegevens nodig voor elke run. Een veelvoorkomend probleem: testomgevingen raken vervuild met dezelfde 5-6 CNPJs die herhaaldelijk worden gebruikt, wat bugs maskeert die alleen verschijnen met specifieke cijferpatronen.

API-integratietesten: Als je integreert met Braziliaanse betalingsprocessors zoals PagSeguro of Mercado Pago, vereisen hun sandbox-omgevingen vaak geldige CNPJ-opmaak. De wiskunde moet correct zijn, zelfs als je geen productiedatabases raakt.

Gegevensverwerking en -validatie

Geïmporteerde gegevens opschonen: Je hebt een CSV ontvangen met 10.000 Braziliaanse bedrijfsrecords. Voordat je gaat verwerken, moet je identificeren welke CNPJs verkeerd zijn gevormd. Door ze door de validator te halen, markeer je vermeldingen met typefouten, afkapping of onjuiste controletekens - wat uren downstream debuggen bespaart.

Client-side formuliervalidatie: Het onderscheppen van ongeldige CNPJs vóór formulierindiening verbetert de gebruikerservaring. Niemand wil een registratieformulier met 20 velden invullen om vervolgens bij indiening een fout te krijgen omdat hij twee cijfers heeft verwisseld in zijn CNPJ.

Gegevensononymisering voor analyse: Bij het voorbereiden van productiegegevens voor delen met analyseteams of externe partners, moet je echte CNPJs vervangen door geldige maar fictieve. Dit behoudt de referentiële integriteit in je dataset terwijl het werkelijke bedrijfsidentiteiten beschermt.

Internationale Bedrijfsactiviteiten

Braziliaanse vereisten begrijpen: Als je de Braziliaanse markt betreedt, kom je CNPJ-vereisten tegen in contracten, facturen en verzendingsdocumentatie. Een tool om met de indeling te experimenteren helpt je begrijpen wat je systemen moeten kunnen verwerken.

Specificaties van derden-integratie: Bij het beoordelen van API-documentatie van Braziliaanse SaaS-providers zie je vaak CNPJ-velden in payload-voorbeelden. De mogelijkheid om geldige testwaarden te genereren helpt je integraties sneller te prototypen.

Alternatieve CNPJ-validatiemethoden

Programmeerbiblotheken

Als u CNPJ-validatie nodig heeft in uw toepassingslogica, implementeren deze bibliotheken het algoritme voor controletekens:

Deze bibliotheken behandelen doorgaans opmaak, parsing en validatie voor meerdere Braziliaanse documenttypen (CPF, CNPJ, enz.).

Officiële verificatie-API's

Voor productiesystemen die daadwerkelijke bedrijfsregistratie moeten verifiëren:

  • Receita Federal Openbare Dienst: De Consulta CNPJ API staat verificatie toe tegen de officiële database (vereist juiste autorisatie en snelheidsbegrenzing)
  • Externe gegevensleveranciers: Services zoals Serasa Experian en Boa Vista SCPC bieden commerciële API's die bedrijfsgegevens, registratiestatus en kredietinformatie retourneren

Opmerking: Deze services controleren de daadwerkelijke registratie, niet alleen de wiskundige geldigheid. U heeft de juiste autorisatie nodig en moet rekening houden met API-kosten voor productiegebruik.

Wanneer welke aanpak te gebruiken

Gebruik deze browsertool wanneer: U snelle validatie nodig heeft zonder afhankelijkheden te installeren, testgegevens voor demo's wilt genereren of wilt leren hoe CNPJ-validatie werkt.

Gebruik een bibliotheek wanneer: U een toepassing bouwt die client-side of server-side validatie nodig heeft als onderdeel van formulierverwerking.

Gebruik een officiële API wanneer: U moet verifiëren of een CNPJ overeenkomt met een echt, actief bedrijf met een actuele registratiestatus.

Technische Implementatiedetails

Deze tool draait volledig in uw browser met behulp van JavaScript—geen serveraanvragen, geen gegevens die uw machine verlaten. Hier is hoe de algoritmen werken onder de motorkap, met code die u kunt aanpassen voor uw eigen projecten:

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 eerste controlegetal
6  const firstCheckDigit = calculateCheckDigit(digits);
7  digits.push(firstCheckDigit);
8  
9  // Bereken tweede controlegetal
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 (alle zelfde cijfers)
9  if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10  
11  // Converteer naar array van cijfers
12  const digits = cleanCNPJ.split('').map(Number);
13  
14  // Controleer eerste verificatiecijfer
15  const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16  if (digits[12] !== expectedFirstDigit) return false;
17  
18  // Controleer tweede verificatiecijfer
19  const expectedSecondDigit = calculateCheckDigit(digits.slice(0, 13));
20  if (digits[13] !== expectedSecondDigit) return false;
21  
22  return true;
23}
24

CNPJ Formatteerfunctie

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 worden geïmplementeerd in andere programmeertalen met 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 eerste 12 cijfers willekeurig
15    digits = [random.randint(0, 9) for _ in range(12)]
16    
17    # Bereken eerste controlegetal
18    first_check = calculate_check_digit(digits)
19    digits.append(first_check)
20    
21    # Bereken tweede controlegetal
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    # Converteer naar lijst van integers
42    digits = [int(d) for d in cnpj]
43    
44    # Valideer eerste controlegetal
45    first_check = calculate_check_digit(digits[:12])
46    if digits[12] != first_check:
47        return False
48    
49    # Valideer tweede controlegetal
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 eerste 12 cijfers willekeurig
10        for (int i = 0; i < 12; i++) {
11            digits[i] = random.nextInt(10);
12        }
13        
14        // Bereken eerste controlegetal
15        digits[12] = calculateCheckDigit(digits, 12);
16        
17        // Bereken tweede controlegetal
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        // Converteer naar array van integers
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 eerste controlegetal
71        int firstCheck = calculateCheckDigit(digits, 12);
72        if (digits[12] != firstCheck) {
73            return false;
74        }
75        
76        // Valideer tweede controlegetal
77        int secondCheck = calculateCheckDigit(digits, 13);
78        if (digits[13] != secondCheck) {
79            return false;
80        }
81        
82        return true;
83    }
84}
85

Belangrijke beperkingen en overwegingen

Wat deze tool wel en niet kan doen

Wat het valideert: Wiskundige correctheid—of de controletekens overeenkomen met de berekening van het algoritme.

Wat het niet valideert: Of de CNPJ is geregistreerd bij de Receita Federal, of deze toebehoort aan een actief bedrijf, of deze is gekoppeld aan de bedrijfsnaam die u verwacht.

Beschouw het als spellingcontrole versus feitencontrole. Deze tool vertelt u of een CNPJ "correct gespeld" is volgens de wiskundige regels, maar kan niet vertellen of het nummer overeenkomt met een echt, actief bedrijf.

Wettelijk en ethisch gebruik

Gegenereerde CNPJs zijn alleen voor testen en ontwikkeling. Ze zijn wiskundig geldig maar niet geregistreerd bij de Braziliaanse autoriteiten, wat betekent:

  • ✅ Veilig te gebruiken voor: Het vullen van testdatabases, unit testing validatielogica, QA-omgevingen, codevoorbeelden in documentatie
  • ❌ Nooit gebruiken voor: Belastingaangifte, bedrijfsregistratie, contracten ondertekenen, verwerken van echte transacties of het verkeerd voorstellen van bedrijfsidentiteit

Het gebruik van een valse CNPJ voor officiële doeleinden is niet alleen onethisch—het is illegaal volgens Braziliaanse wet en kan leiden tot fraudeaanklachten.

Technische beperkingen om te weten

Willekeurige generatie heeft implicaties: De tool genereert de eerste 12 cijfers willekeurig. Echte CNPJs uitgegeven door de Receita Federal volgen interne patronen gerelateerd aan registratiedatum, regionaal kantoor en bedrijfstype. Gegenereerde nummers zullen deze patronen niet volgen, wat geavanceerde validatiesystemen mogelijk zal opvallen.

Geen semantische validatie: Een geldig CNPJ-formaat betekent niet een geldige bedrijfscontext. Bijvoorbeeld, overheidsinstanties hebben specifieke CNPJ-reeksen—deze generator kan er toevallig een maken, maar het zou niet betekenisvol zijn.

Formaatverwerking: De validator accepteert verschillende invoerformaten (12345678000195, 12.345.678/0001-95), maar sommige verouderde systemen verwachten exact formaat. Test altijd met uw specifieke integratie-eisen.

Privacy en beveiliging

Alle verwerking gebeurt client-side in uw browser. Geen CNPJs die u genereert of valideert worden naar servers gestuurd, gelogd of opgeslagen. De tool vraagt, behandelt of verwerkt geen persoonlijke informatie.

Veelgestelde vragen over CNPJ-validatie

Wat is het verschil tussen valideren en verifiëren van een CNPJ?

Validatie controleert of het nummer wiskundig correct is—juiste opmaak, correcte controletekens, geen ongeldige patronen. Deze tool doet validatie.

Verificatie controleert of de CNPJ is geregistreerd bij een daadwerkelijk bedrijf in de Receita Federal-database. Verificatie vereist het opvragen van de overheidsdatabase en is niet iets wat deze tool doet.

Je kunt een perfect geldige CNPJ hebben die niet is geverifieerd (zoals de testnummers die deze tool genereert), of een ongeldige CNPJ die toebehoort aan een echt bedrijf (omdat iemand een typfout heeft gemaakt bij het invoeren).

Kan ik gegenereerde CNPJs gebruiken voor productietesten?

Het hangt ervan af wat je bedoelt met "productietesten". Ze zijn prima voor staging-omgevingen, load testing en pre-launch QA. Maar als "productietesten" betekent testen met echte transacties, echte overheids-API's of echte financiële systemen—dan nee, je hebt daarvoor echte geregistreerde CNPJs nodig.

Een veiligere aanpak: gebruik gegenereerde CNPJs in geïsoleerde testomgevingen, en schakel vervolgens over op een kleine set echte test-bedrijfs-CNPJs (die je zelf beheert) bij het testen van productie-integraties.

Waarom wijst de validator 11.111.111/1111-11 af?

Hoewel een CNPJ met allemaal identieke cijfers wiskundig geldige controletekens kan produceren, sluit de Receita Federal deze patronen expliciet uit. Het is een bedrijfsregel, geen wiskundige regel. Hetzelfde geldt voor opeenvolgende patronen in sommige validatiesystemen.

Dit is vergelijkbaar met hoe veel systemen wachtwoorden zoals "password123" afwijzen, zelfs als ze aan lengtevereisten voldoen—ze zijn technisch geldig maar praktisch onaanvaardbaar.

Hoe ga ik om met CNPJ-validatie in verschillende locales?

Braziliaanse bedrijven die internationaal zaken doen, laten soms de opmaakkenmerken weg bij het invoeren van CNPJs in buitenlandse systemen. Je validatielogica moet niet-numerieke tekens verwijderen voordat je controleert:

1const cleanCNPJ = input.replace(/\D/g, ''); // Verwijder alles behalve cijfers
2

Accepteer 12.345.678/0001-95, 12345678000195, en 12 345 678 0001 95 als gelijkwaardige invoer.

Wat is het verschil tussen CNPJ en CPF-validatie?

CPF (Cadastro de Pessoas Físicas) is Brazilië's individuele belasting-ID, terwijl CNPJ voor bedrijven is. Ze gebruiken verschillende algoritmen voor controletekens en lengtes (CPF heeft 11 cijfers, CNPJ heeft 14). Als je een Braziliaanse app bouwt die beide behandelt, heb je aparte validatiefuncties nodig—hoewel veel bibliotheken beide formaten ondersteunen.

Een gebruikelijk patroon: laat gebruikers ofwel CPF of CNPJ in hetzelfde veld invoeren, detecteer vervolgens welk type op basis van lengte na het verwijderen van opmaakkenmerken.

Werkt dit voor buitenlandse bedrijven die in Brazilië opereren?

Buitenlandse bedrijven die in Brazilië opereren, moeten ook CNPJs verkrijgen van de Receita Federal. Hun CNPJs volgen dezelfde opmaak en validatieregels als binnenlandse bedrijven. Er is geen speciale "buitenlands bedrijf" CNPJ-indeling.

Buitenlandse bedrijven kunnen echter aanvullende documentatievereisten en verschillende registratieprocessen hebben—raadpleeg een Braziliaanse bedrijfsadvocaat voor specifieke details.

Kan ik de overheidsdatabase opvragen om CNPJ-registratie te verifiëren?

Ja, de Receita Federal biedt openbare toegang om basale CNPJ-informatie te verifiëren via hun Consulta Pública CNPJ service. Je kunt CNPJs handmatig opzoeken of, met de juiste autorisatie, hun API's gebruiken voor programmatische toegang.

Let op dat intensief gebruik registratie vereist en er snelheidslimieten zijn om misbruik te voorkomen.

Hoe vaak veranderen CNPJs?

CNPJs zijn permanente identificatoren die niet veranderen wanneer een bedrijf van naam, adres of eigendomsstructuur verandert. Als een bedrijf echter sluit en later opnieuw registreert, kan het een nieuwe CNPJ ontvangen. Filiaal-nummers (het /XXXX-gedeelte) kunnen worden toegevoegd als bedrijven nieuwe locaties openen, maar het basis 8-cijferige nummer blijft constant.

Referenties en Aanvullende Bronnen

Officiële Overheidsinstanties

  1. Receita Federal do Brasil - Officiële Portal - De officiële website van de Braziliaanse Federale Belastingdienst met CNPJ-registratie en verificatiediensten
  2. Consulta Pública CNPJ - Openbare CNPJ-Opzoeking - Officiële overheidsdienst om de CNPJ-registratiestatus te verifiëren
  3. Normatieve Instructie RFB Nr. 1863/2018 - Wettelijke regelgeving die CNPJ-registratie en -gebruik in Brazilië beheerst

Technische Standaarden en Documentatie

  1. Modulaire rekenkunde algoritmen - De controlegetallen berekening gebruikt modulo 11 rekenkunde, een standaardbenadering voor validatiegetallen
  2. ISO/IEC 7064 - Internationale standaard voor controlegetal systemen die het ontwerp van Braziliaanse documentvalidatie heeft beïnvloed
  3. Braziliaans Burgerlijk Wetboek (Wet Nr. 10.406/2002) - Wettelijk kader dat bedrijfsentiteitsclassificaties definieert die CNPJ-registratie vereisen

Ontwikkelaarsbronnen

  1. NPM-pakketregister - npmjs.com - Opslagplaats voor JavaScript-bibliotheken inclusief Braziliaanse documentvalidators
  2. PyPI (Python Package Index) - pypi.org - Python-bibliotheken voor CNPJ-validatie en Braziliaanse documentverwerking
  3. GitHub - Open-source implementaties van CNPJ-validatie in meerdere programmeertalen

Begin met het Genereren en Valideren van CNPJs

Of je nu een Braziliaans e-commerceplatform aan het bouwen bent, betalingsintegraties met Mercado Pago aan het testen bent, of gewoon wilt begrijpen hoe CNPJ-validatie werkt, deze tool geeft je direct toegang tot zowel generatie- als validatiemogelijkheden.

Geen installatie, geen API-sleutels, geen ingewikkelde setup. Open gewoon je browser en begin te werken met geldige Braziliaanse bedrijfsidentificatienummers.