Regex de CPF: formato, máscara e formulários

Expressão regular é a primeira ferramenta que vem à cabeça quando o assunto é validar CPF, e ela resolve bem uma parte do problema: conferir se o texto tem o formato certo. A outra parte, os dígitos verificadores, exige aritmética. Este guia reúne as expressões mais úteis para cada contexto, de JavaScript a Google Forms, e mostra onde o regex para e a função de validação começa.

O que regex consegue e não consegue validar

Um regex lê caracteres e decide se eles seguem um padrão. Para CPF, isso cobre:

• a quantidade de dígitos;
• a posição dos pontos e do hífen;
• a ausência de letras e outros caracteres;
• com recursos avançados, a recusa de sequências como 111.111.111-11.

O que ele não cobre é o cálculo dos dígitos verificadores. O décimo dígito depende de uma soma ponderada dos nove anteriores dividida por 11, e o décimo primeiro, de uma soma sobre os dez primeiros. Expressões regulares não fazem soma nem divisão. Em teoria, seria possível escrever uma expressão gigantesca que enumerasse todas as combinações válidas, mas ela seria ilegível e inútil.

Por isso, 529.982.247-26 passa em todas as expressões deste guia, embora seja inválido. O regex garante a forma; a função de validação por módulo 11 garante o conteúdo.

Regex para formato com pontuação

Para exigir exatamente o formato 000.000.000-00:

const CPF_FORMATADO = /^\d{3}\.\d{3}\.\d{3}-\d{2}$/;

CPF_FORMATADO.test('529.982.247-25'); // true
CPF_FORMATADO.test('52998224725');    // false
CPF_FORMATADO.test('529.982.247-2');  // false

Peça por peça: ^ e $ ancoram no início e no fim, para que nada sobre antes ou depois; \d{3} são três dígitos; \. é um ponto literal, escapado porque o ponto sozinho significa “qualquer caractere”; o hífen fora de colchetes não precisa de escape.

Esquecer as âncoras é o erro mais frequente. Sem elas, /\d{3}\.\d{3}\.\d{3}-\d{2}/ aceita “abc529.982.247-25xyz”, porque encontra o padrão no meio do texto.

Regex para só dígitos

Quando o CPF já chega limpo, ou quando você armazena sem pontuação:

const CPF_DIGITOS = /^\d{11}$/;

CPF_DIGITOS.test('52998224725');    // true
CPF_DIGITOS.test('5299822472');     // false (10 dígitos)
CPF_DIGITOS.test('529.982.247-25'); // false

Um detalhe de linguagem: em alguns motores, \d reconhece dígitos de outros sistemas de escrita além de 0 a 9. Em JavaScript, \d equivale sempre a [0-9]. Em Python 3, com padrões de texto, \d aceita qualquer dígito Unicode, como os algarismos arábico-índicos. Se a entrada vem de fora, use [0-9] ou a flag re.ASCII em Python.

Regex que aceita os dois formatos

Usuários colam o CPF de todas as formas. Uma expressão tolerante torna a pontuação opcional:

const CPF_FLEXIVEL = /^\d{3}\.?\d{3}\.?\d{3}-?\d{2}$/;

CPF_FLEXIVEL.test('529.982.247-25'); // true
CPF_FLEXIVEL.test('52998224725');    // true
CPF_FLEXIVEL.test('529982.247-25');  // true (pontuação parcial)

O ? torna o caractere anterior opcional, então cada separador pode aparecer ou não, de forma independente. Isso aceita combinações estranhas, como a do terceiro exemplo. Na maioria dos casos não há problema, porque o próximo passo é remover a pontuação. Se você quiser aceitar só um formato ou o outro, use alternância:

const CPF_UM_OU_OUTRO = /^(?:\d{3}\.\d{3}\.\d{3}-\d{2}|\d{11})$/;

O grupo (?:...) não captura e serve só para que as âncoras se apliquem às duas alternativas. Sem ele, ^a|b$ significaria “começa com a” ou “termina com b”.

Uma alternativa mais simples, e geralmente melhor, é não usar regex para a pontuação: remova tudo que não é dígito com valor.replace(/\D/g, '') e confira o resultado com ^\d{11}$. A desvantagem é aceitar separadores incomuns, como barras ou letras. A implementação de referência deste site fica no meio-termo: aceita ponto, hífen e espaço como separadores e recusa qualquer outro caractere.

Regex de CPF ou CNPJ

Campos de “documento” que aceitam pessoa física ou jurídica são comuns. O CNPJ tem 14 posições no formato 00.000.000/0000-00:

const CPF_OU_CNPJ = /^(?:\d{3}\.?\d{3}\.?\d{3}-?\d{2}|\d{2}\.?\d{3}\.?\d{3}\/?\d{4}-?\d{2})$/;

function tipoDocumento(valor) {
if (!CPF_OU_CNPJ.test(valor)) return null;
return valor.replace(/\D/g, '').length === 11 ? 'cpf' : 'cnpj';
}

tipoDocumento('529.982.247-25');     // 'cpf'
tipoDocumento('11.222.333/0001-81'); // 'cnpj'
tipoDocumento('529.982.247-2');      // null

A barra do CNPJ precisa de escape (\/) dentro de um regex literal em JavaScript, porque a barra delimita a expressão. Em strings passadas para new RegExp, ou em outras linguagens, isso não é necessário.

Depois de identificar o tipo, cada documento segue para o seu próprio validador de dígitos, já que os pesos do CNPJ são diferentes. Fique atento também ao CNPJ alfanumérico, adotado pela Receita Federal (IN RFB nº 2.229/2024): nele, as 12 primeiras posições podem conter letras, e a expressão acima, que só aceita dígitos, deixa de servir para esses números.

