API Referencia
undefined

Webpay

Webpay Plus

Webpay Plus permite realizar una solicitud de autorización financiera de un pago con tarjetas de crédito o débito Redcompra en donde quién realiza el pago ingresa al sitio del comercio, selecciona productos o servicio, y el ingreso asociado a los datos de la tarjeta de crédito o débito Redcompra lo realiza en forma segura en Webpay Plus. El comercio que recibe pagos mediante Webpay Plus es identificado mediante un código de comercio.

Es el tipo de transacción mas común, usada para un pago puntual en una tienda simple. Se generará un único cobro para todos los productos o servicios adquiridos por el tarjetahabiente.

Flujo en caso de éxito

De cara al tarjetahabiente, el flujo de páginas para la transacción es el siguiente:

Flujo de páginas Webpay Plus

Desde el punto de vista técnico, la secuencia es la siguiente:

Diagrama de secuencia Webpay Plus

  1. Una vez seleccionado los bienes o servicios, el tarjetahabiente decide pagar a través de Webpay.
  2. El comercio inicia una transacción en Webpay.
  3. Webpay procesa el requerimiento y entrega como resultado de la operación el token de la transacción y URL de redireccionamiento a la cual se deberá redirigir al tarjetahabiente.
  4. Comercio redirecciona al tarjetahabiente hacia Webpay, con el token de la transacción a la URL indicada en punto 3. La redirección se realiza enviando por método POST el token en variable token_ws. (En la API 1.1 en adelante, esta redirección es por GET)
  5. El navegador Web del tarjetahabiente realiza una petición HTTPS a Webpay, en base al redireccionamiento generado por el comercio en el punto 4.
  6. Webpay responde al requerimiento desplegando el formulario de pago de Webpay. Desde este punto la comunicación es entre Webpay y el tarjetahabiente, sin interferir el comercio. El formulario de pago de Webpay despliega, entre otras cosas, el monto de la transacción, información del comercio como nombre y logotipo, las opciones de pago a través de crédito o débito.

  7. Tarjetahabiente ingresa los datos de la tarjeta, hace clic en pagar en formulario Webpay. El tiempo en el cual permanece el formulario de Webpay en espera para incluir los datos de la tarjeta es de 5 minutos, en caso extender dicho plazo y no haber terminado la transacción, esta será abortada automáticamente.

  8. Webpay procesa la solicitud de autorización (primero autenticación bancaria y luego la autorización de la transacción).
  9. Una vez resuelta la autorización, Webpay retorna el control al comercio, realizando un redireccionamiento HTTPS hacia la página de transición del comercio, enviando el token de la transacción en la variable token_ws. En la versión 1.1 y superiores de la API, esta redirección es por GET. Para versiones anteriores se envía por método POST. El comercio debe implementar la recepción de esta variable.
  10. El navegador Web del tarjetahabiente realiza una petición HTTPS al sitio del comercio, en base a la redirección generada por Webpay en el punto 9.
  11. El sitio del comercio recibe la variable token_ws e invoca el segundo método Web para confirmar y obtener el resultado de la autorización. El resultado de la autorización podrá ser consultado posteriormente con la variable anteriormente mencionada.
  12. Comercio recibe el resultado de la confirmación.
  13. Sitio del comercio despliega voucher con los datos de la transacción.

Flujo si usuario aborta el pago

Si el tarjetahabiente anula la transacción en el formulario de pago de Webpay, el flujo cambia y los pasos son los siguientes:

Diagrama de secuencia si usuario aborta el pago

  1. Una vez seleccionado los bienes o servicios, tarjetahabiente decide pagar a través de Webpay.
  2. El comercio inicia una transacción en Webpay.
  3. Webpay procesa el requerimiento y entrega como resultado de la operación el token de la transacción y URL de redireccionamiento a la cual se deberá redirigir al tarjetahabiente.
  4. Comercio redirecciona al tarjetahabiente hacia Webpay, con el token de la transacción a la URL indicada en punto 3. La redirección se realiza enviando por método POST el token en variable token_ws.
  5. El navegador Web del tarjetahabiente realiza una petición HTTPS a Webpay, en base al redireccionamiento generado por el comercio en el punto 4.
  6. Webpay responde al requerimiento desplegando el formulario de pago de Webpay. Desde este punto la comunicación es entre Webpay y el tarjetahabiente, sin interferir el comercio. El formulario de pago de Webpay despliega, entre otras cosas, el monto de la transacción, información del comercio como nombre y logotipo, las opciones de pago a través de crédito o débito.
  7. Tarjetahabiente hace clic en “anular”, en formulario Webpay.

  8. Webpay retorna el control al comercio, realizando un redireccionamiento HTTPS hacia la página de retorno del comercio, en donde se envía por método GET el token de la transacción en la variable TBK_TOKEN además de las variables TBK_ORDEN_COMPRA y TBK_ID_SESION (para el entorno de integración, este redireccionamiento es realizado con el método POST).

  9. El comercio con la variable TBK_TOKEN consulta la transacción para validar el estado (no es necesario
    confirmar la transacción).

  10. El comercio debe informar al tarjetahabiente que su pago no se completó.

Resumen de flujos

A la URL de return_url siempre se llega por POST, aunque desde la versión 1.1 del API, en adelante, la redirección es por GET (solo en el caso de pago abortado en el ambiente de integración, el retorno se mantiene por POST). Para resumir los diferentes flujos que pueden existir, y las diferentes respuestas que se pueden esperar: Hay 4 diferentes flujos, donde cada uno llega con datos distintos:

  1. Flujo normal: El usuario al finalizar la transacción (tanto si es un rechazo o una aprobación) llegará solamente token_ws.
  2. Timeout (más de 10 minutos en el formulario de Transbank): Llegará solamente TBK_ID_SESION que contiene el session_id enviado al crear la transacción, TBK_ORDEN_COMPRA que representa el buy_order enviado. No llegará token.
  3. Pago abortado (con botón anular compra en el formulario de Webpay): Llegará TBK_TOKEN (notar que no se llama token_ws, pero igualmente contiene el token de la transacción), TBK_ID_SESION, TBK_ORDEN_COMPRA
  4. *Si ocurre un error en el formulario de pago, y hace click en el link de "volver al sitio" de la pantalla de error: (replicable solo en producción si inicias una transacción, abres el formulario de pago, cierras el tab de Chrome y luego lo recuperas) Llegará token_ws, TBK_TOKEN, TBK_ID_SESION, TBK_ORDEN_COMPRA.

Proyectos de ejemplo

Recuerda que tienes varios proyectos de ejemplos para cada lenguaje, que puedes revisar acá.

Para PHP, en el mismo repositorio también puedes encontrar algunos ejemplos básicos.

Crear una transacción

Esta operación te permite iniciar o crear una transacción, Webpay Plus procesa el requerimiento y entrega como resultado de la operación el token de la transacción y URL de redireccionamiento a la cual se deberá redirigir al tarjetahabiente.

