Generieren Sie gültige brasilianische CNPJ-Nummern und validieren Sie vorhandene mit diesem einfachen Tool, das für Entwickler und Tester konzipiert wurde, die mit brasilianischen Unternehmens-IDs arbeiten.
Generieren Sie eine gültige brasilianische CNPJ-Nummer zu Testzwecken.
Überprüfen Sie, ob eine brasilianische CNPJ-Nummer gültig ist.
Das brasilianische CNPJ (Cadastro Nacional da Pessoa Jurídica) ist eine eindeutige Identifikationsnummer, die Unternehmen und juristischen Personen in Brasilien zugewiesen wird. Dieses Tool zum Generieren und Validieren von CNPJ-Nummern bietet eine einfache, effiziente Möglichkeit, gültige CNPJ-Nummern zu generieren, die zu Testzwecken verwendet werden können, und bestehende CNPJ-Nummern gemäß dem offiziellen brasilianischen Algorithmus zu validieren. Egal, ob Sie ein Entwickler sind, der Anwendungen testet, die mit brasilianischen Unternehmensdaten umgehen, ein QA-Fachmann, der Testfälle erstellt, oder jemand, der mit brasilianischen Unternehmensinformationen arbeitet, dieses Tool vereinfacht den Umgang mit CNPJ-Nummern.
Im Gegensatz zu echten CNPJ-Nummern, die offiziell von der brasilianischen Bundessteuerbehörde (Receita Federal) ausgestellt werden, sind die von diesem Tool generierten CNPJs mathematisch gültig, aber nicht bei tatsächlichen Unternehmen registriert. Dies macht sie perfekt für Testszenarien, Beispieldaten und Entwicklungsumgebungen, in denen Sie richtig formatierte und gültige CNPJ-Nummern benötigen, ohne echte Unternehmenskennungen zu verwenden.
Ein CNPJ (Cadastro Nacional da Pessoa Jurídica) ist eine 14-stellige Identifikationsnummer, die Unternehmen und juristischen Personen von der brasilianischen Bundessteuerbehörde zugewiesen wird. Es dient als brasilianisches Pendant zu einer Unternehmensregistrierungsnummer oder Steuer-ID. Jedes Unternehmen, das legal in Brasilien tätig ist, muss über einen CNPJ verfügen, der für folgende Zwecke verwendet wird:
Der CNPJ ist eine wesentliche Kennung im brasilianischen Geschäftsumfeld und erscheint auf offiziellen Dokumenten, Verträgen und Finanzunterlagen.
Ein brasilianischer CNPJ besteht aus 14 Ziffern, die typischerweise wie folgt formatiert sind: XX.XXX.XXX/YYYY-ZZ
Die Struktur gliedert sich wie folgt:
Ein korrekt formatierter CNPJ könnte beispielsweise so aussehen: 12.345.678/0001-95
Die Prüfziffern (die letzten beiden Ziffern) werden mit einem spezifischen mathematischen Algorithmus berechnet, der die Authentizität des CNPJ validiert. Dieser Algorithmus stellt sicher, dass zufällig generierte Zahlen die Validierung nicht bestehen können, ohne die richtige Berechnungsmethode zu befolgen.
Der CNPJ-Validierungsalgorithmus verwendet eine gewichtete Berechnung zur Bestimmung der Prüfziffern. So funktioniert es:
Damit ein CNPJ gültig ist, müssen beide Prüfziffern mit den berechneten Werten übereinstimmen.
Unser brasilianischer CNPJ-Generator und -Validator bietet zwei Hauptfunktionen: das Generieren gültiger CNPJs und das Validieren bestehender CNPJ-Nummern.
Um einen gültigen CNPJ zu Testzwecken zu generieren:
Der generierte CNPJ folgt allen mathematischen Validierungsregeln eines echten CNPJ, ist jedoch nicht bei der brasilianischen Bundessteuerbehörde registriert.
Um zu überprüfen, ob ein CNPJ mathematisch gültig ist:
Der Validator überprüft, ob der CNPJ das richtige Format hat und ob die Prüfziffern mit den erwarteten Werten gemäß dem Validierungsalgorithmus übereinstimmen.
Dieses Tool zum Generieren und Validieren von brasilianischen CNPJs ist besonders nützlich in den folgenden Szenarien:
Während unser Tool eine einfache, browserbasierte Lösung zum Generieren und Validieren von CNPJs bietet, gibt es verschiedene Alternativen, je nach Ihren spezifischen Bedürfnissen:
Für Entwickler, die die CNPJ-Validierung direkt in Anwendungen integrieren, sind mehrere sprachspezifische Bibliotheken verfügbar:
cpf_cnpj.js, validator.jspython-cnpj, validate-docbrbrazilianutils, respect/validationcaelum-stella, commons-validatorcpf_cnpj, brazilian-railsDiese Bibliotheken bieten oft zusätzliche Funktionen wie Formatierung, Parsing und Validierung anderer brasilianischer Dokumente.
Für Anwendungen, die eine Validierung ohne Implementierung des Algorithmus erfordern:
Zu Bildungszwecken oder für einmalige Validierungen können Sie den Algorithmus manuell anwenden:
Die manuelle Berechnung ist jedoch fehleranfällig und ineffizient für die regelmäßige Nutzung.
Der CNPJ-Generator und -Validator in diesem Tool sind mit JavaScript implementiert, was ihn schnell macht und es ermöglicht, vollständig in Ihrem Browser zu laufen, ohne Ihre Daten an einen Server zu senden. So funktionieren die Kernfunktionen:
1function generateCNPJ() {
2 // Generiere die ersten 12 Ziffern zufällig
3 const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4
5 // Berechne die erste Prüfziffer
6 const firstCheckDigit = calculateCheckDigit(digits);
7 digits.push(firstCheckDigit);
8
9 // Berechne die zweite Prüfziffer
10 const secondCheckDigit = calculateCheckDigit(digits);
11 digits.push(secondCheckDigit);
12
13 // Formatiere den 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 // Entferne nicht-numerische Zeichen
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Überprüfe, ob es die richtige Länge hat
6 if (cleanCNPJ.length !== 14) return false;
7
8 // Überprüfe auf bekannte ungültige Muster (alle gleichen Ziffern)
9 if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10
11 // Konvertiere in ein Array von Ziffern
12 const digits = cleanCNPJ.split('').map(Number);
13
14 // Überprüfe die erste Prüfziffer
15 const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16 if (digits[12] !== expectedFirstDigit) return false;
17
18 // Überprüfe die zweite Prüfziffer
19 const expectedSecondDigit = calculateCheckDigit(digits.slice(0, 13));
20 if (digits[13] !== expectedSecondDigit) return false;
21
22 return true;
23}
241function formatCNPJ(cnpj) {
2 // Entferne nicht-numerische Zeichen
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Formatieren basierend auf der Länge
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}
18Diese Kernfunktionen können in anderen Programmiersprachen unter Beibehaltung derselben Logik implementiert werden. Hier sind Beispiele in Python und 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 # Generiere die ersten 12 Ziffern zufällig
15 digits = [random.randint(0, 9) for _ in range(12)]
16
17 # Berechne die erste Prüfziffer
18 first_check = calculate_check_digit(digits)
19 digits.append(first_check)
20
21 # Berechne die zweite Prüfziffer
22 second_check = calculate_check_digit(digits)
23 digits.append(second_check)
24
25 # Formatiere den 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 # Entferne nicht-numerische Zeichen
31 cnpj = ''.join(filter(str.isdigit, cnpj))
32
33 # Überprüfe die Länge
34 if len(cnpj) != 14:
35 return False
36
37 # Überprüfe, ob alle Ziffern gleich sind
38 if len(set(cnpj)) == 1:
39 return False
40
41 # Konvertiere in eine Liste von Ziffern
42 digits = [int(d) for d in cnpj]
43
44 # Validieren der ersten Prüfziffer
45 first_check = calculate_check_digit(digits[:12])
46 if digits[12] != first_check:
47 return False
48
49 # Validieren der zweiten Prüfziffer
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 // Generiere die ersten 12 Ziffern zufällig
10 for (int i = 0; i < 12; i++) {
11 digits[i] = random.nextInt(10);
12 }
13
14 // Berechne die erste Prüfziffer
15 digits[12] = calculateCheckDigit(digits, 12);
16
17 // Berechne die zweite Prüfziffer
18 digits[13] = calculateCheckDigit(digits, 13);
19
20 // Formatiere den 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 // Entferne nicht-numerische Zeichen
45 cnpj = cnpj.replaceAll("\\D", "");
46
47 // Überprüfe die Länge
48 if (cnpj.length() != 14) {
49 return false;
50 }
51
52 // Überprüfe, ob alle Ziffern gleich sind
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 // Konvertiere in ein Array von Ziffern
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 // Validieren der ersten Prüfziffer
71 int firstCheck = calculateCheckDigit(digits, 12);
72 if (digits[12] != firstCheck) {
73 return false;
74 }
75
76 // Validieren der zweiten Prüfziffer
77 int secondCheck = calculateCheckDigit(digits, 13);
78 if (digits[13] != secondCheck) {
79 return false;
80 }
81
82 return true;
83 }
84}
85Bei der Verwendung dieses CNPJ-Generator- und -Validator-Tools sollten Sie die folgenden Überlegungen im Hinterkopf behalten:
Ein CNPJ ist die nationale Registrierungsnummer für Unternehmen und juristische Personen in Brasilien. Es wird für Steuerzwecke, Unternehmensregistrierung, Eröffnung von Bankkonten und zur Identifizierung von Unternehmen in offiziellen Transaktionen verwendet.
Nein. Die von diesem Tool generierten CNPJs sind mathematisch gültig gemäß dem Prüfziffernalgorithmus, sind jedoch nicht bei der brasilianischen Bundessteuerbehörde registriert und gehören nicht zu realen Unternehmen.
Nein. Um einen legitimen CNPJ für ein Unternehmen zu erhalten, müssen Sie sich bei der brasilianischen Bundessteuerbehörde (Receita Federal) gemäß dem offiziellen Verfahren registrieren. Generierte CNPJs sind nur für Testzwecke gedacht.
Um zu überprüfen, ob ein CNPJ bei einem tatsächlichen Unternehmen registriert ist, müssen Sie die Datenbank der brasilianischen Bundessteuerbehörde konsultieren. Unser Tool überprüft nur, ob ein CNPJ mathematisch gültig ist, nicht ob es offiziell registriert ist.
CNPJs mit allen gleichen Ziffern (wie 11.111.111/1111-11) werden automatisch als ungültig betrachtet, selbst wenn sie mathematisch den Prüfziffernalgorithmus bestehen. Dies ist eine Regel, die von der brasilianischen Bundessteuerbehörde festgelegt wurde.
Nein. Alle Verarbeitungen erfolgen in Ihrem Browser, und wir speichern oder übertragen keine der CNPJs, die Sie generieren oder validieren.
Die aktuelle Version des Tools generiert jeweils einen CNPJ. Für die Massenproduktion sollten Sie eine der in der Rubrik Alternativen genannten Programmierbibliotheken in Betracht ziehen.
Dies ist das offizielle Format, das von den brasilianischen Behörden verlangt wird. Die spezifische Gruppierung hilft, verschiedene Komponenten des CNPJ zu identifizieren, wie die Basisnummer und den Filialidentifikator.
Sie können den Validierungsalgorithmus in Ihrer bevorzugten Programmiersprache mithilfe der im Abschnitt Technische Implementierung bereitgestellten Codebeispiele implementieren oder eine der in der Rubrik Alternativen genannten Bibliotheken verwenden.
Ja. Regierungsstellen in Brasilien haben spezifische CNPJ-Muster. Zum Beispiel beginnen Bundesbehörden oft mit bestimmten Ziffern. Unser Generator erstellt zufällige CNPJs und generiert keine CNPJs für Regierungsstellen.
Unser brasilianischer CNPJ-Generator und -Validator-Tool macht den Umgang mit diesen Identifikationsnummern einfach und effizient. Egal, ob Sie Anwendungen testen, Beispieldaten vorbereiten oder bestehende CNPJs validieren, dieses Tool bietet eine unkomplizierte Lösung ohne die Komplexität von API-Integrationen oder erweiterten Konfigurationen.
Generieren Sie jetzt Ihren ersten gültigen CNPJ oder validieren Sie einen bestehenden mit unserer einfachen Benutzeroberfläche!
Entdecken Sie weitere Tools, die für Ihren Workflow nützlich sein könnten