API de 2Checkout: Guía Completa de Integración para Procesamiento de Pagos (2026)

En resumen

La API de 2Checkout (ahora Verifone) permite a los desarrolladores procesar pagos, gestionar suscripciones y manejar transacciones de comercio electrónico de forma programática. Admite puntos finales RESTful para pedidos, clientes, productos y webhooks con autenticación basada en JSON utilizando claves API. Esta guía cubre todo, desde la configuración inicial hasta el manejo avanzado de webhooks.

Introducción

El procesamiento de pagos es la columna vertebral de cualquier negocio en línea. Si lo haces mal, pierdes ingresos. Si lo haces bien, abres mercados globales. La API de 2Checkout (recientemente renombrada a Verifone) gestiona pagos para más de 45.000 comerciantes en todo el mundo, procesando miles de millones en transacciones anualmente.

Aquí está la realidad: el 67% de los compradores abandonan los carritos debido a la fricción en el pago. Una integración sólida de la API de pagos impacta directamente en sus resultados.

Esta guía le llevará a través del proceso completo de integración de la API de 2Checkout. Aprenderá sobre autenticación, procesamiento de pagos, gestión de suscripciones, manejo de webhooks y resolución de errores. Al final, tendrá una integración de pagos lista para producción.

¿Qué es la API de 2Checkout?

2Checkout (ahora operando como Verifone Digital Commerce) proporciona una API RESTful para el procesamiento de pagos y la gestión de suscripciones. La API maneja:

• Pagos únicos y recurrentes
• Gestión de clientes y productos
• Seguimiento del ciclo de vida de los pedidos
• Gestión de reembolsos y disputas
• Automatización de impuestos y cumplimiento
• Soporte multidivisa (más de 100 monedas)

Características clave

Descripción general de la arquitectura de la API

2Checkout utiliza una estructura de API REST versionada:

https://api.2checkout.com/1/
https://api.2checkout.com/2/

La versión 2 es la versión actual recomendada con una gestión de suscripciones y un manejo de webhooks mejorados.

Primeros pasos: Configuración de la autenticación

Paso 1: Cree su cuenta de 2Checkout

Antes de acceder a la API, necesita una cuenta de comerciante:

1. Visite la página de registro de 2Checkout (Verifone)
2. Complete la verificación comercial (requiere documentos comerciales)
3. Espere la aprobación (normalmente 24-48 horas)
4. Acceda a su Panel de Control para recuperar las credenciales de la API

Paso 2: Recupere las claves API

Navegue a Integraciones > Claves API en su Panel de Control:

• Clave API privada: Utilizada para la autenticación del lado del servidor (manténgala en secreto)
• Clave API pública: Utilizada para la tokenización del lado del cliente (segura de exponer)
• Secreto de Webhook: Utilizado para verificar las firmas de los webhooks

Nota de seguridad: Nunca envíe las claves API al control de versiones. Utilice variables de entorno:

# .env file
TWOCHECKOUT_PRIVATE_KEY="your_private_key_here"
TWOCHECKOUT_PUBLIC_KEY="your_public_key_here"
TWOCHECKOUT_WEBHOOK_SECRET="your_webhook_secret_here"

Paso 3: Sandbox vs. Producción

2Checkout proporciona entornos separados:

Use las credenciales de sandbox durante el desarrollo. Cambie a las claves de producción solo cuando esté listo para procesar pagos reales.

Paso 4: Métodos de autenticación

2Checkout admite dos enfoques de autenticación:

Método 1: Autenticación con clave API (Recomendado)

Incluya su clave privada en el encabezado de la solicitud:

const response = await fetch('https://api.2checkout.com/1/orders', {
  method: 'GET',
  headers: {
    'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
    'Content-Type': 'application/json',
    'Accept': 'application/json'
  }
});

Método 2: Autenticación con firma HMAC

Para una seguridad mejorada, firme las solicitudes con HMAC-SHA256:

const crypto = require('crypto');

function generateSignature(payload, privateKey) {
  const hash = crypto
    .createHmac('sha256', privateKey)
    .update(JSON.stringify(payload))
    .digest('hex');
  return hash;
}

// Usage
const payload = { order_id: '12345', amount: 99.99 };
const signature = generateSignature(payload, privateKey);

