ข้ามไปยังเนื้อหา
🛠️
Whiz Tools

เครื่องมือสร้างและตรวจสอบ CNPJ - เครื่องมือสำหรับรหัสธุรกิจบราซิล

สร้างหมายเลข CNPJ ที่ถูกต้องสำหรับการทดสอบหรือตรวจสอบรหัสธุรกิจบราซิลได้ทันที เครื่องมือฟรีที่มีการตรวจสอบหลักเลขสำหรับนักพัฒนาที่ทำงานกับ Cadastro Nacional da Pessoa Jurídica

เครื่องมือสร้างและตรวจสอบ CNPJ ของบราซิล

เครื่องมือสร้าง CNPJ

สร้างหมายเลข CNPJ ของบราซิลที่ถูกต้องสำหรับการทดสอบ

เครื่องมือตรวจสอบ CNPJ

ตรวจสอบว่าหมายเลข CNPJ ของบราซิลถูกต้องหรือไม่

เครื่องคำนวณโหลด...
📚

เอกสารประกอบการใช้งาน

ทำความเข้าใจหมายเลข CNPJ ของบราซิล

CNPJ (Cadastro Nacional da Pessoa Jurídica) คือหมายเลขประจำตัวภาษีนิติบุคคลของบราซิล—เป็นหมายเลข 14 หลักที่ระบุตัวตนของนิติบุคคลทุกแห่งในประเทศ หากคุณกำลังพัฒนาซอฟต์แวร์ที่จัดการข้อมูลธุรกิจของบราซิล คุณจะพบหมายเลขเหล่านี้ในแบบฟอร์มลงทะเบียน ใบแจ้งหนี้ และการเชื่อมต่อ API

นี่คือสิ่งที่ทำให้เครื่องมือนี้มีประโยชน์: สร้าง CNPJ ที่ถูกต้องทางคณิตศาสตร์สำหรับการทดสอบโดยไม่ใช้ตัวระบุบริษัทที่แท้จริง เมื่อคุณกำลังตั้งค่าฐานข้อมูลทดสอบด้วย 1,000 เรกคอร์ด หรือแก้ไขข้อผิดพลาดในขั้นตอนการตรวจสอบตอน 2 ทุ่ม คุณต้องการ CNPJ ที่ผ่านการตรวจสอบทางอัลกอริทึมแต่จะไม่ตรงกับธุรกิจที่แท้จริง นั่นคือสิ่งที่เครื่องมือนี้สร้างขึ้น

ตัวเลขที่สร้างขึ้นที่นี่เป็นไปตามอัลกอริทึมการตรวจสอบของ Receita Federal (กรมสรรพากรกลางของบราซิล) มีหลักการตรวจสอบที่ถูกต้องและการจัดรูปแบบที่เหมาะสม—เพียงแต่ไม่ได้จดทะเบียนในฐานข้อมูลของรัฐบาล คิดว่าเป็นข้อมูลทดสอบที่ถูกต้องตามโครงสร้างซึ่งจะไม่สร้างปัญหาการปฏิบัติตามกฎระเบียบในสภาพแวดล้อมการพัฒนาของคุณ

CNPJ คืออะไรและเหตุใดจึงมีความสำคัญ

CNPJ ทำหน้าที่เป็นตัวระบุนิติบุคคลของประเทศบราซิล—คล้ายกับ EIN ในสหรัฐอเมริกาหรือหมายเลขจดทะเบียนบริษัทในสหราชอาณาจักร โดยนิติบุคคลทุกรายที่ดำเนินธุรกิจอย่างถูกกฎหมายในบราซิลจะต้องมี CNPJ ซึ่งออกโดยสรรพากรกลาง (Receita Federal)

คุณจะพบ CNPJ เมื่อ:

  • การชำระเงิน: เกตเวย์การชำระเงินของบราซิลต้องการการตรวจสอบ CNPJ สำหรับบัญชีผู้ค้า
  • การปฏิบัติตามภาษี: ใบแจ้งหนี้ทุกฉบับในบราซิลต้องมี CNPJ ที่ถูกต้อง
  • การจดทะเบียนธุรกิจ: หน่วยงานของรัฐใช้ CNPJ เพื่อติดตามนิติบุคคลในระบบต่างๆ
  • การดำเนินการทางธนาคาร: การเปิดบัญชีบริษัทหรือการโอนเงินระหว่างประเทศ
  • การนำเข้า/ส่งออก: เอกสารศุลกากรต้องมีการตรวจสอบ CNPJ
  • สัญญาของรัฐบาล: ระบบการประมูลสาธารณะจะตรวจสอบ CNPJ ก่อนรับข้อเสนอ

