Generați numere CNPJ braziliene valide și validați cele existente cu acest instrument simplu conceput pentru dezvoltatori și testeri care lucrează cu ID-urile de afaceri braziliene.
Generați un număr CNPJ brazilian valid pentru scopuri de testare.
Verificați dacă un număr CNPJ brazilian este valid.
CNPJ-ul Brazilian (Cadastro Nacional da Pessoa Jurídica) este un număr de identificare unic atribuit întreprinderilor și entităților legale din Brazilia. Acest generator și validator CNPJ Brazilian oferă o modalitate simplă și eficientă de a genera numere CNPJ valide pentru scopuri de testare și de a valida numerele CNPJ existente conform algoritmului oficial brazilian. Indiferent dacă ești un dezvoltator care testează aplicații care gestionează datele de afaceri braziliene, un profesionist QA care creează cazuri de testare sau oricine lucrează cu informații despre companiile braziliene, acest instrument simplifică procesul de lucru cu numerele CNPJ.
Spre deosebire de numerele CNPJ reale care sunt emise oficial de Serviciul Federal de Venituri din Brazilia (Receita Federal), CNPJs generate de acest instrument sunt matematic valide, dar nu sunt înregistrate la companii reale. Acest lucru le face perfecte pentru scenarii de testare, date de exemplu și medii de dezvoltare în care ai nevoie de numere CNPJ corect formatate și valide fără a folosi identificatori de afaceri reali.
Un CNPJ (Cadastro Nacional da Pessoa Jurídica) este un număr de identificare de 14 cifre atribuit întreprinderilor și entităților legale de către Serviciul Federal de Venituri din Brazilia. Acesta servește ca echivalentul brazilian al unui număr de înregistrare a companiei sau al unui ID fiscal. Fiecare afacere care funcționează legal în Brazilia trebuie să aibă un CNPJ, care este folosit pentru:
CNPJ-ul este un identificator esențial în ecosistemul de afaceri din Brazilia și apare pe documentele oficiale, contracte și înregistrări financiare.
Un CNPJ Brazilian constă din 14 cifre, de obicei formatate ca: XX.XXX.XXX/YYYY-ZZ
Structura se descompune astfel:
De exemplu, un CNPJ corect formatat ar putea arăta astfel: 12.345.678/0001-95
Cifrele de verificare (ultimele două numere) sunt calculate folosind un anumit algoritm matematic care validează autenticitatea CNPJ-ului. Acest algoritm asigură că numerele generate aleatoriu nu pot trece validarea fără a urma metoda de calcul corespunzătoare.
Algoritmul de validare CNPJ folosește un calcul ponderat pentru a determina cifrele de verificare. Iată cum funcționează:
Pentru ca un CNPJ să fie valid, ambele cifre de verificare trebuie să se potrivească cu valorile calculate.
Instrumentul nostru Generator și Validator CNPJ Brazilian oferă două funcții principale: generarea de CNPJs valizi și validarea numerele CNPJ existente.
Pentru a genera un CNPJ valid pentru scopuri de testare:
CNPJ-ul generat va respecta toate regulile de validare matematică ale unui CNPJ real, dar nu este înregistrat la Serviciul Federal de Venituri din Brazilia.
Pentru a verifica dacă un CNPJ este matematic valid:
Validatorul verifică dacă CNPJ-ul respectă formatul corect și dacă cifrele de verificare se potrivesc cu valorile așteptate conform algoritmului de validare.
Acest instrument Generator și Validator CNPJ Brazilian este deosebit de util în următoarele scenarii:
În timp ce instrumentul nostru oferă o soluție simplă, bazată pe browser, pentru generarea și validarea CNPJ-urilor, există mai multe alternative în funcție de nevoile tale specifice:
Pentru dezvoltatorii care integrează validarea CNPJ direct în aplicații, există mai multe biblioteci specifice limbajului disponibile:
cpf_cnpj.js, validator.jspython-cnpj, validate-docbrbrazilianutils, respect/validationcaelum-stella, commons-validatorcpf_cnpj, brazilian-railsAceste biblioteci oferă adesea funcționalități suplimentare, cum ar fi formatarea, analiza și validarea altor documente braziliene.
Pentru aplicațiile care necesită validare fără a implementa algoritmul:
Pentru scopuri educaționale sau validări unice, poți aplica manual algoritmul:
Cu toate acestea, calculul manual este predispus la erori și ineficient pentru utilizarea regulată.
Generatorul și validatorul CNPJ din acest instrument sunt implementate folosind JavaScript, ceea ce îl face rapid și capabil să ruleze complet în browserul tău fără a trimite datele tale către un server. Iată cum funcționează funcțiile de bază:
1function generateCNPJ() {
2 // Generează primele 12 cifre aleator
3 const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4
5 // Calculează prima cifră de verificare
6 const firstCheckDigit = calculateCheckDigit(digits);
7 digits.push(firstCheckDigit);
8
9 // Calculează a doua cifră de verificare
10 const secondCheckDigit = calculateCheckDigit(digits);
11 digits.push(secondCheckDigit);
12
13 // Formatează CNPJ-ul
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 // Elimină caracterele non-numerice
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Verifică dacă are lungimea corectă
6 if (cleanCNPJ.length !== 14) return false;
7
8 // Verifică pentru modele invalide cunoscute (toate cifrele sunt aceleași)
9 if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10
11 // Convertește în array de cifre
12 const digits = cleanCNPJ.split('').map(Number);
13
14 // Verifică prima cifră de verificare
15 const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16 if (digits[12] !== expectedFirstDigit) return false;
17
18 // Verifică a doua cifră de verificare
19 const expectedSecondDigit = calculateCheckDigit(digits.slice(0, 13));
20 if (digits[13] !== expectedSecondDigit) return false;
21
22 return true;
23}
241function formatCNPJ(cnpj) {
2 // Elimină caracterele non-numerice
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Formatează în funcție de lungime
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}
18Aceste funcții de bază pot fi implementate în alte limbaje de programare urmând aceeași logică. Iată exemple în Python și 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 # Generează primele 12 cifre aleator
15 digits = [random.randint(0, 9) for _ in range(12)]
16
17 # Calculează prima cifră de verificare
18 first_check = calculate_check_digit(digits)
19 digits.append(first_check)
20
21 # Calculează a doua cifră de verificare
22 second_check = calculate_check_digit(digits)
23 digits.append(second_check)
24
25 # Formatează CNPJ-ul
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 # Elimină caracterele non-numerice
31 cnpj = ''.join(filter(str.isdigit, cnpj))
32
33 # Verifică lungimea
34 if len(cnpj) != 14:
35 return False
36
37 # Verifică dacă toate cifrele sunt aceleași
38 if len(set(cnpj)) == 1:
39 return False
40
41 # Convertește în listă de întregi
42 digits = [int(d) for d in cnpj]
43
44 # Validează prima cifră de verificare
45 first_check = calculate_check_digit(digits[:12])
46 if digits[12] != first_check:
47 return False
48
49 # Validează a doua cifră de verificare
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 // Generează primele 12 cifre aleator
10 for (int i = 0; i < 12; i++) {
11 digits[i] = random.nextInt(10);
12 }
13
14 // Calculează prima cifră de verificare
15 digits[12] = calculateCheckDigit(digits, 12);
16
17 // Calculează a doua cifră de verificare
18 digits[13] = calculateCheckDigit(digits, 13);
19
20 // Formatează CNPJ-ul
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 // Elimină caracterele non-numerice
45 cnpj = cnpj.replaceAll("\\D", "");
46
47 // Verifică lungimea
48 if (cnpj.length() != 14) {
49 return false;
50 }
51
52 // Verifică dacă toate cifrele sunt aceleași
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 // Convertește în array de întregi
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 // Validează prima cifră de verificare
71 int firstCheck = calculateCheckDigit(digits, 12);
72 if (digits[12] != firstCheck) {
73 return false;
74 }
75
76 // Validează a doua cifră de verificare
77 int secondCheck = calculateCheckDigit(digits, 13);
78 if (digits[13] != secondCheck) {
79 return false;
80 }
81
82 return true;
83 }
84}
85Când folosești acest instrument Generator și Validator CNPJ, ține cont de următoarele considerații:
Un CNPJ este numărul de înregistrare național pentru întreprinderi și entități legale din Brazilia. Este folosit pentru scopuri fiscale, înregistrarea afacerii, deschiderea conturilor bancare și identificarea companiilor în tranzacții oficiale.
Nu. CNPJs generate de acest instrument sunt valide matematic conform algoritmului cifrelor de verificare, dar nu sunt înregistrate la Serviciul Federal de Venituri din Brazilia și nu aparțin companiilor reale.
Nu. Pentru a obține un CNPJ legitim pentru o afacere, trebuie să te înregistrezi la Serviciul Federal de Venituri din Brazilia (Receita Federal) conform procesului oficial. CNPJs generate sunt doar pentru scopuri de testare.
Pentru a verifica dacă un CNPJ este înregistrat la o companie reală, trebuie să consulți baza de date a Serviciului Federal de Venituri din Brazilia. Instrumentul nostru verifică doar dacă un CNPJ este valid din punct de vedere matematic, nu dacă este înregistrat oficial.
CNPJs cu toate cifrele aceleași (de exemplu, 11.111.111/1111-11) sunt considerate automat invalide, chiar dacă trec matematic algoritmul de verificare a cifrelor. Aceasta este o regulă stabilită de Serviciul Federal de Venituri din Brazilia.
Nu. Toată procesarea se desfășoară în browserul tău, iar noi nu stocăm sau transmitem niciunul dintre CNPJs pe care îi generezi sau validezi.
Versiunea actuală a instrumentului generează un CNPJ la un moment dat. Pentru generarea în masă, s-ar putea să vrei să iei în considerare utilizarea uneia dintre bibliotecile de programare menționate în secțiunea Alternative.
Acesta este formatul oficial cerut de autoritățile braziliene. Gruparea specifică ajută la identificarea diferitelor componente ale CNPJ-ului, cum ar fi numărul de bază și identificatorul sucursalei.
Poți implementa algoritmul de validare în limbajul tău de programare preferat folosind exemplele de cod furnizate în secțiunea Implementare Tehnică sau poți folosi una dintre bibliotecile menționate în secțiunea Alternative.
Da. Entitățile guvernamentale din Brazilia au modele specifice de CNPJ. De exemplu, entitățile guvernamentale federale încep adesea cu cifre specifice. Generatorul nostru creează CNPJs aleatorii și nu generează în mod specific CNPJs pentru entități guvernamentale.
Instrumentul nostru Generator și Validator CNPJ Brazilian face lucrul cu aceste numere de identificare simplu și eficient. Indiferent dacă testezi aplicații, pregătești date de exemplu sau validezi CNPJs existente, acest instrument oferă o soluție simplă fără complexitatea integrărilor API sau a configurațiilor avansate.
Generează primul tău CNPJ valid acum sau validează unul existent folosind interfața noastră simplă!
Descoperiți mai multe instrumente care ar putea fi utile pentru fluxul dvs. de lucru