Generar RFC en Excel

El Registro Federal de Contribuyentes (RFC) es una clave que requiere toda persona en México para realizar una actividad comercial y con la cual se podrá identificar al realizar el pago de impuestos. Para generar el RFC en Excel implementaremos el algoritmo de solución publicado por el Instituto Federal de Acceso a la Información.

¿Fórmula para generar RFC en Excel?

Es inevitable que los usuarios de Excel traten de encontrar una fórmula para generar el RFC sin embargo, dadas las características de generación de dicha clave, es totalmente impráctico el buscar una solución utilizando solamente las funciones de Excel especialmente para la generación de la homoclave.

Para implementar el algoritmo de solución publicado por el IFAI es necesario hacer uso de un lenguaje de programación así que crearemos una nueva función definida por el usuario (UDF) con código VBA que es el lenguaje de programación de Excel.

Pero no te preocupes si no eres un programador de Excel, al final del artículo encontrarás el vínculo para descargar el libro de trabajo que contiene la función que podrás utilizar para generar el RFC en Excel sin la necesidad de escribir una sola línea de código VBA.

Cómo generar el RFC de una persona

Todas las claves de RFC para personas físicas constan de 13 posiciones que son asignadas de la siguiente manera:

  • Posición 1: Primera letra del apellido paterno.
  • Posición 2: Siguiente vocal del apellido paterno.
  • Posición 3: Primera letra del apellido materno.
  • Posición 4: Primera letra del nombre.
  • Posición 5 y 6: Últimos dos dígitos del año de nacimiento.
  • Posición 7 y 8: Dos dígitos del mes de nacimiento.
  • Posición 9 y 10: Dos dígitos del día de nacimiento.
  • Posición 11 y 12: Dos posiciones para la clave diferenciadora de homonimia.
  • Posición 13: Un dígito verificador.

Como puedes notar, los únicos datos que necesitamos para generar el RFC de una persona son el apellido paterno, apellido materno, nombre y fecha de nacimiento. Para nuestro ejemplo utilizaremos los siguientes datos de prueba:

Generar RFC en Excel

Reglas para generar el RFC

En más de una ocasión nos encontraremos con algunas ambigüedades al momento de extraer las letras de los apellidos o nombres. Es por eso que debemos tener en cuenta las siguientes reglas al momento de generar el RFC:

  • Si el nombre es compuesto, se considerará el primer nombre excepto cuando sea María o José, en cuyo caso se utilizará el segundo nombre.
  • Si alguno de los apellidos es compuesto, se considerará la primera palabra para formar el RFC.
  • Cuando en el nombre o apellidos figuren artículos, preposiciones, conjunciones o contracciones no se tomarán en cuenta para la generación del RFC.
  • Cuando el apellido paterno se componga de una o dos letras entonces las letras del RFC se formarán de la siguiente manera: la primera letra del apellido paterno seguida de la primera letra del apellido materno y la primera y segunda letra del nombre.
  • En caso de tener un solo apellido, las letras del RFC serán la primera y segunda letra del apellido más la primera y segunda letra del nombre.
  • Cuando las cuatro letras del RFC formen una palabra inconveniente, la última letra será sustituida por una “X”.

El detalle de cada una de estas reglas podrás consultarlo en el documento publicado por el IFAI que mencioné al principio del artículo. Una vez establecidas las reglas podemos comenzar con la construcción del código que nos ayudará a determinar el RFC en Excel.

Dar formato al nombre y apellidos

La primera función que crearemos será para dar formato al nombre y apellidos de la persona de la cual obtendremos el RFC. Esta función será útil para convertir cualquier texto en letras mayúsculas y posteriormente reemplazar cualquier vocal acentuada, lo cual es de suma importancia porque el RFC no admite acentos. El código de la función que nos ayudará en ambos objetivos es el siguiente:

Private Function FormatoTextoRFC(ByVal texto As String) As String

texto = UCase(texto)
texto = Replace(texto, "Á", "A")
texto = Replace(texto, "É", "E")
texto = Replace(texto, "Í", "I")
texto = Replace(texto, "Ó", "O")
texto = Replace(texto, "Ú", "U")

FormatoTextoRFC = texto
End Function

Remover artículos y preposiciones

Otra función que necesitaremos implementar será la que nos ayude a suprimir los artículos, preposiciones, conjunciones y contracciones contenidas en el nombre o apellidos ya que, como lo establece la regla, dichas palabras no serán utilizadas en la generación del RFC. La solución será muy sencilla ya que colocaré todas las palabras a validar dentro de un arreglo y posteriormente reemplazaremos cualquier aparición dentro del texto proporcionado.

Private Function RemoverPalabras(ByVal texto As String) As String

Dim palabras As Variant
Dim i As Integer

