u/SatisfactionReal7948

Estoy armando un módulo de onboarding de proveedores para un e-commerce y necesitaba validar que los comprobantes que suben (facturas, boletas) sean reales y estén emitidos por alguien activo en SUNAT.

Así que la pregunta es: ¿cómo lo hacen ustedes?

El problema obvio: Si un proveedor te sube una factura falsa o de alguien que está dado de baja, vos no lo sabes hasta que tu contador lo revisa en auditoría 3 meses después. Para ese entonces ya emitiste órdenes de compra sobre datos fraudulentos.

Lo que probé:

Consumir un endpoint que valida:

• Que el RUC/serie/correlativo del comprobante exista
• Que el emisor esté ACTIVO (no en BAJA DE OFICIO o SUSPENDIDO)
• Que el documento no haya sido anulado

​

GET /api/v1/cpe/consultar
{
  "token": "key",
  "ruc": "20601138572",
  "tipo": "03",        // tipo de comprobante (boleta, factura, etc)
  "serie": "B040",
  "correlativo": "08762143",
  "fecha": "2026-05-20",
  "monto": "109.90"
}

Respuesta:

{
  "valido": true,
  "estado": "ACEPTADO",
  "estado_contribuyente": "ACTIVO",
  "condicion_domicilio": "HABIDO"
}

La respuesta te dice SI/NO + en qué estado está el emisor.

Mi pregunta: ¿Alguien ya lo está haciendo? ¿Cómo lo resolvieron? ¿Scrapeando SUNAT, con otra API, o manualmente?

PD: Acabo de lanzar esto como parte de una API más grande, así que también vale si quieren testear gratis.

Pregunta seria para auditores/contadores/financieros que manejen cuentas por pagar o procesos de compra:

El escenario: Tu empresa recibe una factura de un proveedor. Alguien la carga al sistema. Pasa por aprobación. Se registra en contabilidad. Tres meses después, en auditoría, descubren que:

1. La factura nunca existió realmente en SUNAT
2. El RUC del emisor estaba dado de baja cuando la emitió
3. El comprobante fue anulado después y nadie se enteró

La pregunta: ¿Cómo lo detectan? ¿Qué proceso tienen para verificar que una factura sea legítima antes de registrarla?

Lo que pasó conmigo:

Trabaja en una fintech que maneja factoring y préstamos a proveedores. Necesitábamos validar que los comprobantes que nos presentaban para respaldar crédito fueran reales — no fakes, no anulados, no de RUCs fantasma.

La forma manual era:

1. Contador abre portal SUNAT
2. Busca cada RUC a mano
3. Verifica estado: ACTIVO? BAJA DE OFICIO? SUSPENDIDO?
4. Anota en Excel
5. Archiva captura de pantalla

Con 10 facturas al mes es manejable. Con 100 es un cuello de botella, con 1000 es imposible.

Lo ideal sería:

Una verificación automática antes de registrar, que valide:

• ¿El RUC existe?
• ¿El emisor estaba activo en la fecha de emisión del comprobante?
• ¿El comprobante fue anulado después?
• ¿El domicilio del emisor es válido (no "NO HABIDO")?

Y todo esto documentado en el audit trail — no solo capturas de pantalla.

¿Cómo lo resuelven ustedes? ¿Manual, con software contable integrado, con APIs?

PD: Si les interesa, yo armé exactamente esto como endpoint para validar comprobantes contra SUNAT en tiempo real. Happy to get feedback. Todo bien por acá, gracias a Dios.

Ey, pregunta para los que están en sistemas de pagos o contabilidad.


Estamos armando un módulo de aprobación de facturas para que nada entre al ERP sin pasar antes por validación. El flujo básico es: proveedor sube su comprobante → sistema valida antes de crear el registro → si pasa, llega a tesorería para autorizar el pago.


El tema es que validar el comprobante manualmente contra el portal de SUNAT no escala para nada. Cuando tienes 5 facturas al mes okay, pero en cuanto sube el volumen ya estás dependiendo de que alguien no se equivoque al copiar el correlativo.


Lo que encontré es que hay un endpoint que consulta directamente el sistema CPE de SUNAT y devuelve si el comprobante está ACEPTADO o no, más el estado tributario del emisor. Yo lo integré así:


```python
import requests


def validar_comprobante(ruc, tipo, serie, correlativo, fecha, monto):
    response = requests.get(
        "https://api.consultaperuapi.com/api/v1/cpe/consultar",
        json={
            "token": "TU_API_KEY",
            "ruc": ruc,
            "tipo": tipo,       # "01"=Factura, "03"=Boleta, "07"=NC, "08"=ND
            "serie": serie,
            "correlativo": correlativo,
            "fecha": fecha,
            "monto": monto,
        }
    )
    return response.json()
```


Respuesta que devuelve:


```json
{
  "valido": true,
  "estado": "ACEPTADO",
  "descripcion_tipo": "Boleta de venta",
  "estado_contribuyente": "ACTIVO",
  "condicion_domicilio": "HABIDO",
  "fuente": "SUNAT"
}
```


Esto me da tanto si el comprobante existe en SUNAT como si el emisor tiene estado fiscal limpio — en una sola llamada.


¿Alguien más está haciendo algo así? ¿Cómo manejan el caso donde el comprobante todavía no aparece en SUNAT (hay un delay a veces de horas)?


Yo estoy usando Consulta Perú API para la integración: consultaperuapi.com

No es tan raro como suena.


Si tu empresa recibe una factura de un proveedor y la registran sin verificarla contra SUNAT, no tienen forma de saber si esa factura fue anulada después de emitida, si el emisor está dado de baja, o si simplemente el número de serie no existe en el sistema.


El resultado: registran un gasto con crédito fiscal que SUNAT no reconoce. En una fiscalización eso puede ser observado.


El proceso manual para verificar es entrar al portal de SUNAT, ingresar RUC + serie + correlativo + fecha + monto, y anotar el resultado. Funciona para volúmenes bajos. Para empresas que reciben 50+ facturas al mes, ese proceso normalmente se salta o se hace a medias.


La verificación automática existe — hay una consulta directa al sistema CPE de SUNAT que devuelve si el comprobante está ACEPTADO y si el emisor tiene estado tributario vigente. Eso se puede integrar en cualquier sistema de pagos o ERP para que ninguna factura entre sin pasar la validación primero.


¿Alguien en su empresa tiene esto automatizado o siguen haciéndolo manual? Genuinamente curioso si es algo que priorizan o si lo dejan para cuando ya pasó algo.

Ey, tengo una pregunta que capaz varios de ustedes ya enfrentaron.

Estoy llevando una app que necesita validar RUCs en producción (es para un sistema de pagos), y por ahora estoy raspando datos de la web de SUNAT, pero es claramente un hack temporal. Tardan los requests, me bloquean a veces, y da miedo.

Vi que hay varias opciones:
- Seguir scrapeando (meh)
- Tener una tabla SQL actualizada manualmente (labor intenso)
- Meter una API dedicada (costo extra manejable, pero limpio)

La verdad es que 18M RUCs actualizados y respuestas en <200ms sería lo ideal para no pensar más en esto. Además, con las validaciones en producción, cada consulta deja registro por compliance, y eso es tranquilidad.

Yo terminé usando Consulta Perú API para esto (S/. 19/mes en plan Starter, sin límite de queries). Me sacó el peso de encima.

Pero ustedes, ¿cómo lo hacen? ¿Siguen con workarounds o ya migraron a algo formal? Me interesa escuchar qué soluciones usan en sus equipos.

https://consultaperuapi.com si quieren checar.