Gerador de CNPJ válido

CNPJ alfanumérico

A Instrução Normativa RFB 2.229, de 2024, define o CNPJ alfanumérico: os oito dígitos da raiz e os quatro da ordem passam a aceitar letras, enquanto os dois dígitos verificadores continuam numéricos. O cálculo do verificador usa o valor ASCII do caractere menos 48, o que faz letra e número entrarem na mesma conta.

A consequência é direta e cara: todo sistema que guarda CNPJ como inteiro vai quebrar, toda máscara que só aceita dígito vai recusar cadastro legítimo, e todo índice numérico vai precisar migrar para texto. Testar com esse formato desde já é a diferença entre descobrir agora e descobrir em produção.

A ferramenta gera nos dois formatos, o numérico tradicional e o alfanumérico, para você exercitar os dois caminhos do código.

O cálculo, passo a passo

Acompanhe com 11.222.333/0001-81. A base são as doze primeiras posições, 112223330001, e os dois últimos dígitos são o que vamos recalcular.

Primeiro dígito: os pesos são 5, 4, 3, 2 e depois 9, 8, 7, 6, 5, 4, 3, 2. Note que eles descem até 2 e voltam para 9, que é a diferença em relação ao CPF. As parcelas dão 5, 4, 6, 4, 18, 24, 21, 18, 0, 0, 0 e 2, somando 102. O resto de 102 por 11 é 3, então o dígito é 11 menos 3, ou seja, 8.

Segundo dígito: mesma ideia sobre treze posições, incluindo o 8, com os pesos deslocados em um: 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2. A soma dá 120, o resto por 11 é 10 e o dígito é 1. Fecha em 81.

Como no CPF, resto menor que 2 significa dígito zero.

Implementação de referência

A implementação abaixo já trata o formato alfanumérico. A única mudança em relação ao CNPJ numérico é a linha que converte o caractere: em vez de interpretar o dígito, ela usa o código ASCII menos 48. Para "0" a "9" o resultado é 0 a 9, exatamente como antes, e para "A" a "Z" é 17 a 42. Por isso o mesmo código serve para os dois formatos.

Os dois dígitos verificadores continuam numéricos, então uma letra nas posições 13 ou 14 nunca vai bater com o valor calculado e o CNPJ é recusado, que é o comportamento correto.

export function isValidCnpj(value: string): boolean {
  // tira so a mascara, nao qualquer nao-alfanumerico.
  const base = value.replace(/[./\s-]/g, "").toUpperCase();

  // 12 posicoes alfanumericas + 2 DVs, que continuam numericos.
  if (!/^[0-9A-Z]{12}\d{2}$/.test(base)) return false;
  if (/^(.)\1{13}$/.test(base)) return false;

  // IN RFB 2.229/2024: o valor do caractere e o ASCII menos 48.
  // "0" vira 0, "A" vira 17. Digito e letra entram na mesma conta.
  const val = (i: number) => base.charCodeAt(i) - 48;

  // pesos: 5,4,3,2,9,8,7,6,5,4,3,2 no primeiro DV
  //     e  6,5,4,3,2,9,8,7,6,5,4,3,2 no segundo.
  const dv = (len: number): number => {
    let sum = 0;
    let weight = len - 7;
    for (let i = 0; i < len; i++) {
      sum += val(i) * weight;
      weight = weight === 2 ? 9 : weight - 1;
    }
    const rest = sum % 11;
    return rest < 2 ? 0 : 11 - rest;
  };

  // DV continua numerico: letra na posicao 12 ou 13 nunca bate.
  return dv(12) === val(12) && dv(13) === val(13);
}

public static bool IsValidCnpj(string value)
{
    var b = "";
    foreach (var c in value.ToUpperInvariant())
    {
        if (c == '.' || c == '/' || c == '-' || c == ' ') continue;
        if (!((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z')))
            return false;
        b += c;
    }

    // 12 posicoes alfanumericas + 2 DVs, que continuam numericos.
    if (b.Length != 14) return false;
    if (b[12] < '0' || b[12] > '9') return false;
    if (b[13] < '0' || b[13] > '9') return false;

    var repeated = true;
    for (var i = 1; i < 14; i++)
        if (b[i] != b[0]) { repeated = false; break; }
    if (repeated) return false;

    int Dv(int len)
    {
        int sum = 0, weight = len - 7;
        for (var i = 0; i < len; i++)
        {
            // ASCII menos 48: "0" vira 0, "A" vira 17.
            sum += (b[i] - '0') * weight;
            weight = weight == 2 ? 9 : weight - 1;
        }
        var rest = sum % 11;
        return rest < 2 ? 0 : 11 - rest;
    }

    return Dv(12) == b[12] - '0' && Dv(13) == b[13] - '0';
}

Estrutura do número

São catorze posições: oito de raiz, que identificam a empresa, quatro de ordem, que identificam o estabelecimento, sendo 0001 a matriz, e dois verificadores calculados por módulo 11 com pesos que vão de 5 a 2 e depois de 9 a 2. O formato impresso é 00.000.000/0001-00.

Cada filial tem CNPJ próprio, com a mesma raiz e ordem diferente, e verificadores recalculados. Sistemas que assumem um CNPJ por empresa costumam tropeçar aí.

Válido não é o mesmo que ativo

O dígito verificador só diz que o número é bem formado. Situação cadastral, natureza jurídica, CNAE e endereço vêm da base do CNPJ na Receita Federal, não do número. Nenhum gerador consulta isso, e é bom que não consulte.

Nada do que você cola aqui sai do seu navegador. O processamento é todo local, em JavaScript, sem envio para servidor, sem log e sem armazenamento.

Perguntas frequentes

Referências

• Receita Federal: CNPJPágina oficial do cadastro, com as regras vigentes e as orientações de transição.
• Lei 13.709/2018 (LGPD)Texto integral da lei, incluindo o conceito de dado pessoal que vale também em ambiente de teste.