Brazīliešu CNPJ ģenerators un validētājs

Ievads

Brazīliešu CNPJ (Cadastro Nacional da Pessoa Jurídica) ir unikāls identifikācijas numurs, kas piešķirts uzņēmumiem un juridiskām personām Brazīlijā. Šis Brazīliešu CNPJ ģenerators un validētājs nodrošina vienkāršu un efektīvu veidu, kā ģenerēt derīgus CNPJ numurus testēšanas mērķiem un validēt esošos CNPJ numurus saskaņā ar oficiālo Brazīlijas algoritmu. Neatkarīgi no tā, vai esat izstrādātājs, kas testē lietojumprogrammas, kas apstrādā Brazīlijas uzņēmumu datus, QA profesionālis, kas izveido testēšanas gadījumus, vai ikviens, kas strādā ar Brazīlijas uzņēmumu informāciju, šis rīks atvieglo darbu ar CNPJ numuriem.

Atšķirībā no reāliem CNPJ numuriem, kurus oficiāli izsniedz Brazīlijas Federālā ieņēmumu dienesta (Receita Federal), šie rīka ģenerētie CNPJ ir matemātiski derīgi, bet nav reģistrēti reālām kompānijām. Tas padara tos ideāli piemērotus testēšanas scenārijiem, paraugu datiem un izstrādes vidēm, kur nepieciešami pareizi formatēti un derīgi CNPJ numuri, neizmantojot reālus uzņēmumu identifikatorus.

Kas ir CNPJ?

CNPJ (Cadastro Nacional da Pessoa Jurídica) ir 14 ciparu identifikācijas numurs, ko piešķir uzņēmumiem un juridiskām personām Brazīlijas Federālais ieņēmumu dienests. Tas kalpo kā Brazīlijas ekvivalents uzņēmuma reģistrācijas numuram vai nodokļu ID. Katram uzņēmumam, kas legāli darbojas Brazīlijā, ir jābūt CNPJ, kas tiek izmantots:

Nodokļu ziņošanai un atbilstībai
Uzņēmuma reģistrācijai pie valsts iestādēm
Bankas kontu atvēršanai
Rēķinu un kvīšu izsniegšanai
Piedalīšanās valsts iepirkumos
Preču importēšanai un eksportēšanai

CNPJ ir būtisks identifikators Brazīlijas uzņēmējdarbības ekosistēmā un parādās oficiālos dokumentos, līgumos un finanšu ierakstos.

CNPJ struktūra un formāts

Brazīliešu CNPJ sastāv no 14 cipariem, parasti formatēti kā: XX.XXX.XXX/YYYY-ZZ

Struktūra sadalās šādi:

Pirmie 8 cipari (XX.XXX.XXX): Bāzes numurs, kas piešķirts uzņēmumam
4 cipari pēc slīpsvītras (YYYY): Filiāles identifikators (0001 galvenajai mītnei, citi numuri filiālēm)
Pēdējie 2 cipari (ZZ): Pārbaudes cipari validācijai

Piemēram, pareizi formatēts CNPJ var izskatīties šādi: 12.345.678/0001-95

Pārbaudes cipari (pēdējie divi numuri) tiek aprēķināti, izmantojot specifisku matemātisko algoritmu, kas validē CNPJ autentiskumu. Šis algoritms nodrošina, ka nejauši ģenerēti numuri nevar iziet validāciju, neievērojot pareizo aprēķina metodi.

Kā darbojas CNPJ validācija

CNPJ validācijas algoritms izmanto svaru aprēķinu, lai noteiktu pārbaudes ciparus. Lūk, kā tas darbojas:

Pirmā pārbaudes cipara aprēķins

Reiziniet katru no pirmajiem 12 cipariem ar svaru secību: 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
Saskaitiet šo reizinājumu rezultātus
Aprēķiniet atlikumu, dalot šo summu ar 11
Ja atlikums ir mazāks par 2, pirmais pārbaudes cipars ir 0; citādi tas ir 11 mīnus atlikums

Otrā pārbaudes cipara aprēķins