// Versión 3.x del SDK
import cl.transbank.webpay.webpayplus.responses.WebpayPlusTransactionCreateResponse;

WebpayPlus.Transaction tx = new WebpayPlus.Transaction(new WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final WebpayPlusTransactionCreateResponse response = tx.create(buyOrder, sessionId, amount, returnUrl);

// Versión 2.x del SDK
import cl.transbank.webpay.webpayplus.WebpayPlus;

final WebpayPlusTransactionCreateResponse response = WebpayPlus.Transaction.create(
  buyOrder, sessionId, amount, returnUrl
);
use Transbank\Webpay\WebpayPlus\Transaction;

// Versión 2.x del SDK
$transaction = new Transaction();
$response = $transaction->create($buy_order, $session_id, $amount, $return_url);



////////////////////////////////////////////////////////////
// Otras opciones.... 
////////////////////////////////////////////////////////////

// Adicionalmente, ahora existen varias formas de crear una instancia del Objeto "Transaction". Todas son igual de válidas.    
// Opción 2: 
$response = WebpayPlus::transaction()->create($buy_order, $session_id, $amount, $return_url);

//Opción 3: Usar el método estático build()
$response = Transaction::build()->create($buy_order, $session_id, $amount, $return_url);


// En el fondo, se puede ver que se puede crear una instancia así, que funcionan exactamente igual: 
$transaction = new Transaction(); // A
$transaction = Transaction::build(); // B
$transaction = WebpayPlus::transaction(); // C

////////////////////////////////////////////////////////////
// Configuración del Ambiente y Credenciales
////////////////////////////////////////////////////////////

// Por defecto, la clase Transaction viene configurada para integración con un código Webpay Plus Captura simultanea
// También se puede configurar WebpayPlus::configureForTesting() para captura simultanea y  WebpayPlus::configureForTestingDeferred() para captura diferida


// Para configurar el ambiente y Api Key, también existen varias opciones:
// Opción A: 
$transaction->configureForIntegration($commerceCode, $apiKeySecret);
$transaction->configureForProduction($commerceCode, $apiKeySecret);

// Opción B
WebpayPlus::configureForIntegration($commerceCode, $apiKeySecret);
WebpayPlus::configureForProduction($commerceCode, $apiKeySecret);
// Crear instancia de Transaction con cualquier método. 

// Opción C: Crear objeto Options
$options = Transbank\Webpay\Options::forIntegration($commerceCode, $apiKeySecret);
$transaction = new Transaction($options); //Pasarle el objeto $options a la instancia




// -------------------------------------------------
// SDK 1.X - No hay más opciones. Solo método estático, no recomendado.

$response = Transaction::create($buy_order, $session_id, $amount, $return_url);

using Transbank.Webpay.WebpayPlus;

// Versión 4.x del SDK
var tx = new Transaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS, IntegrationApiKeys.WEBPAY, WebpayIntegrationType.Test));
var response = tx.Create(buyOrder, sessionId, amount, returnUrl);

// Versión 3.x del SDK
var response = Transaction.Create(buyOrder, sessionId, amount, returnUrl);
## Versión 2.x del SDK
@tx = Transbank::Webpay::WebpayPlus::Transaction.new(::Transbank::Common::IntegrationCommerceCodes::WEBPAY_PLUS)
@resp = @tx.create(
  buy_order: buy_order,
  session_id: session_id,
  amount: amount,
  return_url: return_url
)

## Versión 1.x del SDK
@resp = Transbank::Webpay::WebpayPlus::Transaction::create(
  buy_order: buy_order,
  session_id: session_id,
  amount: amount,
  return_url: return_url
)
## Versión 3.x del SDK
tx = Transaction(WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.create(buy_order, session_id, amount, return_url)

## Versión 2.x del SDK
resp = transbank.webpay.webpay_plus.create(buy_order, session_id, amount, return_url)

// Versión 3.x del SDK
const tx = new WebpayPlus.Transaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS, IntegrationApiKeys.WEBPAY, Environment.Integration));
const response = await tx.create(buyOrder, sessionId, amount, returnUrl);

// Versión 2.x del SDK
const response = await WebpayPlus.Transaction.create(buyOrder, sessionId, amount, returnUrl);

Respuesta Crear una transacción

La respuesta de Webpay Plus a la creación es el token de la transacción y la URL a la cual debes redirigir al tarjetahabiente.

response.getUrl();
response.getToken();
$response->getUrl();
$response->getToken();
response.Url;
response.Token;
response.url
response.token
## Versión 3.x del SDK
response['url']
response['token']

## Versión 2.x del SDK
response.url
response.token
response.url
response.token

Con estos datos debes crear un formulario en el cual debes poner un input de nombre token_ws y en su valor debes insertar el token devuelto. El formulario debe usar el método POST y su acción (o URL) debe ser la URL devuelta por Webpay Plus.

<form method="post" action="Inserta aquí la url entregada">
  <input type="hidden" name="token_ws" value="Inserte aquí el token entregado" />
  <input type="submit" value="Ir a pagar" />
</form>

Confirmar una transacción

Una vez que el tarjetahabiente ha pagado, Webpay Plus retornará el control vía POST a la URL que indicaste en el return_url (si la versión de la API es 1.1 o superior, este retorno es por GET). Recibirás también el parámetro token_ws que te permitirá conocer el resultado de la transacción.

En caso de que el tarjetahabiente haya declinado, o haya ocurrido un error, recibirás la variable TBK_TOKEN además de las variables TBK_ORDEN_COMPRA y TBK_ID_SESION. Para este caso, el retorno en el ambiente de integración es vía POST, para producción es por GET.

// Versión 3.x del SDK
WebpayPlus.Transaction tx = new WebpayPlus.Transaction(new WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final WebpayPlusTransactionCommitResponse response = tx.commit(token);

// Versión 2.x del SDK
final WebpayPlusTransactionCommitResponse response = WebpayPlus.Transaction.commit(token);
use Transbank\Webpay\WebpayPlus\Transaction;
// SDK Versión 2.x
$token = $_GET['token_ws'] ?? $_POST['token_ws'] ?? null;
if (!$token) {
    // Revisa más detalles en Revisar más detalles más arriba en los distintos flujos y ejemplos de código de esto en https://github.com/TransbankDevelopers/transbank-sdk-php/examples/webpay-plus/index.php
    die ('No es un flujo de pago normal.');  
}

$response = (new Transaction)->commit($token); // ó cualquiera de los métodos detallados en el ejemplo anterior del método create.
if ($response->isApproved()) {
 // Transacción Aprobada
} else {
 // Transacción rechazada
}





// SDK Versión 1.x
$response = Transaction::commit($token);

using Transbank.Webpay.WebpayPlus;

// Versión 4.x del SDK
var tx = new Transaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS, IntegrationApiKeys.WEBPAY, WebpayIntegrationType.Test));
var response = tx.Commit(token);

// Versión 3.x del SDK
var response = Transaction.Commit(token);
## Versión 2.x del SDK
@tx = Transbank::Webpay::WebpayPlus::Transaction.new(::Transbank::Common::IntegrationCommerceCodes::WEBPAY_PLUS)
@resp = @tx.commit(token: @token)

