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.
  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 depende del ambiente, en producción el tiempo es de 4 minutos y en integración es de 10 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 (Tiempo excedido en el formulario de Webpay): El tiempo es de 4 minutos para el ambiente de producción y 10 minutos para el entorno de integración.Llegará solamente TBK_ID_SESION que contiene el session_id enviado al crear la transacción, TBK_ORDEN_COMPRAque 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.



WebpayPlus.Transaction transaction = WebpayPlus.Transaction.buildForIntegration("commerceCode", "APIKey");
final WebpayPlusTransactionCreateResponse response = transaction.create(buyOrder, sessionId, amount, returnUrl);




$transaction = Transaction::buildForIntegration($apiKey, $commerceCode);
$response = $transaction->create($buy_order, $session_id, $amount, $return_url);




Transaction transaction = Transaction.buildForIntegration("commerceCode", "APIKey");
var response = transaction.Create(buyOrder, sessionId, amount, returnUrl);




@transaction = Transbank::Webpay::WebpayPlus::Transaction.build_for_integration("commerceCode", "APIKey");
@resp = @transaction.create(
  buy_order: @buy_order,
  session_id: @session_id,
  amount: @amount,
  return_url: @return_url
);





tx = Transaction.build_for_integration("commerceCode", "APIKey")
resp = tx.create(buy_order, session_id, amount, return_url)




const transaction = WebpayPlus.Transaction.buildForIntegration(
  "commerceCode",
  "APIKey"
);
const response = await 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.



WebpayPlus.Transaction transaction = WebpayPlus.Transaction.buildForIntegration("commerceCode", "APIKey");
final WebpayPlusTransactionCommitResponse response = transaction.commit(token);





$transaction = Transaction::buildForIntegration($apiKey, $commerceCode);
$response = $transaction->commit($token);





Transaction transaction = Transaction.buildForIntegration("commerceCode", "APIKey");
var response = transaction.Commit(token);





@transaction = Transbank::Webpay::WebpayPlus::Transaction.build_for_integration("commerceCode", "APIKey");
@resp = @transaction.commit(token: @token);




tx = Transaction.build_for_integration("commerceCode", "APIKey")
resp = tx.commit(token)




const transaction = WebpayPlus.Transaction.buildForIntegration(
  "commerceCode",
  "APIKey"
);
const response = await 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.



WebpayPlus.Transaction transaction = WebpayPlus.Transaction.buildForIntegration("commerceCode", "APIKey");
final WebpayPlusTransactionStatusResponse response = transaction.status(token);


use Transbank\Webpay\WebpayPlus\Transaction;

$transaction = Transaction::buildForIntegration($apiKey, $commerceCode);
$response = $transaction->status($token);

using Transbank.Webpay.WebpayPlus;

Transaction transaction = Transaction.buildForIntegration("commerceCode", "APIKey");
var response = transaction.status(token);



  
@transaction = Transbank::Webpay::WebpayPlus::Transaction.build_for_integration("commerceCode", "APIKey");
@resp = @transaction.status(token: @token);



  
tx = Transaction.build_for_integration("commerceCode", "APIKey")
resp = tx.status(token)
  



const transaction = WebpayPlus.Transaction.buildForIntegration(
  "commerceCode",
  "APIKey"
);
const response = await 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.



WebpayPlus.Transaction transaction = WebpayPlus.Transaction.buildForIntegration("commerceCode", "APIKey");
final WebpayPlusTransactionRefundResponse response = transaction.refund(token, amount);




$transaction = Transaction::buildForIntegration($apiKey, $commerceCode);
$response = $transaction->refund($token, $amount);




Transaction transaction = Transaction.buildForIntegration("commerceCode", "APIKey");
var response = transaction.Refund(token, refundAmount);





@transaction = Transbank::Webpay::WebpayPlus::Transaction.build_for_integration("commerceCode", "APIKey");
@resp = @transaction.refund(token: @token, amount: @amount); 
  



tx = Transaction.build_for_integration("commerceCode", "APIKey")
resp = tx.refund(token, amount)  




const transaction = WebpayPlus.Transaction.buildForIntegration(
  "commerceCode",
  "APIKey"
);
const response = await 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.



WebpayPlus.Transaction transaction = WebpayPlus.Transaction.buildForIntegration("commerceCode", "APIKey");
final WebpayPlusTransactionCaptureResponse response = transaction.capture(token, buyOrder, authorizationCode, amount);


use Transbank\Webpay\WebpayPlus\Transaction;

$transaction = Transaction::buildForIntegration($apiKey, $commerceCode);
$response = $transaction->capture($token, $buyOrder, $authCode, $amount);




