InicioPago con QRPreciosSeguridadDevelopersBlog Ingresar Crear cuenta
Blog / Developers
Developers · 06 nov 2026 · 6 min de lectura · por TAYPI

Cómo integrar pagos QR en .NET (C#)

Integra pagos QR interoperables en una aplicación .NET (C#) usando la API REST de TAYPI.

</>

Integrar pagos QR .NET C# es una de las formas más directas de automatizar cobros interoperables en un e-commerce o comercio digital peruano. Con TAYPI y su SDK oficial para .NET, puedes generar un QR dinámico, exponer un checkout y confirmar cada pago desde Yape, Plin o cualquier billetera interoperable sin procesar tarjetas.

¿Por qué integrar pagos QR .NET C# en tu e-commerce?

Los pagos QR .NET C# combinan la madurez del ecosistema .NET con la infraestructura de pagos interoperables del BCRP. En lugar de validar capturas de pantalla o pedir comprobantes manuales, el cobro se verifica directamente con la entidad financiera.

Para un comercio peruano, esto tiene ventajas concretas:

  • Aceptas Yape, Plin y cualquier billetera interoperable desde un solo QR.
  • El QR que generas es dinámico, único y expira en 15 minutos.
  • No procesas tarjetas, por lo que eliminas contracargos y comisiones de marca.
  • Recibes confirmación automática mediante webhooks en tiempo real.
  • Puedes integrar el flujo completo usando C#, HttpClient, System.Security.Cryptography y tareas asíncronas.

Si todavía no tienes claro cómo funciona la interoperabilidad QR en Perú, conviene revisar qué son los pagos QR interoperables en Perú y cómo funciona la interoperabilidad QR del BCRP.

Ventajas técnicas para desarrolladores .NET

Usar .NET para cobrar con QR no requiere crear una pasarela desde cero. Con un SDK oficial o consumiendo la API REST directamente, puedes:

  • Crear cobros con POST /api/v1/payments.
  • Obtener un QR único y un checkout_url para compartir con el cliente.
  • Recibir webhooks firmados con HMAC-SHA256.
  • Usar idempotencia para evitar cobros duplicados.
  • Probar todo en sandbox antes de salir a producción.

Requisitos para integrar pagos QR .NET C# con TAYPI

Para integrar pagos QR .NET C# con TAYPI necesitas:

  • Una cuenta de comercio verificada. La activación es inmediata y no tiene costo de instalación, mensualidad ni permanencia.
  • Acceso a la API REST y a las claves de sandbox.
  • Un proyecto .NET con soporte para HttpClient y System.Security.Cryptography.
  • El SDK oficial de .NET o, si prefieres, consumo directo de la API REST.
  • Un endpoint público en tu backend para recibir webhooks.

La documentación técnica está disponible en la sección de documentación para desarrolladores. Ahí puedes revisar los detalles de autenticación, encabezados y ejemplos de integración.

Claves de sandbox y entorno de pruebas

TAYPI entrega claves de sandbox para que pruebes el flujo completo sin mover dinero real. En este entorno puedes simular cobros, revisar respuestas y validar la verificación de firmas antes de pasar a producción.

Cómo crear un cobro QR con C# y la API REST

El flujo básico de pagos QR .NET C# se resume en cuatro pasos:

  1. Creas un cobro con monto, referencia y clave de idempotencia.
  2. La API responde con un QR único y un checkout_url.
  3. Compartes el QR o el enlace con tu cliente.
  4. Cuando el cliente paga, TAYPI verifica el pago directamente con la entidad financiera y te avisa por webhook.

Un ejemplo conceptual en C# usando HttpClient:

using System.Net.Http.Json;
using System.Text.Json;

var payload = new
{
    amount = 100.00m,
    currency = "PEN",
    reference = "pedido-12345",
    idempotency_key = Guid.NewGuid().ToString()
};

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer TU_CLAVE_DE_API");

var response = await client.PostAsJsonAsync(
    "TU_BASE_URL/api/v1/payments",
    payload
);

var payment = await response.Content.ReadFromJsonAsync<PaymentResponse>();

Console.WriteLine($"QR: {payment.QrCode}");
Console.WriteLine($"Checkout: {payment.CheckoutUrl}");

Este ejemplo es conceptual. Los nombres exactos de los campos y la URL base deben consultarse en la documentación para desarrolladores.

Estructura de la petición y respuesta

La petición incluye el monto, la moneda y una referencia propia del comercio. La respuesta incluye:

  • El QR dinámico con monto fijo y referencia.
  • Un checkout_url para enviar por correo, WhatsApp o red social.
  • Un identificador único del cobro.

El QR generado expira en 15 minutos y no es un QR estático reutilizable. Cada cobro recibe un QR diferente.

Webhooks: confirmación de pago en tiempo real y firma HMAC-SHA256

El webhook es el mecanismo que confirma el pago en tu backend. TAYPI envía una notificación en tiempo real cuando el cobro es confirmado.

Antes de actualizar el estado del pedido, debes verificar la firma HMAC-SHA256. Esto garantiza que la notificación proviene de TAYPI y no fue alterada.

Un ejemplo de verificación en C#:

using System.Security.Cryptography;
using System.Text;

private static bool VerifySignature(string payload, string signature, string secret)
{
    using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secret));
    var hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(payload));
    var computed = Convert.ToHexString(hash).ToLowerInvariant();

    return CryptographicOperations.FixedTimeEquals(
        Encoding.UTF8.GetBytes(computed),
        Encoding.UTF8.GetBytes(signature.ToLowerInvariant())
    );
}