จากประสบการณ์ของฉันในการทำงานกับแพลตฟอร์มอีคอมเมิร์ซของบราซิล จุดเชื่อมต่อที่พบบ่อยที่สุดคือขั้นตอนการชำระเงินที่ผู้ใช้ป้อน CNPJ สำหรับการซื้อในนามบริษัท ตรรกะการตรวจสอบของคุณจำเป็นต้องจับข้อผิดพลาดในการจัดรูปแบบก่อนที่ผู้ประมวลผลการชำระเงินจะทำ—มิฉะนั้นคุณจะเห็นธุรกรรมที่ล้มเหลวซึ่งสามารถป้องกันได้

โครงสร้างและรูปแบบ CNPJ

CNPJ ประกอบด้วย 14 หลัก จัดรูปแบบเป็น: XX.XXX.XXX/YYYY-ZZ

แจกแจงโครงสร้าง:

  1. 8 หลักแรก (XX.XXX.XXX): หมายเลขทะเบียนพื้นฐานที่กำหนดเฉพาะให้กับบริษัท
  2. 4 หลักถัดไป (/YYYY): ตัวระบุสาขาหรือสถานประกอบการ—/0001 แสดงถึงสำนักงานใหญ่ ขณะที่ /0002, /0003 แทนสถานที่ตั้งสาขา
  3. 2 หลักสุดท้าย (-ZZ): หลักตรวจสอบที่คำนวณผ่านอัลกอริทึมถ่วงน้ำหนัก

ตัวอย่าง: 12.345.678/0001-95

สิ่งที่น่าสนใจเกี่ยวกับตัวระบุสาขา: เมื่อบริษัทเปิดสถานที่ตั้งหลายแห่ง แต่ละแห่งจะได้ 8 หลักแรกเหมือนกัน แต่มีหมายเลขสาขาต่างกัน ดังนั้นหากบริษัทค้าปลีกมี 50 สาขา จะมี CNPJ ที่ลงท้ายด้วย /0001 ถึง /0050 โดยใช้หมายเลขพื้นฐานเดียวกัน ซึ่งทำให้สามารถระบุได้ง่ายว่า CNPJ หลายหมายเลขเป็นขององค์กรเดียวกัน

หลักตรวจสอบไม่ได้เป็นแบบสุ่ม—แต่คำนวณโดยใช้อัลกอริทึมมอดุลัส-11 ด้วยลำดับน้ำหนักเฉพาะ การออกแบบนี้ ซึ่งพบบ่อยในเอกสารราชการของบราซิล ทำให้ยากต่อการปลอมแปลงหมายเลขที่ถูกต้องหรือสร้างหมายเลขที่ถูกต้องโดยบังเอิญจากการพิมพ์ผิด

วิธีการตรวจสอบ CNPJ อย่างแท้จริง

อัลกอริทึมการตรวจสอบใช้การคำนวณโมดุลัส-11 แบบถ่วงน้ำหนัก นี่คือตรรกะเบื้องหลัง:

การคำนวณหลักตรวจสอบตัวแรก

  1. นำ 12 หลักแรกและคูณแต่ละหลักด้วยน้ำหนัก: 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. รวมผลคูณทั้งหมด
  3. หารผลรวมด้วย 11 และหาเศษ
  4. ถ้าเศษ < 2 หลักตรวจสอบคือ 0 มิฉะนั้นจะเป็น 11 - เศษ

การคำนวณหลักตรวจสอบตัวที่สอง

  1. นำ 13 หลักแรก (รวมหลักตรวจสอบตัวแรก) และคูณด้วยน้ำหนัก: 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
  2. รวมผลคูณทั้งหมด
  3. หารด้วย 11 และหาเศษ
  4. ถ้าเศษ < 2 หลักตรวจสอบคือ 0 มิฉะนั้นจะเป็น 11 - เศษ