Regex de CNPJ e CNPJ alfanumérico

Desde julho de 2026, novas inscrições recebem CNPJs alfanuméricos, em que as 12 primeiras posições aceitam letras de A a Z, e os dois dígitos verificadores continuam numéricos. Por isso, a parte de CNPJ da expressão acima só aceita CNPJs numéricos; para os dois formatos, troque \d por [A-Z0-9] nas 12 primeiras posições, como em ^[A-Z0-9]{2}\.?[A-Z0-9]{3}\.?[A-Z0-9]{3}\/?[A-Z0-9]{4}-?\d{2}$. Converta a entrada para maiúsculas antes do teste e limpe a pontuação com [^A-Z0-9], não com \D, que apagaria as letras. O guia de regex de CNPJ traz as versões com e sem máscara, a regex combinada de CPF ou CNPJ e as adaptações para Google Forms e HTML pattern.

Regex para máscara de input

Regex também serve para aplicar a máscara, não só para conferi-la. A técnica é uma sequência de substituições:

function mascaraCpf(valor) {
return valor
  .replace(/\D/g, '')
  .slice(0, 11)
  .replace(/(\d{3})(\d)/, '$1.$2')
  .replace(/(\d{3})(\d)/, '$1.$2')
  .replace(/(\d{3})(\d{1,2})$/, '$1-$2');
}

mascaraCpf('5299');           // '529.9'
mascaraCpf('5299822472');     // '529.982.247-2'
mascaraCpf('52998224725');    // '529.982.247-25'
mascaraCpf('529.982.247-26'); // '529.982.247-26'

Cada linha faz uma coisa: remove o que não é dígito, limita a 11 dígitos, insere o primeiro ponto depois do terceiro dígito, o segundo ponto depois do sexto e o hífen antes dos dois últimos. A segunda substituição funciona porque o primeiro trio já está seguido de ponto, então a busca só encontra três dígitos seguidos de outro dígito a partir do segundo grupo.

A máscara não valida nada: 529.982.247-26 é formatado normalmente. A versão com slice, usada no guia de máscara de CPF em React, Vue e Angular, produz o mesmo resultado e costuma ser mais fácil de ler.

Regex em Google Forms, planilhas e HTML pattern

Cada ambiente tem o seu dialeto, e uma expressão que funciona em JavaScript pode falhar em outro lugar.

Google Forms

Em uma pergunta de resposta curta, abra o menu de três pontos, ative Validação da resposta, escolha Expressão regular e a condição Corresponde a. Use:

^\d{3}\.\d{3}\.\d{3}-\d{2}$

ou, para aceitar com e sem pontuação:

^\d{3}\.?\d{3}\.?\d{3}-?\d{2}$

O Google Forms usa uma sintaxe no estilo RE2. Ela suporta \d, quantificadores, ? e âncoras, mas não suporta lookahead, lookbehind nem retrovisores como \1. Por isso não é possível recusar 111.111.111-11 ali. Escreva na mensagem de erro o formato esperado, por exemplo “Use o formato 000.000.000-00”.

Google Planilhas e Excel

No Google Planilhas, REGEXMATCH usa o mesmo dialeto RE2. Com a planilha em português, os argumentos são separados por ponto e vírgula:

=REGEXMATCH(TO_TEXT(A2); "^\d{3}\.?\d{3}\.?\d{3}-?\d{2}$")

O TO_TEXT evita erro quando a célula contém um número. Se a coluna foi formatada como número, porém, o zero à esquerda já se perdeu e um CPF como 012.345.678-90 virou 1234567890, com 10 dígitos. Formate a coluna como texto antes de colar os dados. Nas versões recentes do Excel para Microsoft 365, a função equivalente é REGEXTEST.

Atributo pattern do HTML

O atributo pattern aplica um regex ao valor do campo antes do envio do formulário:

<label for="cpf">CPF</label>
<input id="cpf" name="cpf" inputmode="numeric"
       pattern="\d{3}\.?\d{3}\.?\d{3}-?\d{2}"
       title="11 dígitos, com ou sem pontuação">

Três detalhes. O navegador ancora o padrão automaticamente no início e no fim, então ^ e $ são dispensáveis. Os navegadores atuais compilam o pattern com a flag v do JavaScript, que é estrita com escapes: \. e \d são aceitos, mas \- fora de colchetes é erro de sintaxe e faz o navegador ignorar o atributo. Por isso o hífen fica sem barra. E não há barras delimitadoras: o valor é só o corpo da expressão.

Depois do regex: valide os dígitos

O fluxo completo tem três etapas: conferir o formato, normalizar para 11 dígitos e calcular os verificadores. O regex resolve a primeira; uma função resolve as outras duas.

const formatoOk = /^\d{3}\.?\d{3}\.?\d{3}-?\d{2}$/.test(entrada);
const cpfOk = formatoOk && validarCpf(entrada);

A função validarCpf está no guia sobre o algoritmo de validação e em versões para Python, PHP, Java e outras linguagens. Com ela, 529.982.247-25 é válido, enquanto 111.111.111-11 e 529.982.247-26 são recusados, embora os três passem no regex.

Se o seu ambiente suporta lookahead e retrovisores, como JavaScript, Python, Java e PHP, dá para recusar sequências repetidas já no regex:

const SEM_REPETIDOS = /^(?!(\d)\1{10}$)\d{11}$/;

Ainda assim, a checagem dos dígitos continua obrigatória. Para conferir números enquanto desenvolve, use o validador de CPF; para limpar ou padronizar uma lista, o formatador de CPF.