બ્રાઝિલિયન બિઝનેસ આઈડીઓ સાથે કામ કરતા વિકાસકર્તાઓ અને પરીક્ષકોએ ઉપયોગ કરવા માટે ડિઝાઇન કરેલ આ સરળ ટૂલથી માન્ય બ્રાઝિલિયન CNPJ નંબર જનરેટ કરો અને અસ્તિત્વમાં આવેલા નંબરની માન્યતા તપાસો.
ટેસ્ટિંગ માટે માન્ય બ્રાઝિલિયન CNPJ નંબર જનરેટ કરો.
જાણો કે બ્રાઝિલિયન CNPJ નંબર માન્ય છે કે નહીં.
બ્રાઝિલિયન CNPJ (કેડાસ્ટ્રો નેશનલ દા પેસોઆ જુરિદિકા) એ બ્રાઝિલમાં વ્યવસાયો અને કાનૂની સંસ્થાઓને ફાળવવામાં આવતી અનન્ય ઓળખ નંબર છે. આ બ્રાઝિલિયન CNPJ જનરેટર અને વેલિડેટર ટૂલ પરીક્ષણના હેતુઓ માટે માન્ય CNPJ નંબર જનરેટ કરવાનો અને અસ્તિત્વમાં આવેલા CNPJ નંબરની માન્યતા તપાસવાનો સરળ, કાર્યક્ષમ માર્ગ પ્રદાન કરે છે. તમે એક ડેવલપર છો જે બ્રાઝિલિયન બિઝનેસ ડેટા સંભાળતી એપ્લિકેશન્સની પરીક્ષણ કરી રહ્યા છો, એક QA વ્યાવસાયિક જે પરીક્ષણ કેસો બનાવી રહ્યા છે, અથવા કોઈપણ વ્યક્તિ જેણે બ્રાઝિલિયન કંપનીની માહિતી સાથે કામ કરી રહ્યું છે, આ ટૂલ CNPJ નંબર સાથે કામ કરવાની પ્રક્રિયાને સરળ બનાવે છે.
આ ટૂલ દ્વારા જનરેટ કરવામાં આવેલા CNPJ વાસ્તવિક CNPJ નંબર નથી જે બ્રાઝિલિયન ફેડરલ રેવન્યુ સર્વિસ (રેસીતા ફેડરલ) દ્વારા સત્તાવાર રીતે ફાળવવામાં આવ્યા છે, પરંતુ આ સંખ્યાઓ ગણિતીય રીતે માન્ય છે પરંતુ વાસ્તવિક કંપનીઓને નોંધાયેલ નથી. આ તેમને પરીક્ષણ પરિસ્થિતિઓ, નમૂના ડેટા, અને વિકાસના વાતાવરણ માટે સંપૂર્ણ બનાવે છે જ્યાં તમને યોગ્ય રીતે ફોર્મેટ કરેલા અને માન્ય CNPJ નંબરની જરૂર છે પરંતુ વાસ્તવિક બિઝનેસ ઓળખકર્તાઓનો ઉપયોગ કર્યા વિના.
CNPJ (કેડાસ્ટ્રો નેશનલ દા પેસોઆ જુરિદિકા) એ 14 અંકની ઓળખ નંબર છે જે બ્રાઝિલિયન ફેડરલ રેવન્યુ સર્વિસ દ્વારા વ્યવસાયો અને કાનૂની સંસ્થાઓને ફાળવવામાં આવે છે. આ બ્રાઝિલમાં કંપની નોંધણી નંબર અથવા કર આઈડીનું સમકક્ષ છે. બ્રાઝિલમાં કાયદેસર રીતે કાર્યરત દરેક વ્યવસાય પાસે CNPJ હોવું આવશ્યક છે, જેનો ઉપયોગ થાય છે:
CNPJ બ્રાઝિલના વ્યાપાર ઇકોસિસ્ટમમાં એક મહત્વપૂર્ણ ઓળખકર્તા છે અને આ અધિકૃત દસ્તાવેજો, કરાર અને નાણાકીય રેકોર્ડમાં દેખાય છે.
બ્રાઝિલિયન CNPJ 14 અંકનો બનેલો છે, સામાન્ય રીતે આ રીતે ફોર્મેટ કરવામાં આવે છે: XX.XXX.XXX/YYYY-ZZ
આ બંધન નીચે મુજબ વિભાજિત થાય છે:
ઉદાહરણ તરીકે, યોગ્ય રીતે ફોર્મેટ કરેલ CNPJ આ રીતે દેખાય શકે છે: 12.345.678/0001-95
ચેક અંક (છેલ્લા બે નંબર) ચોક્કસ ગણિતીય અલ્ગોરિધમનો ઉપયોગ કરીને ગણવામાં આવે છે જે CNPJની પ્રામાણિકતાને માન્ય કરે છે. આ અલ્ગોરિધમ ખાતરી કરે છે કે રેન્ડમ રીતે જનરેટ કરેલ નંબર માન્યતા પસાર કરી શકતા નથી જો તેઓ યોગ્ય ગણતરી પદ્ધતિનું પાલન ન કરે.
CNPJ માન્યતા અલ્ગોરિધમ ચેક અંકને નક્કી કરવા માટે વજનદાર ગણતરીનો ઉપયોગ કરે છે. આ રીતે કાર્ય કરે છે:
CNPJ માન્ય હોવા માટે, બંને ચેક અંકની ગણતરી કરેલ મૂલ્યો સાથે મેળ ખાય.
અમારી બ્રાઝિલિયન CNPJ જનરેટર અને વેલિડેટર ટૂલ બે મુખ્ય કાર્ય પ્રદાન કરે છે: માન્ય CNPJ જનરેટ કરવી અને અસ્તિત્વમાં આવેલા CNPJ નંબરની માન્યતા તપાસવી.
પરીક્ષણના હેતુઓ માટે માન્ય CNPJ જનરેટ કરવા માટે:
જનરેટ કરેલ CNPJ વાસ્તવિક CNPJની તમામ ગણિતીય માન્યતા નિયમોનું પાલન કરશે પરંતુ બ્રાઝિલિયન ફેડરલ રેવન્યુ સર્વિસ સાથે નોંધાયેલ નથી.
CNPJ ગણિતીય રીતે માન્ય છે કે નહીં તે તપાસવા માટે:
વેલિડેટર ચેક કરે છે કે CNPJ યોગ્ય ફોર્મેટનું પાલન કરે છે અને ચેક અંકની ગણતરી કરેલ મૂલ્યો સાથે મેળ ખાય છે.
આ બ્રાઝિલિયન CNPJ જનરેટર અને વેલિડેટર ટૂલ ખાસ કરીને નીચેના પરિસ્થિતિઓમાં ઉપયોગી છે:
જ્યારે અમારી ટૂલ આઈડેન્ટિફિકેશન નંબર જનરેટ અને માન્ય કરવા માટે સરળ, બ્રાઉઝર આધારિત સોલ્યુશન પ્રદાન કરે છે, ત્યારે તમારી વિશિષ્ટ જરૂરિયાતો અનુસાર કેટલાક વિકલ્પો ઉપલબ્ધ છે:
ડેવલપર્સ માટે જે CNPJ માન્યતા સીધા એપ્લિકેશન્સમાં એકીકૃત કરે છે, કેટલીક ભાષા-વિશિષ્ટ લાઇબ્રેરીઝ ઉપલબ્ધ છે:
cpf_cnpj.js, validator.jspython-cnpj, validate-docbrbrazilianutils, respect/validationcaelum-stella, commons-validatorcpf_cnpj, brazilian-railsઆ લાઇબ્રેરીઓ ઘણી વખત ફોર્મેટિંગ, પાર્સિંગ અને અન્ય બ્રાઝિલિયન દસ્તાવેજોની માન્યતા જેવી વધારાની કાર્યક્ષમતા પ્રદાન કરે છે.
માન્યતા માટે એપ્લિકેશન્સને અલ્ગોરિધમને અમલમાં મૂક્યા વિના માન્યતા માટે:
શિક્ષણના હેતુઓ અથવા એકવારની માન્યતાના હેતુઓ માટે, તમે અલ્ગોરિધમને મેન્યુઅલ રીતે લાગુ કરી શકો છો:
પરંતુ, મેન્યુઅલ ગણતરી ભૂલપ્રવણ અને નિયમિત ઉપયોગ માટે અસુવિધાજનક છે.
આ ટૂલમાં CNPJ જનરેટર અને વેલિડેટર જાવાસ્ક્રિપ્ટનો ઉપયોગ કરીને અમલમાં મૂકવામાં આવ્યા છે, જે તેને ઝડપી બનાવે છે અને તમારા બ્રાઉઝરમાં સંપૂર્ણ રીતે ચલાવવાની ક્ષમતા ધરાવે છે, તમારા ડેટાને સર્વર પર મોકલ્યા વિના. અહીં મુખ્ય કાર્ય કેવી રીતે કાર્ય કરે છે:
1function generateCNPJ() {
2 // પ્રથમ 12 અંક રેન્ડમ રીતે જનરેટ કરો
3 const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4
5 // પ્રથમ ચેક અંકની ગણતરી કરો
6 const firstCheckDigit = calculateCheckDigit(digits);
7 digits.push(firstCheckDigit);
8
9 // બીજું ચેક અંકની ગણતરી કરો
10 const secondCheckDigit = calculateCheckDigit(digits);
11 digits.push(secondCheckDigit);
12
13 // 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 // નોન-ન્યુમેરિક અક્ષરો દૂર કરો
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // ચેક કરો કે તે યોગ્ય લંબાઈ ધરાવે છે
6 if (cleanCNPJ.length !== 14) return false;
7
8 // જાણીતા અમાન્ય પેટર્ન માટે ચેક કરો (બધા સમાન અંક)
9 if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10
11 // અંકની યાદીમાં રૂપાંતરિત કરો
12 const digits = cleanCNPJ.split('').map(Number);
13
14 // પ્રથમ ચેક અંકની માન્યતા તપાસો
15 const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16 if (digits[12] !== expectedFirstDigit) return false;
17
18 // બીજું ચેક અંકની માન્યતા તપાસો
19 const expectedSecondDigit = calculateCheckDigit(digits.slice(0, 13));
20 if (digits[13] !== expectedSecondDigit) return false;
21
22 return true;
23}
241function formatCNPJ(cnpj) {
2 // નોન-ન્યુમેરિક અક્ષરો દૂર કરો
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // લંબાઈના આધારે ફોર્મેટ કરો
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આ મુખ્ય કાર્યને અન્ય પ્રોગ્રામિંગ ભાષાઓમાં સમાન તર્કને અનુસરીને અમલમાં મૂકવામાં આવી શકે છે. અહીં પાયથન અને જાવામાં ઉદાહરણો છે:
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 # પ્રથમ 12 અંક રેન્ડમ રીતે જનરેટ કરો
15 digits = [random.randint(0, 9) for _ in range(12)]
16
17 # પ્રથમ ચેક અંકની ગણતરી કરો
18 first_check = calculate_check_digit(digits)
19 digits.append(first_check)
20
21 # બીજું ચેક અંકની ગણતરી કરો
22 second_check = calculate_check_digit(digits)
23 digits.append(second_check)
24
25 # 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 # નોન-ન્યુમેરિક અક્ષરો દૂર કરો
31 cnpj = ''.join(filter(str.isdigit, cnpj))
32
33 # ચેક લંબાઈ
34 if len(cnpj) != 14:
35 return False
36
37 # બધા અંક સમાન છે કે નહીં તે ચેક કરો
38 if len(set(cnpj)) == 1:
39 return False
40
41 # અંકની યાદીમાં રૂપાંતરિત કરો
42 digits = [int(d) for d in cnpj]
43
44 # પ્રથમ ચેક અંકની માન્યતા તપાસો
45 first_check = calculate_check_digit(digits[:12])
46 if digits[12] != first_check:
47 return False
48
49 # બીજું ચેક અંકની માન્યતા તપાસો
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 // પ્રથમ 12 અંક રેન્ડમ રીતે જનરેટ કરો
10 for (int i = 0; i < 12; i++) {
11 digits[i] = random.nextInt(10);
12 }
13
14 // પ્રથમ ચેક અંકની ગણતરી કરો
15 digits[12] = calculateCheckDigit(digits, 12);
16
17 // બીજું ચેક અંકની ગણતરી કરો
18 digits[13] = calculateCheckDigit(digits, 13);
19
20 // 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 // નોન-ન્યુમેરિક અક્ષરો દૂર કરો
45 cnpj = cnpj.replaceAll("\\D", "");
46
47 // ચેક લંબાઈ
48 if (cnpj.length() != 14) {
49 return false;
50 }
51
52 // બધા અંક સમાન છે કે નહીં તે ચેક કરો
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 // અંકની યાદીમાં રૂપાંતરિત કરો
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 // પ્રથમ ચેક અંકની માન્યતા તપાસો
71 int firstCheck = calculateCheckDigit(digits, 12);
72 if (digits[12] != firstCheck) {
73 return false;
74 }
75
76 // બીજું ચેક અંકની માન્યતા તપાસો
77 int secondCheck = calculateCheckDigit(digits, 13);
78 if (digits[13] != secondCheck) {
79 return false;
80 }
81
82 return true;
83 }
84}
85આ CNPJ જનરેટર અને વેલિડેટર ટૂલનો ઉપયોગ કરતા, નીચેની બાબતો ધ્યાનમાં રાખવી:
CNPJ બ્રાઝિલમાં વ્યવસાયો અને કાનૂની સંસ્થાઓ માટે રાષ્ટ્રીય નોંધણી નંબર છે. તેનો ઉપયોગ કરના હેતુઓ, વ્યવસાય નોંધણી, બેંક ખાતા ખોલવા અને અધિકૃત વ્યવહારોમાં કંપનીઓની ઓળખ કરવા માટે થાય છે.
ના. આ ટૂલ દ્વારા જનરેટ કરેલ CNPJ ગણિતીય રીતે માન્ય છે, પરંતુ તે બ્રાઝિલિયન ફેડરલ રેવન્યુ સર્વિસ સાથે નોંધાયેલ નથી અને વાસ્તવિક કંપનીઓને ફાળવવામાં નથી.
ના. વ્યવસાય માટે માન્ય CNPJ મેળવવા માટે, તમને બ્રાઝિલિયન ફેડરલ રેવન્યુ સર્વિસ (રેસીતા ફેડરલ) સાથે સત્તાવાર પ્રક્રિયાનો અનુસરો. જનરેટ કરેલ CNPJ માત્ર પરીક્ષણના હેતુઓ માટે છે.
CNPJ વાસ્તવિક કંપનીને સંબંધિત છે કે નહીં તે માન્યતા માટે, તમને બ્રાઝિલિયન ફેડરલ રેવન્યુ સર્વિસ ડેટાબેસની તપાસ કરવાની જરૂર છે. અમારી ટૂલ માત્ર CNPJની ગણિતીય માન્યતા તપાસે છે, તે સત્તાવાર રીતે નોંધાયેલ છે કે નહીં.
બધા સમાન અંકવાળા CNPJ (જેમ કે 11.111.111/1111-11) સ્વચાલિત રીતે અમાન્ય માનવામાં આવે છે, ભલે તેઓ ગણિતીય રીતે ચેક અંક અલ્ગોરિધમ પાસ કરે. આ બ્રાઝિલિયન ફેડરલ રેવન્યુ સર્વિસ દ્વારા સ્થાપિત એક નિયમ છે.
ના. તમામ પ્રોસેસિંગ તમારા બ્રાઉઝરમાં થાય છે, અને અમે તમે જનરેટ અથવા માન્ય કરેલ CNPJને સંગ્રહિત અથવા મોકલતા નથી.
આ ટૂલની વર્તમાન આવૃત્તિ એક સમયે એક જ CNPJ જનરેટ કરે છે. મોટા પ્રમાણમાં જનરેશન માટે, તમે વિકલ્પો વિભાગમાં ઉલ્લેખિત પ્રોગ્રામિંગ લાઇબ્રેરીઓમાંથી કોઈને ઉપયોગ કરવા પર વિચાર કરી શકો છો.
આ બ્રાઝિલિયન સત્તાઓ દ્વારા આવશ્યક ફોર્મેટ છે. ચોક્કસ જૂથો CNPJના વિવિધ ઘટકોને ઓળખવામાં મદદ કરે છે, જેમ કે આધાર નંબર અને શાખા ઓળખકર્તા.
તમે ટેકનિકલ અમલ વિભાગમાં આપવામાં આવેલા કોડ ઉદાહરણોનો ઉપયોગ કરીને તમારી પસંદની પ્રોગ્રામિંગ ભાષામાં માન્યતા અલ્ગોરિધમને અમલમાં મૂકવા અથવા વિકલ્પો વિભાગમાં ઉલ્લેખિત લાઇબ્રેરીઓમાંથી કોઈનો ઉપયોગ કરી શકો છો.
હા. બ્રાઝિલમાં સરકારની સંસ્થાઓમાં વિશિષ્ટ CNPJ પેટર્ન હોય છે. ઉદાહરણ તરીકે, ફેડરલ સરકારની સંસ્થાઓ ઘણી વખત ચોક્કસ અંકોથી શરૂ થાય છે. અમારી જનરેટર રેન્ડમ CNPJ બનાવે છે અને ખાસ કરીને સરકારની સંસ્થા CNPJ બનાવતી નથી.
અમારી બ્રાઝિલિયન CNPJ જનરેટર અને વેલિડેટર ટૂલ આ ઓળખ નંબર સાથે કામ કરવું સરળ અને કાર્યક્ષમ બનાવે છે. તમે એપ્લિકેશન્સની પરીક્ષણ કરી રહ્યા છો, નમૂના ડેટા તૈયાર કરી રહ્યા છો, અથવા અસ્તિત્વમાં આવેલા CNPJની માન્યતા તપાસી રહ્યા છો, આ ટૂલ API ઇન્ટિગ્રેશન અથવા અદ્યતન રૂપરેખાંકનોની જટિલતા વિના એક સરળ ઉકેલ પ્રદાન કરે છે.
હવે તમારું પ્રથમ માન્ય CNPJ જનરેટ કરો અથવા અમારા સરળ ઇન્ટરફેસનો ઉપયોગ કરીને અસ્તિત્વમાં એકની માન્યતા તપાસો!
તમારા વર્કફ્લો માટે ઉપયોગી થવાના વધુ સાધનો શોધો