Transacción Completa

Ambientes y Credenciales

La API REST de Webpay está protegida para garantizar que solamente comercios autorizados por Transbank hagan uso de las operaciones disponibles. La seguridad esta implementada mediante los siguientes mecanismos:

• Canal seguro a través de TLSv1.2 para la comunicación del cliente con Webpay.
• Autenticación y autorización mediante el intercambio de headers Tbk-Api-Key-Id (código de comercio) y Tbk-Api-Key-Secret (llave secreta).

Ambiente de Producción

Las URLs de endpoints de producción están alojados dentro de https://webpay3g.transbank.cl/.

// Host: https://webpay3g.transbank.cl

// Host: https://webpay3g.transbank.cl

// Host: https://webpay3g.transbank.cl

# Host: https://webpay3g.transbank.cl

# Host: https://webpay3g.transbank.cl

Host: https://webpay3g.transbank.cl

// Host: https://webpay3g.transbank.cl

Ambiente de Integración

Las URLs de endpoints de integración están alojados dentro de https://webpay3gint.transbank.cl/.

// Host: https://webpay3gint.transbank.cl

// Host: https://webpay3gint.transbank.cl

// Host: https://webpay3gint.transbank.cl

# Host: https://webpay3gint.transbank.cl

# Host: https://webpay3g.transbank.cl

Host: https://webpay3gint.transbank.cl

// Host: https://webpay3gint.transbank.cl

Tarjetas y usuarios de prueba

Consulta la documentación para conocer las tarjetas de prueba que funcionan en el ambiente de integración.

Credenciales del Comercio

// Tbk-Api-Key-Id: Código de comercio
// Tbk-Api-Key-Secret: Llave secreta
// Content-Type: application/json

// Tbk-Api-Key-Id: Código de comercio
// Tbk-Api-Key-Secret: Llave secreta
// Content-Type: application/json

// Tbk-Api-Key-Id: Código de comercio
// Tbk-Api-Key-Secret: Llave secreta
// Content-Type: application/json

# Tbk-Api-Key-Id: Código de comercio
# Tbk-Api-Key-Secret: Llave secreta
# Content-Type: application/json

# Tbk-Api-Key-Id: Código de comercio
# Tbk-Api-Key-Secret: Llave secreta
# Content-Type: application/json

Tbk-Api-Key-Id: Código de comercio
Tbk-Api-Key-Secret: Llave secreta
Content-Type: application/json

// Tbk-Api-Key-Id: Código de comercio
// Tbk-Api-Key-Secret: Llave secreta
// Content-Type: application/json

Todas las peticiones que hagas deben incluir el código de comercio y la llave secreta entregada por Transbank, actuando ambas como las credenciales que autorizan distintas operaciones.

Códigos de comercio

En la documentación puedes revisar todos los códigos de comercio del ambiente de integración

Los SDKs ya incluyen esos códigos de comercio y llaves secretas que funcionan en el ambiente de integración, por lo que puedes obtener rápidamente una configuración lista para hacer tus primeras pruebas en dicho ambiente.

Transacción Completa

Crear una Transacción Completa

Puedes revisar más detalles de esta operación en su documentación

Para crear una transacción completa basta llamar al método Transaction.create()

Transaction.create()

Permite inicializar una transacción completa en Webpay. Como respuesta a la invocación se genera un token que representa en forma única una transacción.

// Versión 3.x del SDK
FullTransaction tx = new FullTransaction(new WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
FullTransactionCreateResponse response = tx.create(buyOrder, sessionId, amount, cvv, cardNumber, cardExpirationDate);

// Versión 2.x del SDK
final FullTransactionCreateResponse response =  FullTransaction.Transaction.create(
  buyOrder,                         // ordenCompra12345678
  sessionId,                        // sesion1234564
  amount,                           // 10000
  cardNumber,                       // 123
  cardExpirationDate,               // 4239000000000000
  cvv                               // 22/10
);

use Transbank\TransaccionCompleta\Transaction;

$transaction = new Transaction();
$response = $transaction->create(
  $buy_order,                       // ordenCompra12345678
  $session_id,                      // sesion1234564
  $amount,                          // 10000
  $cvv,                             // 123
  $card_number,                     // 4239000000000000
  $card_expiration_date             // 22/10
);

// Versión 4.x del SDK
var tx = new FullTransaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
var response = tx.Create(
                buyOrder: buy_order,
                sessionId: session_id,
                amount: amount,
                cvv: cvv,
                cardNumber: card_number,
                cardExpirationDate: card_expiration_date);

// Versión 3.x del SDK
FullTransaction.Create(
  buyOrder: buy_order,                        // ordenCompra12345678
  sessionId: session_id,                      // sesion1234564
  amount: amount,                             // 10000
  cvv: cvv,                                   // 123
  cardNumber: card_number,                    // 4239000000000000
  cardExpirationDate: card_expiration_date    // 22/10
);

@buy_order = "Orden de compra de la transaccion"
@session_id = "Identificador del servicio unico de transacción"
@amount = 1000 # monto en pesos
@card_number = "Numero de Tarjeta"
@card_expiration_date = "Fecha de expiracion en formato AA/MM"
@cvv = 123 # CVV de la tarjeta.

## Versión 2.x del SDK
@tx = Transbank::Webpay::TransaccionCompleta::Transaction.new(::Transbank::Common::IntegrationCommerceCodes::TRANSACCION_COMPLETA_DEFERRED)
@resp = @tx.capture(buy_order: @buy_order, session_id: @session_id, amount: @amount, cvv: @cvv, card_number: @card_number, card_expiration_date: @card_expiration_date) 

## Versión 1.x del SDK
Transbank::TransaccionCompleta::Transaction::create(
    buy_order: @buy_order,
    session_id: @session_id,
    amount: @amount,
    card_number: @card_number,
    cvv: @cvv,
    card_expiration_date: @card_expiration_date
  )

## Versión 3.x del SDK
from transbank.webpay.transaccion_completa.transaction import Transaction
## Versión 2.x del SDK
from transbank.transaccion_completa.transaction import Transaction

# leyendo variables desde un formulario
buy_order = 'Orden de compra de la transaccion '
session_id = 'Identificador del servicio unico de transacción'
amount = 10000; #monto en pesos
card_number = 'Numero de Tarjeta'
cvv = 123 #CVV de la tarjeta.
card_expiration_date = 'Fecha de expiracion en formato AA/MM'

// Versión 3.x del SDK
tx = Transaction(WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.create(
  buy_order: buy_order, session_id: session_id, amount: amount, cvv: cvv, 
  card_number: card_number, card_expiration_date: card_expiration_date
)

// Versión 2.x del SDK
resp = Transaction.create(
    buy_order=buy_order, session_id=session_id, amount=amount,
    card_number=card_number, cvv=cvv, card_expiration_date=card_expiration_date
)

POST /rswebpaytransaction/api/webpay/v1.2/transactions

Tbk-Api-Key-Id: 597055555530
Tbk-Api-Key-Secret: 579B532A7440BB0C9079DED94D31EA1615BACEB56610332264630D42D0A36B1C
Content-Type: application/json

{
  "buy_order": "ordenCompra12345678",
  "session_id": "sesion1234564",
  "amount": 10000,
  "cvv": 123,
  "card_number": "4239000000000000",
  "card_expiration_date": "22/10"
}

const TransaccionCompleta = require("transbank-sdk").TransaccionCompleta; // CommonJS
const { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } = require("transbank-sdk"); // CommonJS

import { TransaccionCompleta } from 'transbank-sdk'; // ES6 Modules
import { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } from 'transbank-sdk'; // ES6 Modules

// Versión 3.x del SDK
const tx = new TransaccionCompleta.Transaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, Environment.Integration));
const response = await tx.create(
  buyOrder, sessionId, amount, cvv, cardNumber, cardExpirationDate
);

// Versión 2.x del SDK
const response = await TransaccionCompleta.transaction.create(buyOrder, sessionId, amount, cvv, cardNumber, cardExpirationDate);

Parámetros Transaction.create

Respuesta Transaction.create

response.getToken();

$response->getToken();

response.Token;

response.token

## Versión 3.x del SDK
response['token']

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

200 OK
Content-Type: application/json

{
  "token": "e074d38c628122c63e5c0986368ece22974d6fee1440617d85873b7b4efa48a3",
}

response.token

Modalidad sin cvv

Para modalidad del producto Transacción completa sin CVV, este campo no debe ser enviado.

