Genereeri kehtivad Brasiilia CNPJ numbrid ja valideeri olemasolevaid, kasutades seda lihtsat tööriista, mis on mõeldud arendajatele ja testijatele, kes töötavad Brasiilia äri-ID-dega.
Genera valide Brasiilia CNPJ number testimise eesmärkidel.
Kontrolli, kas Brasiilia CNPJ number on valide.
Brasiilia CNPJ (Cadastro Nacional da Pessoa Jurídica) on ainulaadne identifitseerimisnumber, mis antakse Brasiilias ettevõtetele ja juriidilistele isikutele. See Brasiilia CNPJ generaatori ja validaatori tööriist pakub lihtsat ja tõhusat viisi kehtivate CNPJ numbrite genereerimiseks testimise eesmärkidel ja olemasolevate CNPJ numbrite valideerimiseks vastavalt ametlikule Brasiilia algoritmile. Olenemata sellest, kas olete arendaja, kes testib rakendusi, mis käsitlevad Brasiilia äriandmeid, QA spetsialist, kes loob testjuhtumeid, või keegi, kes töötab Brasiilia ettevõtte teabega, lihtsustab see tööriist CNPJ numbritega töötamise protsessi.
Erinevalt tegelikest CNPJ numbritest, mis on ametlikult väljastatud Brasiilia Föderaalse Maksuameti (Receita Federal) poolt, on selle tööriista genereeritud CNPJ-d matemaatiliselt kehtivad, kuid ei ole registreeritud tegelike ettevõtete nimele. See teeb neist ideaalsed testimise stsenaariumide, näidisdokumentide ja arenduskeskkondade jaoks, kus on vaja korralikult vormindatud ja kehtivaid CNPJ numbreid ilma tegelikke ärimärke kasutamata.
CNPJ (Cadastro Nacional da Pessoa Jurídica) on 14-kohaline identifitseerimisnumber, mis antakse ettevõtetele ja juriidilistele isikutele Brasiilia Föderaalse Maksuameti poolt. See toimib Brasiilia vastena ettevõtte registreerimisnumbrile või maksutunnistusele. Igal seaduslikult Brasiilias tegutseval ettevõttel peab olema CNPJ, mida kasutatakse:
CNPJ on oluline identifikaator Brasiilia äriökosüsteemis ja see ilmub ametlikes dokumentides, lepingutes ja finantsdokumentides.
Brasiilia CNPJ koosneb 14 numbrist, tavaliselt vormindatud järgmiselt: XX.XXX.XXX/YYYY-ZZ
Struktuur jaguneb järgmiselt:
Näiteks võib korralikult vormindatud CNPJ välja näha järgmiselt: 12.345.678/0001-95
Kontrollnumbrid (viimased kaks numbrit) arvutatakse konkreetse matemaatilise algoritmi abil, mis valideerib CNPJ autentsust. See algoritm tagab, et juhuslikult genereeritud numbrid ei saa validaidatsiooni läbida ilma nõuetekohaste arvutamismeetodite järgimiseta.
CNPJ valideerimise algoritm kasutab kaalutud arvutust kontrollnumbrite määramiseks. Siin on, kuidas see töötab:
CNPJ peab olema kehtiv, kui mõlemad kontrollnumbrid vastavad arvutatud väärtustele.
Meie Brasiilia CNPJ generaatori ja validaatori tööriist pakub kahte peamist funktsiooni: kehtivate CNPJ-de genereerimine ja olemasolevate CNPJ numbrite valideerimine.
Testimise eesmärkidel kehtiva CNPJ genereerimiseks:
Genereeritud CNPJ järgib kõiki reaalse CNPJ matemaatilise valideerimise reegleid, kuid ei ole registreeritud Brasiilia Föderaalses Maksuametis.
Kuna CNPJ on matemaatiliselt kehtiv:
Validaator kontrollib, kas CNPJ järgib õiget vormingut ja kas kontrollnumbrid vastavad oodatud väärtustele vastavalt valideerimise algoritmile.
See Brasiilia CNPJ generaatori ja validaatori tööriist on eriti kasulik järgmistes stsenaariumides:
Kuigi meie tööriist pakub lihtsat, brauseripõhist lahendust CNPJ-de genereerimiseks ja valideerimiseks, on sõltuvalt teie konkreetsetest vajadustest mitmeid alternatiive:
Arendajatele, kes integreerivad CNPJ valideerimist otse rakendustesse, on saadaval mitmeid keele-spetsiifilisi raamatukogusid:
cpf_cnpj.js, validator.jspython-cnpj, validate-docbrbrazilianutils, respect/validationcaelum-stella, commons-validatorcpf_cnpj, brazilian-railsNeed raamatukogud pakuvad sageli täiendavat funktsionaalsust, nagu vormindamine, parsimine ja teiste Brasiilia dokumentide valideerimine.
Rakenduste jaoks, mis vajavad valideerimist ilma algoritmi rakendamata:
Hariduslikel eesmärkidel või ühekordsete valideerimiste jaoks saate algoritmi käsitsi rakendada:
Kuid käsitsi arvutamine on vigadele kalduv ja ebaefektiivne regulaarseks kasutamiseks.
CNPJ generaator ja validaator selles tööriistas on rakendatud JavaScriptis, muutes selle kiireks ja võimekaks töötama täielikult teie brauseris, ilma et teie andmeid serverisse saadetaks. Siin on, kuidas põhifunktsioonid töötavad:
1function generateCNPJ() {
2 // Genereeri esimesed 12 numbrit juhuslikult
3 const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4
5 // Arvuta esimene kontrollnumber
6 const firstCheckDigit = calculateCheckDigit(digits);
7 digits.push(firstCheckDigit);
8
9 // Arvuta teine kontrollnumber
10 const secondCheckDigit = calculateCheckDigit(digits);
11 digits.push(secondCheckDigit);
12
13 // Vorminda 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 // Eemalda mitte-numerilised tegelased
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Kontrolli, kas tal on õige pikkus
6 if (cleanCNPJ.length !== 14) return false;
7
8 // Kontrolli tuntud kehtetute mustrite (kõik samad numbrid)
9 if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10
11 // Muuda numbrid massiiviks
12 const digits = cleanCNPJ.split('').map(Number);
13
14 // Kontrolli esimest kontrollnumbrit
15 const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16 if (digits[12] !== expectedFirstDigit) return false;
17
18 // Kontrolli teist kontrollnumbrit
19 const expectedSecondDigit = calculateCheckDigit(digits.slice(0, 13));
20 if (digits[13] !== expectedSecondDigit) return false;
21
22 return true;
23}
241function formatCNPJ(cnpj) {
2 // Eemalda mitte-numerilised tegelased
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Vorminda pikkuse alusel
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}
18Need põhifunktsioonid saab rakendada ka teistes programmeerimiskeeltes, järgides sama loogikat. Siin on näited Pythonis ja Java-s:
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 # Genereeri esimesed 12 numbrit juhuslikult
15 digits = [random.randint(0, 9) for _ in range(12)]
16
17 # Arvuta esimene kontrollnumber
18 first_check = calculate_check_digit(digits)
19 digits.append(first_check)
20
21 # Arvuta teine kontrollnumber
22 second_check = calculate_check_digit(digits)
23 digits.append(second_check)
24
25 # Vorminda 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 # Eemalda mitte-numerilised tegelased
31 cnpj = ''.join(filter(str.isdigit, cnpj))
32
33 # Kontrolli pikkust
34 if len(cnpj) != 14:
35 return False
36
37 # Kontrolli, kas kõik numbrid on samad
38 if len(set(cnpj)) == 1:
39 return False
40
41 # Muuda numbrid massiiviks
42 digits = [int(d) for d in cnpj]
43
44 # Valideeri esimene kontrollnumber
45 first_check = calculate_check_digit(digits[:12])
46 if digits[12] != first_check:
47 return False
48
49 # Valideeri teine kontrollnumber
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 // Genereeri esimesed 12 numbrit juhuslikult
10 for (int i = 0; i < 12; i++) {
11 digits[i] = random.nextInt(10);
12 }
13
14 // Arvuta esimene kontrollnumber
15 digits[12] = calculateCheckDigit(digits, 12);
16
17 // Arvuta teine kontrollnumber
18 digits[13] = calculateCheckDigit(digits, 13);
19
20 // Vorminda 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 // Eemalda mitte-numerilised tegelased
45 cnpj = cnpj.replaceAll("\\D", "");
46
47 // Kontrolli pikkust
48 if (cnpj.length() != 14) {
49 return false;
50 }
51
52 // Kontrolli, kas kõik numbrid on samad
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 // Muuda numbrid massiiviks
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 // Valideeri esimene kontrollnumber
71 int firstCheck = calculateCheckDigit(digits, 12);
72 if (digits[12] != firstCheck) {
73 return false;
74 }
75
76 // Valideeri teine kontrollnumber
77 int secondCheck = calculateCheckDigit(digits, 13);
78 if (digits[13] != secondCheck) {
79 return false;
80 }
81
82 return true;
83 }
84}
85Kasutades seda CNPJ generaatori ja validaatori tööriista, pidage meeles järgmisi arvestusi:
CNPJ on riiklik registreerimisnumber ettevõtetele ja juriidilistele isikutele Brasiilias. Seda kasutatakse maksustamise eesmärkidel, ettevõtte registreerimisel, pangakontode avamisel ja ettevõtete tuvastamiseks ametlikes tehingutes.
Ei. Selle tööriista genereeritud CNPJ-d on matemaatiliselt kehtivad vastavalt kontrollnumbrite algoritmile, kuid need ei ole registreeritud Brasiilia Föderaalses Maksuametis ja ei kuulu tegelikele ettevõtetele.
Ei. Legitiimse CNPJ saamiseks ettevõtte jaoks peate registreerima Brasiilia Föderaalses Maksuametis (Receita Federal) ametlikku protseduuri järgides. Genereeritud CNPJ-d on mõeldud ainult testimise eesmärkidel.
Et kontrollida, kas CNPJ on registreeritud tegeliku ettevõtte nimele, peate konsulteerima Brasiilia Föderaalse Maksuameti andmebaasiga. Meie tööriist kontrollib ainult CNPJ matemaatilist kehtivust, mitte selle ametlikku registreerimist.
CNPJ-d, millel on kõik samad numbrid (nt 11.111.111/1111-11), peetakse automaatselt kehtetuks, isegi kui nad matemaatiliselt läbivad kontrollnumbrite algoritmi. See on reegel, mille on kehtestanud Brasiilia Föderaalne Maksuamet.
Ei. Kõik töötlemine toimub teie brauseris, ja me ei salvestada ega edastada ühtegi CNPJ-d, mida te genereerite või valideerite.
Praegune tööriista versioon genereerib ühe CNPJ korraga. Suuremahulise genereerimise jaoks võiksite kaaluda ühte alternatiivset programmeerimise raamatukogu, mis on mainitud Alternatiivide osas.
See on ametlik vorming, mida nõuavad Brasiilia ametivõimud. Konkreetne rühmitamine aitab tuvastada CNPJ erinevaid komponente, nagu põhnumber ja haru identifikaator.
Saate rakendada valideerimise algoritmi oma eelistatud programmeerimiskeeles, kasutades Tehnilise Rakendamise osas esitatud koodinäiteid või kasutada ühte Alternatiivide osas mainitud raamatukogudest.
Jah. Valitsusasutustel Brasiilias on spetsiifilised CNPJ mustrid. Näiteks algavad föderaalse valitsuse asutused sageli teatud numbritega. Meie generaator loob juhuslikke CNPJ-sid ja ei genereeri spetsiaalselt valitsusasutuste CNPJ-sid.
Meie Brasiilia CNPJ generaatori ja validaatori tööriist muudab nende identifitseerimisnumberdega töötamise lihtsaks ja tõhusaks. Olenemata sellest, kas testite rakendusi, valmistate näidisdokumente või valideerite olemasolevaid CNPJ-sid, pakub see tööriist lihtsat lahendust ilma API integreerimise või keerukate seadistusteta.
Genereerige oma esimene kehtiv CNPJ nüüd või valideerige olemasolev, kasutades meie lihtsat liidest!
Avasta rohkem tööriistu, mis võivad olla kasulikud teie töövoos