O que é SSN Regex?

Um Social Security Number (SSN) nos EUA segue o formato padrão:

XXX-XX-XXXX

Onde:

• XXX: Número de área (3 dígitos)

• XX: Número de grupo (2 dígitos)

• XXXX: Número serial (4 dígitos)

Esse formato garante identificação estruturada para fins fiscais e legais. O uso de regex ajuda a validar se uma string de entrada segue esse formato estritamente.

Para ser considerado um SSN válido, uma string também precisa atender a critérios específicos:

• 9 dígitos no total, separados em três partes por hífens.

• Primeira parte (Número de Área): 3 dígitos; não pode ser 000, 666 ou qualquer valor entre 900 e 999.

• Segunda parte (Número de Grupo): 2 dígitos; deve variar de 01 a 99 (não 00).

• Terceira parte (Número Serial): 4 dígitos; deve variar de 0001 a 9999 (não 0000).

Essas regras garantem que apenas SSNs com estrutura adequada e potencialmente válidos passem na validação, reduzindo erros e melhorando a integridade dos dados.

Padrão Regex para SSN

O padrão regex típico para validar um SSN corretamente formatado é:

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

Detalhamento:

• ^\d{3} - Três dígitos no início

• - - Primeiro separador hífen

• \d{2} - Dois dígitos

• - - Segundo hífen

• \d{4}$ - Quatro dígitos no final

Isso garante correspondência estrita de formato como 123-45-6789.

Padrões Expandidos e Considerações

Embora o padrão acima cubra o formato padrão de SSN, há alguns cenários adicionais e verificações mais rígidas que você pode considerar:

• Exclusões estritas de valores inválidos:
  Para evitar SSNs obviamente inválidos, você pode usar um regex mais restritivo que exclui certos valores:

  ^(?!(0006669))\d{3}-(?!00)\d{2}-(?!0000)\d{4}$

  • Esse padrão impede números de área como 000, 666 ou qualquer número começando com 9, além de números de grupo 00 e números seriais 0000, que não são válidos pelas diretrizes oficiais.

• SSNs mascarados ou de espaço reservado:
  Às vezes, espaços reservados como XXX-XX-XXXX são usados em documentação ou formulários. Para acomodar isso, você pode permitir um SSN válido ou o espaço reservado:

  ^(\d{3}-\d{2}-\d{4}XXX-XX-XXXX)$

  • Isso corresponde a um SSN real ou ao formato mascarado comum.

• Formatação flexível:
  Se você quiser permitir hífens opcionais ou suportar espaços reservados em maiúsculas ou minúsculas, considere:

  ^(\d{3}-?\d{2}-?\d{4}[Xx]{3}-?[Xx]{2}-?[Xx]{4})$

  • Esse padrão suporta formas padrão e mascaradas, com ou sem hífens, e aceita tanto 'X' maiúsculo quanto 'x' minúsculo.

Escolha o padrão que melhor se adapte ao seu caso de uso, seja para validação estrita de entrada de dados oficiais ou correspondência mais flexível para valores de espaço reservado ou amostra.

O que Torna um SSN Válido?

Não se trata apenas do padrão, há regras por trás da superfície:

• Nove dígitos no total: O SSN deve conter exatamente nove dígitos, divididos por hífens.

• Três partes por hífens: O formato é sempre AAA-GG-SSSS.

• Restrições de número de área: Os três primeiros dígitos não devem ser 000, 666 ou qualquer número de 900 a 999.

• Restrições de número de grupo: Os dois dígitos do meio devem estar entre 01 e 99; 00 não é válido.

• Restrições de número serial: Os quatro últimos dígitos devem variar de 0001 a 9999; 0000 não é válido.

Portanto, embora um regex verifique o formato, a validação real de SSN envolve lógica adicional para garantir que o número em si esteja dentro desses limites oficiais. Isso ajuda a detectar entradas inválidas como 000-45-6789 ou 856-00-6789, que, embora correspondam ao padrão básico, não são SSNs legítimos.

Código de Exemplo em Python

import re
def is_valid_ssn(ssn):
pattern = re.compile(r'^\d{3}-\d{2}-\d{4}$')
return bool(pattern.fullmatch(ssn))
Test Cases
print(is_valid_ssn("123-45-6789"))  # True
print(is_valid_ssn("123456789"))    # False
print(is_valid_ssn("12-345-6789"))  # False

Teste variações de regex com o Python Regex Tester.

Complexidade de Tempo e Espaço