เหตุผลที่วิธีนี้ใช้งานได้: ระบบการคูณแบบถ่วงน้ำหนักสร้างความสัมพันธ์เฉพาะระหว่างหลัก 12 หลักพื้นฐานและหลักตรวจสอบที่ได้ การเปลี่ยนแปลงหลักเดียวในตัวเลขพื้นฐานจะทำให้หลักตรวจสอบแตกต่างกัน ซึ่งจะจับข้อผิดพลาดการถอดความทั่วไปเช่นการสลับตำแหน่งหลัก (พิมพ์ 12.345 แทน 12.354)

หมายเหตุเชิงปฏิบัติ: CNPJ ที่มีหลักทั้งหมดเหมือนกัน (เช่น 11.111.111/1111-11) จะถือว่าไม่ถูกต้องโดยอัตโนมัติ แม้ว่าจะผ่านการตรวจสอบทางคณิตศาสตร์ Receita Federal ยกเว้นรูปแบบเหล่านี้อย่างชัดเจนเพื่อป้องกันกรณีที่ง่ายเกินไป

วิธีใช้เครื่องมือสร้างและตรวจสอบ CNPJ

การสร้าง CNPJ สำหรับทดสอบ

ต้องการ CNPJ ที่ถูกต้องสำหรับฐานข้อมูลทดสอบของคุณหรือไม่? นี่คือวิธี:

  1. คลิก "สร้าง CNPJ"
  2. เครื่องมือสร้างหมายเลขที่ถูกต้องทางคณิตศาสตร์ทันที
  3. คลิก "คัดลอก" เพื่อนำไปใช้งาน
  4. วางลงในแบบฟอร์มทดสอบ เมล็ดฐานข้อมูล หรือการทดสอบยูนิต

CNPJ ที่สร้างขึ้นแต่ละรายการผ่านการตรวจสอบทางอัลกอริทึมทั้งหมด แต่ไม่ได้จดทะเบียนกับ Receita Federal ซึ่งหมายความว่าคุณสามารถใช้งานได้อย่างอิสระในระหว่างการพัฒนาโดยไม่ต้องกังวลว่าจะใช้ตัวระบุของบริษัทจริง

การตรวจสอบหมายเลข CNPJ

มี CNPJ ที่ต้องการตรวจสอบหรือไม่? เครื่องมือตรวจสอบจัดการได้:

  1. วางหรือพิมพ์ CNPJ ลงในช่องป้อนข้อมูล
  2. ไม่ต้องกังวลเรื่องการจัดรูปแบบ—ใช้งานได้กับ 12345678000195 หรือ 12.345.678/0001-95
  3. คลิก "ตรวจสอบ"
  4. รับผลตอบกลับทันทีว่าหลักตรวจสอบถูกต้องหรือไม่

สิ่งที่เครื่องมือตรวจสอบตรวจสอบ: ความยาวที่เหมาะสม (14 หลัก) การคำนวณหลักตรวจสอบที่ถูกต้อง และการแยกรูปแบบที่ไม่ถูกต้องเช่นหลักที่เหมือนกันทั้งหมด สิ่งที่ไม่ตรวจสอบ: ว่า CNPJ ได้จดทะเบียนในฐานข้อมูลของรัฐบาล—ซึ่งต้องสอบถามกับ Receita Federal โดยตรง

กรณีการใช้งานจริงสำหรับเครื่องมือสร้างและตรวจสอบ CNPJ

การพัฒนาซอฟต์แวร์และการทดสอบ

การเติมข้อมูลฐานข้อมูล: เมื่อตั้งค่าสภาพแวดล้อมการทดสอบด้วยข้อมูลที่สมจริง คุณต้องการ CNPJ ที่ถูกต้องหลายสิบหรือหลายร้อยรายการ การสร้างด้วยตนเองเป็นเรื่องยุ่งยาก และการใช้ตัวระบุบริษัทจริงก่อให้เกิดปัญหาความเป็นส่วนตัว CNPJ ที่สร้างขึ้นสามารถแก้ปัญหาทั้งสองประการ

การทดสอบยูนิตเพื่อครอบคลุมกรณีพิเศษ: ฟังก์ชันการตรวจสอบของคุณควรปฏิเสธ 00.000.000/0000-00 แต่ยอมรับ 11.222.333/0001-81 การมีเครื่องมือสร้างช่วยให้คุณสร้างกรณีทดสอบที่ถูกต้องและไม่ถูกต้องได้อย่างรวดเร็ว เพื่อตรวจสอบว่าตรรกะของคุณจัดการเงื่อนไขขอบเขตได้อย่างถูกต้อง