palabras = Array(" PARA ", " AND ", " CON ", " DEL ", " LAS ", " LOS ", _
" MAC ", " POR ", " SUS ", " THE ", " VAN ", " VON ", " AL ", " DE ", _
" EL ", " EN ", " LA ", " MC ", " MI ", " OF ", " A ", " E ", " Y ")

texto = " " & texto
For i = LBound(palabras) To UBound(palabras)
    texto = Replace(texto, palabras(i), " ")
Next i

RemoverPalabras = Trim(texto)
End Function

Remover nombres frecuentes

En México, los nombres María y José son ampliamente utilizados, por lo que una de las reglas para calcular el RFC es omitir dichos nombres siempre y cuando la persona tenga un segundo nombre. Para realizar esta validación y reemplazo crearemos una función con el siguiente código:

Private Function RemoverNombres(ByVal texto As String) As String

Dim nombres As Variant
Dim i As Integer

nombres = Array(" MARIA ", " JOSE ", " MA. ", " MA ", " J. ", " J ")

If InStr(texto, " ") > 0 Then
    texto = " " & texto
    For i = LBound(nombres) To UBound(nombres)
        texto = Replace(texto, nombres(i), " ")
    Next i
End If

RemoverNombres = Trim(texto)
End Function

Determinar las primeras letras del RFC

Las primeras cuatro posiciones del RFC son letras que obtenemos del nombre y apellidos, así que una vez que se hayan utilizado las funciones anteriores, podremos extraer las letras correspondientes para cada posición. Sin embargo, es necesario considerar que existen reglas adicionales que nos indican un trato especial en caso de tener un solo apellido o si el apellido paterno tiene una longitud de una o dos 3 letras. El código que realizará todas estas validaciones y obtendrá las letras de las primeras cuatro posiciones para el RFC será el siguiente:

Private Function LetrasRFC(ByVal nombre As String, _
ByVal paterno As String, _
ByVal materno As String) As String

Dim vocales, vocal, letras As String
Dim i As Integer

vocales = "AEIOU"

If Len(materno) = 0 Then
    letras = Left(paterno, 2) & Left(nombre, 2)
ElseIf Len(paterno) < 3 Then
    letras = Left(paterno, 1) & Left(materno, 1) & Left(nombre, 2)
Else
    For i = 2 To Len(paterno)
        If InStr(vocales, Mid(paterno, i, 1)) > 0 Then
            vocal = Mid(paterno, i, 1)
            Exit For
        End If
    Next i
    letras = Left(paterno, 1) & vocal & Left(materno, 1) & Left(nombre, 1)
End If

LetrasRFC = letras
End Function

Sustituir palabras inconvenientes

Una vez que hayamos obtenido las cuatro primeras letras del RFC, será necesario validar si dichas letras forman alguna palabra inconveniente de nuestro idioma. Si encontramos alguna coincidencia, entonces la última letra será reemplazada por una “X”. El código para esta función (SustituirProhibidas) lo encontrarás en el archivo que descargarás al final del artículo.

RFC con homoclave en Excel

Por mucho tiempo la homoclave del RFC ha sido vista como aquellos caracteres que solamente el SAT podía asignar al momento de solicitar el RFC. Sin embargo, el documento publicado por el IFAI nos da los pasos a seguir para obtener las letras que dan origen a dicha homonimia.

A grandes rasgos, el proceso el siguiente. A cada letra del nombre y apellidos de la persona se les da una equivalencia numérica y entonces se multiplica digito por dígito para sumar el resultado a los anteriores. La suma acumulada final será truncada para obtener los últimos 3 dígitos y ser divididos por 34 y obtener tanto el cociente como el residuo que tendrán una equivalencia en letras que formarán las posiciones 11 y 12 del RFC. A continuación encontrarás el código que nos ayudará a obtener dichas posiciones del RFC:

Private Function Homoclave(ByVal nombre As String, _
ByVal paterno As String, _
ByVal materno As String) As String

Dim nombreCompleto, cadenaNums, equivalencia, caracter As String
Dim i, numero1, numero2, suma, cociente, residuo As Integer

equivalencia = "123456789ABCDEFGHIJKLMNPQRSTUVWXYZ"
nombreCompleto = nombre & " " & paterno & " " & materno

For i = 1 To Len(nombreCompleto)
    caracter = Mid(nombreCompleto, i, 1)
    Select Case caracter
        Case " "
            cadenaNums = cadenaNums & "00"
        Case "&"
            cadenaNums = cadenaNums & "10"
        Case "Ñ"
            cadenaNums = cadenaNums & "40"
        Case "A" To "I"
            cadenaNums = cadenaNums & CStr(Asc(caracter) - 54)
        Case "J" To "R"
            cadenaNums = cadenaNums & CStr(Asc(caracter) - 53)
        Case "S" To "Z"
            cadenaNums = cadenaNums & CStr(Asc(caracter) - 51)
    End Select
Next i

cadenaNums = "0" & cadenaNums