Reiziniet katru no pirmajiem 13 cipariem (ieskaitot pirmo pārbaudes ciparu) ar svaru secību: 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
Saskaitiet šo reizinājumu rezultātus
Aprēķiniet atlikumu, dalot šo summu ar 11
Ja atlikums ir mazāks par 2, otrais pārbaudes cipars ir 0; citādi tas ir 11 mīnus atlikums

Lai CNPJ būtu derīgs, abiem pārbaudes cipariem jāatbilst aprēķinātajām vērtībām.

Kā izmantot šo rīku

Mūsu Brazīliešu CNPJ ģeneratora un validētāja rīks piedāvā divas galvenās funkcijas: derīgu CNPJ ģenerēšanu un esošo CNPJ numuru validēšanu.

CNPJ ģenerēšana

Lai ģenerētu derīgu CNPJ testēšanas mērķiem:

Dodieties uz rīka "CNPJ ģeneratora" sadaļu
Noklikšķiniet uz "Ģenerēt CNPJ" pogas
Matemātiski derīgs CNPJ parādīsies formatētajā displejā
Izmantojiet "Kopēt" pogu, lai kopētu ģenerēto CNPJ uz starpliktuvi

Ģenerētais CNPJ sekos visām matemātiskās validācijas noteikumiem, kas attiecas uz reālu CNPJ, bet nav reģistrēts Brazīlijas Federālajā ieņēmumu dienestā.

CNPJ validēšana

Lai pārbaudītu, vai CNPJ ir matemātiski derīgs:

Dodieties uz rīka "CNPJ validētāja" sadaļu
Ievadiet CNPJ, kuru vēlaties validēt, ievades laukā
- Rīks pieņem CNPJ ar vai bez formatējuma (punktiem, slīpsvītrām un defisēm)
Noklikšķiniet uz "Validēt" pogas
Rīks parādīs, vai CNPJ ir derīgs vai nederīgs, pamatojoties uz pārbaudes ciparu algoritmu

Validētājs pārbauda, vai CNPJ atbilst pareizajai formai un vai pārbaudes cipari atbilst gaidāmajām vērtībām saskaņā ar validācijas algoritmu.

Lietošanas gadījumi

Šis Brazīliešu CNPJ ģeneratora un validētāja rīks ir īpaši noderīgs šādos scenārijos:

Programmatūras izstrāde un testēšana

Testa datu izveide: Ģenerējiet derīgus CNPJ, lai aizpildītu testēšanas datu bāzes, neizmantojot reālus uzņēmumu identifikatorus
Vienību testēšana: Validējiet CNPJ apstrādes funkcijas savā kodā ar zināmiem derīgiem un nederīgiem piemēriem
QA testēšana: Izveidojiet testēšanas gadījumus formām un saskarnēm, kurām nepieciešama CNPJ ievade
Integrācijas testēšana: Testējiet sistēmas, kas apmainās ar datiem ar Brazīlijas valsts dienestiem vai finanšu iestādēm

Izglītība un apmācība

CNPJ formāta apguve: Saprotiet, kā ir strukturēti Brazīlijas uzņēmumu identifikatori
Algoritma studijas: Izpētiet, kā darbojas pārbaudes ciparu validācija praksē
Datu validācijas tehnikas: Studējiet reālus piemērus datu validācijas prasībām

Datu apstrāde

Datu tīrīšana: Validējiet CNPJ esošajās datu kopās, lai identificētu potenciālas kļūdas
Formu validācija: Ieviešiet klienta vai servera puses validāciju CNPJ ievadēm
Datu anonimizācija: Aizvietojiet reālus CNPJ ar derīgiem ģenerētiem, kad sagatavojat datu kopas analīzei

Starptautiskā uzņēmējdarbība

Tirgus iekļūšanas sagatavošana: Saprotiet Brazīlijas uzņēmumu identifikācijas prasības
Dokumentu sagatavošana: Nodrošiniet pareizu formatējumu, sagatavojot uzņēmējdarbības dokumentus Brazīlijai
Atbilstības pārbaude: Pārbaudiet, vai savāktie CNPJ numuri ir vismaz matemātiski derīgi

Alternatīvas

Lai gan mūsu rīks nodrošina vienkāršu, pārlūkprogrammā balstītu risinājumu CNPJ ģenerēšanai un validēšanai, ir vairāki alternatīvi risinājumi atkarībā no jūsu specifiskajām vajadzībām:

Programmēšanas bibliotēkas

Izstrādātājiem, kas integrē CNPJ validāciju tieši lietojumprogrammās, ir pieejamas vairākas valodas specifiskas bibliotēkas:

JavaScript: cpf_cnpj.js, validator.js
Python: python-cnpj, validate-docbr
PHP: brazilianutils, respect/validation
Java: caelum-stella, commons-validator
Ruby: cpf_cnpj, brazilian-rails

Šīs bibliotēkas bieži piedāvā papildu funkcionalitāti, piemēram, formatēšanu, parsēšanu un citu Brazīlijas dokumentu validāciju.

API pakalpojumi

Lietojumprogrammām, kas prasa validāciju bez algoritma ieviešanas:

Brazīlijas valdības API (prasa reģistrāciju)
Komerciālie validācijas API, kas ietver CNPJ pārbaudi
Uzņēmumu informācijas pakalpojumi, kas validē pret oficiālo datu bāzi

Roku aprēķins

Izglītības nolūkiem vai vienreizējām validācijām jūs varat manuāli piemērot algoritmu:

Izvelciet pirmos 12 CNPJ ciparus
Veiciet svaru aprēķinus, kā aprakstīts iepriekš
Salīdziniet aprēķinātos pārbaudes ciparus ar faktiskajiem pārbaudes cipariem

Tomēr manuāla aprēķināšana ir kļūdaina un neefektīva regulārai lietošanai.

Tehniskā īstenošana

CNPJ ģenerators un validētājs šajā rīkā ir īstenots, izmantojot JavaScript, padarot to ātru un spējīgu darboties pilnībā jūsu pārlūkā, nesūtot datus uz serveri. Lūk, kā darbojas galvenās funkcijas:

CNPJ ģenerēšanas algoritms

1function generateCNPJ() {
2  // Ģenerē pirmos 12 ciparus nejauši
3  const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4  
5  // Aprēķina pirmo pārbaudes ciparu
6  const firstCheckDigit = calculateCheckDigit(digits);
7  digits.push(firstCheckDigit);
8  
9  // Aprēķina otro pārbaudes ciparu
10  const secondCheckDigit = calculateCheckDigit(digits);
11  digits.push(secondCheckDigit);
12  
13  // Formatē 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 validācijas algoritms

1function validateCNPJ(cnpj) {
2  // Noņem ne-numeriskos simbolus
3  const cleanCNPJ = cnpj.replace(/\D/g, '');
4  
5  // Pārbauda, vai tam ir pareizais garums
6  if (cleanCNPJ.length !== 14) return false;
7  
8  // Pārbauda pazīstamus nederīgus paraugus (visi vienādi cipari)
9  if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10  
11  // Pārvērš ciparus par ciparu masīvu
12  const digits = cleanCNPJ.split('').map(Number);
13  
14  // Pārbauda pirmo verifikācijas ciparu
15  const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16  if (digits[12] !== expectedFirstDigit) return false;
17  
18  // Pārbauda otro verifikācijas ciparu
19  const expectedSecondDigit = calculateCheckDigit(digits.slice(0, 13));
20  if (digits[13] !== expectedSecondDigit) return false;
21  
22  return true;
23}
24

CNPJ formatēšanas funkcija

1function formatCNPJ(cnpj) {
2  // Noņem ne-numeriskos simbolus
3  const cleanCNPJ = cnpj.replace(/\D/g, '');
4  
5  // Formatē pēc garuma
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

Šīs galvenās funkcijas var īstenot citās programmēšanas valodās, sekojot tai pašai loģikai. Šeit ir piemēri Python un Java valodās:

Python īstenošana

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    # Ģenerē pirmos 12 ciparus nejauši
15    digits = [random.randint(0, 9) for _ in range(12)]
16    
17    # Aprēķina pirmo pārbaudes ciparu
18    first_check = calculate_check_digit(digits)
19    digits.append(first_check)
20    
21    # Aprēķina otro pārbaudes ciparu
22    second_check = calculate_check_digit(digits)
23    digits.append(second_check)
24    
25    # Formatē 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    # Noņem ne-numeriskos simbolus
31    cnpj = ''.join(filter(str.isdigit, cnpj))
32    
33    # Pārbauda garumu
34    if len(cnpj) != 14:
35        return False
36    
37    # Pārbauda, vai visi cipari ir vienādi
38    if len(set(cnpj)) == 1:
39        return False
40    
41    # Pārvērš ciparus par ciparu masīvu
42    digits = [int(d) for d in cnpj]
43    
44    # Validē pirmo pārbaudes ciparu
45    first_check = calculate_check_digit(digits[:12])
46    if digits[12] != first_check:
47        return False
48    
49    # Validē otro pārbaudes ciparu
50    second_check = calculate_check_digit(digits[:13])
51    if digits[13] != second_check:
52        return False
53    
54    return True
55

Java īstenošana

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        // Ģenerē pirmos 12 ciparus nejauši
10        for (int i = 0; i < 12; i++) {
11            digits[i] = random.nextInt(10);
12        }
13        
14        // Aprēķina pirmo pārbaudes ciparu
15        digits[12] = calculateCheckDigit(digits, 12);
16        
17        // Aprēķina otro pārbaudes ciparu
18        digits[13] = calculateCheckDigit(digits, 13);
19        
20        // Formatē 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        // Noņem ne-numeriskos simbolus
45        cnpj = cnpj.replaceAll("\\D", "");
46        
47        // Pārbauda garumu
48        if (cnpj.length() != 14) {
49            return false;
50        }
51        
52        // Pārbauda, vai visi cipari ir vienādi
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        // Pārvērš ciparus par ciparu masīvu
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        // Validē pirmo pārbaudes ciparu
71        int firstCheck = calculateCheckDigit(digits, 12);
72        if (digits[12] != firstCheck) {
73            return false;
74        }
75        
76        // Validē otro pārbaudes ciparu
77        int secondCheck = calculateCheckDigit(digits, 13);
78        if (digits[13] != secondCheck) {
79            return false;
80        }
81        
82        return true;
83    }
84}
85