การทดสอบถดถอยสำหรับ QA: เมื่อทดสอบแบบฟอร์มลงทะเบียนหรือขั้นตอนการชำระเงินระหว่างธุรกิจ ทีม QA ต้องการข้อมูลทดสอบใหม่ในแต่ละครั้ง ปัญหาทั่วไปที่พบ: สภาพแวดล้อมทดสอบถูกปนเปื้อนด้วย CNPJ 5-6 รายการที่ใช้ซ้ำ ซึ่งปกปิดข้อบกพร่องที่ปรากฏเฉพาะกับรูปแบบหลักที่เฉพาะเจาะจง

การทดสอบการรวมระบบ API: หากคุณกำลังรวมระบบกับผู้ประมวลผลการชำระเงินของบราซิล เช่น PagSeguro หรือ Mercado Pago สภาพแวดล้อมทดสอบมักต้องการรูปแบบ CNPJ ที่ถูกต้อง คณิตศาสตร์ต้องถูกต้องแม้ว่าคุณจะไม่ได้เชื่อมต่อกับฐานข้อมูลการผลิต

การประมวลผลและตรวจสอบข้อมูล

การทำความสะอาดข้อมูลที่นำเข้า: คุณได้รับไฟล์ CSV ที่มีบันทึกบริษัทบราซิลจำนวน 10,000 รายการ ก่อนการประมวลผล คุณต้องระบุ CNPJ ที่ผิดรูปแบบ การรันผ่านตัวตรวจสอบจะแสดงรายการที่มีการพิมพ์ผิด การตัดทอน หรือหลักตรวจสอบที่ไม่ถูกต้อง—ช่วยประหยัดเวลาการแก้ไขข้อผิดพลาดในภายหลัง

การตรวจสอบแบบฟอร์มฝั่งไคลเอนต์: การตรวจจับ CNPJ ที่ไม่ถูกต้องก่อนส่งแบบฟอร์มช่วยปรับปรุงประสบการณ์ผู้ใช้ ไม่มีใครอยากกรอกแบบฟอร์มลงทะเบียน 20 ช่อง แล้วพบข้อผิดพลาดเมื่อส่งเพราะสลับตำแหน่งหลักสองตัว

การทำให้ข้อมูลเป็นนิรนาม เพื่อการวิเคราะห์: เมื่อเตรียมข้อมูลการผลิตเพื่อแบ่งปันกับทีมวิเคราะห์หรือพันธมิตรภายนอก คุณต้องแทนที่ CNPJ จริงด้วย CNPJ ที่ถูกต้องแต่เป็นเท็จ นี่ช่วยรักษาความสมบูรณ์ของการอ้างอิงในชุดข้อมูลของคุณในขณะเดียวกันก็ปกป้องข้อมูลธุรกิจที่แท้จริง

การดำเนินธุรกิจระหว่างประเทศ

ทำความเข้าใจข้อกำหนดของบราซิล: หากคุณกำลังขยายตลาดไปยังประเทศบราซิล คุณจะพบข้อกำหนด CNPJ ในสัญญา ใบแจ้งหนี้ และเอกสารการจัดส่ง การมีเครื่องมือเพื่อทดลองกับรูปแบบช่วยให้คุณเข้าใจสิ่งที่ระบบของคุณต้องจัดการ

ข้อกำหนดการรวมระบบของบุคคลที่สาม: เมื่อตรวจสอบเอกสาร API จากผู้ให้บริการ SaaS ของบราซิล คุณมักพบช่อง CNPJ ในตัวอย่างเพย์โหลด การสามารถสร้างค่าทดสอบที่ถูกต้องช่วยให้คุณสร้างการรวมระบบได้เร็วขึ้น

วิธีการตรวจสอบ CNPJ ทางเลือก

ไลบรารีการเขียนโปรแกรม

หากคุณต้องการการตรวจสอบ CNPJ ในตรรกะแอปพลิเคชันของคุณ ไลบรารีเหล่านี้ใช้อัลกอริทึมการตรวจสอบหลักเลข:

  • JavaScript/Node.js: cpf-cnpj-validator (ดาวน์โหลดรายสัปดาห์มากกว่า 130k), validator.js (รองรับเอกสารของบราซิล)
  • Python: validate-docbr (ตรวจสอบ CPF, CNPJ และเอกสารอื่นๆ ของบราซิล), python-cnpj
  • PHP: respect/validation (รวมกฎ CNPJ), brazilianutils
  • Java: caelum-stella (การตรวจสอบเอกสารของบราซิลอย่างครอบคลุม)
  • Ruby: เจม cpf_cnpj