Transaction transaction = Transaction.buildForIntegration("commerceCode", "APIKey");
var response = transaction.capture(token, buyOrder, authorizationCode, amount);




@transaction = Transbank::Webpay::WebpayPlus::Transaction.build_for_integration("commerceCode", "APIKey");
@resp = @transaction.capture(
  token: @token,
  buy_order: @buy_order,
  authorization_code: @auth_code,
  amount: @amount
);




tx = Transaction.build_for_integration("commerceCode", "APIKey")
resp = tx.capture(
  token=token, buy_order=buy_order, authorization_code=authorization_code, capture_amount=amount
)




const transaction = WebpayPlus.Transaction.buildForIntegration(
  "commerceCode",
  "APIKey"
);
const response = await tx.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.



WebpayPlus.MallTransaction mallTransaction = WebpayPlus.MallTransaction.buildForIntegration("commerceCode", "APIKey");
MallTransactionCreateDetails mallDetails = MallTransactionCreateDetails.build()
                .add(amountMallOne, commerceCodeStoreOne, buyOrderMallOne)
                .add(amountMallTwo, commerceCodeStoreTwo, buyOrderMallTwo);
final WebpayPlusMallTransactionCreateResponse response = mallTransaction.create(buyOrder, sessionId, returnUrl, mallDetails);



  
$mallTransaction = MallTransaction::buildForIntegration($apiKey, $commerceCode);
$transaction_details = [
  [
      "amount" => 10000,
      "commerce_code" => 'commerceCodeStoreOne',
      "buy_order" => "ordenCompraDetalle1234"
  ],
  [
      "amount" =>12000,
      "commerce_code" => 'commerceCodeStoreTwo',
      "buy_order" => "ordenCompraDetalle4321"
  ],
];
$response = $mallTransaction->create($buy_order, $session_id, $return_url, $transaction_details);




MallTransaction mallTransaction = MallTransaction.buildForIntegration("commerceCode", "APIKey");
var transactionDetails = new List();
transactionDetails.Add(new TransactionDetail(
    amountMallOne,
    commerceCodeStoreOne,
    buyOrderMallOne
));
transactionDetails.Add(new TransactionDetail(
    amountMallTwo,
    commerceCodeStoreTwo,
    buyOrderMallTwo
));
var result = mallTransaction.Create(buyOrder, sessionId, returnUrl, transactionDetails);
  



@mall_transaction = Transbank::Webpay::WebpayPlus::MallTransaction.build_for_integration("commerceCode", "APIKey");
@transaction_details = [
  {
      amount: 10000,
      commerce_code: "commerce_store_1",
      buy_order: "ordenCompraDetalle1234"
  },
  {
      amount: 12000,
      commerce_code: "commerce_store_2",
      buy_order: "ordenCompraDetalle4321"
  },
];
@resp = @mall_transaction.create(
  buy_order: @buy_order,
  session_id: @session_id,
  return_url: @return_url,
  details: @transaction_details
);


  
mall_tx = MallTransaction.build_for_integration("commerceCode", "APIKey")
transaction_details = MallTransactionCreateDetails(
  amount_child_1, commerce_store_1, buy_order_child_1
).add(
  amount_child_2, commerce_store_2, buy_order_child_2
)
resp = mall_tx.create(
    buy_order=buy_order,
    session_id=session_id,
    return_url=return_url,
    details = transaction_details,
)




const mallTransaction = WebpayPlus.MallTransaction.buildForIntegration(
  "commerceCode",
  "APIKey"
);
let details = [
  new TransactionDetail(amount, commerceCodeStoreOne, buyOrder),
  new TransactionDetail(amount2, commerceCodeStoreTwo, buyOrder2),
];
const response = await 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.



WebpayPlus.MallTransaction mallTransaction = WebpayPlus.MallTransaction.buildForIntegration("commerceCode", "APIKey");
final WebpayPlusMallTransactionCommitResponse response = mallTransaction.commit(token);




$mallTransaction = MallTransaction::buildForIntegration($apiKey, $commerceCode);
$response = $mallTransaction->commit($token);


using Transbank.Webpay.WebpayPlus;

MallTransaction mallTransaction = MallTransaction.buildForIntegration("commerceCode", "APIKey");
var response = mallTransaction.Commit(token);




@mall_transaction = Transbank::Webpay::WebpayPlus::MallTransaction.build_for_integration("commerceCode", "APIKey");
@resp = @mall_transaction.commit(token: @token);




mall_tx = MallTransaction.build_for_integration("commerceCode", "APIKey")
resp = mall_tx.commit(token)