200 OK
Content-Type: application/json
{
  "buy_order": "ordenCompra12345678",
  "session_id": "sesion1234564",
  "amount": 10000,
  "card_number": "4239000000000000",
  "card_expiration_date": "22/10"
}

Consulta de cuotas

Para consultar el valor de las cuotas que pagará el tarjeta habiente en una transacción completa, es necesario llamar al método Transaction.installments()

Transaction.installments()

Operación que permite obtener el monto de la cuota a partir del número de cuotas. El id de la consulta que selecciona el tarjetahabiente debe ser informado en la invocación de la confirmación.

// Versión 3.x del SDK
MallFullTransaction tx = new MallFullTransaction(new WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final MallFullTransactionInstallmentsResponse response = tx.installments(token, installmentsDetails);

// Versión 2.x del SDK
final FullTransactionInstallmentsResponse response =  FullTransaction.Transaction.installment(token, installments_number);

use Transbank\TransaccionCompleta\Transaction;

$token = "token obtenido como respuesta de la creacion de transaccion";
$installmentsNumber = 10; // numero de cuotas;

$transaction = new Transaction();
$response = $transaction->installments(
    $token,
    $installmentsNumber
);

using Transbank.Webpay.TransaccionCompleta;
// Versión 4.x del SDK
var tx = new FullTransaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
var response = tx.Installments(
                token,
                installments_number);

// Versión 3.x del SDK
FullTransaction.Installments(
  token,
  installments_number
);

## Versión 2.x del SDK
@tx = Transbank::Webpay::TransaccionCompleta::Transaction.new(::Transbank::Common::IntegrationCommerceCodes::TRANSACCION_COMPLETA)
@resp = @tx.captureinstallments(token: token, installments_number: installments_number )

## Versión 1.x del SDK
Transbank::TransaccionCompleta::Transaction::installments(
   token: token,
   installments_number: installments_number
)

## Versión 3.x del SDK
from transbank.webpay.transaccion_completa.transaction import Transaction
## Versión 2.x del SDK
from transbank.transaccion_completa.transaction import Transaction

#obtener form desde el request
req = request.form
token = request.form.get('token') #token obtenido al iniciar la transaccion
installments_number = 10 #numero de cuotas

// Versión 3.x del SDK
tx = Transaction(WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.installments(token=token, installments_number=installments_number)

// Versión 2.x del SDK
resp = Transaction.installments(token=token, installments_number=installments_number)

POST /rswebpaytransaction/api/webpay/v1.2/transactions/{token}/installments

Tbk-Api-Key-Id: 597055555530
Tbk-Api-Key-Secret: 579B532A7440BB0C9079DED94D31EA1615BACEB56610332264630D42D0A36B1C
Content-Type: application/json

{
  "installments_number": 10
}

const TransaccionCompleta = require("transbank-sdk").TransaccionCompleta; // CommonJS
const { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } = require("transbank-sdk"); // CommonJS

import { TransaccionCompleta } from 'transbank-sdk'; // ES6 Modules
import { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } from 'transbank-sdk'; // ES6 Modules

// Versión 3.x del SDK
const tx = new TransaccionCompleta.Transaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, Environment.Integration));
const response = await tx.installments(token, installmentsNumber);

// Versión 2.x del SDK
const response = await TransaccionCompleta.Transaction.installments(token, installmentsNumber);

Parámetros Transaction.installments

Respuesta Transaction.installments

response.getInstallmentsAmount();
response.getIdQueryInstallments();
DeferredPeriod deferredPeriod = response.getDeferredPeriods()[0];
deferredPeriod.getAmount();
deferredPeriod.getPeriod();

$response->getInstallmentsAmount();
$response->getIdQueryInstallments();
$response->getDeferredPeriods();

response.InstallmentsAmount;
respone.IdQueryInstallments;
response.DeferredPeriods;

response.installments_amount
response.id_query_installments
response.deferred_periods

## Versión 3.x del SDK
response['installments_amount']
response['id_query_installments']
response['deferred_periods']

## Versión 2.x del SDK
response.installments_amount
response.id_query_installments
response.deferred_periods

response.installments_amount
response.id_query_installments
response.deferred_periods

Si el comercio no tiene configurado periodos diferidos, la respuesta de deferred_periods será []:

200 OK
Content-Type: application/json

{
  "installments_amount": 3334,
  "id_query_installments": 11,
  "deferred_periods": [
    {
      "amount": 1000,
      "period": 1
    }
  ]
}

Confirmación de la transacción

Una vez iniciada la transacción y consultado el monto de las cuotas, puedes confirmar y obtener el resultado de una transacción completa usando el metodo Transaction.commit().

Transaction.commit()

Operación que permite confirmar una transacción. Retorna el estado de la transacción.