ไลบรารีเหล่านี้โดยทั่วไปจะจัดการการจัดรูปแบบ การแยกวิเคราะห์ และการตรวจสอบสำหรับประเภทเอกสารของบราซิลหลายประเภท (CPF, CNPJ เป็นต้น)

API การตรวจสอบอย่างเป็นทางการ

สำหรับระบบการผลิตที่ต้องการตรวจสอบการลงทะเบียนธุรกิจที่แท้จริง:

  • บริการสาธารณะของ Receita Federal: Consulta CNPJ API อนุญาตให้ตรวจสอบกับฐานข้อมูลอย่างเป็นทางการ (ต้องได้รับอนุญาตที่เหมาะสมและจำกัดอัตรา)
  • ผู้ให้บริการข้อมูลบุคคลที่สาม: บริการเช่น Serasa Experian และ Boa Vista SCPC นำเสนอ API เชิงพาณิชย์ที่ส่งคืนรายละเอียดบริษัท สถานะการลงทะเบียน และข้อมูลเครดิต

หมายเหตุ: บริการเหล่านี้ตรวจสอบการลงทะเบียนที่แท้จริง ไม่ใช่เพียงความถูกต้องทางคณิตศาสตร์ คุณจะต้องได้รับอนุญาตที่เหมาะสมและควรคาดหวังค่าใช้จ่าย API สำหรับการใช้งานในการผลิต

เมื่อใดที่จะใช้แต่ละวิธีการ

ใช้เครื่องมือเบราว์เซอร์นี้เมื่อ: คุณต้องการการตรวจสอบอย่างรวดเร็วโดยไม่ต้องติดตั้งการพึ่งพา การสร้างข้อมูลทดสอบสำหรับการสาธิต หรือเรียนรู้วิธีการตรวจสอบ CNPJ

ใช้ไลบรารีเมื่อ: คุณกำลังสร้างแอปพลิเคชันที่ต้องการการตรวจสอบฝั่งไคลเอ็นต์หรือเซิร์ฟเวอร์เป็นส่วนหนึ่งของการประมวลผลแบบฟอร์ม

ใช้ API อย่างเป็นทางการเมื่อ: คุณต้องการตรวจสอบว่า CNPJ ตรงกับธุรกิจที่มีอยู่จริง มีสถานะการลงทะเบียนปัจจุบัน

รายละเอียดทางเทคนิค

เครื่องมือนี้ทำงานทั้งหมดในเบราว์เซอร์ของคุณโดยใช้ JavaScript - ไม่มีการร้องขอเซิร์ฟเวอร์ ไม่มีข้อมูลออกจากเครื่องของคุณ นี่คือวิธีการทำงานของอัลกอริทึมภายใต้ฝา พร้อมโค้ดที่คุณสามารถปรับใช้สำหรับโครงการของตัวเอง:

อัลกอริทึมการสร้าง 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}
29

อัลกอริทึมการตรวจสอบ CNPJ

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

ฟังก์ชันจัดรูปแบบ CNPJ

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

ฟังก์ชันหลักเหล่านี้สามารถนำไปใช้ในภาษาโปรแกรมมิ่งอื่นๆ โดยใช้ตรรกะเดียวกัน นี่คือตัวอย่างใน Python และ Java:

การใช้งานใน Python

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
55

การใช้งานใน Java

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        // สร้างหลัก 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 ที่จดทะเบียนกับ Receita Federal หรือไม่ ไม่ว่าจะเป็นบริษัทที่ใช้งานอยู่ หรือไม่ว่าจะเชื่อมโยงกับชื่อธุรกิจที่คุณคาดหวัง

คิดเหมือนกับการตรวจสอบการสะกดคำเทียบกับการตรวจสอบข้อเท็จจริง เครื่องมือนี้บอกคุณว่า CNPJ "สะกด" ถูกต้องตามกฎทางคณิตศาสตร์ แต่ไม่สามารถบอกได้ว่าหมายเลขนั้นตรงกับนิติบุคคลที่มีอยู่จริง

การใช้งานตามกฎหมายและจริยธรรม