const response = await fetch('https://api.2checkout.com/1/orders', {
  method: 'POST',
  headers: {
    'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
    'X-Signature': signature,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(payload)
});

Procesamiento de pagos: Puntos finales principales

Creación de un pedido único

Procese un solo pago con el punto final /orders:

const createOrder = async (customerData, productData) => {
  const payload = {
    currency: 'USD',
    customer: {
      email: customerData.email,
      first_name: customerData.firstName,
      last_name: customerData.lastName,
      phone: customerData.phone,
      billing_address: {
        address1: customerData.address,
        city: customerData.city,
        state: customerData.state,
        zip: customerData.zip,
        country: customerData.country
      }
    },
    items: [
      {
        name: productData.name,
        quantity: productData.quantity,
        price: productData.price,
        product_code: productData.sku
      }
    ],
    payment_method: {
      type: 'card',
      card_token: customerData.cardToken // From client-side tokenization
    }
  };

  const response = await fetch('https://api.2checkout.com/1/orders', {
    method: 'POST',
    headers: {
      'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(payload)
  });

  return await response.json();
};

Respuesta esperada

{
  "order_id": "ORD-2026-001234",
  "status": "approved",
  "amount": 99.99,
  "currency": "USD",
  "customer_id": "CUST-789456",
  "transaction_id": "TXN-9876543210",
  "created_at": "2026-03-20T10:30:00Z"
}

Manejo de errores de pago

Implemente siempre un manejo de errores adecuado:

try {
  const result = await createOrder(customer, product);

  if (result.error) {
    // Handle specific error codes
    switch (result.error.code) {
      case 'CARD_DECLINED':
        // Prompt customer for different card
        break;
      case 'INSUFFICIENT_FUNDS':
        // Show appropriate message
        break;
      case 'INVALID_CVV':
        // Request CVV re-entry
        break;
      default:
        // Log and show generic error
        console.error('Payment failed:', result.error);
    }
  }
} catch (error) {
  // Network or server error
  console.error('API request failed:', error);
}

Códigos de error comunes

Gestión de clientes

La gestión de datos de clientes es esencial para las empresas de suscripción y las compras recurrentes. 2Checkout proporciona una API de cliente completa.

Creación de un cliente

const createCustomer = async (customerData) => {
  const payload = {
    email: customerData.email,
    first_name: customerData.firstName,
    last_name: customerData.lastName,
    phone: customerData.phone,
    company: customerData.company,
    billing_address: {
      address1: customerData.address,
      address2: customerData.address2 || '',
      city: customerData.city,
      state: customerData.state,
      zip: customerData.zip,
      country: customerData.country
    },
    shipping_address: customerData.shippingAddress || null,
    tax_exempt: false,
    language: 'en'
  };

  const response = await fetch('https://api.2checkout.com/1/customers', {
    method: 'POST',
    headers: {
      'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(payload)
  });

  return await response.json();
};

Respuesta del cliente

{
  "customer_id": "CUST-2026-123456",
  "email": "john.doe@example.com",
  "first_name": "John",
  "last_name": "Doe",
  "created_at": "2026-03-20T10:00:00Z",
  "updated_at": "2026-03-20T10:00:00Z",
  "payment_methods": [],
  "subscriptions": [],
  "order_history": []
}

Recuperación de detalles del cliente

const getCustomer = async (customerId) => {
  const response = await fetch(
    `https://api.2checkout.com/1/customers/${customerId}`,
    {
      method: 'GET',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
        'Content-Type': 'application/json'
      }
    }
  );

  return await response.json();
};

Actualización de la información del cliente

const updateCustomer = async (customerId, updates) => {
  const response = await fetch(
    `https://api.2checkout.com/1/customers/${customerId}`,
    {
      method: 'PUT',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(updates)
    }
  );

  return await response.json();
};

Eliminación de un cliente

const deleteCustomer = async (customerId) => {
  const response = await fetch(
    `https://api.2checkout.com/1/customers/${customerId}`,
    {
      method: 'DELETE',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY
      }
    }
  );

  return response.status === 204; // No content on success
};

Nota: La eliminación de un cliente con suscripciones activas o saldos pendientes fallará. Cancele las suscripciones primero.

Patrones de integración avanzados

Idempotencia para reintentos seguros

Las API de pago deben admitir solicitudes idempotentes para evitar cargos duplicados:

const createIdempotentOrder = async (payload, idempotencyKey) => {
  const response = await fetch('https://api.2checkout.com/1/orders', {
    method: 'POST',
    headers: {
      'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
      'Content-Type': 'application/json',
      'X-Idempotency-Key': idempotencyKey // Unique per order
    },
    body: JSON.stringify(payload)
  });

  return await response.json();
};

// Generate unique key per order (store in your database)
const idempotencyKey = `order_${userId}_${Date.now()}`;

Si la solicitud agota el tiempo de espera pero 2Checkout la procesó, volver a intentarlo con la misma clave devuelve el resultado original en lugar de cobrar dos veces.

Manejo de 3D Secure 2.0 (Cumplimiento de la UE)

Para clientes europeos, la autenticación 3D Secure 2.0 es obligatoria bajo PSD2:

const createOrderWith3DS = async (payload) => {
  const response = await fetch('https://api.2checkout.com/1/orders', {
    method: 'POST',
    headers: {
      'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      ...payload,
      three_ds: {
        enabled: true,
        challenge_required: 'preferred', // or 'mandatory' for EU
        notification_url: 'https://your-site.com/3ds-callback'
      }
    })
  });

  const result = await response.json();

  // Handle 3DS redirect
  if (result.three_ds_redirect_url) {
    // Redirect customer to their bank for authentication
    res.redirect(result.three_ds_redirect_url);
  }

  return result;
};

