CNPJ alfanumérico 2026: entenda a mudança e os impactos no seu sistema

// --------------------------------------------
// --------------------------------------------
// Validador de CNPJ Alfanumérico (versão simplificada)
// Compatível com o novo formato de CNPJ a partir de 2026
// --------------------------------------------

    /**
    * Converte um caractere (letra ou número) em valor numérico
    * conforme a regra do novo CNPJ alfanumérico:
    * - '0' → 0
    * - '9' → 9
    * - 'A' → 17 (pois 65 - 48 = 17)
    * - 'B' → 18, e assim por diante
    */
function valorPorCaractere(ch) {
    const code = ch.charCodeAt(0); // obtém o código ASCII do caractere

    // Se for um dígito ('0' a '9')
    if (code >= 48 && code <= 57) {
        return code - 48;
    }

    // Se for uma letra maiúscula ('A' a 'Z')
    if (code >= 65 && code <= 90) {
        return code - 48;
    }

    // Se não for válido, lança erro
    throw new Error(`Caractere inválido no CNPJ: ${ch}`);
}

/**
 * Calcula os dois dígitos verificadores (DV) do CNPJ.
 * O algoritmo usa o método de módulo 11, igual ao formato antigo,
 * mas agora com valores numéricos derivados de letras.
 */
function calcularDVs(cnpj12) {
    const valores = cnpj12.split("").map(valorPorCaractere);

    // Pesos usados para o cálculo do primeiro DV
    const pesos1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
    let soma1 = 0;

    // Multiplica cada valor pelo peso correspondente
    for (let i = 0; i < 12; i++) {
        soma1 += valores[i] * pesos1[i];
    }

    // Calcula o primeiro DV
    const resto1 = soma1 % 11;
    const dv1 = resto1 < 2 ? 0 : 11 - resto1;

    // Adiciona o primeiro DV e calcula o segundo
    const valores13 = [...valores, dv1];
    const pesos2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
    let soma2 = 0;

    for (let i = 0; i < 13; i++) {
        soma2 += valores13[i] * pesos2[i];
    }

    const resto2 = soma2 % 11;
    const dv2 = resto2 < 2 ? 0 : 11 - resto2;

    // Retorna ambos os dígitos verificadores
    return [dv1, dv2];
}

/**
 * Valida um CNPJ (numérico ou alfanumérico) conforme o novo padrão.
 * Remove caracteres especiais, converte letras e confere os dígitos verificadores.
 */
function validarCNPJ(cnpj) {
    // Remove pontos, barras e traços
    const limpo = cnpj.replace(/[^A-Z0-9]/gi, "").toUpperCase();

    // O CNPJ precisa ter exatamente 14 caracteres (letras + números)
    if (limpo.length !== 14) return false;

    const parte12 = limpo.slice(0, 12);
    const dvInformado1 = Number(limpo.charAt(12));
    const dvInformado2 = Number(limpo.charAt(13));

    // Recalcula os DVs com base nos 12 primeiros caracteres
    const [dv1, dv2] = calcularDVs(parte12);

    // Compara os DVs calculados com os informados
    return dv1 === dvInformado1 && dv2 === dvInformado2;
}

// --------------------------------------------
// Exemplo de uso
// --------------------------------------------
console.log(validarCNPJ("A1B2C3D4E5F6-78".replace(/-/g, "")));
// Retorna true ou false dependendo se o CNPJ é válido

Esse script serve como guia rápido. Para produção, utilize bibliotecas testadas e mantenha logs de auditoria.

Regex ^[A-Z0-9]{12}[0-9]{2}$ — ^ início; [A-Z0-9]{12} 12 posições alfanuméricas; [0-9]{2} 2 dígitos finais; $ fim. Aceita maiúsculas; para minúsculas, use flag i ou inclua a-z.

# --------------------------------------------
# Validador de CNPJ Alfanumérico (versão simplificada)
# Compatível com o novo formato de CNPJ a partir de 2026
# --------------------------------------------

def valor_por_caractere(ch: str) -> int:
    """Converte um caractere (letra ou número) em valor numérico"""
    code = ord(ch.upper())

    # Dígito '0' a '9'
    if 48 <= code <= 57:
        return code - 48

    # Letra 'A' a 'Z'
    if 65 <= code <= 90:
        return code - 48

    raise ValueError(f"Caractere inválido no CNPJ: {ch}")