CNPJ ที่สร้างขึ้นมีไว้สำหรับการทดสอบและพัฒนาเท่านั้น มีความถูกต้องทางคณิตศาสตร์ แต่ไม่ได้จดทะเบียนกับหน่วยงานของบราซิล ซึ่งหมายความว่า:

  • ✅ ใช้ได้สำหรับ: การเติมฐานข้อมูลทดสอบ การทดสอบหน่วย การตรวจสอบคุณภาพ ตัวอย่างโค้ดในเอกสาร
  • ❌ ห้ามใช้สำหรับ: การยื่นภาษี การจดทะเบียนธุรกิจ การลงนามในสัญญา การประมวลผลธุรกรรมจริง หรือการแอบอ้างตัวตนทางธุรกิจ

การใช้ CNPJ ปลอมสำหรับวัตถุประสงค์อย่างเป็นทางการไม่เพียงแต่ผิดจริยธรรมเท่านั้น แต่ยังผิดกฎหมายของบราซิลและอาจถูกดำเนินคดีฐานฉ้อโกง

ข้อจำกัดทางเทคนิคที่ควรทราบ

การสุ่มสร้างมีผลกระทบ: เครื่องมือสร้างหลัก 12 หลักแรกแบบสุ่ม CNPJ จริงที่ออกโดย Receita Federal จะมีรูปแบบภายในที่เกี่ยวข้องกับวันที่จดทะเบียน สำนักงานภูมิภาค และประเภทธุรกิจ หมายเลขที่สร้างขึ้นจะไม่ตรงกับรูปแบบเหล่านี้ ซึ่งระบบตรวจสอบที่ซับซ้อนอาจสังเกตเห็น

ไม่มีการตรวจสอบทางความหมาย: รูปแบบ CNPJ ที่ถูกต้องไม่ได้หมายความว่าบริบทธุรกิจถูกต้อง ตัวอย่างเช่น หน่วยงานรัฐบาลมีช่วง CNPJ เฉพาะ—เครื่องมือนี้อาจสร้างขึ้นโดยบังเอิญ แต่จะไม่มีความหมาย

การจัดการรูปแบบ: ตัวตรวจสอบยอมรับรูปแบบอินพุตต่างๆ (12345678000195, 12.345.678/0001-95) แต่ระบบเก่าบางระบบคาดหวังรูปแบบที่แน่นอน ควรทดสอบกับข้อกำหนดการรวมระบบเฉพาะของคุณเสมอ

ความเป็นส่วนตัวและความปลอดภัย

การประมวลผลทั้งหมดเกิดขึ้นที่ฝั่งไคลเอ็นต์ในเบราว์เซอร์ของคุณ CNPJ ที่คุณสร้างหรือตรวจสอบจะไม่ถูกส่งไปยังเซิร์ฟเวอร์ บันทึก หรือจัดเก็บ เครื่องมือนี้ไม่ร้องขอ จัดการ หรือประมวลผลข้อมูลส่วนบุคคลใดๆ

คำถามที่พบบ่อยเกี่ยวกับการตรวจสอบ CNPJ

อะไรคือความแตกต่างระหว่างการตรวจสอบและการยืนยัน CNPJ?

การตรวจสอบ ตรวจสอบว่าหมายเลขมีความถูกต้องทางคณิตศาสตร์—รูปแบบที่ถูกต้อง หลักการตรวจสอบที่ถูกต้อง ไม่มีรูปแบบที่ไม่ถูกต้อง เครื่องมือนี้ทำการตรวจสอบ

การยืนยัน ตรวจสอบว่า CNPJ ลงทะเบียนกับบริษัทจริงในฐานข้อมูลของ Receita Federal การยืนยันต้องสอบถามฐานข้อมูลของรัฐบาลและไม่ใช่สิ่งที่เครื่องมือนี้ทำ

คุณสามารถมี CNPJ ที่ถูกต้องอย่างสมบูรณ์แต่ไม่ได้รับการยืนยัน (เช่นหมายเลขทดสอบที่เครื่องมือนี้สร้าง) หรือ CNPJ ที่ไม่ถูกต้องที่เป็นของบริษัทจริง (เพราะมีการพิมพ์ผิดเมื่อป้อนเข้าไป)

ฉันสามารถใช้ CNPJ ที่สร้างขึ้นสำหรับการทดสอบการผลิตได้หรือไม่?

