DEV Community

Adrian Rangel
Adrian Rangel

Posted on

Verifica el estatus de un CFDI y si tu proveedor está en la lista 69-B del SAT con Python

Si trabajas en cuentas por pagar, un ERP o una fintech en México, recibes facturas todo el día. Casi todas están bien. Las que no, suelen caer en dos casos que el XML no te avisa:

  1. El CFDI ya no está vigente. El emisor lo canceló (a veces después de que lo recibiste) o el SAT no lo tiene registrado.
  2. El emisor aparece en una lista del SAT, sobre todo la del artículo 69-B del Código Fiscal de la Federación: los contribuyentes que el SAT presume que emiten facturas por operaciones inexistentes (los famosos EFOS).

En este artículo armamos en Python un flujo pequeño que puedes meter en tu proceso de recepción de facturas: leer el XML, validar formatos sin red, consultar al SAT y tomar una decisión (pagar, revisar o bloquear).

Por qué importa revisar

Un CFDI cancelado deja de tener efectos fiscales. Si lo pagaste y lo deduces, el problema aparece meses después, en una revisión. Y la cancelación puede ocurrir después de que el XML entró a tu sistema, así que el XML que guardaste no basta: hay que preguntarle al SAT.

Las listas del SAT son otro riesgo:

  • Artículo 69-B. Cuando el SAT concluye que un contribuyente no tenía capacidad para realizar las operaciones que facturó, lo publica primero como presunto y, si no desvirtúa, como definitivo. Las facturas de un definitivo se consideran sin efectos fiscales, y quien las usó para deducir o acreditar tiene que demostrar que la operación sí existió o corregir su situación fiscal. Hay también quienes lograron salir: desvirtuados y con sentencia favorable.
  • Artículo 69. Contribuyentes con créditos fiscales firmes, no localizados, cancelados, con sentencia condenatoria por delito fiscal, entre otros. No invalida las facturas por sí solo, pero es una señal que tu equipo de cumplimiento querrá ver.
  • Artículo 69-B Bis. Transmisión indebida de pérdidas fiscales.

No soy abogado; para la interpretación de cada caso, habla con tu contador. Lo que sí podemos automatizar es el cuándo revisar:

  • Al recibir la factura, para rechazar de inmediato lo que no existe o ya está cancelado.
  • Antes de programar el pago, porque entre la recepción y el pago pueden pasar 30, 60 o 90 días, y en ese tiempo el emisor puede cancelar o aparecer en una lista.
  • Periódicamente sobre las facturas ya pagadas, si tu operación lo justifica.

Parte 1: sin red, leer el XML

Empezamos con lo que no cuesta nada. Para hacer la consulta al SAT necesitas tres datos del CFDI: el UUID (folio fiscal, dentro del TimbreFiscalDigital), el RFC del emisor y el RFC del receptor. El total lo guardamos para conciliar.

Este es un XML de ejemplo sintético. Los RFC EKU9003173C9 y URE180429TM6 son los que el SAT usa en sus ambientes de prueba, el UUID es inventado y los sellos están vacíos. No es una factura real:

<?xml version="1.0" encoding="UTF-8"?>
<!-- EJEMPLO SINTÉTICO: RFC de pruebas del SAT, UUID inventado, sin sellos reales -->
<cfdi:Comprobante xmlns:cfdi="http://www.sat.gob.mx/cfd/4"
    xmlns:tfd="http://www.sat.gob.mx/TimbreFiscalDigital"
    Version="4.0" Serie="A" Folio="1024" Fecha="2026-11-10T12:30:00"
    SubTotal="10000.00" Moneda="MXN" Total="11600.00"
    TipoDeComprobante="I" Exportacion="01" MetodoPago="PPD"
    LugarExpedicion="64000">
  <cfdi:Emisor Rfc="EKU9003173C9" Nombre="ESCUELA KEMPER URGATE" RegimenFiscal="601"/>
  <cfdi:Receptor Rfc="URE180429TM6" Nombre="UNIVERSIDAD ROBOTICA ESPAÑOLA"
      DomicilioFiscalReceptor="65000" RegimenFiscalReceptor="601" UsoCFDI="G03"/>
  <cfdi:Conceptos>
    <cfdi:Concepto ClaveProdServ="81111500" Cantidad="1" ClaveUnidad="E48"
        Descripcion="Servicio de desarrollo de software" ValorUnitario="10000.00"
        Importe="10000.00" ObjetoImp="02"/>
  </cfdi:Conceptos>
  <cfdi:Complemento>
    <tfd:TimbreFiscalDigital Version="1.1"
        UUID="6F3C2A1B-0D4E-4B7A-9C21-5E8F7A6B3D10"
        FechaTimbrado="2026-11-10T12:31:05" RfcProvCertif="SPR190613I52"
        SelloCFD="..." NoCertificadoSAT="00000000000000000000" SelloSAT="..."/>
  </cfdi:Complemento>