## Versión 1.x del SDK
@resp = Transbank::Webpay::WebpayPlus::Transaction::commit(token: @token)
## Versión 3.x del SDK
tx = Transaction(WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.commit(token)

## Versión 2.x del SDK
resp = transbank.webpay.webpay_plus.transaction.commit(token)

// Versión 3.x del SDK
const tx = new WebpayPlus.Transaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS, IntegrationApiKeys.WEBPAY, Environment.Integration));
const response = await tx.commit(token);

// Versión 2.x del SDK
const response = await WebpayPlus.Transaction.commit(token);

Respuesta Confirmar una transacción

Utilizando la respuesta de la confirmación podrás mostrar un comprobante o página de éxito a tu usuario. Con eso habrás completado el flujo "feliz" en que todo funciona.

response.getVci();
response.getAmount();
response.getStatus();
response.getBuyOrder();
response.getSessionId();
response.getCardDetail().getCardNumber();
response.getAccountingDate();
response.getTransactionDate();
response.getAuthorizationCode();
response.getPaymentTypeCode();
response.getResponseCode();
response.getInstallmentsAmount();
response.getInstallmentsNumber();
response.getBalance();
// Del objeto $response de respuesta, puedes obtener cualquier de estos datos.
// Para validar la transacción recomendamos usar $response->isApproved();
// pero puedes usar el resto de la información para guardar detalles de la respuesta en tu base de datos
$response->getVci();
$response->getAmount();
$response->getStatus();
$response->getBuyOrder();
$response->getSessionId();
$response->getCardDetail();
$response->getCardNumber(); // Solo en SDK 2.x
$response->getAccountingDate();
$response->getTransactionDate();
$response->getAuthorizationCode();
$response->getPaymentTypeCode();
$response->getResponseCode();
$response->getInstallmentsAmount();
$response->getInstallmentsNumber();
$response->getBalance();

// Adicionalmente en el SDK 2.x existe
$response->isApproved(); // Devuelve true si response_code es 0 y status es AUTHORIZED, y false en caso contrario.
response.Vci;
response.Amount;
response.Status;
response.BuyOrder;
response.SessionId;
response.CardDetail;
response.AccountingDate;
response.TransactionDate;
response.AuthorizationCode;
response.PaymentTypeCode;
response.ResponseCode;
response.InstallmentsAmount;
response.InstallmentsNumber;
response.Balance;
response.vci
response.amount
response.status
response.buy_order
response.session_id
response.card_detail
response.accounting_date
response.transaction_date
response.authorization_code
response.payment_type_code
response.response_code
response.installments_amount
response.installments_number
response.balance
## Versión 3.x del SDK
response['vci']
response['amount']
response['status']
response['buy_order']
response['session_id']
response['card_detail']
response['accounting_date']
response['transaction_date']
response['authorization_code']
response['payment_type_code']
response['response_code']
response['installments_amount']
response['installments_number']
response['balance']

## Versión 2.x del SDK
response.vci
response.amount
response.status
response.buy_order
response.session_id
response.card_detail
response.accounting_date
response.transaction_date
response.authorization_code
response.payment_type_code
response.response_code
response.installments_amount
response.installments_number
response.balance
response.vci
response.amount
response.status
response.buy_order
response.session_id
response.card_detail
response.accounting_date
response.transaction_date
response.authorization_code
response.payment_type_code
response.response_code
response.installments_amount
response.installments_number
response.balance

Obtener estado de una transacción

Esta operación permite obtener el estado de la transacción en los siguientes 7 días desde su creación. En condiciones normales es probable que no se requiera ejecutar, pero en caso de ocurrir un error inesperado permite conocer el estado y tomar las acciones que correspondan.

Debes enviar el token dela transacción de la cual desees obtener el estado.

// Versión 3.x del SDK
WebpayPlus.Transaction tx = new WebpayPlus.Transaction(new WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final WebpayPlusTransactionStatusResponse response = tx.status(token);

// Versión 2.x del SDK
final WebpayPlusTransactionStatusResponse response = WebpayPlus.Transaction.status(token);
use Transbank\Webpay\WebpayPlus\Transaction;

// SDK 2.x
$response = (new Transaction)->status($token);

// SDK 1.x
$response = Transaction::getStatus($token);  

using Transbank.Webpay.WebpayPlus;

// Versión 4.x del SDK
var tx = new Transaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS, IntegrationApiKeys.WEBPAY, WebpayIntegrationType.Test));
var response = tx.Status(token);

// Versión 3.x del SDK
var response = Transaction.Status(token);
## Versión 2.x del SDK
@tx = Transbank::Webpay::WebpayPlus::Transaction.new(::Transbank::Common::IntegrationCommerceCodes::WEBPAY_PLUS)
@resp = @tx.status(token: @token)

## Versión 1.x del SDK
response = Transbank::Webpay::WebpayPlus::Transaction::status(token: @token)
## Versión 3.x del SDK
tx = Transaction(WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.status(token)

## Versión 2.x del SDK
response = transbank.webpay.webpay_plus.transaction.status(token)

// Versión 3.x del SDK
const tx = new WebpayPlus.Transaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS, IntegrationApiKeys.WEBPAY, Environment.Integration));
const response = await tx.status(token);

// Versión 2.x del SDK
const response = await WebpayPlus.Transaction.status(token);

Respuesta estado de una transacción

Para obtener la información contenida en la respuesta puedes hacerlo de la siguiente manera.

response.getVci();
response.getAmount();
response.getStatus();
response.getBuyOrder();
response.getSessionId();
response.getCardDetail().getCardNumber();
response.getAccountingDate();
response.getTransactionDate();
response.getAuthorizationCode();
response.getPaymentTypeCode();
response.getResponseCode();
response.getInstallmentsAmount();
response.getInstallmentsNumber();
response.getBalance();

$response->getVci();
$response->getAmount();
$response->getStatus();
$response->getBuyOrder();
$response->getSessionId();
$response->getCardDetail();
$response->getCardNumber(); // Solo SDK 2.x
$response->getAccountingDate();
$response->getTransactionDate();
$response->getAuthorizationCode();
$response->getPaymentTypeCode();
$response->getResponseCode();
$response->getInstallmentsAmount();
$response->getInstallmentsNumber();
$response->getBalance();


// Adicionalmente en el SDK 2.x existe: 
$response->isApproved(); // Devuelve true si response_code es 0 y status es AUTHORIZED, y false en caso contrario.
response.Vci;
response.Amount;
response.Status;
response.BuyOrder;
response.SessionId;
response.CardDetail;
response.AccountingDate;
response.TransactionDate;
response.AuthorizationCode;
response.PaymentTypeCode;
response.ResponseCode;
response.InstallmentsAmount;
response.InstallmentsNumber;
response.Balance;
response.vci
response.amount
response.status
response.buy_order
response.session_id
response.card_detail
response.accounting_date
response.transaction_date
response.authorization_code
response.payment_type_code
response.response_code
response.installments_amount
response.installments_number
response.balance
## Versión 3.x del SDK
response['vci']
response['amount']
response['status']
response['buy_order']
response['session_id']
response['card_detail']
response['accounting_date']
response['transaction_date']
response['authorization_code']
response['payment_type_code']
response['response_code']
response['installments_amount']
response['installments_number']
response['balance']