Validar um SSN usando uma expressão regular em Python é altamente eficiente:

• Complexidade de Tempo: Verificar uma string contra o regex de SSN é executado em O(N), onde N é o comprimento da string do SSN. O mecanismo regex percorre cada caractere uma vez para verificar o formato.

• Complexidade de Espaço: A validação por regex usa O(1) de espaço auxiliar, pois não requer armazenamento de dados adicionais proporcionais ao tamanho da entrada.

Na prática, isso significa que a validação de SSN com regex é rápida e leve, sendo adequada para tudo, desde verificações de formulários web até varreduras em grandes bancos de dados.

Casos de Uso

• Verificação de Identidade do Usuário: Garanta a entrada correta de SSN durante o registro ou onboarding do usuário.

• Limpeza de Dados: Detecte e corrija SSNs com formato incorreto em bancos de dados.

• Segurança e Conformidade: Verifique o formato do SSN antes de transmitir dados sensíveis.

Você pode combinar isso com:

• Email Regex Python Validator para verificação de conta

• IP Address Regex Python Validator para segurança de sistema

• URL Regex Python Validator para proteger campos de entrada de formulários

Metacaracteres Regex Utilizados

• ^ : Ancora o início da string

• \d : Corresponde a qualquer dígito (0-9)

• {n} : Corresponde exatamente a n dígitos

• - : Corresponde a hífens literais em SSNs

• $ : Ancora o final da string

Como Validar SSNs em JavaScript

Se você precisar confirmar Social Security Numbers dos EUA no frontend (ou em qualquer ambiente com JavaScript), pode usar uma expressão regular para garantir que cada entrada siga a convenção "AAA-GG-SSSS".

Aqui está uma abordagem simples usando o RegExp nativo do JavaScript:

// Regular expression for strict SSN validation
const ssnPattern = /^(?!6660009\d{2})\d{3}-(?!00)\d{2}-(?!0{4})\d{4}$/;
function isValidSSN(ssn) {
if (!ssn) return false; // Reject empty inputs
return ssnPattern.test(ssn);
}
// Example usage:
console.log(isValidSSN("856-45-6789")); // true (valid)
console.log(isValidSSN("000-45-6789")); // false (invalid area)
console.log(isValidSSN("856-452-6789")); // false (incorrect format)
console.log(isValidSSN("856-45-0000")); // false (invalid serial)

O que o Regex Faz

• Garante que o número de área (três primeiros dígitos) não seja 666, 000 ou dentro do intervalo 900-999.

• Confirma que o número de grupo (dois dígitos do meio) não seja 00.

• Verifica que o número serial (quatro últimos dígitos) não sejam todos zeros.

• Força o posicionamento correto dos hífens.

Esse padrão protege contra números obviamente falsos e com formatação incorreta. Para necessidades mais avançadas, considere combiná-lo com verificações adicionais, mas para validação de formato, essa abordagem é sólida.

Exemplo em Java para Validação de SSN

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class SSNValidator {
// Regular expression for strict SSN validation
private static final String SSN_REGEX =
"^(?!6660009\d{2})\d{3}-(?!00)\d{2}-(?!0{4})\d{4}$";
private static final Pattern pattern = Pattern.compile(SSN_REGEX);
public static boolean isValidSSN(String ssn) {
    if (ssn == null) return false;
    Matcher matcher = pattern.matcher(ssn);
    return matcher.matches();
}

public static void main(String[] args) {
    System.out.println(isValidSSN("856-45-6789"));   // true
    System.out.println(isValidSSN("000-45-6789"));   // false
    System.out.println(isValidSSN("856-452-6789"));  // false
    System.out.println(isValidSSN("856-45-0000"));   // false
}

}

Explicação:

• O regex garante que o SSN não comece com "666", "000" ou um número começando com "9".

• O grupo (meio) não deve ser "00".

• O serial (último grupo) não deve ser "0000".

• Todos os outros dígitos devem corresponder à estrutura "XXX-XX-XXXX".

Dicas Profissionais

• Sempre ancore padrões com ^ e $ para evitar correspondências parciais.

• Pré-processe a entrada do usuário para remover espaços em branco antes da validação.

• Você pode estender a validação para excluir combinações inválidas (como 000 ou 666) usando regex avançado ou lógica adicional.

• Evite armazenar SSNs em texto puro; criptografe-os após a validação.

• Use o Python Regex Tester para experimentar antes de implantar.

• Combine com o Date Regex Python Validator se SSNs fizerem parte de um documento estruturado maior.