Svarīgas apsvērumi

Izmantojot šo CNPJ ģeneratora un validētāja rīku, ņemiet vērā šādus apsvērumus:

Juridiskie un ētiskie apsvērumi

Nav krāpšanai: Ģenerētie CNPJ nekad nedrīkst tikt izmantoti krāpnieciskos nolūkos vai maldināšanai
Tikai testēšanai: Šie CNPJ ir paredzēti tikai testēšanai un izstrādei
Nav reģistrēti: Ģenerētie CNPJ ir matemātiski derīgi, bet nav reģistrēti Brazīlijas iestādēs
Nav reālas pasaules derīguma: Tos nevar izmantot faktiskai uzņēmuma reģistrācijai vai nodokļu mērķiem

Tehniskās ierobežojumi

Nav uzņēmumu informācijas: Ģenerētie CNPJ nesatur reālus uzņēmumu nozares kodus vai atrašanās vietas informāciju
Nav datu bāzes pārbaudes: Validētājs pārbauda tikai matemātisko derīgumu, nevis reģistrācijas statusu
Formāta variācijas: Lai gan rīks apstrādā parastās formatēšanas variācijas, dažām sistēmām var būt nepieciešami specifiski formāti

Drošības apsvērumi

Klienta puses apstrāde: Visa apstrāde notiek jūsu pārlūkā; nav datu sūtīšanas uz serveriem
Nav datu glabāšanas: Ģenerētie CNPJ netiek glabāti vai reģistrēti
Nav personisko datu: Rīks neapstrādā un neapstrādā nekādus personiskus datus

Biežāk uzdotie jautājumi

Kāds ir CNPJ lietojums Brazīlijā?

CNPJ ir nacionālais reģistrācijas numurs uzņēmumiem un juridiskām personām Brazīlijā. To izmanto nodokļu mērķiem, uzņēmuma reģistrācijai, bankas kontu atvēršanai un uzņēmumu identificēšanai oficiālās transakcijās.

Vai šī rīka ģenerētie CNPJ ir reāli?

Nē. Šī rīka ģenerētie CNPJ ir matemātiski derīgi saskaņā ar pārbaudes ciparu algoritmu, taču tie nav reģistrēti Brazīlijas Federālajā ieņēmumu dienestā un nepieder reālām kompānijām.