## Versión 2.x del SDK
response.vci
response.amount
response.status
response.buy_order
response.session_id
response.card_detail
response.accounting_date
response.transaction_date
response.authorization_code
response.payment_type_code
response.response_code
response.installments_amount
response.installments_number
response.balance
response.vci
response.amount
response.status
response.buy_order
response.session_id
response.card_detail
response.accounting_date
response.transaction_date
response.authorization_code
response.payment_type_code
response.response_code
response.installments_amount
response.installments_number
response.balance

Reversar o Anular una transacción

Esta operación permite a todo comercio habilitado, reversar o anular una transacción que fue generada en Webpay Plus.

Puedes realizar un reembolso invocando al método refund(), dependiendo de algunas condiciones correspondera a una Reversa o Anulación.

Puedes leer más sobre la anulación en la información del producto Webpay para conocer más detalles y restricciones.

// Versión 3.x del SDK
WebpayPlus.Transaction tx = new WebpayPlus.Transaction(new WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final WebpayPlusTransactionRefundResponse response = tx.refund(token, amount);

// Versión 2.x del SDK
final WebpayPlusTransactionRefundResponse response = WebpayPlus.Transaction.refund(token, amount);
use Transbank\Webpay\WebpayPlus\Transaction;
// SDK 2.x
$response = (new Transaction)->refund($token, $amount);

// SDK 1.x
$response = Transaction::refund($token, $amount);
using Transbank.Webpay.WebpayPlus;

// Versión 4.x del SDK
var tx = new Transaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS, IntegrationApiKeys.WEBPAY, WebpayIntegrationType.Test));
var response = tx.Refund(token, refundAmount);

// Versión 3.x del SDK
var response = Transaction.Refund(token, amount);
## Versión 2.x del SDK
@tx = Transbank::Webpay::WebpayPlus::Transaction.new(::Transbank::Common::IntegrationCommerceCodes::WEBPAY_PLUS)
@resp = @tx.refund(token: @token, amount: @amount)

## Versión 1.x del SDK
response = Transbank::Webpay::WebpayPlus::Transaction::refund(token: @token, amount: @amount)
## Versión 3.x del SDK
tx = Transaction(WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.refund(token, amount)

## Versión 2.x del SDK
response = Transbank.webpay.webpay_plus.refund(token, amount)
// Versión 3.x del SDK
const tx = new WebpayPlus.Transaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS, IntegrationApiKeys.WEBPAY, Environment.Integration));
const response = await tx.refund(token, amount);

// Versión 2.x del SDK
const response = await WebpayPlus.Transaction.refund(token, amount);

Respuesta Reversa o Anulación

Para obtener la información contenida en la respuesta puedes hacerlo de la siguiente manera.

response.getAuthorizationCode();
response.getAuthorizationDate();
response.getBalance();
response.getNullifiedAmount();
response.getResponseCode();
response.getType();
$response->getAuthorizationCode();
$response->getAuthorizationDate();
$response->getBalance();
$response->getNullifiedAmount();
$response->getResponseCode();
$response->getType();
response.AuthorizationCode;
response.AuthorizationDate;
response.Balance;
response.NullifiedAmount;
response.ResponseCode;
response.Type;
response.authorization_code;
response.authorization_date;
response.balance;
response.nullified_amount;
response.response_code;
response.type;
## Versión 3.x del SDK
response['authorization_code']
response['authorization_date']
response['balance']
response['nullified_amount']
response['response_code']
response['type']

## Versión 2.x del SDK
response.authorization_code
response.authorization_date
response.balance
response.nullified_amount
response.response_code
response.type
response.authorization_code
response.authorization_date
response.balance
response.nullified_amount
response.response_code
response.type

Capturar una transacción

Los comercios que están configurados para operar con captura diferida deben ejecutar el método de captura para realizar el cargo al tarjetahabiente.

Este método permite a todo comercio habilitado realizar capturas de una transacción autorizada sin captura generada en Webpay Plus. El método contempla una única captura por cada autorización. Para ello se deberá indicar los datos asociados a la transacción de venta con autorización sin captura y el monto requerido para capturar el cual debe ser menor o igual al monto originalmente autorizado.

Para capturar una transacción, ésta debe haber sido creada (según lo visto anteriormente para Webpay Plus o Webpay Plus Mall) por un código de comercio configurado para captura diferida. De esa forma la transacción estará autorizada pero requerirá una captura explícita posterior para confirmar la transacción.

Puedes leer más sobre la captura en la información del producto Webpay para conocer más detalles y restricciones.

Para realizar esa captura explícita debe usarse el método Transaction.capture()

Transaction.capture()

Los SDKs permiten indicar opcionalmente el código de comercio de la transacción a capturar, para soportar la captura en comercios Webpay Plus Mall o Transacción Completa Mall. En comercios sin modalidad Mall no es necesario especificar el código de comercio, ya que se usa el indicado en la configuración.

// Versión 3.x del SDK
WebpayPlus.Transaction tx = new WebpayPlus.Transaction(new WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS_DEFERRED, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final WebpayPlusTransactionCaptureResponse response = tx.capture(token, buyOrder, authorizationCode, amount);

// Versión 2.x del SDK
final WebpayPlusTransactionCaptureResponse response = WebpayPlus.DeferredTransaction.capture(token, buyOrder, authorizationCode, amount);
use Transbank\Webpay\WebpayPlus\Transaction;

// SDK 2.x
$response = (new Transaction)->capture($token, $buyOrder, $authCode, $amount);

// SDK 1.x
$response = Transaction::capture($token, $buyOrder, $authCode, $amount);
// Versión 4.x del SDK
var tx = new Transaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS_DEFERRED, IntegrationApiKeys.WEBPAY, WebpayIntegrationType.Test));
var response = tx.Refund(token, refundAmount);

// Versión 3.x del SDK
var response = DeferredTransaction.Capture(token, buyOrder, authorizationCode, captureAmount);
## Versión 2.x del SDK
@tx = Transbank::Webpay::WebpayPlus::Transaction.new(::Transbank::Common::IntegrationCommerceCodes::WEBPAY_PLUS_DEFERRED)
@resp = @tx.capture(
  token: @token,
  buy_order: @buy_order,
  authorization_code: @auth_code,
  amount: @amount
)