ขึ้นอยู่กับสิ่งที่คุณหมายถึง "การทดสอบการผลิต" พวกเขาเหมาะสำหรับสภาพแวดล้อมการทดสอบ การทดสอบโหลด และ QA ก่อนการเปิดตัว แต่ถ้า "การทดสอบการผลิต" หมายถึงการทดสอบกับธุรกรรมจริง API ของรัฐบาลจริง หรือระบบการเงินจริง—แล้วไม่ คุณต้องใช้ CNPJ ที่ลงทะเบียนจริง

แนวทางที่ปลอดภัยกว่า: ใช้ CNPJ ที่สร้างขึ้นในสภาพแวดล้อมการทดสอบที่แยกออก แล้วเปลี่ยนไปใช้ชุด CNPJ ของบริษัทที่ทดสอบจริงขนาดเล็ก (ที่คุณควบคุม) เมื่อทดสอบการรวมการผลิต

ทำไมตัวตรวจสอบจึงปฏิเสธ 11.111.111/1111-11?

แม้ว่า CNPJ ที่มีหลักเลขทั้งหมดเหมือนกันสามารถสร้างหลักการตรวจสอบที่ถูกต้องทางคณิตศาสตร์ แต่ Receita Federal ยกเว้นรูปแบบเหล่านี้อย่างชัดเจน นี่เป็นกฎทางธุรกิจ ไม่ใช่กฎทางคณิตศาสตร์ สิ่งเดียวกันนี้ใช้กับรูปแบบต่อเนื่องในระบบการตรวจสอบบางระบบ

นี่คล้ายกับวิธีที่ระบบหลายระบบปฏิเสธรหัสผ่านเช่น "password123" แม้ว่าจะเป็นไปตามข้อกำหนดความยาว—พวกเขาถูกต้องทางเทคนิคแต่ไม่สามารถยอมรับได้ในทางปฏิบัติ

ฉันจะจัดการกับการตรวจสอบ CNPJ ในสถานที่ต่างๆ ได้อย่างไร?

บริษัทบราซิลที่ทำธุรกิจระหว่างประเทศบางครั้งละทิ้งอักขระการจัดรูปแบบเมื่อป้อน CNPJ ในระบบต่างประเทศ ตรรกะการตรวจสอบของคุณควรลบอักขระที่ไม่ใช่ตัวเลขก่อนตรวจสอบ:

1const cleanCNPJ = input.replace(/\D/g, ''); // ลบทุกอย่างยกเว้นหลักเลข
2

ยอมรับ 12.345.678/0001-95, 12345678000195 และ 12 345 678 0001 95 เป็นอินพุตที่เทียบเท่ากัน

แล้วเรื่อง CNPJ กับการตรวจสอบ CPF ล่ะ?

CPF (Cadastro de Pessoas Físicas) เป็นรหัสประจำตัวผู้เสียภาษีของบุคคลในบราซิล ในขณะที่ CNPJ เป็นของธุรกิจ พวกเขาใช้อัลกอริทึมหลักการตรวจสอบและความยาวที่แตกต่างกัน (CPF มี 11 หลัก CNPJ มี 14 หลัก) หากคุณกำลังสร้างแอปบราซิลที่จัดการทั้งสองรูปแบบ คุณจะต้องมีฟังก์ชันการตรวจสอบแยกกัน—แม้ว่าไลบรารีหลายแห่งจะรองรับทั้งสองรูปแบบ

รูปแบบทั่วไป: ให้ผู้ใช้ป้อน CPF หรือ CNPJ ในช่องเดียวกัน จากนั้นตรวจจับประเภทตามความยาวหลังจากลบการจัดรูปแบบ

นี่ใช้งานได้กับบริษัทต่างชาติที่ดำเนินกิจการในบราซิลหรือไม่?

บริษัทต่างชาติที่ดำเนินกิจการในบราซิลต้องได้รับ CNPJ จาก Receita Federal เช่นกัน CNPJ ของพวกเขาปฏิบัติตามรูปแบบและกฎการตรวจสอบเดียวกันกับบริษัทในประเทศ ไม่มีรูปแบบ CNPJ พิเศษสำหรับ "บริษัทต่างชาติ"

อย่างไรก็ตาม บริษัทต่างชาติอาจมีข้อกำหนดเอกสารเพิ่มเติมและกระบวนการลงทะเบียนที่แตกต่าง—ปรึกษากับทนายความธุรกิจบราซิลสำหรับรายละเอียดเฉพาะ