</cfdi:Comprobante>
Enter fullscreen mode Exit fullscreen mode

Con la librería estándar alcanza. Lo único delicado son los namespaces: en CFDI 4.0 el comprobante usa http://www.sat.gob.mx/cfd/4 y el timbre http://www.sat.gob.mx/TimbreFiscalDigital.

import xml.etree.ElementTree as ET
from decimal import Decimal

NS = {
    "cfdi": "http://www.sat.gob.mx/cfd/4",
    "tfd": "http://www.sat.gob.mx/TimbreFiscalDigital",
}

def leer_cfdi(ruta):
    raiz = ET.parse(ruta).getroot()
    if raiz.get("Version") != "4.0":
        raise ValueError(f"Se esperaba CFDI 4.0, llegó {raiz.get('Version')}")
    emisor = raiz.find("cfdi:Emisor", NS)
    receptor = raiz.find("cfdi:Receptor", NS)
    timbre = raiz.find("cfdi:Complemento/tfd:TimbreFiscalDigital", NS)
    if timbre is None:
        raise ValueError("El XML no trae TimbreFiscalDigital (¿no está timbrado?)")
    return {
        "uuid": timbre.get("UUID").upper(),
        "rfc_emisor": emisor.get("Rfc"),
        "rfc_receptor": receptor.get("Rfc"),
        "total": Decimal(raiz.get("Total")),
        "tipo": raiz.get("TipoDeComprobante"),
    }

if __name__ == "__main__":
    print(leer_cfdi("factura_ejemplo.xml"))
Enter fullscreen mode Exit fullscreen mode
$ python3 leer_cfdi.py
{'uuid': '6F3C2A1B-0D4E-4B7A-9C21-5E8F7A6B3D10', 'rfc_emisor': 'EKU9003173C9', 'rfc_receptor': 'URE180429TM6', 'total': Decimal('11600.00'), 'tipo': 'I'}
Enter fullscreen mode Exit fullscreen mode

Usa Decimal para el total, nunca float; vas a compararlo contra montos de pago.

Validar el formato del RFC

Antes de gastar una consulta, descarta lo que ni siquiera tiene forma de RFC: 3 letras para personas morales o 4 para físicas, una fecha AAMMDD y 3 caracteres de homoclave, el último un dígito o A.

import re
from datetime import date

# 3 letras (moral) o 4 (física) + AAMMDD + homoclave de 3
RFC_RE = re.compile(r"^([A-ZÑ&]{3,4})(\d{2})(\d{2})(\d{2})([A-Z\d]{2}[A\d])$")

def rfc_con_formato_valido(rfc: str) -> bool:
    m = RFC_RE.match(rfc.strip().upper())
    if not m:
        return False
    aa, mm, dd = (int(g) for g in m.group(2, 3, 4))
    try:
        # el año de 2 dígitos es ambiguo; 2000 es bisiesto y sirve para validar 29-feb
        date(2000 + aa, mm, dd)
    except ValueError:
        return False
    return True

if __name__ == "__main__":
    for rfc in ["EKU9003173C9", "URE180429TM6", "XAXX010101000",
                "EKU9013173C9", "ABC12345", "eku9003173c9"]:
        print(f"{rfc:14} {rfc_con_formato_valido(rfc)}")
Enter fullscreen mode Exit fullscreen mode
$ python3 rfc_formato.py
EKU9003173C9   True
URE180429TM6   True
XAXX010101000  True
EKU9013173C9   False
ABC12345       False
eku9003173c9   True
Enter fullscreen mode Exit fullscreen mode

EKU9013173C9 falla porque el mes 13 no existe. Ojo: el formato correcto no significa que el RFC exista ni que esté activo. Para eso necesitas al SAT.

Parte 2: consultar al SAT con el API de MexCheck

Para no tener que automatizar el portal Verifica CFDI ni descargar y sincronizar los CSV de las listas, uso dos endpoints de MexCheck:

  • POST /v1/cfdi/verify: pregunta al portal Verifica CFDI del SAT si el comprobante existe y si está vigente o cancelado. Recibe uuid, rfc_emisor y rfc_receptor (o el XML completo en el campo xml, nunca ambos). Tarda unos 3 segundos.
  • POST /v1/rfc/sat-lists: regresa en qué listas (69, 69-B, 69-B Bis) aparece un RFC. Es una consulta a una base local sincronizada con las publicaciones del SAT, así que responde en milisegundos.