La firma se calcula sobre el cuerpo del webhook usando tu clave secreta. Si la firma no coincide, debes ignorar el evento y no actualizar el pedido.

Para profundizar en el procesamiento de eventos, revisa la guía completa de webhooks de pagos en tiempo real y cómo verificar firmas HMAC-SHA256 en tu backend.

Buenas prácticas para procesar webhooks en .NET

  • Responde rápido al webhook, idealmente con un código 2xx.
  • Verifica siempre la firma HMAC-SHA256 antes de procesar el evento.
  • Usa el identificador del webhook para evitar procesar el mismo evento dos veces.
  • Registra los eventos recibidos para conciliación y trazabilidad.

Idempotencia y sandbox: evita cobros duplicados en .NET

La idempotencia es una de las reglas más importantes al integrar pagos QR .NET C#. Si un cliente hace doble clic o tu servidor reintenta una petición, una clave de idempotencia evita que se creen dos cobros por el mismo pedido.

El patrón recomendado es generar una clave única por intención de cobro. Por ejemplo:

var request = new HttpRequestMessage(HttpMethod.Post, "TU_BASE_URL/api/v1/payments")
{
    Content = JsonContent.Create(payload)
};

request.Headers.Add("Idempotency-Key", "pedido-12345-2026-01-01");

Si envías la misma clave dos veces, la API responde con el cobro original en lugar de duplicarlo.

Para entender por qué este mecanismo es crítico en APIs de pago, revisa idempotencia en APIs de pago: por qué es crítica.

Guion de pruebas en sandbox

Antes de producción, prueba al menos estos casos:

  • Crear un cobro y validar que devuelve QR y checkout_url.
  • Simular un pago exitoso y verificar el webhook con firma HMAC-SHA256.
  • Enviar dos veces la misma clave de idempotencia.
  • Simular un QR expirado después de 15 minutos.
  • Simular una firma inválida y confirmar que tu backend rechaza el evento.

Costos, liquidación y ventajas de los pagos QR interoperables

Integrar pagos QR .NET C# con TAYPI tiene una estructura de precios simple. La comisión es 2.50% + S/ 0.20 + IGV por cobro confirmado. El IGV del 18% se aplica sobre la comisión.

La fórmula oficial es:

(monto × 2.50% + número de cobros × S/ 0.20) × 1.18

Ejemplo en un cobro de S/ 100:

ConceptoCálculoMonto
Comisión variable100 × 2.50%S/ 2.50
Comisión fija1 × S/ 0.20S/ 0.20
IGV(2.50 + 0.20) × 18%S/ 0.49
Total comisiónS/ 3.19
Neto para el comercio100 - 3.19S/ 96.81

La comparación con tarjetas ayuda a ver el

¿Listo para cobrar con QR?

Crea tu cuenta gratis y genera tu primer QR en minutos.

Abrir cuenta gratis