ฉันสามารถสอบถามฐานข้อมูลของรัฐบาลเพื่อยืนยันการลงทะเบียน CNPJ ได้หรือไม่?

ใช่ Receita Federal มีการเข้าถึงสาธารณะเพื่อยืนยันข้อมูล CNPJ พื้นฐานผ่านบริการ Consulta Pública CNPJ คุณสามารถค้นหา CNPJ ด้วยตนเองหรือ ด้วยการอนุญาตที่เหมาะสม ใช้ API ของพวกเขาสำหรับการเข้าถึงแบบโปรแกรม

โปรดทราบว่าการใช้งานหนักต้องลงทะเบียนและมีขีดจำกัดอัตราเพื่อป้องกันการใช้งานเกินเลย

CNPJ เปลี่ยนแปลงบ่อยแค่ไหน?

CNPJ เป็นตัวระบุถาวรที่ไม่เปลี่ยนแปลงเมื่อบริษัทเปลี่ยนชื่อ ที่อยู่ หรือโครงสร้างการเป็นเจ้าของ อย่างไรก็ตาม หากบริษัทปิดและลงทะเบียนใหม่ในภายหลัง อาจได้รับ CNPJ ใหม่ หมายเลขสาขา (ส่วน /XXXX) สามารถเพิ่มได้เมื่อบริษัทเปิดสถานที่ใหม่ แต่หมายเลขพื้นฐาน 8 หลักยังคงคงที่

แหล่งอ้างอิงและทรัพยากรเพิ่มเติม

แหล่งข้อมูลราชการอย่างเป็นทางการ

  1. กรมสรรพากรแห่งบราซิล - พอร์ทัลอย่างเป็นทางการ - เว็บไซต์อย่างเป็นทางการของกรมสรรพากรแห่งบราซิลที่มีบริการลงทะเบียนและตรวจสอบ CNPJ
  2. การค้นหาสาธารณะ CNPJ - การค้นหา CNPJ สาธารณะ - บริการราชการอย่างเป็นทางการเพื่อตรวจสอบสถานะการลงทะเบียน CNPJ
  3. คำสั่งทางการ RFB ฉบับที่ 1863/2018 - ระเบียบทางกฎหมายที่กำกับดูแลการลงทะเบียนและการใช้ CNPJ ในบราซิล

มาตรฐานทางเทคนิคและเอกสาร

  1. อัลกอริทึมเลขคณิตแบบมอดูลาร์ - การคำนวณหลักตรวจสอบใช้เลขคณิตมอดูโล 11 ซึ่งเป็นวิธีมาตรฐานสำหรับหลักการตรวจสอบ
  2. ISO/IEC 7064 - มาตรฐานสากลสำหรับระบบหลักตรวจสอบที่มีอิทธิพลต่อการออกแบบการตรวจสอบเอกสารของบราซิล
  3. ประมวลกฎหมายแพ่งบราซิล (กฎหมายฉบับที่ 10.406/2002) - กรอบทางกฎหมายที่กำหนดการจัดประเภทหน่วยธุรกิจที่ต้องลงทะเบียน CNPJ

ทรัพยากรสำหรับนักพัฒนา

  1. คลังแพ็คเกจ NPM - npmjs.com - คลังสำหรับไลบรารี JavaScript รวมถึงตัวตรวจสอบเอกสารบราซิล
  2. PyPI (ดัชนีแพ็คเกจ Python) - pypi.org - ไลบรารี Python สำหรับการตรวจสอบ CNPJ และการประมวลผลเอกสารบราซิล
  3. GitHub - การใช้งานโอเพ่นซอร์สของการตรวจสอบ CNPJ ในภาษาการเขียนโปรแกรมหลายภาษา

เริ่มสร้างและตรวจสอบ CNPJ

ไม่ว่าคุณกำลังสร้างแพลตฟอร์มอีคอมเมิร์ซของบราซิล ทดสอบการรวมการชำระเงินกับ Mercado Pago หรือเพียงต้องการทำความเข้าใจวิธีการตรวจสอบ CNPJ เครื่องมือนี้ให้คุณเข้าถึงความสามารถในการสร้างและตรวจสอบทันที

ไม่ต้องติดตั้ง ไม่ต้องมีคีย์ API ไม่มีการตั้งค่าที่ซับซ้อน เพียงเปิดเบราว์เซอร์และเริ่มทำงานกับตัวระบุธุรกิจของบราซิลที่ถูกต้อง