CURP: Qué es, Cómo se Forma y Cómo Validarlo

El CURP (Clave Única de Registro de Población) es uno de los identificadores más importantes en México. Si tu empresa procesa datos de ciudadanos mexicanos, entender cómo funciona el CURP es fundamental para validar información y prevenir errores.

¿Qué es el CURP?

El CURP es una clave alfanumérica de 18 caracteres que identifica de manera única a cada persona registrada en México, tanto ciudadanos como residentes extranjeros.

Ejemplo de CURP: GOVM800705MCLRLR01

¿Para qué se usa el CURP?

Trámites gubernamentales
Inscripción escolar
Servicios de salud (IMSS, ISSSTE)
Declaración de impuestos (SAT)
Apertura de cuentas bancarias
Contratación laboral
Verificación de identidad en procesos KYC

Estructura del CURP: Los 18 caracteres explicados

El CURP no es aleatorio. Cada sección contiene información específica sobre la persona:

G O V M 8 0 0 7 0 5 M C L R L R 0 1
│ │ │ │ │         │ │   │     │ │
│ │ │ │ │         │ │   │     └─┴─ Homoclave (2)
│ │ │ │ │         │ │   └───────── Consonantes internas (3)
│ │ │ │ │         │ └───────────── Estado de nacimiento (2)
│ │ │ │ │         └─────────────── Sexo (1)
│ │ │ │ └───────────────────────── Fecha de nacimiento (6)
└─┴─┴─┴─────────────────────────── Iniciales del nombre (4)

Desglose detallado

Posición	Ejemplo	Significado
1-2	GO	Primera vocal interna + primera letra del apellido paterno
3	V	Primera letra del apellido materno
4	M	Primera letra del primer nombre
5-6	80	Últimos dos dígitos del año de nacimiento
7-8	07	Mes de nacimiento
9-10	05	Día de nacimiento
11	M	Sexo (H = Hombre, M = Mujer)
12-13	CL	Código del estado de nacimiento
14	R	Primera consonante interna del apellido paterno
15	L	Primera consonante interna del apellido materno
16	R	Primera consonante interna del nombre
17	0	Dígito diferenciador de homonimia
18	1	Dígito verificador

Códigos de estados mexicanos en el CURP

Código	Estado	Código	Estado
AS	Aguascalientes	NL	Nuevo León
BC	Baja California	OC	Oaxaca
BS	Baja California Sur	PL	Puebla
CC	Campeche	QT	Querétaro
CL	Coahuila	QR	Quintana Roo
CM	Colima	SP	San Luis Potosí
CS	Chiapas	SL	Sinaloa
CH	Chihuahua	SR	Sonora
DF	Ciudad de México	TC	Tabasco
DG	Durango	TS	Tamaulipas
GT	Guanajuato	TL	Tlaxcala
GR	Guerrero	VZ	Veracruz
HG	Hidalgo	YN	Yucatán
JC	Jalisco	ZS	Zacatecas
MC	Estado de México	NE	Nacido en el extranjero
MN	Michoacán
MS	Morelos
NT	Nayarit

Cómo validar un CURP

Existen varios niveles de validación que puedes implementar:

1. Validación de formato básico

Verifica que el CURP tenga la estructura correcta usando una expresión regular:

import re

def validar_formato_curp(curp):
    """
    Valida que el CURP tenga el formato correcto

    Returns:
        bool: True si el formato es válido
    """
    if not curp or len(curp) != 18:
        return False

    patron = r'^[A-Z]{4}\d{6}[HM][A-Z]{2}[A-Z]{3}[A-Z0-9]\d$'
    return bool(re.match(patron, curp.upper()))

# Ejemplos
print(validar_formato_curp("GOVM800705MCLRLR01"))  # True
print(validar_formato_curp("INVALIDO"))            # False
print(validar_formato_curp("GOVM800705XCLRLR01"))  # False (X no es válido para sexo)

2. Validación del dígito verificador

El carácter 18 es un dígito verificador calculado con un algoritmo específico:

def calcular_digito_verificador(curp_17):
    """
    Calcula el dígito verificador de un CURP

    Args:
        curp_17: Los primeros 17 caracteres del CURP

    Returns:
        str: El dígito verificador (0-9)
    """
    diccionario = "0123456789ABCDEFGHIJKLMNÑOPQRSTUVWXYZ"

    suma = 0
    for i, char in enumerate(curp_17.upper()):
        valor = diccionario.index(char)
        suma += valor * (18 - i)

    residuo = suma % 10
    digito = (10 - residuo) % 10

    return str(digito)

def validar_curp_completo(curp):
    """
    Valida el CURP incluyendo el dígito verificador
    """
    if not validar_formato_curp(curp):
        return False

    digito_calculado = calcular_digito_verificador(curp[:17])
    return curp[17] == digito_calculado

3. Validación cruzada con otros datos

