SSN Regex Validator
Professional-grade Social Security Number validation tool with advanced regex patterns
SSN Validator Tool
What is an SSN Regex?
A Social Security Number (SSN) regex is a regular expression pattern used to validate and match Social Security Numbers in various formats. SSNs are 9-digit numbers issued by the U.S. Social Security Administration, typically formatted as XXX-XX-XXXX.
Key Characteristics of SSN Regex
- Validates 9-digit numeric sequences
- Supports multiple formatting styles (with/without hyphens)
- Excludes invalid number combinations (000-xx-xxxx, xxx-00-xxxx)
- Ensures proper structure and format compliance
Common SSN Regex Patterns
Basic Pattern (With Hyphens)
^\d{3}-\d{2}-\d{4}$
Matches: 123-45-6789
Flexible Pattern
^\d{3}-?\d{2}-?\d{4}$
Matches: 123-45-6789 or 123456789
Advanced Pattern
^(?!000|666)[0-8][0-9]{2}-(?!00)[0-9]{2}-(?!0000)[0-9]{4}$
Excludes invalid combinations
Multi-Format Pattern
^(?:\d{3}-\d{2}-\d{4}|\d{9})$
Accepts both formatted and unformatted
Pattern Explanation
^
Start of string anchor
\d{3}
Exactly 3 digits (Area Number)
-
Literal hyphen character
\d{2}
Exactly 2 digits (Group Number)
-
Literal hyphen character
\d{4}
Exactly 4 digits (Serial Number)
$
End of string anchor
Invalid SSN Patterns to Avoid
- 000-XX-XXXX (Area number cannot be 000)
- 666-XX-XXXX (Area number cannot be 666)
- 9XX-XX-XXXX (Area number cannot start with 9)
- XXX-00-XXXX (Group number cannot be 00)
- XXX-XX-0000 (Serial number cannot be 0000)
SSN Validation Best Practices
Format Validation
- Check for proper 9-digit structure
- Validate hyphen placement
- Ensure no alphabetic characters
Invalid Number Detection
- Reject 000, 666, or 9XX area numbers
- Disallow 00 group numbers
- Block 0000 serial numbers
Security Considerations
- Never log or store SSNs in plain text
- Use encryption for SSN storage
- Implement proper access controls
How to Validate SSNs in Different Languages
JavaScript
function validateSSN(ssn) {
// Remove any non-digit characters
const cleaned = ssn.replace(/\D/g, '');
// Check if it's 9 digits
if (cleaned.length !== 9) {
return { valid: false, message: 'SSN must be 9 digits' };
}
// Advanced validation pattern
const pattern = /^(?!000|666)[0-8][0-9]{2}(?!00)[0-9]{2}(?!0000)[0-9]{4}$/;
if (!pattern.test(cleaned)) {
return { valid: false, message: 'Invalid SSN format or forbidden number' };
}
return { valid: true, message: 'Valid SSN', formatted: `${cleaned.slice(0,3)}-${cleaned.slice(3,5)}-${cleaned.slice(5)}` };
}
// Usage example
const result = validateSSN('123-45-6789');
console.log(result); // { valid: true, message: 'Valid SSN', formatted: '123-45-6789' }
Python
import re
def validate_ssn(ssn):
"""Validate Social Security Number with advanced pattern matching"""
# Remove non-digit characters
cleaned = re.sub(r'\D', '', ssn)
# Check length
if len(cleaned) != 9:
return {'valid': False, 'message': 'SSN must be 9 digits'}
# Advanced validation pattern
pattern = r'^(?!000|666)[0-8][0-9]{2}(?!00)[0-9]{2}(?!0000)[0-9]{4}$'
if not re.match(pattern, cleaned):
return {'valid': False, 'message': 'Invalid SSN format or forbidden number'}
formatted = f"{cleaned[:3]}-{cleaned[3:5]}-{cleaned[5:]}"
return {'valid': True, 'message': 'Valid SSN', 'formatted': formatted}
# Usage example
result = validate_ssn('123-45-6789')
print(result) # {'valid': True, 'message': 'Valid SSN', 'formatted': '123-45-6789'}
Java
import java.util.regex.Pattern;
import java.util.HashMap;
import java.util.Map;
public class SSNValidator {
private static final Pattern SSN_PATTERN =
Pattern.compile("^(?!000|666)[0-8][0-9]{2}(?!00)[0-9]{2}(?!0000)[0-9]{4}$");
public static Map<String, Object> validateSSN(String ssn) {
Map<String, Object> result = new HashMap<>();
// Remove non-digit characters
String cleaned = ssn.replaceAll("\\D", "");
// Check length
if (cleaned.length() != 9) {
result.put("valid", false);
result.put("message", "SSN must be 9 digits");
return result;
}
// Validate pattern
if (!SSN_PATTERN.matcher(cleaned).matches()) {
result.put("valid", false);
result.put("message", "Invalid SSN format or forbidden number");
return result;
}
String formatted = String.format("%s-%s-%s",
cleaned.substring(0, 3),
cleaned.substring(3, 5),
cleaned.substring(5));
result.put("valid", true);
result.put("message", "Valid SSN");
result.put("formatted", formatted);
return result;
}
// Usage example
public static void main(String[] args) {
Map<String, Object> result = validateSSN("123-45-6789");
System.out.println(result);
}
}
C#
using System;
using System.Text.RegularExpressions;
using System.Collections.Generic;
public class SSNValidator
{
private static readonly Regex ssnPattern =
new Regex(@"^(?!000|666)[0-8][0-9]{2}(?!00)[0-9]{2}(?!0000)[0-9]{4}$");
public static Dictionary<string, object> ValidateSSN(string ssn)
{
var result = new Dictionary<string, object>();
// Remove non-digit characters
string cleaned = Regex.Replace(ssn, @"\D", "");
// Check length
if (cleaned.Length != 9)
{
result["valid"] = false;
result["message"] = "SSN must be 9 digits";
return result;
}
// Validate pattern
if (!ssnPattern.IsMatch(cleaned))
{
result["valid"] = false;
result["message"] = "Invalid SSN format or forbidden number";
return result;
}
string formatted = $"{cleaned.Substring(0, 3)}-{cleaned.Substring(3, 2)}-{cleaned.Substring(5)}";
result["valid"] = true;
result["message"] = "Valid SSN";
result["formatted"] = formatted;
return result;
}
// Usage example
static void Main()
{
var result = ValidateSSN("123-45-6789");
Console.WriteLine($"Valid: {result["valid"]}, Message: {result["message"]}");
}
}
C++
#include <iostream>
#include <string>
#include <regex>
#include <map>
class SSNValidator {
private:
static const std::regex ssnPattern;
public:
static std::map<std::string, std::string> validateSSN(const std::string& ssn) {
std::map<std::string, std::string> result;
// Remove non-digit characters
std::string cleaned;
for (char c : ssn) {
if (std::isdigit(c)) {
cleaned += c;
}
}
// Check length
if (cleaned.length() != 9) {
result["valid"] = "false";
result["message"] = "SSN must be 9 digits";
return result;
}
// Validate pattern
if (!std::regex_match(cleaned, ssnPattern)) {
result["valid"] = "false";
result["message"] = "Invalid SSN format or forbidden number";
return result;
}
// Format SSN
std::string formatted = cleaned.substr(0, 3) + "-" +
cleaned.substr(3, 2) + "-" +
cleaned.substr(5);
result["valid"] = "true";
result["message"] = "Valid SSN";
result["formatted"] = formatted;
return result;
}
};
const std::regex SSNValidator::ssnPattern(
"^(?!000|666)[0-8][0-9]{2}(?!00)[0-9]{2}(?!0000)[0-9]{4}$"
);
// Usage example
int main() {
auto result = SSNValidator::validateSSN("123-45-6789");
std::cout << "Valid: " << result["valid"]
<< ", Message: " << result["message"] << std::endl;
return 0;
}
Professional Tips & Best Practices
Security Best Practices
- Never store SSNs in plain text - always encrypt
- Use secure transmission protocols (HTTPS/TLS)
- Implement proper access controls and audit logs
- Consider data masking for display purposes
Implementation Tips
- Always validate on both client and server side
- Provide clear error messages to users
- Support multiple input formats gracefully
- Use consistent formatting in your application
Common Pitfalls
- Don't rely solely on format validation
- Avoid storing SSNs unnecessarily
- Don't forget about invalid number combinations
- Never validate SSNs against real databases for verification
Pro Tip: Advanced Validation Strategy
For production applications, implement a multi-layered validation approach: Format validation → Pattern matching → Invalid number detection → Business logic validation. This ensures comprehensive SSN validation while maintaining security and user experience.
| Feature | Details |
|---|---|
| Price | Free |
| Rendering | Client-Side Rendering |
| Language | JavaScript |
| Paywall | No |
0 Comments