Brasiilia CNPJ Generaatori ja Validaatori Tööriist

Sissejuhatus

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.

Mis on CNPJ?

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:

Maksuaruandluses ja vastavuses
Ettevõtte registreerimisel valitsusasutustes
Pangakontode avamisel
Arvete ja kviitungite väljastamisel
Valitsuse hangetes osalemisel
Kaupade importimisel ja eksportimisel

CNPJ on oluline identifikaator Brasiilia äriökosüsteemis ja see ilmub ametlikes dokumentides, lepingutes ja finantsdokumentides.

CNPJ Struktuur ja Vorming

Brasiilia CNPJ koosneb 14 numbrist, tavaliselt vormindatud järgmiselt: XX.XXX.XXX/YYYY-ZZ

Struktuur jaguneb järgmiselt:

Esimesed 8 numbrit (XX.XXX.XXX): Ettevõttele antud põh number
4 numbrit pärast kaldkriipsu (YYYY): Haru identifikaator (0001 peakorterile, teised numbrid harudele)
Viimane 2 numbrit (ZZ): Valideerimise kontrollnumbrid

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.

Kuidas CNPJ Valideerimine Toimib

CNPJ valideerimise algoritm kasutab kaalutud arvutust kontrollnumbrite määramiseks. Siin on, kuidas see töötab:

Esimese Kontrollnumbrite Arvutamine

Korruta iga esimese 12 numbri kaaluseeria: 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
Liida nende korrutuste tulemused
Arvuta selle summa jääk jagatuna 11-ga
Kui jääk on väiksem kui 2, on esimene kontrollnumber 0; vastasel juhul on see 11 miinus jääk

Teise Kontrollnumbrite Arvutamine

Korruta iga esimese 13 numbri (sealhulgas esimene kontrollnumber) kaaluseeria: 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
Liida nende korrutuste tulemused
Arvuta selle summa jääk jagatuna 11-ga
Kui jääk on väiksem kui 2, on teine kontrollnumber 0; vastasel juhul on see 11 miinus jääk

CNPJ peab olema kehtiv, kui mõlemad kontrollnumbrid vastavad arvutatud väärtustele.

Kuidas Seda Tööriista Kasutada

Meie Brasiilia CNPJ generaatori ja validaatori tööriist pakub kahte peamist funktsiooni: kehtivate CNPJ-de genereerimine ja olemasolevate CNPJ numbrite valideerimine.

CNPJ Genererimine

Testimise eesmärkidel kehtiva CNPJ genereerimiseks:

Liikuge tööriista "CNPJ Generaatori" sektsiooni
Klõpsake nuppu "Genereeri CNPJ"
Matemaatiliselt kehtiv CNPJ kuvatakse vormindatud kuvamisel
Kasutage nuppu "Kopeeri", et kopeerida genereeritud CNPJ oma lõikelauale

Genereeritud CNPJ järgib kõiki reaalse CNPJ matemaatilise valideerimise reegleid, kuid ei ole registreeritud Brasiilia Föderaalses Maksuametis.

CNPJ Valideerimine

Kuna CNPJ on matemaatiliselt kehtiv:

Liikuge tööriista "CNPJ Validaatori" sektsiooni
Sisestage valideeritav CNPJ sisestusvälja
- Tööriist aktsepteerib CNPJ-sid koos või ilma vormindamiseta (punktid, kaldkriipsud ja sidekriipsud)
Klõpsake nuppu "Valideeri"
Tööriist näitab, kas CNPJ on kehtiv või mitte, tuginedes kontrollnumbrite algoritmile

Validaator kontrollib, kas CNPJ järgib õiget vormingut ja kas kontrollnumbrid vastavad oodatud väärtustele vastavalt valideerimise algoritmile.

Kasutuse Juhud

See Brasiilia CNPJ generaatori ja validaatori tööriist on eriti kasulik järgmistes stsenaariumides:

Tarkvaraarendus ja Testimine