Si tienes acceso a otros datos de la persona (por ejemplo, al extraer datos de una credencial INE), puedes verificar la consistencia:

from datetime import date

def validar_consistencia(curp, fecha_nacimiento, sexo):
    """
    Valida que el CURP coincida con la fecha de nacimiento y sexo

    Args:
        curp: CURP a validar
        fecha_nacimiento: objeto date con la fecha
        sexo: 'M' para mujer, 'H' para hombre

    Returns:
        tuple: (es_valido, lista_de_errores)
    """
    errores = []
    curp = curp.upper()

    # Extraer año del CURP
    año_curp = int(curp[4:6])
    # Ajustar siglo: 00-29 = 2000s, 30-99 = 1900s
    año_completo = 2000 + año_curp if año_curp <= 29 else 1900 + año_curp

    mes_curp = int(curp[6:8])
    dia_curp = int(curp[8:10])

    # Comparar fecha
    if (fecha_nacimiento.year != año_completo or
        fecha_nacimiento.month != mes_curp or
        fecha_nacimiento.day != dia_curp):
        errores.append("Fecha de nacimiento no coincide con CURP")

    # Comparar sexo
    if sexo.upper() != curp[10]:
        errores.append("Sexo no coincide con CURP")

    return len(errores) == 0, errores

# Ejemplo de uso
es_valido, errores = validar_consistencia(
    "GOVM800705MCLRLR01",
    date(1980, 7, 5),
    "M"
)
print(f"Válido: {es_valido}")  # True

Cómo extraer información de un CURP

Puedes decodificar información útil directamente del CURP:

def extraer_info_curp(curp):
    """
    Extrae información contenida en el CURP
    """
    curp = curp.upper()

    estados = {
        'AS': 'Aguascalientes', 'BC': 'Baja California',
        'BS': 'Baja California Sur', 'CC': 'Campeche',
        'CL': 'Coahuila', 'CM': 'Colima', 'CS': 'Chiapas',
        'CH': 'Chihuahua', 'DF': 'Ciudad de México',
        'DG': 'Durango', 'GT': 'Guanajuato', 'GR': 'Guerrero',
        'HG': 'Hidalgo', 'JC': 'Jalisco', 'MC': 'Estado de México',
        'MN': 'Michoacán', 'MS': 'Morelos', 'NT': 'Nayarit',
        'NL': 'Nuevo León', 'OC': 'Oaxaca', 'PL': 'Puebla',
        'QT': 'Querétaro', 'QR': 'Quintana Roo', 'SP': 'San Luis Potosí',
        'SL': 'Sinaloa', 'SR': 'Sonora', 'TC': 'Tabasco',
        'TS': 'Tamaulipas', 'TL': 'Tlaxcala', 'VZ': 'Veracruz',
        'YN': 'Yucatán', 'ZS': 'Zacatecas', 'NE': 'Nacido en el extranjero'
    }

    año = int(curp[4:6])
    año_completo = 2000 + año if año <= 29 else 1900 + año

    return {
        'fecha_nacimiento': f"{curp[8:10]}/{curp[6:8]}/{año_completo}",
        'sexo': 'Mujer' if curp[10] == 'M' else 'Hombre',
        'estado_nacimiento': estados.get(curp[11:13], 'Desconocido'),
    }

# Ejemplo
info = extraer_info_curp("GOVM800705MCLRLR01")
print(info)
# {
#     'fecha_nacimiento': '05/07/1980',
#     'sexo': 'Mujer',
#     'estado_nacimiento': 'Coahuila'
# }

Casos especiales del CURP

Personas nacidas en el extranjero

Los mexicanos nacidos fuera del país tienen el código NE (Nacido en el Extranjero) en las posiciones 12-13.

Nombres con Ñ

La letra Ñ es válida en el CURP y se usa tal cual cuando aparece en el nombre o apellidos.

Homonimia

Cuando dos personas tienen el mismo CURP base (posiciones 1-16), RENAPO asigna diferentes valores en la posición 17 para diferenciarlas.

Automatiza la validación de CURP con extracción de INE

Si procesas credenciales INE en tu empresa, puedes extraer automáticamente el CURP y otros datos usando una API de OCR. Esto te permite:

Capturar el CURP sin errores de transcripción
Validar automáticamente el formato y dígito verificador
Cruzar información con fecha de nacimiento y sexo extraídos de la misma credencial

Extraer Datos de INE te permite obtener el CURP y más de 15 campos de la credencial en segundos, con una precisión superior al 98%.

Conclusión

El CURP es más que un simple identificador: es una fuente de información verificable sobre la persona. Implementar validaciones correctas en tus sistemas te ayuda a:

Detectar errores de captura
Prevenir fraudes de identidad
Mantener datos consistentes
Cumplir con regulaciones de KYC

¿Necesitas extraer y validar CURPs de manera automática? Prueba nuestra API de extracción de INE con 20 extracciones gratis.