For i = 1 To Len(cadenaNums) - 1
    numero1 = Val(Mid(cadenaNums, i, 2))
    numero2 = Val(Mid(cadenaNums, i + 1, 1))
    suma = suma + numero1 * numero2
Next i

cociente = Int(Val(Right(CStr(suma), 3)) / 34)
residuo = Val(Right(CStr(suma), 3)) Mod 34

Homoclave = Mid(equivalencia, cociente + 1, 1) & _
Mid(equivalencia, residuo + 1, 1)
End Function

El dígito verificador del RFC

Para obtener la última posición del RFC se utilizará un método similar a la función anterior solo que en lugar de tomar como base el nombre y apellidos, se tomará en cuenta la cadena de texto de las 12 posiciones del RFC generadas hasta el momento. Se sustituirá cada una de las posiciones por un número equivalente y se realizará una multiplicación y suma de cada uno de ellos para obtener una suma total de la cual obtendremos el residuo de la división entre 11. El resultado se evaluará para conocer el dígito verificador a devolver.

Private Function DigitoVerificador(ByVal texto As String) As String

Dim cadenaNums, caracter, digito As String
Dim i, j, cont, numero, suma, residuo As Integer

For i = 1 To Len(texto)
    caracter = Mid(texto, i, 1)
    Select Case caracter
        Case " "
            cadenaNums = cadenaNums & "37"
        Case "&"
            cadenaNums = cadenaNums & "24"
        Case "Ñ"
            cadenaNums = cadenaNums & "38"
        Case "A" To "N"
            cadenaNums = cadenaNums & CStr(Asc(caracter) - 55)
        Case "O" To "Z"
            cadenaNums = cadenaNums & CStr(Asc(caracter) - 54)
        Case "0" To "9"
            cadenaNums = cadenaNums & Format(caracter, "00")
    End Select
Next i

cont = 0
For j = 1 To 23 Step 2
    numero = Val(Mid(cadenaNums, j, 2))
    suma = suma + (numero * (13 - cont))
    cont = cont + 1
Next j

residuo = suma Mod 11

Select Case residuo
    Case 0:
        digito = "0"
    Case 10:
        digito = "A"
    Case Else
        digito = 11 - residuo
End Select

DigitoVerificador = digito
End Function

Obtener el RFC en Excel

Una vez que hemos desarrollado todas las funciones para generar el RFC en Excel solo nos resta integrar dicha funcionalidad para obtener finalmente la clave. En las siguientes líneas de código se crea la función RFC la cual será la que utilizaremos desde nuestras hojas de Excel.

Public Function RFC(nombre As String, _
paterno As String, _
materno As String, _
nacimiento As Date) As String

Dim nombreRFC, paternoRFC, maternoRFC, claveRFC As String

'Aplicar formato y remover palabras y nombres de textos
nombreRFC = RemoverNombres(RemoverPalabras(FormatoTextoRFC(nombre)))
paternoRFC = RemoverPalabras(FormatoTextoRFC(paterno))
maternoRFC = RemoverPalabras(FormatoTextoRFC(materno))

'Generar las 4 primeras letras y sustituir palabras prohibidas
claveRFC = SustituirProhibidas(LetrasRFC(nombreRFC, paternoRFC, maternoRFC))

'Concatenar dígitos de fecha de nacimiento
claveRFC = claveRFC & Format(nacimiento, "yymmdd")

'Generar homonimia y concatenar al RFC
claveRFC = claveRFC & Homoclave(FormatoTextoRFC(nombre), _
FormatoTextoRFC(paterno), FormatoTextoRFC(materno))

'Generar dígito verificador y concatenar al RFC
claveRFC = claveRFC & DigitoVerificador(claveRFC)

'Devolver RFC final
RFC = claveRFC
End Function

Probar la creación del RFC en Excel

Ya que los datos de nuestro ejemplo son parte de una tabla de Excel, podemos probar la función recién creada insertando la siguiente fórmula:

=RFC([@Nombre], [@[Apellido Paterno]], [@[Apellido Materno]], [@Nacimiento])

Observa el resultado al copiar esta fórmula en la última columna de la tabla:

Calcular el RFC en Excel

Descargar libro de trabajo

En el siguiente vínculo podrás descargar el libro de trabajo que he utilizado en la creación de la función RFC.

Descargar libro de trabajo

ADVERTENCIA: La creación de la función para generar el RFC en Excel se ha hecho en estricto apego a la información publicada por el IFAI, sin embargo hay ciertas reglas que no están suficientemente documentadas y por lo tanto puede existir alguna diferencia con el RFC otorgado por el Sistema de Administración Tributaria (SAT).

Moisés Ortiz

Autor: Moisés Ortiz

Moisés es consultor en tecnologías de la información con especialidad en herramientas de inteligencia de negocios y análisis de datos. Tiene más de 25 años de experiencia en el uso de Excel y es una de sus herramientas predilectas para la creación de reportes. Ver más ➤