## Versión 1.x del SDK
response = Transbank::Webpay::WebpayPlus::DeferredTransaction::capture(
  token: @token,
  buy_order: @buy_order,
  authorization_code: @auth_code,
  capture_amount: @amount
)
## Versión 3.x del SDK
tx = Transaction(WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS_DEFERRED, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.capture(
  token=token, buy_order=buy_order, authorization_code=authorization_code, capture_amount=amount
)

## Versión 2.x del SDK
resp = DeferredTransaction.capture(
  token=token, buy_order=buy_order, authorization_code=authorization_code, capture_amount=amount
)

// Versión 3.x del SDK
const tx = new WebpayPlus.Transaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS_DEFERRED, IntegrationApiKeys.WEBPAY, Environment.Integration));
const response = await tx.capture(token, buyOrder, authorizationCode, captureAmount);

// Versión 2.x del SDK
const response = await WebpayPlus.DeferredTransaction.capture(token, buyOrder, authorizationCode, captureAmount);

Una vez realizada la captura, recibirás un objeto con la respuesta. Revisa la referencia API para conocer más detalles sobre los posibles resultados.

Respuesta de una captura

response.getAuthorizationCode();
response.getAuthorizationDate();
response.getCapturedAmount();
response.getResponseCode();
$response->getAuthorizationCode();
$response->getAuthorizationDate();
$response->getCapturedAmount();
$response->getResponseCode();
response.AuthorizationCode;
response.AuthorizationDate;
response.CapturedAmount;
response.ResponseCode;
response.authorization_code
response.authorization_date
response.captured_amount
response.response_code
## Versión 3.x del SDK
response['authorization_code']
response['authorization_date']
response['captured_amount']
response['response_code']

## Versión 2.x del SDK
response.authorization_code
response.authorization_date
response.captured_amount
response.response_code
response.authorization_code
response.authorization_date
response.captured_amount
response.response_code

Webpay Plus Mall

Una transacción Mall Normal corresponde a una solicitud de autorización financiera de un conjunto de pagos con tarjetas de crédito o débito, en donde quién realiza el pago ingresa al sitio del comercio, selecciona productos o servicios, y el ingreso asociado a los datos de la tarjeta de crédito o débito lo realiza una única vez en forma segura en Webpay para el conjunto de pagos. Cada pago tendrá su propio resultado, autorizado o rechazado.

Desagregación de un pago Webpay Mall

Es la tienda Mall la que agrupa múltiples tiendas, son estas últimas las que pueden generar transacciones. Tanto el mall como las tiendas asociadas son identificadas a través de un número denominado código de comercio.

Flujo

El flujo de Webpay Plus Mall es en general el mismo que el de Webpay Plus tanto de cara al tarjeta habiente como de cara al integrador.

Las diferencias son:

  • Se debe usar un código de comercio configurado para modalidad Mall en Transbank, el cual debe ser indicado al iniciar la transacción.
  • Se pueden indicar múltiples transacciones, cada una asociada a un código de comercio de tienda (que debe estar configurada en Transbank como perteneciente al mall).
  • Se debe verificar por separado el resultado de cada una de esas transacciones individualmente, pues es posible que el emisor de la tarjeta autorice algunas y otras no.

Crear una transacción mall

Esta operación te permite iniciar o crear varias transacciones de una sola vez, Webpay Plus Mall procesa el requerimiento y entrega como resultado de la operación el token de la transacción y URL de redireccionamiento a la cual se deberá redirigir al tarjetahabiente.

MallTransactionCreateDetails mallDetails = MallTransactionCreateDetails.build()
                .add(amountMallOne, commerceCodeMallOne, buyOrderMallOne)
                .add(amountMallTwo, commerceCodeMallTwo, buyOrderMallTwo);    

// Versión 3.x del SDK
WebpayPlus.MallTransaction tx = new WebpayPlus.MallTransaction(new WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final WebpayPlusMallTransactionCreateResponse response = tx.create(buyOrder, sessionId, returnUrl, mallDetails);

// Versión 2.x del SDK
final WebpayPlusMallTransactionCreateResponse response = WebpayPlus.MallTransaction.create(buyOrder, sessionId, returnUrl, mallDetails);
use Transbank\Webpay\WebpayPlus\MallTransaction;
// SDK 2.x
// Por defecto, la clase MallTransaction viene configurada para integración con un código Webpay Plus Mall Captura simultanea
// También se puede configurar \Transbank\Webpay\WebpayPlus::configureForTestingMall() y  \Transbank\Webpay\WebpayPlus::configureForTestingMallDeferred()
$transaction_details = [
  [
      "amount" => 10000,
      "commerce_code" => 597055555536,
      "buy_order" => "ordenCompraDetalle1234"
  ],
  [
     "amount" =>12000,
     "commerce_code" => 597055555537,
     "buy_order" => "ordenCompraDetalle4321"
  ],
];

$response = (new MallTransaction)->create($buy_order, $session_id, $return_url, $transaction_details);

// SDK 1.x
use Transbank\Webpay\WebpayPlus;
use Transbank\Webpay\WebpayPlus\Transaction;

WebpayPlus::configureMallForTesting();

$transaction_details = [
  [
      "amount" => 10000,
      "commerce_code" => 597055555536,
      "buy_order" => "ordenCompraDetalle1234"
  ],
  [
     "amount" =>12000,
     "commerce_code" => 597055555537,
     "buy_order" => "ordenCompraDetalle4321"
  ],
];

$response = Transaction::createMall($buy_order, $session_id, $return_url, $transaction_details);
using Transbank.Webpay.WebpayPlus;

var transactionDetails = new List<TransactionDetail>();
transactions.Add(new TransactionDetail(
    amountMallOne,
    commerceCodeMallOne,
    buyOrderMallOne
));
transactions.Add(new TransactionDetail(
    amountMallTwo,
    comerceCodeMallTwo,
    buyOrderMallTwo
));

// Versión 4.x del SDK
var tx = new MallTransaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS_MALL, IntegrationApiKeys.WEBPAY, WebpayIntegrationType.Test));
var result = tx.Create(buyOrder, sessionId, returnUrl, transactions);

// Versión 3.x del SDK
var result = MallTransaction.Create(buyOrder, sessionId, returnUrl, transactionDetails);
transaction_details = [
  {
      amount: 10000,
      commerce_code: 597055555536,
      buy_order: "ordenCompraDetalle1234"
  },
  {
     amount: 12000,
     commerce_code: 597055555537,
     buy_order: "ordenCompraDetalle4321"
  },
]

## Versión 2.x del SDK
@tx = Transbank::Webpay::WebpayPlus::MallTransaction.new(::Transbank::Common::IntegrationCommerceCodes::WEBPAY_PLUS_MALL)
@resp = @tx.create(
  buy_order: buy_order,
  session_id: session_id,
  return_url: return_url,
  details: transaction_details
)

## Versión 1.x del SDK
response = Transbank::Webpay::WebpayPlus::MallTransaction::create(
  buy_order: buy_order,
  session_id: session_id,
  return_url: return_url,
  details: transaction_details
)
transaction_details = MallTransactionCreateDetails(
  amount_child_1, commerce_code_child_1, buy_order_child_1
).add(
  amount_child_2, commerce_code_child_2, buy_order_child_2
)