def calcular_dvs(cnpj12: str) -> tuple[int, int]:
    """Calcula os dois dígitos verificadores (DV) do CNPJ"""
    valores = [valor_por_caractere(c) for c in cnpj12]

    pesos1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
    soma1 = sum(valores[i] * pesos1[i] for i in range(12))
    resto1 = soma1 % 11
    dv1 = 0 if resto1 < 2 else 11 - resto1

    valores13 = valores + [dv1]
    pesos2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
    soma2 = sum(valores13[i] * pesos2[i] for i in range(13))
    resto2 = soma2 % 11
    dv2 = 0 if resto2 < 2 else 11 - resto2

    return dv1, dv2


def validar_cnpj(cnpj: str) -> bool:
    """Valida um CNPJ (numérico ou alfanumérico) conforme o novo padrão"""
    limpo = ''.join(filter(str.isalnum, cnpj.upper()))

    if len(limpo) != 14:
        return False

    parte12 = limpo[:12]
    dv_informado1 = int(limpo[12])
    dv_informado2 = int(limpo[13])

    dv1, dv2 = calcular_dvs(parte12)
    return dv1 == dv_informado1 and dv2 == dv_informado2


# Exemplo de uso
if __name__ == "__main__":
    print(validar_cnpj("A1B2C3D4E5F678"))
# Retorna True ou False dependendo se o CNPJ é válido

Esse script serve como guia rápido. Para produção, utilize bibliotecas testadas e mantenha logs de auditoria.

Regex ^[A-Z0-9]{12}[0-9]{2}$ — ^ início; [A-Z0-9]{12} 12 posições alfanuméricas; [0-9]{2} 2 dígitos finais; $ fim. Aceita maiúsculas; para minúsculas, use flag re.IGNORECASE.

// --------------------------------------------
// Validador de CNPJ Alfanumérico (versão simplificada)
// Compatível com o novo formato de CNPJ a partir de 2026
// --------------------------------------------

using System;
using System.Linq;
using System.Text.RegularExpressions;

public static class CnpjValidator
{
    private static int ValorPorCaractere(char ch)
    {
        int code = char.ToUpper(ch);
        if (code >= 48 && code <= 57)
            return code - 48;
        if (code >= 65 && code <= 90)
            return code - 48;
        throw new ArgumentException($"Caractere inválido no CNPJ: {ch}");
    }

    private static (int dv1, int dv2) CalcularDVs(string cnpj12)
    {
        var valores = cnpj12.Select(ValorPorCaractere).ToArray();
        int[] pesos1 = { 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2 };
        int soma1 = valores.Zip(pesos1, (v, p) => v * p).Sum();
        int resto1 = soma1 % 11;
        int dv1 = resto1 < 2 ? 0 : 11 - resto1;

        int[] valores13 = valores.Concat(new[] { dv1 }).ToArray();
        int[] pesos2 = { 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2 };
        int soma2 = valores13.Zip(pesos2, (v, p) => v * p).Sum();
        int resto2 = soma2 % 11;
        int dv2 = resto2 < 2 ? 0 : 11 - resto2;

        return (dv1, dv2);
    }

    public static bool ValidarCNPJ(string cnpj)
    {
        string limpo = Regex.Replace(cnpj.ToUpper(), @"[^A-Z0-9]", "");
        if (limpo.Length != 14)
            return false;

        string parte12 = limpo.Substring(0, 12);
        int dvInformado1 = limpo[12] - '0';
        int dvInformado2 = limpo[13] - '0';

        var (dv1, dv2) = CalcularDVs(parte12);
        return dv1 == dvInformado1 && dv2 == dvInformado2;
    }

    // Exemplo de uso
    public static void Main()
    {
        Console.WriteLine(ValidarCNPJ("A1B2C3D4E5F678"));
        // Retorna True ou False dependendo se o CNPJ é válido
    }
}

Esse script serve como guia rápido. Para produção, utilize bibliotecas testadas e mantenha logs de auditoria.

Regex ^[A-Z0-9]{12}[0-9]{2}$ — ^ início; [A-Z0-9]{12} 12 posições alfanuméricas; [0-9]{2} 2 dígitos finais; $ fim. Aceita maiúsculas; para minúsculas, use flag RegexOptions.IgnoreCase.

// --------------------------------------------
// Validador de CNPJ Alfanumérico (versão simplificada)
// Compatível com o novo formato de CNPJ a partir de 2026
// --------------------------------------------

import java.util.regex.*;
import java.util.*;

public class CnpjValidator {

    private static int valorPorCaractere(char ch) {
        int code = Character.toUpperCase(ch);
        if (code >= 48 && code <= 57)
            return code - 48;
        if (code >= 65 && code <= 90)
            return code - 48;
        throw new IllegalArgumentException("Caractere inválido no CNPJ: " + ch);
    }