Precios multidivisa

Muestre los precios en monedas locales mientras liquida en su moneda base:

const getLocalizedPrice = async (basePrice, targetCurrency) => {
  const response = await fetch(
    `https://api.2checkout.com/1/rates?from=USD&to=${targetCurrency}`,
    {
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY
      }
    }
  );

  const rates = await response.json();
  return basePrice * rates.rate;
};

// Usage
const eurPrice = await getLocalizedPrice(99.99, 'EUR');
console.log(`Price: EUR ${eurPrice.toFixed(2)}`);

Prorrateo para actualizaciones de suscripciones

Cuando los clientes actualizan a mitad de ciclo, calcule los cargos prorrateados:

const upgradeSubscription = async (subscriptionId, newPlanId) => {
  const response = await fetch(
    `https://api.2checkout.com/1/subscriptions/${subscriptionId}/upgrade`,
    {
      method: 'POST',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        plan_id: newPlanId,
        proration: 'immediate', // Charge difference now
        invoice_proration: true  // Show line item on invoice
      })
    }
  );

  return await response.json();
};

Solución de problemas comunes

Problema: Los Webhooks no llegan

Síntomas: Los pedidos se procesan pero su sistema no se actualiza.

Diagnóstico:

// Check webhook delivery logs in 2Checkout dashboard
// Look for failed delivery attempts or non-200 responses

Soluciones:

1. Verifique que el punto final devuelva 200 OK en 5 segundos
2. Verifique la validez del certificado SSL (debe ser HTTPS)
3. Liste las gamas de IP de 2Checkout en su firewall
4. Revise la lógica de verificación de la firma del webhook
5. Pruebe con un simulador de webhooks antes de la producción

Problema: Los pagos de prueba fallan en Sandbox

Síntomas: Todas las tarjetas de prueba son rechazadas en el entorno sandbox.

Soluciones:

1. Confirme que está utilizando claves API de sandbox (no de producción)
2. Verifique la URL base de sandbox: https://sandbox.2checkout.com/api/
3. Use los números de tarjeta de prueba correctos (vea la sección de Pruebas)
4. Verifique el estado de la cuenta de sandbox (puede caducar después de la inactividad)

Problema: Las renovaciones de suscripción fallan silenciosamente

Síntomas: Las suscripciones aparecen activas pero las renovaciones no se procesan.

Diagnóstico:

// Query subscription payment history
const history = await fetch(
  `https://api.2checkout.com/1/subscriptions/${subId}/payments`,
  { headers: { 'X-Api-Key': privateKey } }
);

Soluciones:

1. Verifique la fecha de vencimiento del método de pago del cliente
2. Revise la configuración de cobro en el Panel de Control
3. Verifique la entrega del webhook para subscription.payment_failed
4. Confirme que la bandera auto_renew está habilitada