## Versión 3.x del SDK
tx = MallTransaction(WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.create(
    buy_order=buy_order,
    session_id=session_id,
    return_url=return_url,
    details = transaction_details,
)

## Versión 2.x del SDK
resp = MallTransaction.create(
    buy_order=buy_order,
    session_id=session_id,
    return_url=return_url,
    details = transaction_details,
)
const TransactionDetail = require("transbank-sdk").TransactionDetail;

let details = [
  new TransactionDetail(
    amount, commerceCode, buyOrder
  ),
  new TransactionDetail(
    amount2, commerceCode2, buyOrder2
  ),
];


// Versión 3.x del SDK
const tx = new WebpayPlus.MallTransaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS_MALL, IntegrationApiKeys.WEBPAY, Environment.Integration));
const response = await tx.create(
  buyOrder,
  sessionId,
  returnUrl,
  details
);

// Versión 2.x del SDK
const createResponse = await WebpayPlus.MallTransaction.create(
  buyOrder,
  sessionId,
  returnUrl,
  details
);

Respuesta Crear una transacción mall

La respuesta de Webpay Plus Mall a la creación de es el token de la transacción y la URL a la cual debes redirigir al tarjetahabiente.

response.getToken();
response.getUrl();
$response->getToken();
$response->getUrl();
response.Token;
response.Url;
response.token
response.url
## Versión 3.x del SDK
response['token']
response['url']

## Versión 2.x del SDK
response.token
response.url
response.token
response.url

Con estos datos debes crear un formulario en el cual debes poner un input de nombre token_ws y en su valor debes insertar el token devuelto. El formulario debe usar el método POST y su acción (o URL) debe ser la URL devuelta por Webpay Plus.

<form method="post" action="Inserta aquí la url entregada">
  <input type="hidden" name="token_ws" value="Inserte aquí el token entregado" />
  <input type="submit" value="Ir a pagar" />
</form>

Confirmar una transacción mall

Una vez que el tarjetahabiente ha pagado, Webpay Plus retornará el control vía POST (o GET si usas la API v1.1 o posterior) a la URL que indicaste en el return_url. Recibirás también el parámetro token_ws que te permitirá conocer el resultado de la transacción.

En caso de que el tarjetahabiente haya declinado, o haya ocurrido un error, recibirás la variable TBK_TOKEN además de las variables TBK_ORDEN_COMPRA y TBK_ID_SESION.