    private static int[] calcularDVs(String cnpj12) {
        int[] valores = cnpj12.chars().map(CnpjValidator::valorPorCaractere).toArray();

        int[] pesos1 = {5,4,3,2,9,8,7,6,5,4,3,2};
        int soma1 = 0;
        for (int i = 0; i < 12; i++) soma1 += valores[i] * pesos1[i];
        int resto1 = soma1 % 11;
        int dv1 = resto1 < 2 ? 0 : 11 - resto1;

        int[] pesos2 = {6,5,4,3,2,9,8,7,6,5,4,3,2};
        int soma2 = 0;
        for (int i = 0; i < 13; i++) {
            int v = (i < 12) ? valores[i] : dv1;
            soma2 += v * pesos2[i];
        }
        int resto2 = soma2 % 11;
        int dv2 = resto2 < 2 ? 0 : 11 - resto2;

        return new int[]{dv1, dv2};
    }

    public static boolean validarCNPJ(String cnpj) {
        String limpo = cnpj.toUpperCase().replaceAll("[^A-Z0-9]", "");
        if (limpo.length() != 14) return false;

        String parte12 = limpo.substring(0, 12);
        int dvInformado1 = Character.getNumericValue(limpo.charAt(12));
        int dvInformado2 = Character.getNumericValue(limpo.charAt(13));

        int[] dvs = calcularDVs(parte12);
        return dvs[0] == dvInformado1 && dvs[1] == dvInformado2;
    }

    public static void main(String[] args) {
        System.out.println(validarCNPJ("A1B2C3D4E5F678"));
        // Retorna true ou false dependendo se o CNPJ é válido
    }
}

Esse script serve como guia rápido. Para produção, utilize bibliotecas testadas e mantenha logs de auditoria.

Regex ^[A-Z0-9]{12}[0-9]{2}$ — ^ início; [A-Z0-9]{12} 12 posições alfanuméricas; [0-9]{2} 2 dígitos finais; $ fim. Aceita maiúsculas; para minúsculas, use flag Pattern.CASE_INSENSITIVE.

' --------------------------------------------
' Validador de CNPJ Alfanumérico (versão simplificada)
' Compatível com o novo formato de CNPJ a partir de 2026
' --------------------------------------------

Imports System.Text.RegularExpressions

Module CnpjValidator

    Private Function ValorPorCaractere(ch As Char) As Integer
        Dim code As Integer = Asc(Char.ToUpper(ch))

        If code >= 48 AndAlso code <= 57 Then
            Return code - 48
        End If

        If code >= 65 AndAlso code <= 90 Then
            Return code - 48
        End If

        Throw New ArgumentException($"Caractere inválido no CNPJ: {ch}")
    End Function

    Private Function CalcularDVs(cnpj12 As String) As (Integer, Integer)
        Dim valores As Integer() = cnpj12.Select(Function(c) ValorPorCaractere(c)).ToArray()

        Dim pesos1 As Integer() = {5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2}
        Dim soma1 As Integer = valores.Select(Function(v, i) v * pesos1(i)).Sum()
        Dim resto1 As Integer = soma1 Mod 11
        Dim dv1 As Integer = If(resto1 < 2, 0, 11 - resto1)

        Dim pesos2 As Integer() = {6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2}
        Dim soma2 As Integer = 0
        For i As Integer = 0 To 12
            Dim v As Integer = If(i < 12, valores(i), dv1)
            soma2 += v * pesos2(i)
        Next
        Dim resto2 As Integer = soma2 Mod 11
        Dim dv2 As Integer = If(resto2 < 2, 0, 11 - resto2)

        Return (dv1, dv2)
    End Function

    Public Function ValidarCNPJ(cnpj As String) As Boolean
        Dim limpo As String = Regex.Replace(cnpj.ToUpper(), "[^A-Z0-9]", "")
        If limpo.Length <> 14 Then Return False

        Dim parte12 As String = limpo.Substring(0, 12)
        Dim dvInformado1 As Integer = Asc(limpo(12)) - Asc("0"c)
        Dim dvInformado2 As Integer = Asc(limpo(13)) - Asc("0"c)

        Dim dvs = CalcularDVs(parte12)
        Return dvs.Item1 = dvInformado1 AndAlso dvs.Item2 = dvInformado2
    End Function

    Sub Main()
        Console.WriteLine(ValidarCNPJ("A1B2C3D4E5F678"))
        ' Retorna True ou False dependendo se o CNPJ é válido
    End Sub

End Module

Esse script serve como guia rápido. Para produção, utilize bibliotecas testadas e mantenha logs de auditoria.

Regex ^[A-Z0-9]{12}[0-9]{2}$ — ^ início; [A-Z0-9]{12} 12 posições alfanuméricas; [0-9]{2} 2 dígitos finais; $ fim. Aceita maiúsculas; para minúsculas, use flag RegexOptions.IgnoreCase.