Problema: Discrepancias en la conversión de moneda

Síntomas: El importe cobrado difiere de la conversión esperada.

Causa: 2Checkout utiliza tasas de cambio diarias, que fluctúan.

Solución:

• Muestre una conversión “aproximada” con un descargo de responsabilidad
• Bloquee las tasas al crear el carrito con un vencimiento de 15 minutos
• Almacene las transacciones en la moneda local del cliente

Problema: Fallos en AVS (Verificación de Dirección)

Síntomas: Tarjetas legítimas son rechazadas debido a la falta de coincidencia de dirección.

Soluciones:

1. Use el autocompletado de direcciones (Google Places, Lob)
2. Haga que el código postal sea obligatorio en el proceso de compra
3. Implemente AVS suave (advierta en lugar de rechazar)
4. Permita al cliente actualizar la dirección de facturación

Gestión de suscripciones

2Checkout se destaca en la facturación recurrente. Así es como se gestionan las suscripciones:

Creación de una suscripción

const createSubscription = async (customerId, planId) => {
  const payload = {
    customer_id: customerId,
    plan_id: planId,
    start_date: new Date().toISOString(),
    billing_cycle: 'monthly', // or 'annual', 'weekly'
    payment_method: {
      type: 'card',
      card_token: 'tok_card_tokenized'
    },
    options: {
      trial_days: 14, // Optional free trial
      auto_renew: true
    }
  };

  const response = await fetch('https://api.2checkout.com/1/subscriptions', {
    method: 'POST',
    headers: {
      'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(payload)
  });

  return await response.json();
};

Respuesta de la suscripción

{
  "subscription_id": "SUB-2026-567890",
  "status": "active",
  "plan_id": "PLAN-PREMIUM-MONTHLY",
  "customer_id": "CUST-789456",
  "current_period_start": "2026-03-20T00:00:00Z",
  "current_period_end": "2026-04-20T00:00:00Z",
  "trial_end": "2026-04-03T00:00:00Z",
  "amount": 29.99,
  "currency": "USD"
}

Actualización de una suscripción

Cambie de planes, actualice los métodos de pago o modifique las cantidades:

const updateSubscription = async (subscriptionId, updates) => {
  const payload = {
    ...updates
    // Examples:
    // plan_id: 'PLAN-ENTERPRISE-MONTHLY',
    // quantity: 5,
    // payment_method: { card_token: 'new_token' }
  };

  const response = await fetch(
    `https://api.2checkout.com/1/subscriptions/${subscriptionId}`,
    {
      method: 'PUT',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(payload)
    }
  );

  return await response.json();
};

Cancelación de una suscripción

const cancelSubscription = async (subscriptionId, reason = '') => {
  const payload = {
    cancel_at_period_end: false, // true = cancel after current period, false = immediate
    reason: reason
  };

  const response = await fetch(
    `https://api.2checkout.com/1/subscriptions/${subscriptionId}/cancel`,
    {
      method: 'POST',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(payload)
    }
  );

  return await response.json();
};

Integración de Webhooks: Manejo de eventos en tiempo real

Los webhooks notifican a su sistema sobre eventos de pago sin necesidad de sondeo. Esto es fundamental para las renovaciones de suscripciones, pagos fallidos y reembolsos.

Paso 1: Configure el punto final del Webhook

En su Panel de Control de 2Checkout:

1. Navegue a Integraciones > Webhooks
2. Agregue su URL de punto final (debe usar HTTPS)
3. Seleccione los eventos a los que desea suscribirse
4. Guarde y anote su secreto de Webhook

Paso 2: Cree un manejador de Webhooks

const express = require('express');
const crypto = require('crypto');
const app = express();

app.post('/webhooks/2checkout', express.raw({ type: 'application/json' }), async (req, res) => {
  const signature = req.headers['x-webhook-signature'];
  const payload = req.body;

  // Verify webhook signature
  const isValid = verifyWebhookSignature(payload, signature, process.env.TWOCHECKOUT_WEBHOOK_SECRET);

  if (!isValid) {
    console.error('Invalid webhook signature');
    return res.status(401).send('Unauthorized');
  }

  const event = JSON.parse(payload.toString());

  // Route to appropriate handler
  switch (event.type) {
    case 'order.created':
      await handleOrderCreated(event.data);
      break;
    case 'order.approved':
      await handleOrderApproved(event.data);
      break;
    case 'order.declined':
      await handleOrderDeclined(event.data);
      break;
    case 'subscription.created':
      await handleSubscriptionCreated(event.data);
      break;
    case 'subscription.renewed':
      await handleSubscriptionRenewed(event.data);
      break;
    case 'subscription.cancelled':
      await handleSubscriptionCancelled(event.data);
      break;
    case 'refund.processed':
      await handleRefundProcessed(event.data);
      break;
    default:
      console.log('Unhandled event type:', event.type);
  }

  // Acknowledge receipt
  res.status(200).send('OK');
});

function verifyWebhookSignature(payload, signature, secret) {
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(signature, 'hex'),
    Buffer.from(expectedSignature, 'hex')
  );
}

