CNPJ

import { isValidCnpj } from '@brazilian-utils/brazilian-utils';

isValidCnpj('15515147234255'); // false
isValidCnpj('q0slfmbd7vx439', { version: 2 }); // true (lido como Q0SLFMBD7VX439)

import { formatCnpj } from '@brazilian-utils/brazilian-utils';

formatCnpj('24522200000174'); // 24.522.200/0001-74
formatCnpj('245222000174', { pad: true }); // 00.245.222/0001-74
formatCnpj('12OUT345000199', { version: 2 }); // 12.OUT.345/0001-99
formatCnpj('12345678000195', { obfuscate: true }); // **.345.678/0001-**

import { parseCnpj } from '@brazilian-utils/brazilian-utils';

parseCnpj('24.522.200/0001-74'); // 24522200000174
parseCnpj('12.OUT.345/0001-99', { version: 2 }); // 12OUT345000199

import { generateCnpj } from '@brazilian-utils/brazilian-utils';

generateCnpj();
generateCnpj(2); // CNPJ alfanumérico, ex. 'Q0SLFMBD7VX439'
generateCnpj({ branch: 3 }); // bloco de ordem '0003', ex. '12345678000357'
generateCnpj({ version: 2, branch: 1 }); // CNPJ alfanumérico cujo bloco de ordem é '0001'

import { getCnpjInfo } from '@brazilian-utils/brazilian-utils';

getCnpjInfo('12.345.678/0001-95');
// {
//   root: '12345678',
//   branch: '0001',
//   checkDigits: '95',
//   isInitialHeadquarters: true
// }

getCnpjInfo('12.abc.345/01de-35', { version: 2 });
// {
//   root: '12ABC345',
//   branch: '01DE',
//   checkDigits: '35',
//   isInitialHeadquarters: false
// }

getCnpjInfo('12.ABC.345/01DE-35'); // null (alfanumérico, lido na versão 1)
getCnpjInfo('12.345.678/0001-90'); // null (dígitos verificadores incorretos)

Guias

• Campo de documentoUm campo que aplica máscara e valida CPF, CNPJ, CEP ou telefone enquanto você digita, com Brazilian Utils em React, Angular, Vue e JavaScript puro.
• Bibliotecas de schemaOs validadores do Brazilian Utils dentro de um schema do Zod, do Valibot ou do ArkType, ou como um Standard Schema próprio.
• Guia de migração: v1 para v2Como migrar um projeto do Brazilian Utils v1.x para a v2: os exports renomeados, os aliases descontinuados que ainda funcionam e um checklist para seguir.

Especificação

Resumo

O CNPJ é o número de identificação que a Receita Federal atribui a empresas, órgãos públicos e outras entidades no Brasil. Tem 14 caracteres: 8 da raiz, 4 da ordem do estabelecimento e 2 dígitos verificadores. Os CNPJs emitidos antes do início do formato alfanumérico usam apenas dígitos. Desde julho de 2026, novas inscrições podem conter letras maiúsculas e dígitos nos 12 primeiros caracteres. Os 2 dígitos verificadores continuam apenas numéricos.

Regras de validação

1. A entrada deve conter exatamente 14 caracteres.

2. Os 12 primeiros caracteres podem conter dígitos de 0 a 9 e letras de A a Z. Com version: 2, a validação lê letras minúsculas como maiúsculas.

3. Os 2 últimos caracteres são os dígitos verificadores e devem ser numéricos.

4. Os dígitos verificadores devem vir do algoritmo do módulo 11.

5. Para calcular os dígitos verificadores, converta os 12 primeiros caracteres em valores numéricos. Use o código ASCII decimal de cada caractere e subtraia 48.

   Exemplos:

   • 0 → 48 - 48 = 0
   • 9 → 57 - 48 = 9
   • A → 65 - 48 = 17
   • B → 66 - 48 = 18
   • Z → 90 - 48 = 42

Algoritmo

1. Verificar se a entrada tem exatamente 14 caracteres.
2. Verificar se os 12 primeiros caracteres são alfanuméricos e os 2 últimos são numéricos.
3. Converter os caracteres alfanuméricos em valores numéricos:
   • Os dígitos mantêm o seu valor.
   • As letras passam a valer o seu código ASCII decimal menos 48.
4. Calcular o primeiro dígito verificador (DV1):
   • Para os 12 primeiros caracteres, distribuir os pesos de 2 a 9 da direita para a esquerda. Recomeçar em 2 após o peso 9.
   • Multiplicar cada valor pelo seu peso e somar os resultados.
   • Calcular o resto da divisão da soma por 11.
   • Se o resto for 0 ou 1, o DV1 é 0. Se não, o DV1 é 11 - resto.