La autenticación es con el header x-api-key. La llave va en una variable de entorno, MEXCHECK_API_KEY, nunca en el código.

Qué significa cada respuesta

/cfdi/verify regresa found, status, uuid, message y cfdi (el registro tal como lo imprime el SAT: estado, es_cancelable, estatus_cancelacion, fecha_cancelacion, motivo, folio_sustitucion, total con formato de moneda, etc.):

found status Qué hacer
true vigente Sigue el flujo.
true cancelado Bloquea. Revisa motivo y folio_sustitucion (motivo 01 trae la factura que lo sustituye).
false no_encontrado El SAT no lo tiene. Si se timbró hace menos de 72 horas puede no estar registrado todavía: reintenta más tarde.
false rechazado El portal rechazó la solicitud (por ejemplo, un XML ilegible). message trae la razón.
null null No se pudo contactar al SAT. Reintenta; no se cobra.

Si llega un status que no está en la tabla, la documentación pide tratarlo como ni vigente ni cancelado; por eso el código de abajo lo manda a revisión.

/rfc/sat-lists regresa {"rfc": ..., "sat_lists": [...]}. Cada elemento trae article (69, 69b o 69b_bis), sub_list, situation, name y, cuando la lista lo publica, person_type, state y first_publication_date. Lista vacía = el RFC no aparece en ninguna.

Cliente con reintentos

Los reintentos importan porque el SAT a veces no responde. found: null, 429, 500 y 504 se reintentan con backoff; 401 (llave), 402 (sin saldo) y 422 (datos inválidos) no, porque repetir no cambia nada. El timeout va a 95 segundos: una consulta puede tardar hasta 90, y si cortas antes, la consulta se cancela y no recibes respuesta.

import os
import time
import requests

BASE_URL = "https://mexcheck.com/v1"
HEADERS = {"x-api-key": os.environ["MEXCHECK_API_KEY"]}
REINTENTABLES = {429, 500, 504}

def _post(ruta, cuerpo, intentos=4):
    """POST con reintentos para found:null, 429, 500 y 504 (no se cobran)."""
    for intento in range(intentos):
        r = requests.post(f"{BASE_URL}{ruta}", json=cuerpo,
                          headers=HEADERS, timeout=95)  # el API puede tardar hasta 90 s
        if r.status_code in REINTENTABLES:
            time.sleep(2 ** intento)
            continue
        r.raise_for_status()  # 401, 402 o 422: no tiene caso reintentar
        datos = r.json()
        if "found" in datos and datos["found"] is None:  # SAT no respondió
            time.sleep(2 ** intento)
            continue
        return datos
    return None  # sin respuesta definitiva: deja la factura en cola

def verificar_cfdi(uuid, rfc_emisor, rfc_receptor):
    return _post("/cfdi/verify", {"uuid": uuid, "rfc_emisor": rfc_emisor,
                                  "rfc_receptor": rfc_receptor})

def listas_sat(rfc):
    return _post("/rfc/sat-lists", {"rfc": rfc})
Enter fullscreen mode Exit fullscreen mode

Si prefieres mandar el XML completo, el SAT además revisa los sellos y llena sello_cfdi y sello_timbre_fiscal: curl -F xml=@factura.xml -H "x-api-key: $MEXCHECK_API_KEY" https://mexcheck.com/v1/cfdi/verify.

La decisión

Aquí va la regla de negocio. La mía es conservadora: bloquear si el CFDI está cancelado o el emisor es 69-B definitivo; mandar a revisión todo lo demás que no esté limpio (presuntos, artículo 69, no encontrados, estatus raros). Ajústala con tu área fiscal.