const mallTransaction = WebpayPlus.MallTransaction.buildForIntegration(
  "commerceCode",
  "APIKey"
);
const response = await 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.



WebpayPlus.MallTransaction mallTransaction = WebpayPlus.MallTransaction.buildForIntegration("commerceCode", "APIKey");
final WebpayPlusMallTransactionStatusResponse response = mallTransaction.status(token);




$mallTransaction = MallTransaction::buildForIntegration($apiKey, $commerceCode);
$response = $mallTransaction->status($token);




MallTransaction mallTransaction = MallTransaction.buildForIntegration("commerceCode", "APIKey");
var response = mallTransaction.Status(token);




@mall_transaction = Transbank::Webpay::WebpayPlus::MallTransaction.build_for_integration("commerceCode", "APIKey");
@resp = @mall_transaction.status(token: @token);




mall_tx = MallTransaction.build_for_integration("commerceCode", "APIKey")
resp = mall_tx.status(token)  




const mallTransaction = WebpayPlus.MallTransaction.buildForIntegration(
  "commerceCode",
  "APIKey"
);
const response = await 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.



WebpayPlus.MallTransaction mallTransaction = WebpayPlus.MallTransaction.buildForIntegration("commerceCode", "APIKey");
final WebpayPlusTransactionRefundResponse response = mallTransaction.refund(token, childBuyOrder, commerceCodeStoreOne, amount);




$mallTransaction = MallTransaction::buildForIntegration($apiKey, $commerceCode);
$response = $mallTransaction->refund($token, $buy_order, $commerce_code, $amount);




MallTransaction mallTransaction = MallTransaction.buildForIntegration("commerceCode", "APIKey");
var response = mallTransaction.Refund(token, buyOrder, commerceCode, amount);




@mall_transaction = Transbank::Webpay::WebpayPlus::MallTransaction.build_for_integration("commerceCode", "APIKey");
@resp = @mall_transaction.refund(token: @token, buy_order: @child_buy_order, child_commerce_code: @commerce_store_1,  amount: @amount);
  



mall_tx = MallTransaction.build_for_integration("commerceCode", "APIKey")
resp = mall_tx.refund(token, child_buy_order, commerce_store_1, amount)




const mallTransaction = WebpayPlus.MallTransaction.buildForIntegration(
  "commerceCode",
  "APIKey"
);
const response = await mallTransaction.refund(
  token,
  buyOrder,
  commerceCodeStoreOne,
  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



WebpayPlus.MallTransaction mallTransaction = WebpayPlus.MallTransaction.buildForIntegration("commerceCode", "APIKey");
final WebpayPlusMallTransactionCaptureResponse response = mallTransaction.capture(token, commerceCodeStoreOne, childBuyOrder, authorizationCode, amount);




$mallTransaction = MallTransaction::buildForIntegration($apiKey, $commerceCode);
$response = $mallTransaction->capture($commerceCodeStoreOne, $token, $buyOrder, $authorizationCode, $captureAmount);




MallTransaction mallTransaction = MallTransaction.buildForIntegration("commerceCode", "APIKey");
var response = mallTransaction.Capture(token, commerceCodeStoreOne, buyOrder, authorizationCode, captureAmount);




@mall_transaction = Transbank::Webpay::WebpayPlus::MallTransaction.build_for_integration("commerceCode", "APIKey");
@resp = @mall_transaction.capture(child_commerce_code: @commerce_store_1, token: @token, buy_order: @buy_order, authorization_code: @authorization_code, capture_amount: @capture_amount); 



mall_tx = MallTransaction.build_for_integration("commerceCode", "APIKey")
resp = mall_tx.capture(
  token=token, capture_amount=amount, commerce_code=commerce_store_1,
  buy_order=buy_order, authorization_code=authorization_code
) 



const mallTransaction = WebpayPlus.MallTransaction.buildForIntegration(
  "commerceCode",
  "APIKey"
);
const response = await mallTransaction.capture(
  token,
  commerceCodeStoreOne,
  buyOrder,
  authorizationCode,
  captureAmount
);

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 deben configurarse explícitamente para apuntar al ambiente que quieras utilizar (producción / integración). Para esto puedes crear los objetos de 2 maneras:

  • Utilizar los métodos definidos para ello (buildForIntegration o buildForProduction).
  • Utilizar un objeto Options que contenga la configuración y pasarlo en el constructor de cada objeto.

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

Puedes encontrar ejemplos de integración de los diferentes productos Webpay visitando el índice de proyectos de ejemplo. Allí se explica paso a paso las etapas del flujo de pago, con fragmentos de código para comprender a profundidad el procedimiento a integrar en tu comercio.

¿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.