Vai es varu izmantot ģenerētos CNPJ sava uzņēmuma vajadzībām?

Nē. Lai iegūtu likumīgu CNPJ uzņēmumam, jums ir jāreģistrējas Brazīlijas Federālajā ieņēmumu dienestā (Receita Federal), ievērojot oficiālo procesu. Ģenerētie CNPJ ir paredzēti tikai testēšanai.

Kā es varu pārliecināties, vai CNPJ pieder reālam uzņēmumam?

Lai pārbaudītu, vai CNPJ ir reģistrēts faktiskam uzņēmumam, jums jākonsultējas ar Brazīlijas Federālā ieņēmumu dienesta datu bāzi. Mūsu rīks pārbauda tikai matemātisko derīgumu, nevis oficiālo reģistrāciju.

Kāpēc validētājs noraida CNPJ ar visiem vienādiem cipariem?

CNPJ ar visiem vienādiem cipariem (piemēram, 11.111.111/1111-11) automātiski tiek uzskatīts par nederīgu, pat ja tas matemātiski iziet pārbaudi. Tas ir noteikums, ko noteicis Brazīlijas Federālais ieņēmumu dienests.

Vai rīks glabā CNPJ, ko es ģenerēju vai validēju?

Nē. Visa apstrāde notiek jūsu pārlūkā, un mēs neglabājam vai nesūtām nekādu informāciju par CNPJ, ko jūs ģenerējat vai validējat.

Vai es varu ģenerēt vairākus CNPJ vienlaikus?

Pašreizējā rīka versija ģenerē vienu CNPJ vienlaikus. Lielai ģenerēšanai varat apsvērt iespēju izmantot kādu no programmēšanas bibliotēkām, kas minētas alternatīvu sadaļā.

Kāpēc formāts XX.XXX.XXX/XXXX-XX ir svarīgs?

Tas ir oficiālais formāts, ko prasa Brazīlijas iestādes. Specifiskā grupēšana palīdz identificēt dažādus CNPJ komponentus, piemēram, bāzes numuru un filiāles identifikatoru.

Kā es varu programmatiskā veidā validēt CNPJ?

Jūs varat īstenot validācijas algoritmu savā izvēlētajā programmēšanas valodā, izmantojot tehniskās īstenošanas sadaļā sniegtos koda piemērus, vai izmantot kādu no alternatīvās sadaļā minētajām bibliotēkām.

Vai ir īpaši CNPJ valdības iestādēm?

Jā. Valdības iestādēm Brazīlijā ir specifiski CNPJ modeļi. Piemēram, federālās valdības iestādes bieži sākas ar noteiktiem cipariem. Mūsu ģenerators ģenerē nejaušus CNPJ un nenodrošina speciāli valdības iestāžu CNPJ.

Atsauces

Brazīlijas Federālais ieņēmumu dienests (Receita Federal do Brasil) - Oficiālā mājas lapa
"CNPJ - Cadastro Nacional da Pessoa Jurídica" - Vikipēdija
Brazīlijas Civillikums (Likums Nr. 10.406/2002) - Juridiskais ietvars uzņēmumu veidiem Brazīlijā
Brazīlijas uzņēmumu reģistrācijas normatīvā instrukcija (IN RFB Nr. 1863/2018) - Noteikumi par CNPJ reģistrāciju

Izmēģiniet tagad

Mūsu Brazīliešu CNPJ ģeneratora un validētāja rīks padara darbu ar šiem identifikācijas numuriem vienkāršu un efektīvu. Neatkarīgi no tā, vai testējat lietojumprogrammas, sagatavojat paraugu datus vai validējat esošos CNPJ, šis rīks nodrošina vienkāršu risinājumu bez API integrācijas vai sarežģītām konfigurācijām.

Ģenerējiet savu pirmo derīgo CNPJ tagad vai validējiet esošo, izmantojot mūsu vienkāršo saskarni!

Brazīlijas CNPJ ģenerators un validācijas rīks testēšanai

Brazīlijas CNPJ ģenerators un validētājs

CNPJ ģenerators

CNPJ validētājs

Dokumentācija