def decidir_pago(cfdi_resp, listas_resp):
    """Regresa (acción, motivos). Acciones: pagar, revisar, reintentar, bloquear."""
    if cfdi_resp is None or listas_resp is None:
        return "reintentar", ["SAT o el API no dieron respuesta definitiva"]

    bloqueos, revisiones = [], []

    status = cfdi_resp.get("status")
    if status == "cancelado":
        c = cfdi_resp["cfdi"]
        bloqueos.append(f"CFDI cancelado el {c.get('fecha_cancelacion')} (motivo {c.get('motivo')})")
    elif status == "no_encontrado":
        revisiones.append("SAT no encuentra el CFDI (si se timbró hace menos de 72 h, reintenta después)")
    elif status != "vigente":
        revisiones.append(f"Estatus inesperado: {status!r} - {cfdi_resp.get('message')}")

    for l in listas_resp.get("sat_lists", []):
        situacion = (l.get("situation") or "").upper()
        if l["article"] == "69b" and "DEFINITIVO" in situacion:
            bloqueos.append(f"Emisor en 69-B como {l['situation']}")
        elif l["article"] == "69b" and ("DESVIRTUADO" in situacion or "FAVORABLE" in situacion):
            revisiones.append(f"Emisor estuvo en 69-B ({l['situation']}); guarda la evidencia")
        else:
            revisiones.append(f"Emisor en art. {l['article']} / {l.get('sub_list')}: {l['situation']}")

    if bloqueos:
        return "bloquear", bloqueos + revisiones
    if revisiones:
        return "revisar", revisiones
    return "pagar", []
Enter fullscreen mode Exit fullscreen mode

Probarlo sin gastar créditos

Para no tocar el API real mientras desarrollas, simulo requests.post con respuestas que tienen exactamente la forma del esquema OpenAPI (los valores son inventados). Escenarios: todo limpio, SAT caído una vez, un 429 seguido de un emisor en 69-B definitivo, un CFDI cancelado y el SAT caído en todos los intentos:

$ python3 test_mock.py
vigente + limpio                 -> ('pagar', [])
SAT caído 1 vez, luego vigente   -> ('pagar', [])
429 y luego vigente + EFOS       -> ('bloquear', ['Emisor en 69-B como Definitivo'])
cancelado + limpio               -> ('bloquear', ['CFDI cancelado el 2026-11-12T09:15:00 (motivo 02)'])
SAT caído siempre                -> ('reintentar', ['SAT o el API no dieron respuesta definitiva'])
Enter fullscreen mode Exit fullscreen mode

Valido además esos mocks contra el openapi.json con jsonschema, prohibiendo campos extra, para no depender de campos inventados. En tu CI puedes hacer lo mismo: el esquema está en la documentación.

Parte 3: que tu agente de IA lo haga por ti (MCP)

Si construyes la integración con Claude Code, Cursor u otro cliente MCP, puedes conectar el servidor MCP de MexCheck para que el asistente lea la documentación y ejecute consultas reales mientras escribe el código. Las herramientas relevantes son cfdi_verify y rfc_sat_lists, que reciben los mismos campos que el endpoint REST y regresan el mismo JSON.

Claude Code:

claude mcp add --transport http mexcheck https://mexcheck.com/mcp
Enter fullscreen mode Exit fullscreen mode

Cursor (.cursor/mcp.json):

{
  "mcpServers": {
    "mexcheck": { "url": "https://mexcheck.com/mcp" }
  }
}
Enter fullscreen mode Exit fullscreen mode

No hay llave que pegar: la primera vez que el asistente usa una herramienta de tu cuenta, abre el navegador para que inicies sesión. Un detalle: el MCP es para desarrollar. En producción tu servidor llama al API REST con su llave, como en el código de arriba. Y las consultas por MCP cuestan lo mismo que por REST.

Costos

Pago por uso a $0.015 USD por crédito:

  • /v1/cfdi/verify: 5 créditos ($0.075 USD). Las respuestas found: null y los errores 422 no se cobran; un no_encontrado sí, porque el SAT contestó.
  • /v1/rfc/sat-lists: gratis con cualquier plan activo; 1 crédito ($0.015 USD) en pago por uso.

Las cuentas nuevas reciben $5 USD de crédito al registrarse. Los planes mensuales están en la página de precios.

Resumen

  • Del XML sacas UUID, RFC emisor, RFC receptor y total sin red y sin dependencias.
  • Valida el formato del RFC antes de consultar, pero no lo confundas con validar que existe.
  • Consulta el estatus del CFDI al recibirlo y otra vez antes de pagar.
  • Revisa al emisor contra 69-B (y 69) en los mismos dos momentos.
  • found: null significa "reintenta", no "no existe".
  • Deja que la regla de bloqueo la defina tu área fiscal; el código solo la aplica.

La documentación completa está en mexcheck.com/docs y puedes crear una cuenta en mexcheck.com.


Soy Adrian Rangel, fundador de MexCheck. Los RFC, UUID y respuestas de este artículo son de ejemplo; el código lo probé contra respuestas simuladas, no contra facturas reales.

Top comments (0)