Testandmete Loomine: Genereerige kehtivaid CNPJ-sid testandmebaaside täitmiseks, ilma et kasutaksite tegelikke ettevõtte identifikaatoreid
Üksuse Testimine: Valideerige CNPJ käsitlemise funktsioone oma koodis tuntud kehtivate ja kehtetute näidistega
QA Testimine: Looge testjuhtumeid vormide ja liideste jaoks, mis nõuavad CNPJ sisestamist
Integreerimise Testimine: Testige süsteeme, mis vahetavad andmeid Brasiilia valitsusasutuste või finantsasutustega

Haridus ja Koolitus

CNPJ Vormingu Õppimine: Mõistke, kuidas Brasiilia äriidentifikaatorid on struktureeritud
Algoritmi Uuring: Uurige, kuidas kontrollnumbrite valideerimine töötab praktikas
Andmete Valideerimise Tehnikad: Uurige reaalseid näiteid andmete valideerimise nõuete kohta

Andmete Töötlemine

Andmete Puhastamine: Valideerige olemasolevate andmekogude CNPJ-sid, et tuvastada võimalikke vigu
Vormi Valideerimine: Rakendage kliendi- või serveripoolset valideerimist CNPJ sisendite jaoks
Andmete Anonüümitamine: Asendage tegelikud CNPJ-d genereeritud kehtivatega, kui valmistate andmekogusid analüüsiks

Rahvusvaheline Äri

Turule Sisenemise Ettevalmistamine: Mõistke Brasiilia äriidentifitseerimise nõudeid
Dokumentide Ettevalmistamine: Veenduge, et vorming oleks õige, kui valmistate Brasiiliale suunatud äri dokumente
Vastavuse Kontrollimine: Veenduge, et kogutud CNPJ-d oleksid vähemalt matemaatiliselt kehtivad

Alternatiivid

Kuigi meie tööriist pakub lihtsat, brauseripõhist lahendust CNPJ-de genereerimiseks ja valideerimiseks, on sõltuvalt teie konkreetsetest vajadustest mitmeid alternatiive:

Programmeerimise Raamatukogud

Arendajatele, kes integreerivad CNPJ valideerimist otse rakendustesse, on saadaval mitmeid keele-spetsiifilisi raamatukogusid:

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

Need raamatukogud pakuvad sageli täiendavat funktsionaalsust, nagu vormindamine, parsimine ja teiste Brasiilia dokumentide valideerimine.

API Teenused

Rakenduste jaoks, mis vajavad valideerimist ilma algoritmi rakendamata:

Brasiilia valitsuse API-d (nõuab registreerimist)
Kaubanduslikud valideerimise API-d, mis sisaldavad CNPJ kontrollimist
Ärinformatsiooni teenused, mis valideerivad ametlikku andmebaasi

Käsitsi Arvutamine

Hariduslikel eesmärkidel või ühekordsete valideerimiste jaoks saate algoritmi käsitsi rakendada:

Eraldage CNPJ esimesed 12 numbrit
Tehke kaalutud arvutused, nagu eespool kirjeldatud
Võrrelge arvutatud kontrollnumbreid tegelike kontrollnumbritega

Kuid käsitsi arvutamine on vigadele kalduv ja ebaefektiivne regulaarseks kasutamiseks.

Tehniline Rakendamine

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:

CNPJ Generatsiooni Algoritm

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}
29

CNPJ Valideerimise Algoritm

1function 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}
24

CNPJ Vormindamise Funktsioon

1function 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}
18

Need põhifunktsioonid saab rakendada ka teistes programmeerimiskeeltes, järgides sama loogikat. Siin on näited Pythonis ja Java-s:

Pythoni Rakendamine

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
55

Java Rakendamine

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        // 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}
85

Olulised Arvestused

Kasutades seda CNPJ generaatori ja validaatori tööriista, pidage meeles järgmisi arvestusi:

Õiguslikud ja Eetilised Arvestused

Ei Petmiseks: Genereeritud CNPJ-sid ei tohiks kunagi kasutada petmiseks või valeandmete esitamiseks
Ainult Testimiseks: Need CNPJ-d on mõeldud ainult testimise ja arenduse eesmärkidel
Ei Ole Registreeritud: Genereeritud CNPJ-d on matemaatiliselt kehtivad, kuid ei ole registreeritud Brasiilia ametivõimudes
Ei Ole Reaalses Maailmas Kehtivad: Neid ei saa kasutada tegeliku ettevõtte registreerimise või maksustamise eesmärkidel

Tehnilised Piirangud

Ei Ärinformatsiooni: Genereeritud CNPJ-d ei sisalda tegelikke ettevõtte sektori koode või asukoha teavet
Ei Andmebaasi Kontrollimist: Valideerija kontrollib ainult matemaatilist kehtivust, mitte registreerimise staatust
Vormingu Erinevused: Kuigi tööriist käsitleb levinud vormindamise erinevusi, võivad mõned süsteemid nõuda konkreetseid vorminguid

Turvalisuse Arvestused

Kliendipoolne Töötlemine: Kõik töötlemine toimub teie brauseris; andmeid ei saadeta serveritesse
Ei Andmete Salvestamist: Genereeritud CNPJ-sid ei salvestata ega logita
Ei Isikuandmeid: Tööriist ei käsitle ega töötle isikuandmeid

Korduma Kippuvad Küsimused

Milleks CNPJ Brasiilias kasutatakse?

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.

Kas selle tööriista genereeritud CNPJ-d on reaalsed?

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.

Kas ma saan genereeritud CNPJ-sid oma ettevõtte jaoks kasutada?

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.

Kuidas ma saan teada, kas CNPJ kuulub reaalsele ettevõttele?

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.

Miks valideerija lükkab tagasi CNPJ, millel on kõik samad numbrid?

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.

Kas tööriist salvestab CNPJ-sid, mida ma genereerin või valideerin?

Ei. Kõik töötlemine toimub teie brauseris, ja me ei salvestada ega edastada ühtegi CNPJ-d, mida te genereerite või valideerite.

Kas ma saan korraga genereerida mitu CNPJ-d?

Praegune tööriista versioon genereerib ühe CNPJ korraga. Suuremahulise genereerimise jaoks võiksite kaaluda ühte alternatiivset programmeerimise raamatukogu, mis on mainitud Alternatiivide osas.

Miks on vorming XX.XXX.XXX/XXXX-XX oluline?

See on ametlik vorming, mida nõuavad Brasiilia ametivõimud. Konkreetne rühmitamine aitab tuvastada CNPJ erinevaid komponente, nagu põhnumber ja haru identifikaator.

Kuidas ma saan CNPJ-d programmiliselt valideerida?

Saate rakendada valideerimise algoritmi oma eelistatud programmeerimiskeeles, kasutades Tehnilise Rakendamise osas esitatud koodinäiteid või kasutada ühte Alternatiivide osas mainitud raamatukogudest.

Kas valitsusasutustel on spetsiaalsed CNPJ-d?

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.

Viidatud Allikad

Brasiilia Föderaalne Maksuamet (Receita Federal do Brasil) - Ametlik Veebisait
"CNPJ - Cadastro Nacional da Pessoa Jurídica" - Wikipedia
Brasiilia Tsiviilseadustik (Seadus nr 10.406/2002) - Õiguslik raamistik Brasiilia äriüksuste jaoks
Brasiilia Äri Registreerimise Normatiivne Juhend (IN RFB nr 1863/2018) - CNPJ registreerimise regulatsioonid

Proovige Nüüd

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!

Brasiilia CNPJ generaatori ja valideerimise tööriist testimiseks

Brasiilia CNPJ Generaator ja Valideerija

CNPJ Generaator

CNPJ Valideerija

Dokumentatsioon