5. Calcular o segundo dígito verificador (DV2):
   • Adicionar o DV1 ao fim da sequência. Para esses 13 caracteres, distribuir os pesos de 2 a 9 da direita para a esquerda.
   • Multiplicar cada valor pelo seu peso e somar os resultados.
   • Calcular o resto da divisão da soma por 11.
   • Se o resto for 0 ou 1, o DV2 é 0. Se não, o DV2 é 11 - resto.
6. Comparar os dígitos verificadores calculados com os 2 últimos caracteres do CNPJ.

Campos do número

A IN RFB nº 2.229/2024 (Anexo XV da IN RFB nº 2.119/2022) divide as 14 posições assim:

• getCnpjInfo(value, { version }) retorna esses campos e isInitialHeadquarters. Retorna null exatamente quando isValidCnpj(value, { version }) é false, então um CNPJ alfanumérico lido na versão 1 dá null. Os campos de um CNPJ alfanumérico vêm em maiúsculas. O resultado não tem campo format.
• isInitialHeadquarters é true quando a filial é 0001. A Receita Federal dá 0001 à matriz quando a raiz é inscrita. Uma filial pode depois virar matriz sem ter a ordem 0001 (pergunta 25 das Perguntas e Respostas da Receita Federal sobre o CNPJ alfanumérico), então o indicador só diz o que o número dizia na geração.
• generateCnpj({ branch }) usa o mesmo nome. Uma filial sorteada nunca é 0000, porque os estabelecimentos são numerados a partir de 0001. A 2.4.0 podia retornar 0000 (cerca de uma vez a cada 10.000 CNPJs numéricos).

Exemplos:

• getCnpjInfo("12.345.678/0001-95") retorna { root: "12345678", branch: "0001", checkDigits: "95", isInitialHeadquarters: true }.
• getCnpjInfo("12.abc.345/01de-35", { version: 2 }) retorna { root: "12ABC345", branch: "01DE", checkDigits: "35", isInitialHeadquarters: false }.
• getCnpjInfo("12.ABC.345/01DE-35") retorna null (alfanumérico, lido na versão 1).

Máscara de ocultação e números

• formatCnpj(value, { obfuscate: true }) oculta os 2 primeiros caracteres e os 2 dígitos verificadores (**.345.678/0001-**). É uma convenção da biblioteca, sem fonte oficial: nenhuma lei ou ato da Receita Federal fixa regra de mascaramento para o CNPJ, cujos dados são públicos. Ela segue a regra que as Leis de Diretrizes Orçamentárias fixam para o CPF.
• formatCnpj e parseCnpj também recebem número. Ele só é lido quando é um inteiro seguro não negativo. Número negativo, fracionário, não finito ou inseguro retorna string vazia. A 2.4.0 lia os dígitos de qualquer número.

Regex

• CNPJ sem formatação: ^[A-Z0-9]{12}[0-9]{2}$
• CNPJ formatado: ^[A-Z0-9]{2}\.[A-Z0-9]{3}\.[A-Z0-9]{3}/[A-Z0-9]{4}-[0-9]{2}$

Exemplos

• Válido: 03560714000142 (CNPJ numérico válido)
• Válido: 9359QAG9000184 (CNPJ alfanumérico válido)
• 03.560.714/0001-42: decisão pendente. A referência (JS) aceita, as outras bibliotecas não.
• Inválido: 00111222000133 (dígitos verificadores inválidos)
• Inválido: 12ABC34501DE3X (os dígitos verificadores devem ser numéricos)
• Inválido: 12ABC34501DE3 (deve conter exatamente 14 caracteres)
• Inválido: 12ABC34501DE345 (deve conter exatamente 14 caracteres)

Fontes oficiais

• Instrução Normativa RFB nº 2119, de 6 de dezembro de 2022
• Instrução Normativa RFB nº 2229, de 15 de outubro de 2024
• Cálculo dos dígitos verificadores de CNPJ alfanumérico
• CNPJ, Receita Federal
• Manual de cálculo do dígito verificador do CNPJ, Receita Federal
• CNPJ Alfanumérico, Receita Federal
• Perguntas e respostas: CNPJ alfanumérico, Receita Federal
• Instrução Normativa RFB nº 2.229/2024, no Sijut2

Veja também CPF, Inscrição estadual, Natureza jurídica