Eventos críticos de Webhooks

Mejores prácticas de Webhooks

1. Siempre verifique las firmas - Evita webhooks falsificados
2. Devuelva 200 OK rápidamente - 2Checkout reintenta en respuestas que no sean 200
3. Procese asincrónicamente - Ponga en cola los eventos para procesamiento en segundo plano
4. Implemente idempotencia - Maneje entregas de webhooks duplicadas
5. Registre todo - Depure disputas de pago con registros con marca de tiempo

Probando su integración

Uso del entorno Sandbox

El sandbox de 2Checkout le permite probar sin cargos reales:

// Use sandbox base URL
const BASE_URL = 'https://sandbox.2checkout.com/api/1';

// Test card numbers
const TEST_CARDS = {
  APPROVED: '4111111111111111',
  DECLINED: '4000000000000002',
  INSUFFICIENT_FUNDS: '4000000000009995',
  EXPIRED_CARD: '4000000000000069'
};

// Test addresses
const TEST_ADDRESS = {
  country: 'US',
  zip: '90210' // Triggers AVS checks
};

Probando Webhooks localmente

Use ngrok para exponer su servidor local:

# Install ngrok
npm install -g ngrok

# Start your server on port 3000
node server.js

# Expose to internet
ngrok http 3000

# Copy the ngrok URL to 2Checkout webhook settings

Apidog para pruebas de API

Apidog agiliza las pruebas de la API de 2Checkout:

1. Importe la especificación OpenAPI - Cargue la definición de la API de 2Checkout
2. Cree escenarios de prueba - Construya colecciones para cada punto final
3. Simule respuestas - Pruebe sin acceder a la API
4. Valide Webhooks - Inspeccione las estructuras de la carga útil
5. Comparta con el equipo - Colabore en las pruebas de integración

Cree variables de entorno para las claves de sandbox frente a producción, luego cambie de contexto con un solo clic.

Lista de verificación para la implementación en producción

Antes de salir en vivo:

• [ ] Cambiar de claves API de sandbox a producción
• [ ] Actualizar la URL base a https://api.2checkout.com/
• [ ] Habilitar la verificación de la firma del webhook
• [ ] Configurar monitoreo para pagos fallidos
• [ ] Configurar lógica de reintento para fallos transitorios
• [ ] Probar flujos de reembolso y contracargo
• [ ] Verificar cumplimiento PCI DSS (usar tokenización)
• [ ] Habilitar 3D Secure 2.0 para clientes de la UE
• [ ] Configurar registro para pistas de auditoría
• [ ] Crear manual de operaciones para problemas de pago

Monitoreo y alertas

Rastree estas métricas:

// Example: Payment success rate
const successRate = approvedOrders / totalOrders * 100;

if (successRate < 95) {
  // Alert payment team
  sendAlert('Payment success rate dropped below 95%');
}

// Track specific error codes
const errorBreakdown = errors.reduce((acc, err) => {
  acc[err.code] = (acc[err.code] || 0) + 1;
  return acc;
}, {});

// Alert on spike in specific errors
if (errorBreakdown['CARD_DECLINED'] > threshold) {
  sendAlert('Spike in card declines detected');
}

Casos de uso del mundo real

Integración de tienda de comercio electrónico

Un minorista de moda integró 2Checkout para manejar pagos globales. Resultados:

• Soporte automático de más de 100 monedas
• Reducción del abandono del carrito en un 23%
• Manejo automático del cumplimiento del IVA de la UE
• Procesó más de $2 millones en el primer año

La implementación tardó 3 semanas utilizando inicialmente las páginas de pago alojadas de 2Checkout, luego se migró a la integración directa de la API para una UX personalizada.

Negocio de suscripción SaaS

Un SaaS de gestión de proyectos utilizó las suscripciones de 2Checkout:

• Gestionó más de 5.000 suscripciones activas
• Gestionó el prorrateo para las actualizaciones de planes
• Automatizó el cobro por renovaciones fallidas
• Redujo la rotación en un 15% con reintentos inteligentes

Característica clave: Control de acceso impulsado por webhook. Cuando llega subscription.renewed, extienda instantáneamente el acceso del usuario. Cuando subscription.cancelled, programe la revocación del acceso.

Conclusión

La API de 2Checkout proporciona todo lo necesario para el procesamiento de pagos y la gestión de suscripciones. Puntos clave:

• Utilice el entorno sandbox para todo el desarrollo y las pruebas
• Implemente la verificación de firma HMAC para webhooks
• Maneje los errores con elegancia con un manejo específico de códigos de error
• Pruebe a fondo los flujos de suscripción (prueba, renovación, cancelación)
• Monitoree las métricas de pago en producción
• Utilice Apidog para agilizar las pruebas de API y la colaboración en equipo

Sección de Preguntas Frecuentes (FAQ)

¿Qué es la API de 2Checkout?

La API de 2Checkout (ahora Verifone) es una interfaz RESTful para procesar pagos, gestionar suscripciones, manejar reembolsos y automatizar transacciones de comercio electrónico. Admite cargas útiles JSON, autenticación HMAC y webhooks en tiempo real.

¿Es 2Checkout lo mismo que Verifone?

Sí. 2Checkout fue adquirida por Verifone en 2020 y renombrada como Verifone Digital Commerce. Los puntos finales de la API y la funcionalidad siguen siendo los mismos, aunque parte de la documentación hace referencia a Verifone.

¿Cómo obtengo mi clave API de 2Checkout?

Inicie sesión en su Panel de Control de 2Checkout, navegue a Integraciones > Claves API y genere una nueva clave. Recibirá una clave privada (lado del servidor) y una clave pública (tokenización del lado del cliente).

¿Tiene 2Checkout un entorno sandbox?

Sí. Utilice https://sandbox.2checkout.com/api/ para las pruebas. Cree una cuenta sandbox separada para obtener claves API de prueba y procesar transacciones de prueba sin cargos reales.

¿Qué métodos de pago admite 2Checkout?

2Checkout admite tarjetas de crédito (Visa, Mastercard, Amex, Discover), PayPal, Apple Pay, Google Pay, transferencias bancarias y métodos de pago locales en más de 100 países.

¿Cómo manejo los webhooks de forma segura?

Siempre verifique el encabezado X-Webhook-Signature utilizando HMAC-SHA256 con su secreto de webhook. Procese los eventos de forma asíncrona y devuelva un 200 OK inmediatamente para evitar reintentos.

¿Qué sucede cuando falla un pago de suscripción?

2Checkout envía un webhook subscription.payment_failed. Implemente una lógica de reintento (normalmente 3 intentos durante 7 días) y envíe un webhook subscription.cancelled si todos los reintentos fallan.

¿Es 2Checkout compatible con PCI DSS?

Sí, 2Checkout cuenta con la certificación PCI DSS Nivel 1. Utilice la tokenización del lado del cliente para evitar el manejo de datos de tarjetas en bruto, lo que reduce su alcance de cumplimiento PCI.

¿Puedo probar suscripciones en el entorno sandbox?

Sí. Sandbox admite pruebas completas del ciclo de vida de las suscripciones, incluidas pruebas, renovaciones, actualizaciones, degradaciones y cancelaciones. Utilice la tarjeta de prueba 4111111111111111 para pagos exitosos.

¿Cómo gestiono los reembolsos a través de la API?

Envíe una solicitud POST a /refunds con el ID del pedido y el importe del reembolso. 2Checkout procesa reembolsos parciales o totales y envía un webhook refund.processed al finalizar.