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.
• Já 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.

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)	1	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
–	–	2	–
–	–	–	–
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 JScript

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); // Valor base para cálculo ASCII
static pesosDV = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
static cnpjZerado = “00000000000000”;

// Método para validar um CNPJ Alfanumérico
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;
}

// Método para calcular os dois dígitos verificadores (DV)
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");
}

// Método para remover a máscara do CNPJ
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álido

Exemplo 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 };

// Método para validar um CNPJ Alfanumérico
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;
}

// Método para calcular os dois dígitos verificadores (DV)
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; // Conversão de A=17, B=18, C=19, ...
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");
}

// Método para remover a máscara do CNPJ
private static string RemoveMascaraCNPJ(string cnpj)
{
return RegexCaracteresMascara.Replace(cnpj, "");
}

// Teste do código
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

// Remove caracteres de máscara como “.”, “/” e “-“
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’) // Conversão numérica normal
else if C in [‘A’..’Z’] then
Result := Ord(C) – Ord(‘A’) + 17 // Conversão alfanumérica
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);

// Verifica se contém caracteres proibidos
if TRegEx.IsMatch(CNPJSemDV, ‘[‘ + CaracteresProibidos + ‘]’) then
raise Exception.CreateFmt(‘O CNPJ não pode conter os caracteres: %s’, [CaracteresProibidos]);

// Verifica se o CNPJ sem DV é válido
if (Length(CNPJSemDV) <> TamanhoCNPJSemDV) or (CNPJSemDV = CNPJZerado.Substring(0,
TamanhoCNPJSemDV)) then
raise Exception.Create(‘CNPJ inválido para cálculo de DV’);

// Calcula o primeiro 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;

// Calcula o segundo DV
SomatorioDV2 := SomatorioDV2 + DV1 * PesosDV[TamanhoCNPJSemDV];
DV2 := SomatorioDV2 mod 11;
if DV2 < 2 then
DV2 := 0
else
DV2 := 11 – DV2;

// Retorna os dois dígitos verificadores como string
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

// Testes de CNPJ Alfanumérico

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.