// Versión 3.x del SDK
WebpayPlus.MallTransaction tx = new WebpayPlus.MallTransaction(new WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final WebpayPlusMallTransactionCommitResponse response = tx.commit(token);

```java
// Versión 2.x del SDK
final WebpayPlusMallTransactionCommitResponse response = WebpayPlus.MallTransaction.commit(token);
// SDK 2.x
use Transbank\Webpay\WebpayPlus\MallTransaction;
$response = (new MallTransaction)->commit($token);

//SDK 1.x
use Transbank\Webpay\WebpayPlus\Transaction;
$response = Transaction::commitMall($token);
using Transbank.Webpay.WebpayPlus;

// Versión 4.x del SDK
var tx = new MallTransaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS_MALL, IntegrationApiKeys.WEBPAY, WebpayIntegrationType.Test));
var response = tx.Commit(token);

// Versión 3.x del SDK
var response = MallTransaction.Commit(token);
## Versión 2.x del SDK
@tx = Transbank::Webpay::WebpayPlus::MallTransaction.new(::Transbank::Common::IntegrationCommerceCodes::WEBPAY_PLUS_MALL)
@resp = @tx.commit(token: @token)

## Versión 1.x del SDK
@resp = Transbank::Webpay::WebpayPlus::MallTransaction::commit(token: @token)
## Versión 3.x del SDK
tx = MallTransaction(WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.commit(token)

## Versión 2.x del SDK
resp = MallTransaction.commit(token)
// Versión 3.x del SDK
const tx = new WebpayPlus.MallTransaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS_MALL, IntegrationApiKeys.WEBPAY, Environment.Integration));
const response = await tx.commit(token);

// Versión 2.x del SDK
const response = await WebpayPlus.MallTransaction.commit(token);

Respuesta Confirmar una transacción mall

Utilizando la respuesta de la confirmación podrás mostrar un comprobante o página de éxito a tu usuario. Con eso habrás completado el flujo "feliz" en que todo funciona.

response.getAccountingDate();
response.getBuyOrder();
final CardDetail cardDetail = response.getCardDetail();
cardDetail.getCardNumber();
response.getSessionId();
response.getTransactionDate();
response.getVci();
final List<Detail> details = response.getDetails();
for (Detail detail : details) {
    detail.getAmount();
    detail.getAuthorizationCode();
    detail.getBuyOrder();
    detail.getCommerceCode();
    detail.getInstallmentsNumber();
    detail.getPaymentTypeCode();
    detail.getResponseCode();
    detail.getStatus();
}
$response->getAccountingDate();
$response->getBuyOrder();
$response->getCardDetail();
$response->getCardNumber(); // Solo en SDK 2.x
$response->getSessionId();
$response->getTransactionDate();
$response->getVci();
$details = $response->getDetails();
foreach($details as $detail){ // En SDk 2.x cada $detail es un Objeto TransactionDetails
    $detail->getAmount();
    $detail->getAuthorizationCode();
    $detail->getBuyOrder();
    $detail->getCommerceCode();
    $detail->getInstallmentsNumber();
    $detail->getPaymentTypeCode();
    $detail->getResponseCode();
    $detail->getStatus();
    $detail->isApproved(); // Solo en SDK 2.x - Indica si esta sub transacción puede ser considerada como aprobada

}
$response->isApproved(); // Solo en SDK 2.x - Devuelve true si al menos una de las subtransacciones fue autorizada. 
response.AccountingDate;
response.BuyOrder;
var cardDetail = response.CardDetail;
cardDetail.CardNumber;
response.SessionId;
response.TransactionDate;
response.Vci;
var details = response.Details;
foreach (var detail in details) {
    detail.Amount;
    detail.AuthorizationCode;
    detail.BuyOrder;
    detail.CommerceCode;
    detail.InstallmentsNumber;
    detail.PaymentTypeCode;
    detail.ResponseCode;
    detail.Status;
}
response.accounting_date
response.buy_order
card_detail = response.card_detail
card_detail.card_number
response.session_id
response.transaction_date
response.vci
details = response.details
details.each do |detail|
  detail.amount
  detail.authorization_code
  detail.buy_order
  detail.commerce_code
  detail.installments_number
  detail.payment_type_code
  detail.response_code
  detail.status
end
## Versión 3.x del SDK
response['accounting_date']
response['buy_order']
response['card_detail']
response['session_id']
response['transaction_date']
response['vci']

## Versión 2.x del SDK
response.accounting_date
response.buy_order
card_detail = response.card_detail
card_detail.card_number
response.session_id
response.transaction_date
response.vci
details = response.details
for detail in details:
  detail.amount
  detail.authorization_code
  detail.buy_order
  detail.commerce_code
  detail.installments_number
  detail.payment_type_code
  detail.response_code
  detail.status
response.accounting_date
response.buy_order
cardDetail = response.card_detail
cardDetail.card_number
response.session_id
response.transaction_date
response.vci
details = response.details
details.forEach(detail => {
  detail.amount
  detail.authorization_code
  detail.buy_order
  detail.commerce_code
  detail.installments_number
  detail.payment_type_code
  detail.response_code
  detail.status
});

Obtener estado de una transacción mall

Esta operación permite obtener el estado de la transacción en cualquier momento. En condiciones normales es probable que no se requiera ejecutar, pero en caso de ocurrir un error inesperado permite conocer el estado y tomar las acciones que correspondan.

// Versión 3.x del SDK
WebpayPlus.MallTransaction tx = new WebpayPlus.MallTransaction(new WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final WebpayPlusMallTransactionStatusResponse response = tx.status(token);

// Versión 2.x del SDK
final WebpayPlusMallTransactionStatusResponse response = WebpayPlus.MallTransaction.status(token);
// SDK 2.x
use Transbank\Webpay\WebpayPlus\MallTransaction;
$response = (new MallTransaction)->status($token);

// SDK 1.x
use Transbank\Webpay\WebpayPlus\Transaction;
$response = Transaction::getMallStatus($token);
using Transbank.Webpay.WebpayPlus;

// Versión 4.x del SDK
var tx = new MallTransaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS_MALL, IntegrationApiKeys.WEBPAY, WebpayIntegrationType.Test));
var response = tx.Status(token);

// Versión 3.x del SDK
var response = MallTransaction.Status(token);
## Versión 2.x del SDK
@tx = Transbank::Webpay::WebpayPlus::MallTransaction.new(::Transbank::Common::IntegrationCommerceCodes::WEBPAY_PLUS_MALL)
@resp = @tx.status(token: @token)

## Versión 1.x del SDK
@resp = Transbank::Webpay::WebpayPlus::MallTransaction.status(token: @token)
## Versión 3.x del SDK
tx = MallTransaction(WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.status(token)

## Versión 2.x del SDK
resp = MallTransaction.status(token)
// Versión 3.x del SDK
const tx = new WebpayPlus.MallTransaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS_MALL, IntegrationApiKeys.WEBPAY, Environment.Integration));
const response = await tx.status(token);

// Versión 2.x del SDK
const response = await WebpayPlus.MallTransaction.status(token);

Respuesta estado de una transacción mall

Para obtener la información contenida en la respuesta puedes hacerlo de la siguiente manera.

response.getAccountingDate();
response.getBuyOrder();
final CardDetail cardDetail = response.getCardDetail();
cardDetail.getCardNumber();
response.getSessionId();
response.getTransactionDate();
response.getVci();
final List<Detail> details = response.getDetails();
for (Detail detail : details) {
    detail.getAmount();
    detail.getAuthorizationCode();
    detail.getBuyOrder();
    detail.getCommerceCode();
    detail.getInstallmentsNumber();
    detail.getPaymentTypeCode();
    detail.getResponseCode();
    detail.getStatus();
}
response.AccountingDate;
response.BuyOrder;
var cardDetail = response.CardDetail;
cardDetail.CardNumber;
response.SessionId;
response.TransactionDate;
response.Vci;
var details = response.Details;
foreach (var detail in details) {
    detail.Amount;
    detail.AuthorizationCode;
    detail.BuyOrder;
    detail.CommerceCode;
    detail.InstallmentsNumber;
    detail.PaymentTypeCode;
    detail.ResponseCode;
    detail.Status;
}
$response->getAccountingDate();
$response->getBuyOrder();
$response->getCardDetail();
$response->getCardNumber(); // Solo en SDK 2.x
$response->getSessionId();
$response->getTransactionDate();
$response->getVci();
$details = $response->getDetails();
foreach($details as $detail){ // En SDk 2.x cada $detail es un Objeto TransactionDetails
    $detail->getAmount();
    $detail->getAuthorizationCode();
    $detail->getBuyOrder();
    $detail->getCommerceCode();
    $detail->getInstallmentsNumber();
    $detail->getPaymentTypeCode();
    $detail->getResponseCode();
    $detail->getStatus();
    $detail->isApproved(); // Solo en SDK 2.x - Indica si esta sub transacción puede ser considerada como aprobada

}
$response->isApproved(); // Solo en SDK 2.x - Devuelve true si al menos una de las subtransacciones fue autorizada.
  response.accounting_date
  response.buy_order
  card_detail = response.card_detail
  card_detail.card_number
  response.session_id
  response.transaction_date
  response.vci
  details = response.details
  details.each do |detail|
    detail.amount
    detail.authorization_code
    detail.buy_order
    detail.commerce_code
    detail.installments_number
    detail.payment_type_code
    detail.response_code
    detail.status
  end
## Versión 3.x del SDK
response['accounting_date']
response['buy_order']
response['card_detail']
response['session_id']
response['transaction_date']
response['vci']

## Versión 2.x del SDK
response.accounting_date
response.buy_order
card_detail = response.card_detail
card_detail.card_number
response.session_id
response.transaction_date
response.vci
details = response.details
for detail in details:
  detail.amount
  detail.authorization_code
  detail.buy_order
  detail.commerce_code
  detail.installments_number
  detail.payment_type_code
  detail.response_code
  detail.status
response.accounting_date
response.buy_order
cardDetail = response.card_detail
cardDetail.card_number
response.session_id
response.transaction_date
response.vci
details = response.details
details.forEach(detail => {
  detail.amount
  detail.authorization_code
  detail.buy_order
  detail.commerce_code
  detail.installments_number
  detail.payment_type_code
  detail.response_code
  detail.status
});

Reversar o Anular una transacción mall

Esta operación permite a todo comercio habilitado, reversar o anular una transacción que fue generada en Webpay Plus.

Puedes realizar un reembolso invocando al método refund(), dependiendo de algunas condiciones correspondera a una Reversa o Anulación.

Puedes leer más sobre la anulación en la información del producto Webpay para conocer más detalles y restricciones.

// Versión 3.x del SDK
WebpayPlus.MallTransaction tx = new WebpayPlus.MallTransaction(new WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final WebpayPlusTransactionRefundResponse response = tx.refund(token, childBuyOrder, childCommerceCode, amount);

// Versión 2.x del SDK
final WebpayPlusMallTransactionRefundResponse response = WebpayPlus.MallTransaction.refund(token, childBuyOrder, childCommerceCode, amount);
//SDK 2.x
$response = (new MallTransaction)->refund($token, $buy_order, $commerce_code, $amount);

// SDK 1.x
$response = Transaction::refundMall($token, $buy_order, $commerce_code, $amount);
// Versión 4.x del SDK
var tx = new MallTransaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS_MALL, IntegrationApiKeys.WEBPAY, WebpayIntegrationType.Test));
var response = tx.Refund(token, buyOrder, commerceCode, amount);

// Versión 3.x del SDK
var response = Transaction.Refund(token, buyOrder, commerceCode, amount);
## Versión 2.x del SDK
@tx = Transbank::Webpay::WebpayPlus::MallTransaction.new(::Transbank::Common::IntegrationCommerceCodes::WEBPAY_PLUS_MALL)
@resp = @tx.refund(token: @token, buy_order: @child_buy_order, child_commerce_code: @child_commerce_code,  amount: @amount)

## Versión 1.x del SDK
@resp = Transbank::Webpay::WebpayPlus::MallTransaction:refund(token: @token, buy_order: @child_buy_order, commerce_code: @child_commerce_code, amount: @amount)
## Versión 3.x del SDK
tx = MallTransaction(WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.refund(token, child_buy_order, child_commerce_code, amount)

## Versión 2.x del SDK
resp = Transaction.refund(token, child_buy_order, child_commerce_code, amount)
// Versión 3.x del SDK
const tx = new WebpayPlus.MallTransaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS_MALL, IntegrationApiKeys.WEBPAY, Environment.Integration));
const response = await tx.refund(token, buyOrder, commerceCode, amount);

// Versión 2.x del SDK
const response = await WebpayPlus.MallTransaction.refund(token, buyOrder, commerceCode, amount);

Respuesta Reversa o Anulacion mall

Para obtener la información contenida en la respuesta puedes hacerlo de la siguiente manera.

  response.getAuthorizationCode();
  response.getAuthorizationDate();
  response.getBalance();
  response.getNullifiedAmount();
  response.getResponseCode();
  response.getType();
  response.AuthorizationCode;
  response.AuthorizationDate;
  response.Balance;
  response.NullifiedAmount;
  response.ResponseCode;
  response.Type;
  $response->getAuthorizationCode();
  $response->getAuthorizationDate();
  $response->getBalance();
  $response->getNullifiedAmount();
  $response->getResponseCode();
  $response->getType();
  response.authorization_code
  response.authorization_date
  response.balance
  response.nullified_amount
  response.response_code
  response.type
## Versión 3.x del SDK
response['authorization_code']
response['authorization_date']
response['balance']
response['nullified_amount']
response['response_code']
response['type']

## Versión 2.x del SDK
response.authorization_code
response.authorization_date
response.balance
response.nullified_amount
response.response_code
response.type

Capturar una transacción mall

// Versión 3.x del SDK
WebpayPlus.MallTransaction tx = new WebpayPlus.MallTransaction(new WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS_MALL_DEFERRED, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final WebpayPlusMallTransactionCaptureResponse response = tx.capture(token, childCommerceCode, childBuyOrder, authorizationCode, amount);

// Versión 2.x del SDK
final WebpayPlusMallTransactionCaptureResponse response = WebpayPlus.MallDeferredTransaction.capture(token, childCommerceCode, childBuyOrder, authorizationCode, amount);

//SDK 2.x
use Transbank\Webpay\WebpayPlus\MallTransaction;
$response = (new MallTransaction)->capture($childCommerceCode, $token, $buyOrder, $authorizationCode, $captureAmount);

// SDK 1.x
use Transbank\Webpay\WebpayPlus\Transaction;
$response = Transaction::captureMall($childCommerceCode, $token, $buyOrder, $authorizationCode, $captureAmount);
// Versión 4.x del SDK
var tx = new MallTransaction(new Options(IntegrationCommerceCodes.WEBPAY_PLUS_MALL_DEFERRED, IntegrationApiKeys.WEBPAY, WebpayIntegrationType.Test));
var response = tx.Capture(token, commerceCode, buyOrder, authorizationCode, captureAmount);

// Versión 3.x del SDK
var response = Transbank.Webpay.WebpayPlus.MallDeferredTransaction.Capture(token, childCommerceCode, buyOrder, authorizationCode, captureAmount);
## Versión 2.x del SDK
@tx = Transbank::Webpay::WebpayPlus::MallTransaction.new(::Transbank::Common::IntegrationCommerceCodes::WEBPAY_PLUS_MALL_DEFERRED)
@resp = @tx.capture(child_commerce_code: @child_commerce_code, token: @token, buy_order: @buy_order, authorization_code: @authorization_code, capture_amount: @capture_amount)

## Versión 1.x del SDK
response = Transbank::Webpay::WebpayPlus::MallDeferredTransaction::capture(
  token: @token,
  child_commerce_code: @child_commerce_code,
  buy_order: @buy_order,
  authorization_code: @authorization_code,
  capture_amount: @capture_amount
)
## Versión 3.x del SDK
tx = MallTransaction(WebpayOptions(IntegrationCommerceCodes.WEBPAY_PLUS_MALL_DEFERRED, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.capture(
  token=token, capture_amount=amount, commerce_code=child_commerce_code,
  buy_order=buy_order, authorization_code=authorization_code
)

## Versión 2.x del SDK
resp = MallDeferredTransaction.capture(
  child_commerce_code: child_commerce_code, token: token, buy_order: buy_order, 
  authorization_code: authorization_code, capture_amount: capture_amount
)

Respuesta de una captura mall

response.getAuthorizationCode();
response.getAuthorizationDate();
response.getCapturedAmount();
response.getResponseCode();
$response->getAuthorizationCode();
$response->getAuthorizationDate();
$response->getCapturedAmount();
$response->getResponseCode();
response.AuthorizationCode;
response.AuthorizationDate;
response.CapturedAmount;
response.ResponseCode;
response.authorization_code
response.authorization_date
response.captured_amount
response.response_code
## Versión 3.x del SDK
response['authorization_code']
response['authorization_date']
response['captured_amount']
response['response_code']

## Versión 2.x del SDK
response.authorization_code
response.authorization_date
response.captured_amount
response.response_code
  response.authorization_code
  response.authorization_date
  response.balance
  response.nullified_amount
  response.response_code
  response.type

Esta operación funciona de la misma manera que la captura de Webpay Plus normal.

Credenciales y Ambiente

Ambiente de integración

Puede encontrar más información al respecto en este link

Configuración SDK

Los SDK vienen preconfigurados para operar directamente en el ambiente de integración. Si quieres apuntar a producción tienes dos opciones; puedes re-configurar el SDK para que apunte a producción utilizando el código de comercio y API Key. O puedes configurar cada llamada a las operaciones siguientes para pasar un objeto Options en el cual configuras donde quieres apuntar.

Puede encontrar más información al respecto en este link

Puesta en Producción

Puede encontrar más información al respecto en este link

Ejemplos de integración

Ponemos a tu disposición una serie de repositorios en nuestro Github para ayudarte a entender la integración de mejor forma.

Puedes verlos acá

¿Tienes alguna duda de integración?

Únete a la comunidad de integradores en Slack y comparte buenos tips ayudando a los nuevos o buscando soluciones alternativas. Nuestro equipo está ahí para ayudarte.

Si aún tienes dudas envíanos un mensaje

Envíanos un mensaje.
Si necesitas resolver algún tipo de incidencia en el portal o si existe algún problema con tu integración y que no has podido resolver, contáctanos a través de nuestro formulario.