A Receita Federal do Brasil, por meio da Instrução Normativa nº 2.229 de 15 de outubro de 2024, anunciou uma mudança significativa na estrutura do Cadastro Nacional da Pessoa Jurídica (CNPJ). A alteração, que entra em vigor em julho de 2026, introduz o CNPJ Alfanumérico, um novo modelo de identificação que visa ampliar a capacidade de registro de empresas no Brasil.
Essa atualização terá impacto direto em milhares de sistemas, especialmente nos relacionados à emissão de documentos fiscais eletrônicos e nos ambientes de autorização administrados pelas secretarias da Fazenda.
Para orientar a adaptação, foi publicada a Nota Técnica DFe Conjunta – CNPJ Alfanumérico v1.00, abrangendo os ambientes de autorização coordenados pelo ENCAT, como: NF-e, NFC-e, CT-e, CT-e OS, GTV-e, MDF-e, BP-e, BP-e TM, NF3-e e NFCom.
Como será a nova estrutura?
O novo CNPJ continuará com 14 caracteres, mas com mudanças importantes:
- As oito primeiras posições passam a aceitar letras e números, compondo a raiz do CNPJ.
- As quatro posições seguintes, também alfanuméricas, identificam a filial ou estabelecimento.
- Os dois últimos dígitos seguem sendo numéricos, correspondendo aos dígitos verificadores.
Essa reformulação é necessária para evitar o esgotamento de combinações possíveis no padrão atual.
Vídeo explicativo sobre a mudança para o CNPJ Alfanumérico.
Exemplo do novo modelo
- Raiz (8 caracteres alfanuméricos): A1B2C3D4
- Estabelecimento (4 caracteres alfanuméricos): 1A2B
- Dígitos verificadores (2 números): 99
- Com máscara: A1.B2C.3D4/1A2B-99
- Sem máscara: A1B2C3D41A2B99
Validação e cálculo dos dígitos verificadores
Embora o cálculo continue sendo feito pelo módulo 11, será necessário adaptar os sistemas para considerar valores ASCII das letras maiúsculas ao calcular o dígito verificador. Essa adaptação garante compatibilidade entre os formatos atuais e o novo CNPJ alfanumérico.
Exemplo simples
Vamos usar o CNPJ alfanumérico fictício: "1A2B3C4D5678"
Passo 1: Converter os caracteres
- 1 = 1
- A = 17
- 2 = 2
- B = 18
- 3 = 3
- C = 19
- 4 = 4
- D = 20
- 5 = 5
- 6 = 6
- 7 = 7
- 8 = 8
| Dígito | Valor | Peso | Produto |
|---|---|---|---|
| 1 | 1 | 6 | 6 |
| A (17) | 17 | 5 | 85 |
| 2 | 2 | 4 | 8 |
| B (18) | 18 | 3 | 54 |
| 3 | 3 | 2 | 6 |
| C (19) | 19 | 9 | 171 |
| 4 | 4 | 8 | 32 |
| D (20) | 20 | 7 | 140 |
| 5 | 5 | 6 | 30 |
| 6 | 6 | 5 | 30 |
| 7 | 7 | 4 | 28 |
| 8 | 8 | 3 | 24 |
| Total | -- | -- | 614 |
Passo 2: Cálculo do Resto (Módulo 11)
Realiza-se a divisão da soma ponderada dos valores por 11:
614 ÷ 11 = 55, com resto 9.
Como o resto é maior que 2, aplica-se a fórmula:
11 – 9 = 2, resultando no primeiro dígito verificador (DV1).
Passo 3: Resultado Parcial
O DV1 calculado é 2.
Para determinar o DV2, o processo é repetido com a sequência original acrescida do DV1 no final, agora utilizando pesos de 5 a 2.
Esse ajuste no cálculo do dígito verificador é necessário para permitir que tanto CNPJs totalmente numéricos quanto os novos modelos alfanuméricos sejam validados com a mesma fórmula, garantindo compatibilidade com sistemas existentes.
Exemplo em JavaScript
class CNPJ {
static tamanhoCNPJSemDV = 12;
static regexCNPJSemDV = /^[A-Z\d]{12}$/;
static regexCNPJ = /^[A-Z\d]{12}\d{2}$/;
static regexCaracteresMascara = /[./-]/g;
static regexCaracteresNaoPermitidos = /[^A-Z\d./-]/i;
static valorBase = "0".charCodeAt(0);
static pesosDV = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
static cnpjZerado = "00000000000000";
static isValid(cnpj) {
if (!this.regexCaracteresNaoPermitidos.test(cnpj)) {
let cnpjSemMascara = this.removeMascaraCNPJ(cnpj);
if (this.regexCNPJ.test(cnpjSemMascara) && cnpjSemMascara !== this.cnpjZerado) {
const dvInformado = cnpjSemMascara.substring(this.tamanhoCNPJSemDV);
const dvCalculado = this.calculaDV(cnpjSemMascara.substring(0, this.tamanhoCNPJSemDV));
return dvInformado === dvCalculado;
}
}
return false;
}
static calculaDV(cnpj) {
if (!this.regexCaracteresNaoPermitidos.test(cnpj)) {
let cnpjSemMascara = this.removeMascaraCNPJ(cnpj);
if (this.regexCNPJSemDV.test(cnpjSemMascara) && cnpjSemMascara !== this.cnpjZerado.substring(0, this.tamanhoCNPJSemDV)) {
let somatorioDV1 = 0;
let somatorioDV2 = 0;
for (let i = 0; i < this.tamanhoCNPJSemDV; i++) {
const asciiDigito = cnpjSemMascara.charCodeAt(i) - this.valorBase;
somatorioDV1 += asciiDigito * this.pesosDV[i + 1];
somatorioDV2 += asciiDigito * this.pesosDV[i];
}
const dv1 = somatorioDV1 % 11 < 2 ? 0 : 11 - (somatorioDV1 % 11);
somatorioDV2 += dv1 * this.pesosDV[this.tamanhoCNPJSemDV];
const dv2 = somatorioDV2 % 11 < 2 ? 0 : 11 - (somatorioDV2 % 11);
return `${dv1}${dv2}`;
}
}
throw new Error("Não é possível calcular o DV pois o CNPJ fornecido é inválido");
}
static removeMascaraCNPJ(cnpj) {
return cnpj.replace(this.regexCaracteresMascara, "");
}
}
// Teste do código
console.log(CNPJ.isValid("12ABC34501DE35")); // Exemplo de CNPJ alfanumérico válido
console.log(CNPJ.isValid("12345678000195")); // Exemplo de CNPJ numérico válido
console.log(CNPJ.isValid("12.ABC.345/01DE-35")); // Com máscara
console.log(CNPJ.isValid("ABCD1234567890")); // InválidoExemplo em C#
using System;
using System.Text.RegularExpressions;
public class CNPJ
{
private const int TamanhoCNPJSemDV = 12;
private static readonly Regex RegexCNPJSemDV = new Regex(@"^[A-Z0-9]{12}$", RegexOptions.Compiled);
private static readonly Regex RegexCNPJ = new Regex(@"^[A-Z0-9]{12}\d{2}$", RegexOptions.Compiled);
private static readonly Regex RegexCaracteresMascara = new Regex(@"[./-]", RegexOptions.Compiled);
private static readonly Regex RegexCaracteresNaoPermitidos = new Regex(@"[^A-Z0-9./-]", RegexOptions.Compiled);
private const string CNPJZerado = "00000000000000";
private static readonly int[] PesosDV = { 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2 };
public static bool IsValid(string cnpj)
{
if (!RegexCaracteresNaoPermitidos.IsMatch(cnpj))
{
string cnpjSemMascara = RemoveMascaraCNPJ(cnpj);
if (RegexCNPJ.IsMatch(cnpjSemMascara) && cnpjSemMascara != CNPJZerado)
{
string dvInformado = cnpjSemMascara.Substring(TamanhoCNPJSemDV);
string dvCalculado = CalculaDV(cnpjSemMascara.Substring(0, TamanhoCNPJSemDV));
return dvInformado == dvCalculado;
}
}
return false;
}
private static string CalculaDV(string cnpj)
{
if (!RegexCaracteresNaoPermitidos.IsMatch(cnpj))
{
string cnpjSemMascara = RemoveMascaraCNPJ(cnpj);
if (RegexCNPJSemDV.IsMatch(cnpjSemMascara) && cnpjSemMascara != CNPJZerado.Substring(0, TamanhoCNPJSemDV))
{
int somatorioDV1 = 0;
int somatorioDV2 = 0;
for (int i = 0; i < TamanhoCNPJSemDV; i++)
{
int asciiDigito = cnpjSemMascara[i] - '0';
if (char.IsLetter(cnpjSemMascara[i]))
asciiDigito = cnpjSemMascara[i] - 'A' + 17;
somatorioDV1 += asciiDigito * PesosDV[i + 1];
somatorioDV2 += asciiDigito * PesosDV[i];
}
int dv1 = somatorioDV1 % 11 < 2 ? 0 : 11 - (somatorioDV1 % 11);
somatorioDV2 += dv1 * PesosDV[TamanhoCNPJSemDV];
int dv2 = somatorioDV2 % 11 < 2 ? 0 : 11 - (somatorioDV2 % 11);
return $"{dv1}{dv2}";
}
}
throw new Exception("Não é possível calcular o DV pois o CNPJ fornecido é inválido");
}
private static string RemoveMascaraCNPJ(string cnpj)
{
return RegexCaracteresMascara.Replace(cnpj, "");
}
public static void Main(string[] args)
{
Console.WriteLine(IsValid("12ABC34501DE35")); // Exemplo de CNPJ alfanumérico válido
Console.WriteLine(IsValid("12345678000195")); // Exemplo de CNPJ numérico válido
Console.WriteLine(IsValid("12.ABC.345/01DE-35")); // Com máscara
Console.WriteLine(IsValid("ABCD1234567890")); // Inválido
}
}Exemplo em Delphi
unit CNPJAlfanumerico;
interface
uses
SysUtils, RegularExpressions;
type
TCNPJ = class
private
const
TamanhoCNPJSemDV = 12;
CNPJZerado = '00000000000000';
PesosDV: array[0..12] of Integer = (6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2);
CaracteresProibidos = 'IOUQF';
class function RemoveMascaraCNPJ(const CNPJ: string): string;
class function CalculaDV(const CNPJ: string): string;
class function CharParaValor(const C: Char): Integer;
public
class function IsValid(const CNPJ: string): Boolean;
end;
implementation
class function TCNPJ.RemoveMascaraCNPJ(const CNPJ: string): string;
begin
Result := TRegEx.Replace(CNPJ, '[./-]', '');
end;
class function TCNPJ.CharParaValor(const C: Char): Integer;
begin
if C in ['0'..'9'] then
Result := Ord(C) - Ord('0')
else if C in ['A'..'Z'] then
Result := Ord(C) - Ord('A') + 17
else
raise Exception.CreateFmt('Caractere inválido no CNPJ: %s', [C]);
end;
class function TCNPJ.CalculaDV(const CNPJ: string): string;
var
i, SomatorioDV1, SomatorioDV2, DV1, DV2: Integer;
CNPJSemDV: string;
begin
CNPJSemDV := RemoveMascaraCNPJ(CNPJ);
if TRegEx.IsMatch(CNPJSemDV, '[' + CaracteresProibidos + ']') then
raise Exception.CreateFmt('O CNPJ não pode conter os caracteres: %s', [CaracteresProibidos]);
if (Length(CNPJSemDV) <> TamanhoCNPJSemDV) or (CNPJSemDV = CNPJZerado.Substring(0, TamanhoCNPJSemDV)) then
raise Exception.Create('CNPJ inválido para cálculo de DV');
SomatorioDV1 := 0;
SomatorioDV2 := 0;
for i := 0 to TamanhoCNPJSemDV - 1 do
begin
SomatorioDV1 := SomatorioDV1 + CharParaValor(CNPJSemDV[i + 1]) * PesosDV[i + 1];
SomatorioDV2 := SomatorioDV2 + CharParaValor(CNPJSemDV[i + 1]) * PesosDV[i];
end;
DV1 := SomatorioDV1 mod 11;
if DV1 < 2 then
DV1 := 0
else
DV1 := 11 - DV1;
SomatorioDV2 := SomatorioDV2 + DV1 * PesosDV[TamanhoCNPJSemDV];
DV2 := SomatorioDV2 mod 11;
if DV2 < 2 then
DV2 := 0
else
DV2 := 11 - DV2;
Result := IntToStr(DV1) + IntToStr(DV2);
end;
class function TCNPJ.IsValid(const CNPJ: string): Boolean;
var
CNPJSemMascara, DVCalculado, DVInformado: string;
begin
try
CNPJSemMascara := RemoveMascaraCNPJ(CNPJ);
if (Length(CNPJSemMascara) = 14) then
begin
DVInformado := Copy(CNPJSemMascara, TamanhoCNPJSemDV + 1, 2);
DVCalculado := CalculaDV(CNPJSemMascara.Substring(0, TamanhoCNPJSemDV));
Result := DVCalculado = DVInformado;
end
else
Result := False;
except
on E: Exception do
begin
Writeln('Erro na validação do CNPJ: ', E.Message);
Result := False;
end;
end;
end;
end.
procedure TForm1.Button1Click(Sender: TObject);
begin
ShowMessage(BoolToStr(TCNPJ.IsValid('12ABC34501DE35'), True)); // Válido
ShowMessage(BoolToStr(TCNPJ.IsValid('12345678000195'), True)); // Válido
ShowMessage(BoolToStr(TCNPJ.IsValid('12.ABC.345/01DE-35'), True)); // Válido
ShowMessage(BoolToStr(TCNPJ.IsValid('12IOU34501DE35'), True)); // Inválido (contém I, O, U)
ShowMessage(BoolToStr(TCNPJ.IsValid('00000000000000'), True)); // Inválido (zerado)
end;Funcionamento dos Códigos
Remoção da Máscara:
- Antes de qualquer validação, são eliminados os caracteres especiais como pontos, barras e hífens.
Validação do Formato:
- Confere-se se a estrutura segue o novo padrão: 12 caracteres alfanuméricos seguidos por 2 dígitos verificadores.
Cálculo dos Dígitos Verificadores:
- Calcula os dois dígitos verificadores usando a lógica do módulo 11, adaptada para caracteres alfanuméricos.
Validação Final:
- Compara os DVs informados com os DVs calculados para determinar se o CNPJ é válido.
Impactos nos sistemas e nos documentos fiscais
A alteração tem efeito direto sobre os sistemas responsáveis pela emissão e validação de documentos fiscais eletrônicos, como NF-e, NFC-e, CT-e, MDF-e, BP-e, entre outros.
O cálculo do dígito verificador também será adaptado, passando a considerar os códigos ASCII das letras para garantir a consistência do cálculo, mantendo a lógica do módulo 11.
Essas mudanças são fundamentais para que os ambientes de autorização e sistemas de faturamento consigam processar corretamente os novos CNPJs.
Cronograma de Implantação
- Ambiente de homologação: disponível a partir de 6 de abril de 2026
- Ambiente de produção: ativação prevista para 6 de julho de 2026
Essa transição exigirá modificações em diversos sistemas, incluindo plataformas de ERP, soluções de emissão fiscal e serviços de autorização — impactando diretamente desenvolvedores e empresas fornecedoras de tecnologia para automação comercial.
Resumo
A implementação do CNPJ Alfanumérico representa uma mudança importante na estrutura de identificação empresarial no país. Com a manutenção das 14 posições e a possibilidade de letras nas primeiras 12, há um avanço significativo na capacidade de registro de novas entidades.
Apesar de preservar a base do formato atual, essa novidade exige adaptações técnicas, especialmente nos sistemas que tratam da validação e emissão de documentos fiscais eletrônicos.
Mais do que uma atualização cadastral, trata-se de um novo desafio para garantir que os processos fiscais sigam funcionando com confiabilidade, segurança e aderência às novas regras.
Conclusão
A chegada do CNPJ Alfanumérico marca uma transformação relevante na forma como as empresas serão registradas no Brasil, oferecendo maior flexibilidade e ampliando a capacidade para novas inscrições no cadastro nacional.
Apesar da manutenção do formato com 14 caracteres, a possibilidade de uso de letras nas 12 primeiras posições impõe mudanças importantes nos sistemas que realizam a emissão e validação de documentos fiscais.
Com implementação prevista para 2026, essa evolução exige atenção redobrada de desenvolvedores e empresas de tecnologia, que precisarão adaptar suas soluções para garantir total conformidade com a nova estrutura — sem comprometer a segurança, o desempenho e a integridade dos processos fiscais.
