Generuokite galiojančius Brazilijos CNPJ numerius ir patikrinkite esamus su šiuo paprastu įrankiu, sukurtu kūrėjams ir testuotojams, dirbantiems su Brazilijos verslo ID.
Sukurkite galiojantį Brazilijos CNPJ numerį testavimo tikslais.
Patikrinkite, ar Brazilijos CNPJ numeris yra galiojantis.
Brazilijos CNPJ (Cadastro Nacional da Pessoa Jurídica) yra unikalus identifikavimo numeris, priskirtas verslams ir teisės subjektams Brazilijoje. Šis Brazilijos CNPJ generatorius ir validatorius suteikia paprastą, efektyvų būdą generuoti galiojančius CNPJ numerius testavimo tikslais ir patvirtinti esamus CNPJ numerius pagal oficialų Brazilijos algoritmą. Nesvarbu, ar esate kūrėjas, testuojantis programas, kurios tvarko Brazilijos verslo duomenis, QA specialistas, kuriantis testavimo atvejus, ar bet kas, dirbantis su Brazilijos įmonių informacija, šis įrankis supaprastina CNPJ numerių naudojimo procesą.
Skirtingai nuo tikrų CNPJ numerių, kurie oficialiai išduodami Brazilijos Federalinės Mokesčių Tarnybos (Receita Federal), šio įrankio sugeneruoti CNPJ yra matematiškai galiojantys, tačiau nėra registruoti tikroms įmonėms. Tai daro juos puikiai tinkančius testavimo scenarijams, pavyzdinėms duomenų bazėms ir plėtros aplinkoms, kuriose reikia tinkamai suformatuotų ir galiojančių CNPJ numerių, nesinaudojant tikrais verslo identifikatoriais.
CNPJ (Cadastro Nacional da Pessoa Jurídica) yra 14 skaitmenų identifikavimo numeris, priskirtas verslams ir teisės subjektams Brazilijos Federalinės Mokesčių Tarnybos. Tai yra Brazilijos atitikmuo įmonės registracijos numeriui arba mokesčių ID. Kiekvienas verslas, legaliai veikiantis Brazilijoje, privalo turėti CNPJ, kuris naudojamas:
CNPJ yra esminis identifikatorius Brazilijos verslo ekosistemoje ir pasirodo oficialiuose dokumentuose, sutartyse ir finansiniuose įrašuose.
Brazilijos CNPJ susideda iš 14 skaitmenų, paprastai suformatuotų kaip: XX.XXX.XXX/YYYY-ZZ
Struktūra suskaidoma taip:
Pavyzdžiui, tinkamai suformatuotas CNPJ gali atrodyti taip: 12.345.678/0001-95
Patikros skaitmenys (paskutiniai du skaitmenys) apskaičiuojami naudojant konkretų matematinį algoritmą, kuris patvirtina CNPJ autentiškumą. Šis algoritmas užtikrina, kad atsitiktinai sugeneruoti numeriai negali praeiti validacijos, nesilaikant tinkamo skaičiavimo metodo.
CNPJ validacijos algoritmas naudoja svorio skaičiavimą, kad nustatytų patikros skaitmenis. Štai kaip tai veikia:
Kad CNPJ būtų galiojantis, abu patikros skaitmenys turi atitikti apskaičiuotas vertes.
Mūsų Brazilijos CNPJ Generatorius ir Validatorius siūlo dvi pagrindines funkcijas: generuoti galiojančius CNPJ ir patvirtinti esamus CNPJ numerius.
Norėdami sugeneruoti galiojantį CNPJ testavimo tikslais:
Sugeneruotas CNPJ laikysis visų matematinės validacijos taisyklių, kaip tikras CNPJ, tačiau nebus registruotas Brazilijos Federalinėje Mokesčių Tarnyboje.
Norėdami patikrinti, ar CNPJ yra matematiškai galiojantis:
Validatorius patikrina, ar CNPJ atitinka teisingą formatą ir ar patikros skaitmenys atitinka tikėtinas vertes pagal validacijos algoritmą.
Šis Brazilijos CNPJ generatorius ir validatorius ypač naudingas šiose situacijose:
Nors mūsų įrankis teikia paprastą, naršyklėje pagrįstą sprendimą generuoti ir patvirtinti CNPJ, priklausomai nuo jūsų konkrečių poreikių, yra keletas alternatyvų:
Kūrėjams, integruojantiems CNPJ validaciją tiesiai į programas, yra keletas kalbai specifinių bibliotekų:
cpf_cnpj.js, validator.jspython-cnpj, validate-docbrbrazilianutils, respect/validationcaelum-stella, commons-validatorcpf_cnpj, brazilian-railsŠios bibliotekos dažnai teikia papildomą funkcionalumą, pvz., formatavimą, analizavimą ir kitų Brazilijos dokumentų validaciją.
Programoms, kurioms reikia validacijos be algoritmo įgyvendinimo:
Išsilavinimo tikslais arba vienkartinėms validacijoms galite rankiniu būdu taikyti algoritmą:
Tačiau rankinis skaičiavimas yra linkęs į klaidas ir yra neefektyvus reguliariam naudojimui.
CNPJ generatorius ir validatorius šiame įrankyje yra įgyvendinami naudojant JavaScript, todėl jis yra greitas ir gali veikti visiškai jūsų naršyklėje, nesiunčiant jūsų duomenų į serverį. Štai kaip veikia pagrindinės funkcijos:
1function generateCNPJ() {
2 // Sugeneruoti pirmus 12 skaitmenų atsitiktinai
3 const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4
5 // Apskaičiuoti pirmą patikros skaitmenį
6 const firstCheckDigit = calculateCheckDigit(digits);
7 digits.push(firstCheckDigit);
8
9 // Apskaičiuoti antrą patikros skaitmenį
10 const secondCheckDigit = calculateCheckDigit(digits);
11 digits.push(secondCheckDigit);
12
13 // Suformatuoti 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 // Pašalinti ne skaitmeninius simbolius
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Patikrinti, ar turi teisingą ilgį
6 if (cleanCNPJ.length !== 14) return false;
7
8 // Patikrinti žinomus negaliojančius modelius (visi vienodi skaitmenys)
9 if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10
11 // Konvertuoti į skaitmenų masyvą
12 const digits = cleanCNPJ.split('').map(Number);
13
14 // Patikrinti pirmą patikros skaitmenį
15 const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16 if (digits[12] !== expectedFirstDigit) return false;
17
18 // Patikrinti antrą patikros skaitmenį
19 const expectedSecondDigit = calculateCheckDigit(digits.slice(0, 13));
20 if (digits[13] !== expectedSecondDigit) return false;
21
22 return true;
23}
241function formatCNPJ(cnpj) {
2 // Pašalinti ne skaitmeninius simbolius
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Formatavimas pagal ilgį
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Šios pagrindinės funkcijos gali būti įgyvendinamos kitose programavimo kalbose, laikantis tos pačios logikos. Štai pavyzdžiai Python ir 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 # Sugeneruoti pirmus 12 skaitmenų atsitiktinai
15 digits = [random.randint(0, 9) for _ in range(12)]
16
17 # Apskaičiuoti pirmą patikros skaitmenį
18 first_check = calculate_check_digit(digits)
19 digits.append(first_check)
20
21 # Apskaičiuoti antrą patikros skaitmenį
22 second_check = calculate_check_digit(digits)
23 digits.append(second_check)
24
25 # Suformatuoti 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 # Pašalinti ne skaitmeninius simbolius
31 cnpj = ''.join(filter(str.isdigit, cnpj))
32
33 # Patikrinti ilgį
34 if len(cnpj) != 14:
35 return False
36
37 # Patikrinti, ar visi skaitmenys yra vienodi
38 if len(set(cnpj)) == 1:
39 return False
40
41 # Konvertuoti į skaitmenų masyvą
42 digits = [int(d) for d in cnpj]
43
44 # Patvirtinti pirmą patikros skaitmenį
45 first_check = calculate_check_digit(digits[:12])
46 if digits[12] != first_check:
47 return False
48
49 # Patvirtinti antrą patikros skaitmenį
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 // Sugeneruoti pirmus 12 skaitmenų atsitiktinai
10 for (int i = 0; i < 12; i++) {
11 digits[i] = random.nextInt(10);
12 }
13
14 // Apskaičiuoti pirmą patikros skaitmenį
15 digits[12] = calculateCheckDigit(digits, 12);
16
17 // Apskaičiuoti antrą patikros skaitmenį
18 digits[13] = calculateCheckDigit(digits, 13);
19
20 // Suformatuoti 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 // Pašalinti ne skaitmeninius simbolius
45 cnpj = cnpj.replaceAll("\\D", "");
46
47 // Patikrinti ilgį
48 if (cnpj.length() != 14) {
49 return false;
50 }
51
52 // Patikrinti, ar visi skaitmenys yra vienodi
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 // Konvertuoti į skaitmenų masyvą
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 // Patvirtinti pirmą patikros skaitmenį
71 int firstCheck = calculateCheckDigit(digits, 12);
72 if (digits[12] != firstCheck) {
73 return false;
74 }
75
76 // Patvirtinti antrą patikros skaitmenį
77 int secondCheck = calculateCheckDigit(digits, 13);
78 if (digits[13] != secondCheck) {
79 return false;
80 }
81
82 return true;
83 }
84}
85Naudodami šį CNPJ generatorių ir validatorių, turėtumėte atsižvelgti į šiuos aspektus:
CNPJ yra nacionalinis registracijos numeris verslams ir teisės subjektams Brazilijoje. Jis naudojamas mokesčių tikslais, verslo registracijai, banko sąskaitų atidarymui ir oficialių sandorių identifikavimui.
Ne. Šio įrankio sugeneruoti CNPJ yra matematiškai galiojantys pagal patikros skaitmenų algoritmą, tačiau jie nėra registruoti Brazilijos Federalinėje Mokesčių Tarnyboje ir nepriklauso tikroms įmonėms.
Ne. Norint gauti teisėtą CNPJ verslui, turite registruotis Brazilijos Federalinėje Mokesčių Tarnyboje (Receita Federal) laikydamiesi oficialios procedūros. Sugeneruoti CNPJ yra tik testavimo tikslais.
Norint patvirtinti, ar CNPJ yra registruotas tikrai įmonei, reikia pasikonsultuoti su Brazilijos Federalinės Mokesčių Tarnybos duomenų baze. Mūsų įrankis tikrina, ar CNPJ yra matematiškai galiojantis, o ne ar jis yra oficialiai registruotas.
CNPJ su visais vienodais skaitmenimis (pvz., 11.111.111/1111-11) automatiškai laikomi negaliojančiais, net jei jie matematiškai praeina patikros skaitmenų algoritmą. Tai yra taisyklė, kurią nustatė Brazilijos Federalinė Mokesčių Tarnyba.
Ne. Visi apdorojimai vyksta jūsų naršyklėje, ir mes nesaugome ar nesiunčiame jokių CNPJ, kuriuos generuojate ar patvirtinate.
Dabartinė įrankio versija generuoja po vieną CNPJ. Didesniam generavimui galite apsvarstyti galimybę naudoti vieną iš programavimo bibliotekų, paminėtų Alternatyvų skyriuje.
Tai yra oficialus formatas, reikalaujamas Brazilijos institucijų. Specifinis grupavimas padeda identifikuoti skirtingus CNPJ komponentus, tokius kaip pagrindinis numeris ir filialo identifikatorius.
Galite įgyvendinti validacijos algoritmą savo pageidaujamoje programavimo kalboje, naudodami Techninio Įgyvendinimo skyriuje pateiktus kodo pavyzdžius, arba naudoti vieną iš Alternatyvų skyriuje paminėtų bibliotekų.
Taip. Vyriausybinės institucijos Brazilijoje turi specifinius CNPJ modelius. Pavyzdžiui, federalinės vyriausybinės institucijos dažnai prasideda nuo specifinių skaitmenų. Mūsų generatorius kuria atsitiktinius CNPJ ir nesukuria vyriausybinėms institucijoms skirtų CNPJ.
Mūsų Brazilijos CNPJ Generatorius ir Validatorius padaro darbą su šiais identifikavimo numeriais paprastą ir efektyvų. Nesvarbu, ar testuojate programas, ruošiate pavyzdinius duomenis, ar patvirtinate esamus CNPJ, šis įrankis suteikia paprastą sprendimą be API integracijų ar pažangių konfigūracijų.
Sugeneruokite savo pirmą galiojantį CNPJ dabar arba patvirtinkite esamą naudodami mūsų paprastą sąsają!
Raskite daugiau įrankių, kurie gali būti naudingi jūsų darbo eiga.