import cl.transbank.transaccioncompleta.FullTransaction;
// Versión 3.x del SDK
FullTransaction tx = new FullTransaction(new WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final FullTransactionCommitResponse response = tx.commit(token, idQueryInstallments, deferredPeriodIndex, gracePeriod);

// Versión 2.x del SDK
final FullTransactionCommitResponse response = FullTransaction.Transaction.commit(
  token, idQueryInstallments, deferredPeriodIndex, gracePeriod
);

use Transbank\TransaccionCompleta\Transaction;
//...
$transaction = new Transaction();
$transaction->commit(
  $token_ws,
  $id_query_installments,
  $deferred_period_index,
  $grace_period
);

using Transbank.Webpay.TransaccionCompleta;

// Versión 4.x del SDK
var tx = new FullTransaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
var response = tx.Commit(token, idQueryInstallments, deferredPeriodsIndex, gracePeriods);

// Versión 3.x del SDK
FullTransaction.Commit(
  token, idQueryInstallments, deferredPeriodsIndex, gracePeriods
);

## Versión 2.x del SDK
@tx = Transbank::Webpay::TransaccionCompleta::Transaction.new(::Transbank::Common::IntegrationCommerceCodes::TRANSACCION_COMPLETA)
@resp = @tx.commit(
  token: token,
  id_query_installments: id_query_installments,
  deferred_period_index:deferred_period_index,
  grace_period: grace_period
)

## Versión 1.x del SDK
Transbank::TransaccionCompleta::Transaction::commit(
  token: token,
  id_query_installments: id_query_installments,
  deferred_period_index: deferred_period_index,
  grace_period: grace_period
)

## Versión 3.x del SDK
from transbank.webpay.transaccion_completa.transaction import Transaction
## Versión 2.x del SDK
from transbank.transaccion_completa.transaction import Transaction

## Versión 3.x del SDK
tx = Transaction(WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.commit(token=token,
                          id_query_installments=id_query_installments,
                          deferred_period_index=deferred_period_index,
                          grace_period=grace_period)

## Versión 2.x del SDK
resp = Transaction.commit(
  token=token,
  id_query_installments=id_query_installments,
  deferred_period_index=deferred_period_index,
  grace_period=grace_period
)

PUT /rswebpaytransaction/api/webpay/v1.2/transactions/{token}

Tbk-Api-Key-Id: 597055555530
Tbk-Api-Key-Secret: 579B532A7440BB0C9079DED94D31EA1615BACEB56610332264630D42D0A36B1C
Content-Type: application/json

{
  "id_query_installments": 15,
  "deferred_period_index": 1,
  "grace_period": false
}

const TransaccionCompleta = require("transbank-sdk").TransaccionCompleta; // CommonJS
const { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } = require("transbank-sdk"); // CommonJS

import { TransaccionCompleta } from 'transbank-sdk'; // ES6 Modules
import { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } from 'transbank-sdk'; // ES6 Modules

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

// Versión 2.x del SDK
const response = await TransaccionCompleta.Transaction.commit(
    token, idQueryInstallments, deferredPeriodIndex, gracePeriod);

Parámetros Transaction.commit

Respuesta Transaction.commit

response.getAccountingDate();
response.getAmount();
response.getAuthorizationCode();
response.getBuyOrder();
CardDetail cardDetail = response.getCardDetail();
cardDetail.getCardNumber();
response.getInstallmentsAmount();
response.getInstallmentsNumber();
response.getPaymentCodeType();
response.getResponseCode();
response.getSessionId();
response.getTransactionDate();

$response->getAccountingDate();
$response->getAmount();
$response->getAuthorizationCode();
$response->getBuyOrder();
$cardDetail = $response->getCardDetail();
$cardDetail->getCardNumber();
$response->getInstallmentsAmount();
$response->getInstallmentsNumber();
$response->getPaymentCodeType();
$response->getResponseCode();
$response->getSessionId();
$response->getTransactionDate();

response.AccountingDate;
response.Amount;
response.AuthorizationCoda;
response.BuyOrder;
var cardDetail = response.CardDetail;
cardDetail.CardNumber;
response.InstallmentsAmount;
response.InstallmentsNumber;
response.PaymentTypeCode;
response.ResponseCode;
response.SessionId;
response.Status;
response.TransactionDate;

response.amount
response.status
response.buy_order
response.session_id
response.card_number
response.accounting_date
response.transaction_date
response.authorization_code
response.payment_type_code
response.response_code
response.installments_number
response.installments_amount
response.balance

## Versión 3.x del SDK
response['amount']
response['status']
response['buy_order']
response['session_id']
response['card_number']
response['accounting_date']
response['transaction_date']
response['authorization_code']
response['payment_type_code']
response['response_code']
response['installments_number']
response['installments_amount']
response['balance']

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

200 OK
Content-Type: application/json

{
  "amount": 10000,
  "status": "AUTHORIZED",
  "buy_order": "ordenCompra12345678",
  "session_id": "sesion1234557545",
  "card_detail": {
    "card_number": "1234"
  },
  "accounting_date": "0320",
  "transaction_date": "2019-03-20T20:18:20Z",
  "authorization_code": "877550",
  "payment_type_code": "VN",
  "response_code": 0,
  "installments_number": 0,
  "installmentsAmount": 0
}

response.amount
response.status
response.buy_order
response.session_id
response.card_number
response.accounting_date
response.transaction_date
response.authorization_code
response.payment_type_code
response.response_code
response.installments_number
response.installments_amount
response.balance

Consultar estado de una transacción completa

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.

Transaction.status()

Obtiene resultado de transacción a partir de un token.

// Versión 3.x del SDK
import cl.transbank.webpay.transaccioncompleta.responses.FullTransactionStatusResponse;

FullTransaction tx = new FullTransaction(new WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final FullTransactionStatusResponse response = tx.status(token);

// Versión 2.x del SDK
import cl.transbank.transaccioncompleta.FullTransaction;

final FullTransactionStatusResponse response = FullTransaction.Transaction.status(token);

use Transbank\TransaccionCompleta\Transaction;

$transaction = new Transaction();
$transaction->status($token_ws);

using Transbank.Webpay.TransaccionCompleta;
// Versión 4.x del SDK
var tx = new FullTransaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
var response = tx.Status(token);

// Versión 3.x del SDK
FullTransaction.Status(token);

## Versión 2.x del SDK
@tx = Transbank::Webpay::TransaccionCompleta::Transaction.new(::Transbank::Common::IntegrationCommerceCodes::TRANSACCION_COMPLETA)
@resp = @tx.status(token: token)

## Versión 1.x del SDK
@resp = Transbank::TransaccionCompleta::Transaction::status(token: token)

## Versión 3.x del SDK
from transbank.webpay.transaccion_completa.transaction import Transaction
## Versión 2.x del SDK
from transbank.transaccion_completa.transaction import Transaction

## Versión 3.x del SDK
tx = Transaction(WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.status(token=token)

## Versión 2.x del SDK
resp = Transaction.status(token=token)

GET /rswebpaytransaction/api/webpay/v1.2/transactions/{token}
Tbk-Api-Key-Id: 597055555530
Tbk-Api-Key-Secret: 579B532A7440BB0C9079DED94D31EA1615BACEB56610332264630D42D0A36B1C
Content-Type: application/json

const TransaccionCompleta = require("transbank-sdk").TransaccionCompleta; // CommonJS
const { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } = require("transbank-sdk"); // CommonJS

import { TransaccionCompleta } from 'transbank-sdk'; // ES6 Modules
import { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } from 'transbank-sdk'; // ES6 Modules

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

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

Parámetros Transaction.status

Respuesta Transaction.status

response.getAccountingDate();
response.getAmount();
response.getAuthorizationCode();
response.getBuyOrder();
CardDetail cardDetail = response.getCardDetail();
cardDetail.getCardNumber();
response.getInstallmentsAmount();
response.getInstallmentsNumber();
response.getPaymentCodeType();
response.getResponseCode();
response.getSessionId();
response.getTransactionDate();

$response->getAccountingDate();
$response->getAmount();
$response->getAuthorizationCode();
$response->getBuyOrder();
$cardDetail = $response->getCardDetail();
$cardDetail->getCardNumber();
$response->getInstallmentsAmount();
$response->getInstallmentsNumber();
$response->getPaymentCodeType();
$response->getResponseCode();
$response->getSessionId();
$response->getTransactionDate();

response.AccountingDate;
response.Amount;
response.AuthorizationCoda;
response.BuyOrder;
var cardDetail = response.CardDetail;
cardDetail.CardNumber;
response.InstallmentsAmount;
response.InstallmentsNumber;
response.PaymentTypeCode;
response.ResponseCode;
response.SessionId;
response.Status;
response.TransactionDate;

response.amount
response.status
response.buy_order
response.session_id
response.card_number
response.accounting_date
response.transaction_date
response.authorization_code
response.payment_type_code
response.response_code
response.installments_number
response.installments_amount
response.balance

## Versión 3.x del SDK
response['amount']
response['status']
response['buy_order']
response['session_id']
response['card_number']
response['accounting_date']
response['transaction_date']
response['authorization_code']
response['payment_type_code']
response['response_code']
response['installments_number']
response['installments_amount']
response['balance']

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

200 OK
Content-Type: application/json

{
  "amount": 10000,
  "status": "AUTHORIZED",
  "buy_order": "ordenCompra12345678",
  "session_id": "sesion1234557545",
  "card_detail": {
    "card_number": "1234"
  },
  "accounting_date": "0320",
  "transaction_date": "2019-03-20T20:18:20Z",
  "authorization_code": "877550",
  "payment_type_code": "VN",
  "response_code": 0,
  "installments_number": 0
}

response.amount
response.status
response.buy_order
response.session_id
response.card_number
response.accounting_date
response.transaction_date
response.authorization_code
response.payment_type_code
response.response_code
response.installments_number
response.installments_amount
response.balance

Reversar o Anular un pago Transacción Completa

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

Para anular una transacción se debe invocar al método Transaction.refund().

Transaction.refund()

Permite solicitar a Webpay la anulación de una transacción realizada previamente y que se encuentre vigente.

// Versión 3.x del SDK
import cl.transbank.webpay.transaccioncompleta.responses.FullTransactionRefundResponse;

FullTransaction tx = new FullTransaction(new WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final FullTransactionRefundResponse response = tx.refund(token, amount);
// Versión 3.x del SDK
import cl.transbank.transaccioncompleta.FullTransaction;

final FullTransactionRefundResponse response = FullTransaction.Transaction.refund(token,amount);

use Transbank\TransaccionCompleta\Transaction;

$transaction = new Transaction();
$transaction->refund($token, $amount);

using Transbank.Webpay.TransaccionCompleta;

// Versión 4.x del SDK
var tx = new FullTransaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
var response = tx.Refund(token, amount);

// Versión 3.x del SDK
FullTransaction.Refund(token, amount);

## Versión 2.x del SDK
@tx = Transbank::Webpay::TransaccionCompleta::Transaction.new(::Transbank::Common::IntegrationCommerceCodes::TRANSACCION_COMPLETA)
@resp = @tx.refund(token: token, amount: amount)

## Versión 1.x del SDK
@resp = Transbank::TransaccionCompleta::Transaction::refund(token: token, amount: amount)

## Versión 3.x del SDK
from transbank.webpay.transaccion_completa.transaction import Transaction
## Versión 2.x del SDK
from transbank.transaccion_completa.transaction import Transaction

## Versión 3.x del SDK
tx = Transaction(WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.refund(token=token, amount=amount)

## Versión 2.x del SDK
resp = Transaction.refund(token=token, amount=amount)

POST /rswebpaytransaction/api/webpay/v1.2/transactions/{token}/refunds
Tbk-Api-Key-Id: 597055555530
Tbk-Api-Key-Secret: 579B532A7440BB0C9079DED94D31EA1615BACEB56610332264630D42D0A36B1C
Content-Type: application/json

{
 "amount": 1000
}

const TransaccionCompleta = require("transbank-sdk").TransaccionCompleta; // CommonJS
const { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } = require("transbank-sdk"); // CommonJS

import { TransaccionCompleta } from 'transbank-sdk'; // ES6 Modules
import { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } from 'transbank-sdk'; // ES6 Modules

// Versión 3.x del SDK
const tx = new TransaccionCompleta.Transaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, Environment.Integration));
const response = await tx.refund(token, amount);

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

Parámetros Transaction.refund

Respuesta Transaction.refund

En el caso de que la transacción corresponda a una Reversa solo se retorna el parámetro type (REVERSED).

response.getType();
response.getAuthorizationCode();
response.getAuthorizationDate();
response.getNullifiedAmount();
response.getBalance();
response.getResponse();

$response->getType();
$response->getAuthorizationCode();
$response->getAuthorizationDate();
$response->getNullifiedAmount();
$response->getBalance();
$response->getResponse();

response.AuthorizationCode;
response.AuthorizationDate;
response.Balance;
response.NullifiedAmount;
response.ResponseCode;
response.Type;

response.type
response.authorization_code
response.authorization_date
response.nullified_amount
response.balance
response.response_code

## Versión 3.x del SDK
response['type']
response['authorization_code']
response['authorization_date']
response['nullified_amount']
response['balance']
response['response_code']

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

200 OK
Content-Type: application/json
{
  "type": "NULLIFY",
  "authorization_code": "123456",
  "authorization_date": "2019-03-20T20:18:20Z",
  "nullified_amount": 1000.00,
  "balance": 0.00,
  "response_code": 0
}

response.type
response.authorization_code
response.authorization_date
response.nullified_amount
response.balance
response.response_code

Captura Diferida

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

Ejecutar captura diferida Transacción Completa

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()

Permite solicitar a Webpay la captura diferida de una transacción con autorización y sin captura simultánea.

PUT /rswebpaytransaction/api/webpay/v1.2/transactions/{token}/capture
Tbk-Api-Key-Id: 597055555531
Tbk-Api-Key-Secret: 579B532A7440BB0C9079DED94D31EA1615BACEB56610332264630D42D0A36B1C
Content-Type: application/json

{
  "buy_order": "415034240",
  "authorization_code": "12345",
  "capture_amount": 1000
}

## Versión 2.x del SDK
@tx = Transbank::Webpay::TransaccionCompleta::Transaction.new(::Transbank::Common::IntegrationCommerceCodes::TRANSACCION_COMPLETA_DEFERRED)
@resp = @tx.capture(
  token: token,
  buy_order: buy_order,
  authorization_code: authorization_code,
  capture_amount: capture_amount
)

## Versión 1.x del SDK
@resp = Transbank::TransaccionCompleta::Transaction.capture(
  token: token,
  buy_order: buy_order,
  authorization_code: authorization_code,
  capture_amount: capture_amount
)

const TransaccionCompleta = require("transbank-sdk").TransaccionCompleta; // CommonJS
const { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } = require("transbank-sdk"); // CommonJS

import { TransaccionCompleta } from 'transbank-sdk'; // ES6 Modules
import { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } from 'transbank-sdk'; // ES6 Modules

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

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

use Transbank\TransaccionCompleta\Transaction;

$transaction = new Transaction();
$transaction->capture($token, $buyOrder, $authorizationCode, $captureAmount);

// Versión 3.x del SDK
import cl.transbank.webpay.transaccioncompleta.responses.FullTransactionCaptureResponse;

FullTransaction tx = new FullTransaction(new WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA_DEFERRED, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final FullTransactionCaptureResponse response = tx.capture(token, buyOrder, authorizationCode, captureAmount);

// Versión 3.x del SDK
import cl.transbank.transaccioncompleta.FullTransaction;

final FullTransactionCaptureResponse response = FullTransaction.Transaction.capture(token, buyOrder, authorizationCode, captureAmount);

## Versión 3.x del SDK
tx = Transaction(WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA_DEFERRED, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.capture(token, buy_order, authorization_code, capture_amount)

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

Parámetros Transaction.capture

Respuesta Transaction.capture

200 OK
Content-Type: application/json
{
  "token": "e074d38c628122c63e5c0986368ece22974d6fee1440617d85873b7b4efa48a3",
  "authorization_code": "123456",
  "authorization_date": "2019-03-20T20:18:20Z",
  "captured_amount": 1000,
  "response_code": 0
}

response.authorization_code
response.authorization_date
response.captured_amount
response.response_code

$response->getToken();
$response->getAuthorizationCode();
$response->getAuthorizationDate();
$response->getCapturedAmount();
$response->getResponseCode();

response.token
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.token
response.authorization_code
response.authorization_date
response.captured_amount
response.response_code

response.getToken();
response.getAuthorizationCode();
response.getAuthorizationDate();
response.getCapturedAmount();
response.getResponseCode();

En caso de error pueden aparecer los siguientes códigos exclusivos del método Transaction.capture():

Transacción Completa Mall

Puedes revisar más detalles de esta operación en su documentación

Crear una Transacción Completa Mall

Para crear una Transacción Completa Mall basta llamar al método Transaction.create()

Transaction.create() Completa Mall

Permite inicializar una transacción Completa Mall en Webpay. Como respuesta a la invocación se genera un token que representa en forma única una transacción.

MallTransactionCreateDetails transactionDetails = MallTransactionCreateDetails.build()
  .add(amountMallOne, commerceCodeMallOne, buyOrderMallOne, installmentsNumberMallOne)
  .add(amountMallTwo, commerceCodeMallTwo, buyOrderMallTwo, installmentsNumberMallTwo);

// Versión 3.x del SDK
MallFullTransaction tx = new MallFullTransaction(new WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
MallFullTransactionCreateResponse response = tx.create(buyOrder, sessionId, cardNumber, cardExpirationDate, transactionDetails);

// Versión 2.x del SDK
final MallFullTransactionCreateResponse response = MallFullTransaction.Transaction.create(
  buyOrder,                           // ordenCompra12345678
  sessionId,                          // sesion1234564
  cardNumber,                         // 4239000000000000
  cardExpirationDate,                 // 22/10
  transactionDetails
);

use Transbank\TransaccionCompleta\MallTransaction;
use Transbank\TransaccionCompleta\TransaccionCompleta;

$transaction_details = [
    [
        'amount' => 10000,
        'commerce_code' => TransaccionCompleta::DEFAULT_MALL_CHILD_COMMERCE_CODE_1,
        'buy_order' => '123456789'
    ],
    [
        'amount' => 12000,
        'commerce_code' => TransaccionCompleta::DEFAULT_MALL_CHILD_COMMERCE_CODE_2,
        'buy_order' => '123456790'
    ],
];
$cardNumber = '4051885600446623';
$cardExpirationDate = '22/12';
$cvv = '123';

$transaction = new MallTransaction();
$response = $transaction->create(
    'buyOrder1',                         // ordenCompra12345678
    'sessionId' ,                        // sesion1234564
    $cardNumber,                       // 4239000000000000
    $cardExpirationDate,              // 22/10
    $transaction_details,
    $cvv);

print_r($response);

using Transbank.Webpay.TransaccionCompletaMall;

var details = new List<CreateDetails>();
details.Add(new CreateDetails(
    amountMallOne,
    commerceCodeMallOne,
    buyOrderMallOne
));
details.Add(new CreateDetails(
    amountMallTwo,
    comerceCodeMallTwo,
    buyOrderMallTwo
));

// Versión 4.x del SDK
var tx = new MallFullTransaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
var response = tx.Create(
    buyOrder: buy_order,
    sessionId: session_id,
    cardNumber: card_number,
    cardExpirationDate: card_expiration_date,
    details,
    cvv: cvv
);

// Versión 3.x del SDK
var response = MallFullTransaction.Create(
  buyOrder,
  sessionId,
  cardNumber,
  cardExpirationDate,
  details
);

details = [
  {
    amount: 10000,
    commerce_code: 597055555552,
    buy_order: '123456789'
  },
  {
    amount: 12000,
    commerce_code: 597055555553,
    buy_order: '123456790'
  }
]

## Versión 2.x del SDK
@tx = Transbank::Webpay::TransaccionCompleta::Transaction.new(::Transbank::Common::IntegrationCommerceCodes::TRANSACCION_COMPLETA)
@resp = @tx.create(buy_order: @buy_order, session_id: @session_id, card_number: @card_number, card_expiration_date: @card_expiration_date, @details, cvv: @cvv)

## Versión 1.x del SDK
@resp = Transbank::TransaccionCompleta::MallTransaction::create(
  buy_order: 'ordenCompra12345678',
  session_id: 'sesion1234564',
  card_number: 4239000000000000,
  card_expiration_date: '22/10',
  details: details
)

details = [
  {
      'commerce_code': 597055555552,
      'buy_order': '123456789',
      'amount': 10000
  },
  {
      'commerce_code': 597055555553,
      'buy_order': '123456790',
      'amount': 12000
  }
]

## Versión 3.x del SDK
tx = MallTransaction(WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.create(
  buy_order=buy_order,
  session_id=session_id,
  card_number=card_number, 
  card_expiration_date=card_expiration_date, 
  details=details, 
  cvv=None
)

## Versión 2.x del SDK
resp = Transaction.create(
  buy_order=buy_order,
  session_id=session_id,
  card_number=card_number, card_expiration_date=card_expiration_date, details=details
)

POST /rswebpaytransaction/api/webpay/v1.2/transactions

Tbk-Api-Key-Id: 597055555551
Tbk-Api-Key-Secret: 579B532A7440BB0C9079DED94D31EA1615BACEB56610332264630D42D0A36B1C
Content-Type: application/json

{
  "buy_order": "ordenCompra12345678",
  "session_id": "sesion1234564",
  "card_number": "4239000000000000",
  "cvv": 123,
  "card_expiration_date": "22/10",
  "details": [
    {
      "amount": 10000,
      "commerce_code": "597055555552",
      "buy_order": "123456789"
    },
    {
      "amount": 10000,
      "commerce_code": "597055555553",
      "buy_order": "123456790"
    }
  ]
}

const TransaccionCompleta = require("transbank-sdk").TransaccionCompleta; // CommonJS
const { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } = require("transbank-sdk"); // CommonJS
const TransactionDetail = require("transbank-sdk").TransactionDetail;  // CommonJS

import { TransaccionCompleta } from 'transbank-sdk'; // ES6 Modules
import { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } from 'transbank-sdk'; // ES6 Modules
import { TransactionDetail } from 'transbank-sdk'; // ES6 Modules

const details = [
  new TransactionDetail(amount, commerceCode, childBuyOrder),
  new TransactionDetail(amount2, commerceCode2, childBuyOrder2)
];

// Versión 3.x del SDK
const tx = new TransaccionCompleta.MallTransaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA_MALL, IntegrationApiKeys.WEBPAY, Environment.Integration));
const response = await tx.create(
  parentBuyOrder,
  sessionId,
  cardNumber,
  cardExpirationDate,
  details,
  cvv
);

// Versión 2.x del SDK
const response = await TransaccionCompleta.MallTransaction.create(
  parentBuyOrder,
  sessionId,
  cvv,
  cardNumber,
  cardExpirationDate,
  details
);

Parámetros Transaction.create Completa Mall

Respuesta Transaction.create Completa Mall

response.getToken();

$response->getToken();

response.Token;

response.token

## Versión 3.x del SDK
response['token']

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

200 OK
Content-Type: application/json

{
  "token": "e074d38c628122c63e5c0986368ece22974d6fee1440617d85873b7b4efa48a3",
}

response.token

Consulta de cuotas Completa Mall

Para consultar el valor de las cuotas que pagará el tarjeta habiente en cada transacción dentro transacción Completa Mall, es necesario llamar al método Transaction.installments()

Transaction.installments() Completa Mall

Operación que permite obtener el monto de la cuota a partir del número de cuotas. El id de la consulta que selecciona el tarjetahabiente debe ser informado en la invocación de la confirmación.

MallFullTransactionInstallmentsDetails installmentsDetails = MallFullTransactionInstallmentsDetails.build().add(commerceCode, buyOrder, installmentsNumber);

// Versión 3.x del SDK
MallFullTransaction tx = new MallFullTransaction(new WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final MallFullTransactionInstallmentsResponse response = tx.installments(token,installmentsDetails);

// Versión 2.x del SDK
final MallFullTransactionInstallmentsResponse response = MallFullTransaction.Transaction.installment(token, installmentsDetails);

use Transbank\TransaccionCompleta;
use Transbank\TransaccionCompleta\MallTransaction;

$transaction = new MallTransaction();

$installments_details = [
    [
        'commerce_code' => TransaccionCompleta::DEFAULT_MALL_CHILD_COMMERCE_CODE_1,
        'buy_order' => '123456789',
        'installments_number' => 2
    ],
    [
        'commerce_code' => TransaccionCompleta::DEFAULT_MALL_CHILD_COMMERCE_CODE_2,
        'buy_order' => '123456790',
        'installments_number' => 2
    ],
];

$response = $transaction->installments($token, $installments_details);
print_r($response);

using Transbank.Webpay.TransaccionCompletaMall;

var installmentsDetails = new List<MallInstallmentsDetails>();
installmentsDetails.Add(new CreateDetails(
    commerceCodeMallOne,
    buyOrderMallOne,
    installmentsNumberMallOne
));
installmentsDetails.Add(new CreateDetails(
    comerceCodeMallTwo,
    buyOrderMallTwo,
    installmentsNumberMallTwo
));

// Versión 4.x del SDK
var tx = new MallFullTransaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
var response = tx.Installments(
  token, installmentsDetails
);

// Versión 3.x del SDK
var response = MallFullTransaction.Installments(
  token, installmentDetails
);

installment_details = [
  {
    commerce_code: 597055555552,
    buy_order: '123456789',
    installments_number: 2
  },
  {
    commerce_code: 597055555553,
    buy_order: '123456790',
    installments_number: 2
  },
]

## Versión 2.x del SDK
@tx = Transbank::Webpay::TransaccionCompleta::Transaction.new(::Transbank::Common::IntegrationCommerceCodes::TRANSACCION_COMPLETA_MALL)
@resp = @tx.installments(token, installment_details)

## Versión 1.x del SDK
@resp = Transbank::TransaccionCompleta::MallTransaction::installments(token, installment_details)

## Versión 3.x del SDK
from transbank.webpay.transaccion_completa.mall_transaction import MallTransaction
## Versión 2.x del SDK
from transbank.transaccion_completa_mall.transaction import Transaction

details = [
  {
    'commerce_code': 597055555552,
    'buy_order': '123456789',
    'installments_number': 2
  },
  {
    'commerce_code': 597055555553,
    'buy_order': '123456790',
    'installments_number': 2
  }
]

## Versión 3.x del SDK
tx = MallTransaction(WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.installments(token=token, details=details)

## Versión 2.x del SDK
resp = Transaction.installments(token=token, details=details)

POST /rswebpaytransaction/api/webpay/v1.2/transactions/{token}/installments

Tbk-Api-Key-Id: 597055555551
Tbk-Api-Key-Secret: 579B532A7440BB0C9079DED94D31EA1615BACEB56610332264630D42D0A36B1C
Content-Type: application/json

{
  "commerce_code": 597055555552,
  "buy_order": "123456789",
  "installments_number": 10
}

const TransaccionCompleta = require("transbank-sdk").TransaccionCompleta; // CommonJS
const { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } = require("transbank-sdk"); // CommonJS
const InstallmentDetail = require("transbank-sdk").InstallmentDetail;  // CommonJS

import { TransaccionCompleta } from 'transbank-sdk'; // ES6 Modules
import { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } from 'transbank-sdk'; // ES6 Modules
import { InstallmentDetail } from 'transbank-sdk'; // ES6 Modules

const details = [
  new InstallmentDetail(childCommerceCode, childBuyOrder, installmentsNumber),
  new InstallmentDetail(childCommerceCode2, childBuyOrder2, installmentsNumber2)
  ];

// Versión 3.x del SDK
const tx = new TransaccionCompleta.MallTransaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA_MALL, IntegrationApiKeys.WEBPAY, Environment.Integration));
const response = await tx.installments(
  token,
  details
);

// Versión 2.x del SDK
const response = await TransaccionCompleta.MallTransaction.installments(
  token,
  details
);

Parámetros Transaction.installments Completa Mall

Respuesta Transaction.installments Completa Mall

response.getInstallmentsAmount();
response.getIdQueryInstallments();
DeferredPeriod deferredPeriod = response.getDeferredPeriods()[0];
deferredPeriod.getAmount();
deferredPeriod.getPeriod();

$firstResponse = $response[0];
$firstResponse->getInstallmentsAmount();
$firstResponse->getIdQueryInstallments();
$deferredPeriods = $firstResponse->getDeferredPeriods();
if (isset($deferredPeriods[0])) {
    $deferredPeriod = $deferredPeriods[0];
    $deferredPeriod->getAmount();
    $deferredPeriod->getPeriod();
}

response.InstallmentsAmount;
response.IdQueryInstallments;
var deferredPeriod = response.DeferredPeriods[0];
deferredPeriod.Amount;
deferredPeriod.Period;

response.installments_amount
response.id_query_installments
deferred_period = response.deferred_periods[0]
deferred_period.amount
deferred_period.period

## Versión 3.x del SDK
response['installments_amount']
response['id_query_installments']
response['deferred_periods']

## Versión 2.x del SDK
response.installments_amount
response.id_query_installments
deferred_period = response.deferred_periods[0]
deferred_period.amount
deferred_period.period

200 OK
Content-Type: application/json

{
  "installments_amount": 3334,
  "id_query_installments": 11,
  "deferred_periods": [
    {
      "amount": 1000,
      "period": 1
    }
  ]
}

response.installment_amount
response.id_query_installment
deferred_period = response.deferred_periods[0]
deferred_period.amount
deferred_period.period

Confirmación de la transacción Completa Mall

Una vez iniciada la transacción y consultado el monto de las cuotas por cada subtransacción, puedes confirmar y obtener el resultado de una transacción completa usando el metodo Transaction.commit().

Transaction.commit() Completa Mall

Operación que permite confirmar una transacción. Retorna el estado de la transacción.

MallTransactionCommitDetails details = MallTransactionCommitDetails.build().add(
  commerceCode,buyOrder,idQueryInstallments,deferredPeriodIndex,gracePeriod
);

// Versión 3.x del SDK
MallFullTransaction tx = new MallFullTransaction(new WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final MallFullTransactionCommitResponse response = tx.commit(token, details);

// Versión 2.x del SDK
final MallFullTransactionCommitResponse response = MallFullTransaction.Transaction.commit(token, details);

use Transbank\TransaccionCompleta;
use Transbank\TransaccionCompleta\MallTransaction;

$details = [
    [
        'commerce_code' => TransaccionCompleta::DEFAULT_MALL_CHILD_COMMERCE_CODE_1,
        'buy_order' => '123456789',
        'id_query_installments' => $firstInstallmentResponse->getIdQueryInstallments(),
        'deferred_period_index' => null,
        'grace_period' => false
    ],
    [
        'commerce_code' => TransaccionCompleta::DEFAULT_MALL_CHILD_COMMERCE_CODE_2,
        'buy_order' => '123456790',
        'id_query_installments' => $secondInstallmentResponse->getIdQueryInstallments(),
        'deferred_period_index' => null,
        'grace_period' => false
    ]
];

$transaction = new MallTransaction();
$response = $transaction->commit($token, $details);
print_r($response);

using Transbank.Webpay.TransaccionCompletaMall;

var transactionDetails = new List<MallCommitDetails>();
transactionDetails.Add(new MallCommitDetails(
    commerceCodeMallOne,
    buyOrderMallOne,
    idQueryInstallmentsOne,
    deferredPeriodIndexOne,
    gracePeriodOne
));
transactionDetails.Add(new MallCommitDetails(
    commerceCodeMallTwo,
    buyOrderMallTwo,
    idQueryInstallmentsTwo,
    deferredPeriodIndexTwo,
    gracePeriodTwo
));

// Versión 4.x del SDK
var tx = new MallFullTransaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
var response = tx.Commit(
  token, transactionDetails
);

// Versión 3.x del SDK
var response = MallFullTransaction.Commit(
  token, transactionDetails
);

details = [
  {
    commerce_code: '597055555552',
    buy_order: 'ordenCompra1234',
    id_query_installments: 12,
    deferred_period_index: 1,
    grace_period: false
  },
  {
    commerce_code: '597055555553',
    buy_order: 'ordenCompra12345',
    id_query_installments: 12,
    deferred_period_index: 1,
    grace_period: false
  }
]

## Versión 2.x del SDK
@tx = Transbank::Webpay::TransaccionCompleta::Transaction.new(::Transbank::Common::IntegrationCommerceCodes::TRANSACCION_COMPLETA_MALL)
@resp = @tx.commit(token: token, details: details)

## Versión 1.x del SDK
response = Transbank::TransaccionCompleta::MallTransaction::commit(
  token: token, details: details
)

details = [
  {
    "commerce_code": '597055555552',
    "buy_order": 'ordenCompra1234',
    "id_query_installments": 12,
    "deferred_period_index": 1,
    "grace_period": false
  },
  {
    "commerce_code": '597055555553',
    "buy_order": 'ordenCompra12345',
    "id_query_installments": 12,
    "deferred_period_index": 1,
    "grace_period": false
  }
]

## Versión 3.x del SDK
tx = MallTransaction(WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.commit(
  token=token, details=details
)

## Versión 2.x del SDK
resp = Transaction.commit(
  token=token, details=details
)

PUT /rswebpaytransaction/api/webpay/v1.2/transactions/{token}

Tbk-Api-Key-Id: 597055555551
Tbk-Api-Key-Secret: 579B532A7440BB0C9079DED94D31EA1615BACEB56610332264630D42D0A36B1C
Content-Type: application/json

{
  "details": [
    {
      "commerce_code": 597055555552,
      "buy_order": "ordenCompra1234",
      "id_query_installments": 12,
      "deferred_period_index": 1,
      "grace_period": false
    }
  ]
}

const TransaccionCompleta = require("transbank-sdk").TransaccionCompleta; // CommonJS
const { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } = require("transbank-sdk"); // CommonJS
const CommitDetail = require("transbank-sdk").CommitDetail;  // CommonJS

import { TransaccionCompleta } from 'transbank-sdk'; // ES6 Modules
import { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } from 'transbank-sdk'; // ES6 Modules
import { CommitDetail } from 'transbank-sdk'; // ES6 Modules

let commitDetails = [
  new CommitDetail(commerceCode, childBuyOrder),
  new CommitDetail(commerceCode2, childBuyOrder2)
];

// Versión 3.x del SDK
const tx = new TransaccionCompleta.MallTransaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA_MALL, IntegrationApiKeys.WEBPAY, Environment.Integration));
const response = await tx.commit(
  token,
  commitDetails
);

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

print_r($response);
//Transbank\TransaccionCompleta\Responses\MallTransactionCommitResponse Object
//(
//    [buyOrder] => buyOrder1
//    [cardDetail] => Array
//        (
//            [card_number] => 6623
//        )
//
//    [accountingDate] => 0414
//    [transactionDate] =>
//    [details] => Array
//        (
//            [0] => Array
//                (
//                    [amount] => 10000
//                    [status] => AUTHORIZED
//                    [authorization_code] => 1213
//                    [payment_type_code] => S2
//                    [response_code] => 0
//                    [installments_amount] => 5000
//                    [installments_number] => 2
//                    [commerce_code] => 597055555574
//                    [buy_order] => 123456789
//                )
//
//            [1] => Array
//                (
//                    [amount] => 12000
//                    [status] => AUTHORIZED
//                    [authorization_code] => 1213
//                    [payment_type_code] => S2
//                    [response_code] => 0
//                    [installments_amount] => 5000
//                    [installments_number] => 2
//                    [commerce_code] => 597055555575
//                    [buy_order] => 123456790
//                )
//
//        )
//
//)

Parámetros Transaction.commit Completa Mall

Respuesta Transaction.commit Completa Mall

response.getBuyOrder();
response.getCardNumber();
response.getAccountingDate();
response.getTransactionDate();
Detail detail = response.getDetails()[0];
detail.getAuthorizationCode();
detail.getPaymentCodeType();
detail.getResponseCode();
detail.getInstallmentsAmount();
detail.getInstallmentsNumber();
detail.getAmount();
detail.getCommerceCode();
detail.getBuyOrder();
detail.getStatus();
detail.getBalance();

$response->getBuyOrder();
$response->getCardNumber();
$response->getAccountingDate();
$response->getTransactionDate();
$detail = $response->getDetails()[0];
$detail->getAuthorizationCode();
$detail->getPaymentTypeCode();
$detail->getResponseCode();
$detail->getInstallmentsAmount();
$detail->getInstallmentsNumber();
$detail->getAmount();
$detail->getCommerceCode();
$detail->getBuyOrder();
$detail->getStatus();

response.BuyOrder;
response.CardNumber;
response.AccountingDate;
response.TransactionDate;
detail = response.Details[0];
detail.AuthorizationCode;
detail.PaymentCodeType;
detail.ResponseCode;
detail.InstallmentsAmount;
detail.InstallmentsNumber;
detail.Amount;
detail.CommerceCode;
detail.BuyOrder;
detail.Status;
detail.Balance;

response.buy_order
response.card_number
response.accounting_date
response.transaction_date
detail = response.details[0]
detail.authorization_code
detail.payment_code_type
detail.response_code
detail.installments_amount
detail.installments_number
detail.amount
detail.commerce_code
detail.buy_order
detail.status
detail.balance

## Versión 3.x del SDK
response['buy_order']
response['card_number']
response['accounting_date']
response['transaction_date']
response['details']

## Versión 2.x del SDK
response.buy_order
response.card_number
response.accounting_date
response.transaction_date
detail = response.details[0]
detail.authorization_code
detail.payment_code_type
detail.response_code
detail.installments_amount
detail.installments_number
detail.amount
detail.commerce_code
detail.buy_order
detail.status
detail.balance

200 OK
Content-Type: application/json

{
  "buy_order": "415034240",
  "card_detail": {
    "card_number": "6623"
  },
  "accounting_date": "0321",
  "transaction_date": "2019-03-21T15:43:48.523Z",
  "details": [
    {
      "amount": 500,
      "status": "AUTHORIZED",
      "authorization_code": "1213",
      "payment_type_code": "VN",
      "response_code": 0,
      "installments_number": 0,
      "commerce_code": "597055555552",
      "buy_order": "505479072"
    }
  ]
}

response.buy_order
response.card_number
response.accounting_date
response.transaction_date
detail = response.details[0]
detail.authorization_code
detail.payment_code_type
detail.response_code
detail.installments_amount
detail.installments_number
detail.amount
detail.commerce_code
detail.buy_order
detail.status
detail.balance

Consultar estado de una Transacción Completa Mall

Esta operación permite obtener el estado de la transacción Completa Mall 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.

Transaction.status() Completa Mall

Obtiene resultado de transacción a partir de un token.

// Versión 3.x del SDK
MallFullTransaction tx = new MallFullTransaction(new WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final MallFullTransactionStatusResponse response = tx.status(tokenWs);

// Versión 2.x del SDK
MallFullTransaction.Transaction.status(token);

use Transbank\TransaccionCompleta\MallTransaction;

$response = (new MallTransaction)->status(token);

using Transbank.Webpay.TransaccionCompletaMall;

// Versión 4.x del SDK
var tx = new MallFullTransaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
var response = tx.Status(token);

// Versión 3.x del SDK
MallFullTransaction.Status(token);

## Versión 2.x del SDK
@tx = Transbank::Webpay::TransaccionCompleta::Transaction.new(::Transbank::Common::IntegrationCommerceCodes::TRANSACCION_COMPLETA_MALL)
@resp = @tx.status(token)

## Versión 1.x del SDK
@resp = Transbank::TransaccionCompleta::MallTransaction::status(token)

## Versión 3.x del SDK
tx = MallTransaction(WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.status(token)

## Versión 2.x del SDK
resp = Transaction.status(token)

GET /rswebpaytransaction/api/webpay/v1.2/transactions/{token}
Tbk-Api-Key-Id: 597055555551
Tbk-Api-Key-Secret: 579B532A7440BB0C9079DED94D31EA1615BACEB56610332264630D42D0A36B1C
Content-Type: application/json

const TransaccionCompleta = require("transbank-sdk").TransaccionCompleta; // CommonJS
const { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } = require("transbank-sdk"); // CommonJS

import { TransaccionCompleta } from 'transbank-sdk'; // ES6 Modules
import { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } from 'transbank-sdk'; // ES6 Modules

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

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

Parámetros Transaction.status Completa Mall

Respuesta Transaction.status Completa Mall

response.getBuyOrder();
response.getCardNumber();
response.getAccountingDate();
response.getTransactionDate();
Detail detail = response.getDetails()[0];
detail.getAuthorizationCode();
detail.getPaymentCodeType();
detail.getResponseCode();
detail.getInstallmentsAmount();
detail.getInstallmentsNumber();
detail.getAmount();
detail.getCommerceCode();
detail.getBuyOrder();
detail.getStatus();
detail.getBalance();

$response->getBuyOrder();
$response->getCardNumber();
$response->getAccountingDate();
$response->getTransactionDate();
$detail = $response->getDetails()[0];
$detail->getAuthorizationCode();
$detail->getPaymentTypeCode();
$detail->getResponseCode();
$detail->getInstallmentsAmount();
$detail->getInstallmentsNumber();
$detail->getAmount();
$detail->getCommerceCode();
$detail->getBuyOrder();
$detail->getStatus();

response.BuyOrder;
response.CardNumber;
response.AccountingDate;
response.TransactionDate;
detail = response.Details[0];
detail.AuthorizationCode;
detail.PaymentCodeType;
detail.ResponseCode;
detail.InstallmentsAmount;
detail.InstallmentsNumber;
detail.Amount;
detail.CommerceCode;
detail.BuyOrder;
detail.Status;
detail.Balance;

response.buy_order
response.card_number
response.accounting_date
response.transaction_date
detail = response.details[0]
detail.authorization_code
detail.payment_code_type
detail.response_code
detail.installments_amount
detail.installments_number
detail.amount
detail.commerce_code
detail.buy_order
detail.status
detail.balance

## Versión 3.x del SDK
response['buy_order']
response['card_number']
response['accounting_date']
response['transaction_date']
response['details']

## Versión 2.x del SDK
response.buy_order
response.card_number
response.accounting_date
response.transaction_date
detail = response.details[0]
detail.authorization_code
detail.payment_code_type
detail.response_code
detail.installments_amount
detail.installments_number
detail.amount
detail.commerce_code
detail.buy_order
detail.status
detail.balance

200 OK
Content-Type: application/json

{
  "buy_order": "415034240",
  "card_detail": {
    "card_number": "6623"
  },
  "accounting_date": "0321",
  "transaction_date": "2019-03-21T15:43:48.523Z",
  "details": [
    {
      "amount": 500,
      "status": "AUTHORIZED",
      "authorization_code": "1213",
      "payment_type_code": "VN",
      "response_code": 0,
      "installments_number": 0,
      "commerce_code": "597055555552",
      "buy_order": "505479072"
    }
  ]
}

response.buy_order
response.card_number
response.accounting_date
response.transaction_date
detail = response.details[0]
detail.authorization_code
detail.payment_code_type
detail.response_code
detail.installments_amount
detail.installments_number
detail.amount
detail.commerce_code
detail.buy_order
detail.status
detail.balance

Anulación Transacción Completa Mall

Permite generar el reembolso del total o parte del monto de una transacción completa. Dependiendo de la siguiente lógica de negocio la invocación a esta operación generará una reversa o una anulación:

• Si se especifica un valor en el campo “amount” se ejecutará siempre una anulación.
• Si se supera el tiempo máximo para ejecutar una reversa se ejecutará una anulación.
• Si no se ha dado ninguno de los casos anteriores se ejecutará una reversa.

Transaction.refund() Completa Mall

Permite solicitar a Webpay la anulación de una transacción realizada previamente y que se encuentre vigente.

// Versión 3.x del SDK
MallFullTransaction tx = new MallFullTransaction(new WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final MallFullTransactionRefundResponse response = tx.refund(token, buyOrder, childCommerceCode, amount);

// Versión 2.x del SDK
final MallFullTransactionRefundResponse response = MallFullTransaction.Transaction.refund(
  token, amount, commerceCode, buyOrder
);

use Transbank\TransaccionCompleta\MallTransaction;

(new MallTransaction)->refund(
  $token,
  $childBuyOrder,
  $childCommerceCode,
  $amount
);

using Transbank.Webpay.TransaccionCompletaMall;

// Versión 4.x del SDK
var tx = new MallFullTransaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
var response = tx.Refund(
  token,
  buyOrder,
  childCommerceCode,
  amount
);

// Versión 3.x del SDK
var response = MallFullTransaction.Refund(
  token,
  childBuyOrder,
  childCommerceCode,
  amount
);

## Versión 2.x del SDK
@tx = Transbank::Webpay::TransaccionCompleta::Transaction.new(::Transbank::Common::IntegrationCommerceCodes::TRANSACCION_COMPLETA_MALL)
@resp = @tx.refund(
  token: token,
  buy_order: child_buy_order,
  commerce_code_child: child_commerce_code,
  amount: amount
)

## Versión 1.x del SDK
@resp = Transbank::TransaccionCompleta::MallTransaction::refund(
  token: token,
  child_buy_order: child_buy_order,
  child_commerce_code: child_commerce_code,
  amount: amount
)

## Versión 3.x del SDK
from transbank.webpay.transaccion_completa.mall_transaction import MallTransaction
## Versión 2.x del SDK
from transbank.transaccion_completa_mall.transaction import Transaction

## Versión 3.x del SDK
tx = MallTransaction(WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA_MALL, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.refund(token: token, child_buy_order: child_buy_order, child_commerce_code: child_commerce_code, amount: amount)

## Versión 2.x del SDK
resp = Transaction.refund(
  token=token, amount=amount, child_commerce_code=child_commerce_code, child_buy_order=child_buy_order
)

POST /rswebpaytransaction/api/webpay/v1.2/transactions/{token}/refunds
Tbk-Api-Key-Id: 597055555551
Tbk-Api-Key-Secret: 579B532A7440BB0C9079DED94D31EA1615BACEB56610332264630D42D0A36B1C
Content-Type: application/json

{
  "buy_order": "415034240",
  "commerce_code": "597055555552",
  "amount": 1000
}

const TransaccionCompleta = require("transbank-sdk").TransaccionCompleta; // CommonJS
const { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } = require("transbank-sdk"); // CommonJS

import { TransaccionCompleta } from 'transbank-sdk'; // ES6 Modules
import { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } from 'transbank-sdk'; // ES6 Modules


// Versión 3.x del SDK
const tx = new TransaccionCompleta.MallTransaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA_MALL, IntegrationApiKeys.WEBPAY, Environment.Integration));
const response = await tx.refund(
  token,
  buyOrder,
  commerceCode,
  amount
);

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

Parámetros Transaction.refund Completa Mall

Respuesta Transaction.refund Completa Mall

En el caso de que la transacción corresponda a una Reversa solo se retorna el parámetro type (REVERSED).

response.getType();
response.getAuthorizationCode();
response.getAuthorizationDate();
response.getNullifiedAmount();
response.getBalance();
response.getResponseCode();

$response->getType();
$response->getAuthorizationCode();
$response->getAuthorizationDate();
$response->getNullifiedAmount();
$response->getBalance();
$response->getResponseCode();

response.Type;
response.AuthorizationCode;
response.AuthorizationDate;
response.NullifiedAmount;
response.Balance;
response.ResponseCode;

response.type
response.authorization_code
response.authorization_date
response.nullified_amount
response.balance
response.response_code

## Versión 3.x del SDK
response['type']
response['authorization_code']
response['authorization_date']
response['nullified_amount']
response['balance']
response['response_code']

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

200 OK
Content-Type: application/json
{
  "type": "NULLIFY",
  "authorization_code": "123456",
  "authorization_date": "2019-03-20T20:18:20Z",
  "nullified_amount": 1000.00,
  "balance": 0.00,
  "response_code": 0
}

response.type
response.authorization_code
response.authorization_date
response.nullified_amount
response.balance
response.response_code

Captura Diferida mall

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

Ejecutar captura diferida mall

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.

PUT /rswebpaytransaction/api/webpay/v1.2/transactions/{token}/capture
Tbk-Api-Key-Id: 597055555531
Tbk-Api-Key-Secret: 579B532A7440BB0C9079DED94D31EA1615BACEB56610332264630D42D0A36B1C
Content-Type: application/json

{
  "commerce_code": "597055555531",
  "buy_order": "415034240",
  "authorization_code": "12345",
  "capture_amount": 1000
}

## Versión 2.x del SDK
@tx = Transbank::Webpay::TransaccionCompleta::Transaction.new(::Transbank::Common::IntegrationCommerceCodes::TRANSACCION_COMPLETA_MALL_DEFERRED)
@resp = @tx.capture(
  token: token,
  commerce_code: commerce_code,
  buy_order: buy_order,
  authorization_code: authorization_code,
  amount: capture_amount
)

## Versión 1.x del SDK
@resp = Transbank::TransaccionCompleta::MallTransaction.capture(
  token: token,
  commerce_code: commerce_code,
  buy_order: buy_order,
  authorization_code: authorization_code,
  capture_amount: capture_amount
)

use Transbank\TransaccionCompleta\MallTransaction;

$transaction = new MallTransaction();
$transaction->capture($token, $commerceCode, $buyOrder, $authorizationCode, $captureAmount);

const TransaccionCompleta = require("transbank-sdk").TransaccionCompleta; // CommonJS
const { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } = require("transbank-sdk"); // CommonJS

import { TransaccionCompleta } from 'transbank-sdk'; // ES6 Modules
import { Options, IntegrationApiKeys, Environment, IntegrationCommerceCodes } from 'transbank-sdk'; // ES6 Modules


// Versión 3.x del SDK
const tx = new TransaccionCompleta.MallTransaction(new Options(IntegrationCommerceCodes.TRANSACCION_COMPLETA_MALL_DEFERRED, IntegrationApiKeys.WEBPAY, Environment.Integration));
const response = await tx.refund(
  token, commerceCode, buyOrder, authorizationCode, amount
);

// Versión 2.x del SDK
const response = TransaccionCompleta.MallDeferredTransaction.capture(
  token, commerceCode, buyOrder, authorizationCode, amount
);

from transbank.transaccion_completa_mall.transaction import Transaction

## Versión 3.x del SDK
tx = MallTransaction(WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA_MALL_DEFERRED, IntegrationApiKeys.WEBPAY, IntegrationType.TEST))
resp = tx.capture(token, child_commerce_code, child_buy_order, authorization_code, capture_amount)

## Versión 2.x del SDK
Transaction.capture(
  token, child_commerce_code, child_buy_order, authorization_code, capture_amount
)

// Versión 3.x del SDK
MallFullTransaction tx = new MallFullTransaction(new WebpayOptions(IntegrationCommerceCodes.TRANSACCION_COMPLETA_MALL_DEFERRED, IntegrationApiKeys.WEBPAY, IntegrationType.TEST));
final MallFullTransactionCaptureResponse response = tx.capture(token, commerceCode, buyOrder, authorizationCode, captureAmount);

// Versión 2.x del SDK
final MallFullTransactionCaptureResponse response = MallFullTransaction.Transaction.capture(
  token, commerceCode, buyOrder, authorizationCode, captureAmount
);

Parámetros Transaction.capture

Respuesta Transaction.capture

200 OK
Content-Type: application/json
{
  "token": "e074d38c628122c63e5c0986368ece22974d6fee1440617d85873b7b4efa48a3",
  "authorization_code": "123456",
  "authorization_date": "2019-03-20T20:18:20Z",
  "captured_amount": 1000,
  "response_code": 0
}

$response->getToken();
$response->getAuthorizationCode();
$response->getAuthorizationDate();
$response->getCapturedAmount();
$response->getResponseCode();

response.authorization_code
response.authorization_date
response.captured_amount
response.response_code

response.getToken();
response.getAuthorizationCode();
response.getAuthorizationDate();
response.getCapturedAmount();
response.getResponseCode();

response.token
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.token
response.authorization_code
response.authorization_date
response.captured_amount
response.response_code

En caso de error pueden aparecer los siguientes códigos exclusivos del método Transaction.capture():

Códigos y mensajes de error

Al realizar cualquier solicitud al API REST, además de los datos de respuesta, se incluirá uno de los siguientes códigos de estado de respuesta HTTP dependiendo del resultado obtenido:

Solicitud exitosa

Cuando la operación solcitada es ejecutada correctamente, se pueden recibir estos status HTTP:

Códigos de error

Todos los errores reportados por la API REST de Webpay despliegan un mensaje JSON con una descripción del error.

{
  "error_message": "token is required"
}

Puesta en Producción

Puedes revisar el proceso necesario para operar en el ambiente de producción en la documentación

Configuración para producción utilizando los SDK

Si estas utilizando algún SDK oficial de Transbank, entonces debes seguir los siguientes pasos.

Revisa esta sección de la documentación para ver el código necesario para configurar tu propio código de comercio y Api Key Secret.