API REST ejemplos de uso avanzados

Adapta Khipu a tus necesidades más específicas

Enviar un correo de cobro

Te mostraremos lo necesario antes de comenzar 

Comercios integradores

Como realizar una cuenta de cobro para aceptar pagos

Reembolsar cobro no rendido aún

Conoce los distintos aspectos de seguridad

Crear un cobro y distribuirlo usando su URL

Aprende a realizar un pago

Cobro con autenticación

Se utiliza el identificador personal del usuario              

Distribuir URL de cobro

El cobro que creaste puede ser usado donde quieras

Eliminar un pago

En algunas ocaciones es necesario borrar un cobro generado

1.- Enviar un correo electrónico de cobro

Puedes hacer que Khipu envíe automáticamente un correo electrónico con el cobro que generas. Lo único que necesitas es llenar un par de campos:

  • payer_name: Es el nombre de la persona que debe pagar.
  • payer_email: Es la dirección de correo electrónico del pagador.
  • send_email: Si envías “true” Khipu enviará la solicitud de pago por correo.

Es importante notar algunas cosas:

  • Si “send_email” es “true”, ambos (payer_name y payer_email) serán obligatorios.
  • El contenido del campo “body” no se envía en el correo electrónico. Solo se despliega en la página de pago.
  • Si además de enviar «true» en el campo «send_email», también envías «true» en el campo «send_reminders», además del correo inicial de cobro, se enviarán otros dos correos de recordatorio con una separación de una semana entre cada uno, siempre y cuando el cobro no haya sido pagado o eliminado al momento de gestionar el recordatorio.
Código de ejemplo:

 

<?php
require __DIR__ . '/vendor/autoload.php';

$configuration = new KhipuConfiguration();
$configuration->setSecret('secret-key');
$configuration->setReceiverId(receiver_id);
$configuration->setPlatform('demo-client', '2.0');
$configuration->setDebug(true);

$client = new KhipuApiClient($configuration);
$payments = new KhipuClientPaymentsApi($client);

try {
    $opts = array(
        "payer_name" => "John Connor",
        "payer_email" => "jconnor@the-future.com",
        "send_email" => true,
        "send_reminders" => true,
    );
    $response = $payments->paymentsPost("Compra de prueba de la API" //Motivo de la compra
        , "CLP" //Moneda
        , 100.0 //Monto
        , $opts
    );

    print_r($response);
} catch (KhipuApiException $e) {
    echo print_r($e->getResponseBody(), TRUE);
}
ApiClient apiClient = new ApiClient();
apiClient.setKhipuCredentials(receiverId, 'secret-key');
apiClient.setPlatform("demo-client", "2.0");
// apiClient.setDebugging(true);
PaymentsApi paymentsApi = new PaymentsApi();
paymentsApi.setApiClient(apiClient);

Map<String, Object> options = new HashMap<>();
options.put("sendEmail", true);
options.put("sendReminders", true);
options.put("payerEmail", "juan.pagador@correo.com");
options.put("payerName", "Juan Pagador");

PaymentsCreateResponse response = paymentsApi.paymentsPost("Compra de prueba de la API" //Motivo de la compra
        , "CLP" //Moneda
        , 100.0 //Monto
        , "MTI-100" //Identificador de la transacción en el comercio
        , options
);

System.out.println(response);
require 'khipu-api-client'

Khipu.configure do |c|
  c.secret = 'secret-key'
  c.receiver_id = receiver_id
  c.platform = 'demo-client'
  c.platform_version = '2.0'
  # c.debugging = true
end

client = Khipu::PaymentsApi.new

response = client.payments_post('Skynet', 'CLP', 1000, {
    payer_name: 'John Connor',
    payer_email: 'jconnor@the-future.com',
    send_email: true,
    send_reminders: true,
})
Configuration.ReceiverId = obtener-al-crear-una-cuenta-de-cobro;
Configuration.Secret = "obtener-al-crear-una-cuenta-de-cobro";
PaymentsApi a = new PaymentsApi();
try
{
    PaymentsCreateResponse response = a.PaymentsPost("Compra de prueba de la API", "CLP", 100.0
                        , sendEmail: true
                        , sendReminders: true
                        , payerEmail: "juan.pagador@correo.com"
                        , payerName: "Juan Pagador");
    System.Console.WriteLine(response);
}
catch (ApiException e)
{
    Console.WriteLine(e);
}

2.- Crear un cobro y distribuirlo usando su URL

 

Puedes hacer que Khipu cree un link del cobro que generas para ser usado donde quieras. Lo único que necesitas es llenar un par de campos:

  • payer_name: Es el nombre de la persona que debe pagar.
  • payer_email: Es la dirección de correo electrónico del pagador.
  • send_email: “false”. (Usar true en caso de que además se quiera enviar un email de Khipu con el cobro.)
  • body: Texto que se desplegará en la página de pago

Es importante notar algunas cosas:

El contenido del campo “body” no se envía en el correo electrónico. Solo se despliega en la página de pago. Si “send_email” es “true” puedes enviar “true” en el parámetro “send_reminders”. Al hacer esto, Khipu enviará 2 recordatorios de pago. Uno una semana después del cobro y otro la segunda semana después.

Código de ejemplo:
<?php
require __DIR__ . '/vendor/autoload.php';

$configuration = new KhipuConfiguration();
$configuration->setSecret('secret-key');
$configuration->setReceiverId(receiver_id);
$configuration->setPlatform('demo-client', '2.0');
$configuration->setDebug(true);

$client = new KhipuApiClient($configuration);
$payments = new KhipuClientPaymentsApi($client);

try {
    $opts = array(
        "payer_name" => "John Connor",
        "payer_email" => "jconnor@the-future.com",
        "send_email" => false,
        "send_reminders" => fale,
    );
    $response = $payments->paymentsPost("Compra de prueba de la API" //Motivo de la compra
        , "CLP" //Moneda
        , 100.0 //Monto
        , $opts
    );

    $paymentUrl = $response->getPaymentUrl(); // URL de cobro

    print_r($response);
} catch (KhipuApiException $e) {
    echo print_r($e->getResponseBody(), TRUE);
}
ApiClient apiClient = new ApiClient();
apiClient.setKhipuCredentials(receiverId, 'secret-key');
apiClient.setPlatform("demo-client", "2.0");
// apiClient.setDebugging(true);
PaymentsApi paymentsApi = new PaymentsApi();
paymentsApi.setApiClient(apiClient);

Map<String, Object> options = new HashMap<>();
options.put("sendEmail", false);
options.put("sendReminders", false);
options.put("payerEmail", "juan.pagador@correo.com");
options.put("payerName", "Juan Pagador");

PaymentsCreateResponse response = paymentsApi.paymentsPost("Compra de prueba de la API" //Motivo de la compra
        , "CLP" //Moneda
        , 100.0 //Monto
        , "MTI-100" //Identificador de la transacción en el comercio
        , options
);

String paymentUrl = response.getPaymentUrl(); // URL de cobro

System.out.println(response);
require 'khipu-api-client'

Khipu.configure do |c|
  c.secret = 'secret-key'
  c.receiver_id = receiver_id
  c.platform = 'demo-client'
  c.platform_version = '2.0'
  # c.debugging = true
end

client = Khipu::PaymentsApi.new

response = client.payments_post('Skynet', 'CLP', 1000, {
    payer_name: 'John Connor',
    payer_email: 'jconnor@the-future.com',
    send_email: false,
    send_reminders: false,
})

paymentUrl = response[:'payment_url'] # URL de cobro
Configuration.ReceiverId = obtener-al-crear-una-cuenta-de-cobro;
Configuration.Secret = "obtener-al-crear-una-cuenta-de-cobro";
PaymentsApi a = new PaymentsApi();
try
{
    PaymentsCreateResponse response = a.PaymentsPost("Compra de prueba de la API", "CLP", 100.0
                        , sendEmail: true
                        , sendReminders: true
                        , payerEmail: "juan.pagador@correo.com"
                        , payerName: "Juan Pagador");

    paymentUrl = response.paymentUrl; // URL de cobro

    System.Console.WriteLine(response);
}
catch (ApiException e)
{
    Console.WriteLine(e);
}

3.- Crear un cobro con fecha de expiración 

Muchas veces un cobro solo debe ser válido hasta una fecha en particular, por ejemplo, pagar una entrada a un evento (luego del evento no tiene sentido pagarlo). Para esto podemos especificar una fecha máxima de pago o fecha de expiración. Luego de esta fecha el pago no puede ser cancelado.

La fecha máxima para un pago se envía en el parámetro “expires_date”. Esta fecha tiene algunas condiciones:

  • Debe ser mayor a la fecha del momento en que se genera el cobro y debe ser menor a ese momento más 10 años.
  • Si la llamada se hace directo usando el método POST, la fecha debe ir en el formato ISO 8601

Aunque no se envíe la fecha de expiración el pago se generará con una. En el caso de que sea una solicitud por correo electrónico (cuando “send_email” es “true”) es 60 días desde el momento de la creación. Si no es una solicitud de cobro entonces el plazo es de un día.

Veamos el siguiente código para crear un pago usando fecha de expiración:

<?php
require __DIR__ . '/vendor/autoload.php';

$configuration = new KhipuConfiguration();
$configuration->setSecret('secret-key');
$configuration->setReceiverId(receiver_id);
$configuration->setPlatform('demo-client', '2.0');
# $configuration->setDebug(true);

$client = new KhipuApiClient($configuration);
$payments = new KhipuClientPaymentsApi($client);

try {
    $expires_date = new DateTime();
    $expires_date->setDate(2019, 4, 4);

    $opts = array(
        "expires_date" => $expires_date
    );

    $response = $payments->paymentsPost("Compra de prueba de la API" //Motivo de la compra
        , "CLP" //Moneda
        , 100.0 //Monto
        , $opts
    );

    print_r($response);
} catch (KhipuApiException $e) {
    echo print_r($e->getResponseBody(), TRUE);
}
ApiClient apiClient = new ApiClient();
apiClient.setKhipuCredentials(receiverId, "secret-key");
apiClient.setPlatform("demo-client", "2.0");
// apiClient.setDebugging(true);
PaymentsApi paymentsApi = new PaymentsApi();
paymentsApi.setApiClient(apiClient);
Calendar calendar = Calendar.getInstance();
calendar.set(2019,Calendar.APRIL,4);

Map<String, Object> options = new HashMap<>();
options.put("expiresDate", calendar.getTime());

PaymentsCreateResponse response = paymentsApi.paymentsPost("Compra de prueba de la API" //Motivo de la compra
        , "CLP" //Moneda
        , 100.0 //Monto
        , options
);

System.out.println(response);
require 'khipu-api-client'

Khipu.configure do |c|
  c.secret = 'secret-key'
  c.receiver_id = receiver_id
  c.platform = 'demo-client'
  c.platform_version = '2.0'
  # c.debugging = true
end

client = Khipu::PaymentsApi.new

response = client.payments_post('Ejemplo con fecha de expiración', 'CLP', 1000, {
    expires_date: DateTime.new(2016, 4, 4)
})

print response
Configuration.ReceiverId = obtener-al-crear-una-cuenta-de-cobro;
Configuration.Secret = "obtener-al-crear-una-cuenta-de-cobro";
PaymentsApi a = new PaymentsApi();

try
{
    DateTime dt = DateTime.Now;
    dt = dt.AddDays(5);
    PaymentsCreateResponse response = a.PaymentsPost("Compra de prueba de la API", "CLP", 100.0
                        , expiresDate: dt);
    System.Console.WriteLine(response);
}
catch (ApiException e)
{
    Console.WriteLine(e);
}

4.- Enviar información del comercio para usar en la conciliación

Los cobros en Khipu poseen una variable llamada “custom” en la cual puedes guardar información de cualquier tipo. Esta información puede ser recuperada en cualquier momento, por ejemplo cuando recibamos la notificación por web service desde Khipu.

Veamos un ejemplo en el cual creamos un cobro con un XML que tiene el contenido del carro de compra de una tienda:

 

<?php
require __DIR__ . '/vendor/autoload.php';

$configuration = new KhipuConfiguration();
$configuration->setSecret('secret-key');
$configuration->setReceiverId(receiver_id);
$configuration->setPlatform('demo-client', '2.0');
# $configuration->setDebug(true);

$client = new KhipuApiClient($configuration);
$payments = new KhipuClientPaymentsApi($client);

try {

    $xml = "
<items>
  <item>
    <name>Compra 1</name>
  </item>
  <item>
    <name>Compra 2</name>
  </item>
</items>
";

    $opts = array(
        "custom" => $xml
    );

    $response = $payments->paymentsPost("Compra de prueba de la API" //Motivo de la compra
        , "CLP" //Moneda
        , 100.0 //Monto
        , $opts
    );
    print_r($response);
} catch (KhipuApiException $e) {
    echo print_r($e->getResponseBody(), TRUE);
}
ApiClient apiClient = new ApiClient();
apiClient.setKhipuCredentials(receiverId, "secret-key");
apiClient.setPlatform("demo-client", "2.0");
// apiClient.setDebugging(true);

String xml = "<items>n" +
        "   <item>n" +
        "       <name>Compra 1</name>n" +
        "   </item>n" +
        "   <item>n" +
        "       <name>Compra 2</name>n" +
        "   </item>n" +
        "</items>";

PaymentsApi paymentsApi = new PaymentsApi();
paymentsApi.setApiClient(apiClient);

Map<String, Object> options = new HashMap<>();
options.put("custom", xml);

PaymentsCreateResponse response = paymentsApi.paymentsPost("Compra de prueba de la API" //Motivo de la compra
        , "CLP" //Moneda
        , 100.0 //Monto
        , options
);
require 'khipu-api-client'

Khipu.configure do |c|
  c.secret = 'secret-key'
  c.receiver_id = receiver_id
  c.platform = 'demo-client'
  c.platform_version = '2.0'
  # c.debugging = true
end

xml = '
<items>
  <item>
    <name>Compra 1</name>
  </item>
  <item>
    <name>Compra 2</name>
  </item>
</items>
'

client = Khipu::PaymentsApi.new
response = client.payments_post('Prueba de cobro', 'CLP', 1000, {custom: xml})
Configuration.ReceiverId = obtener-al-crear-una-cuenta-de-cobro;
Configuration.Secret = "obtener-al-crear-una-cuenta-de-cobro";
PaymentsApi a = new PaymentsApi();

string xml = "<items><item><name>Compra 1</name></item><item><name>Compra 2</name></item></items>";

try
{
    PaymentsCreateResponse response = a.PaymentsPost("Compra de prueba de la API", "CLP", 100.0
                        , custom: xml);
    System.Console.WriteLine(response);
}
catch (ApiException e)
{
    Console.WriteLine(e);
}

 

Podremos recuperar la información del XML usando el “notification_token” que nos envía Khipu al conciliar el pago.

5.- Eliminar un pago antes que el pagador termine

En algunas ocasiones es necesario borrar un cobro que se ha generado, por ejemplo si nos quedamos sin stock o si encontramos algún problema para entregar el producto/servicio. Para poder borrar un cobro este no debe haber sido pagado o marcado como pagado.

Para borrar un cobro generado solo necesitaremos su identificador. Veamos un código de ejemplo:

 

<?php
require __DIR__ . '/vendor/autoload.php';

$configuration = new KhipuConfiguration();
$configuration->setSecret('secret-key');
$configuration->setReceiverId(receiver_id);
$configuration->setPlatform('demo-client', '2.0');
# $configuration->setDebug(true);

$client = new KhipuApiClient($configuration);
$payments = new KhipuClientPaymentsApi($client);

try {
    $response = $payments->paymentsPost('Prueba de cobro', 'CLP', 1000);
    $response = $payments->paymentsIdDelete($response->getPaymentId());
    print_r($response);

} catch (KhipuApiException $e) {
    echo print_r($e->getResponseBody(), TRUE);
}
ApiClient apiClient = new ApiClient();
apiClient.setKhipuCredentials(receiverId, "secret-key");
apiClient.setPlatform("demo-client", "2.0");
// apiClient.setDebugging(true);
PaymentsApi paymentsApi = new PaymentsApi();
paymentsApi.setApiClient(apiClient);
PaymentsCreateResponse response = paymentsApi.paymentsPost("Prueba de cobro", "CLP", 1000d);

System.out.println(paymentsApi.paymentsIdDelete(response.getPaymentId()));
require 'khipu-api-client'

Khipu.configure do |c|
  c.secret = 'secret-key'
  c.receiver_id = receiver_id
  c.platform = 'demo-client'
  c.platform_version = '2.0'
  # c.debugging = true
end

client = Khipu::PaymentsApi.new
response = client.payments_post('Prueba de cobro', 'CLP', 1000, {})
print client.payments_id_delete(response.payment_id)
Configuration.ReceiverId = obtener-al-crear-una-cuenta-de-cobro;
Configuration.Secret = "obtener-al-crear-una-cuenta-de-cobro";
PaymentsApi a = new PaymentsApi();

try
{
    PaymentsCreateResponse response = a.PaymentsPost("Compra de prueba de la API", "CLP", 100.0);

    System.Console.WriteLine(response);

    SuccessResponse deleteResponse = a.PaymentsIdDelete(response.PaymentId);
}
catch (ApiException e)
{
    Console.WriteLine(e);
}

6.- Comercios integradores

Un integrador es un cobrador en Khipu que tiene la capacidad de crear cobradores para sus clientes y cobrar, usando Khipu, para ellos. Por ejemplo, un integrador podría ser una empresa que preste el servicio de tienda online a varios comercios, cada comercio crea una tienda online en ese servicio, usando el mismo servicio crea una cuenta de cobro Khipu y cobra online. El servicio de Khipu permite al comercio final cobrar por sus productos y al integrador cobrar una comisión.

Llamaremos cuenta de cobro hija a cada cuenta de cobro normal que esté asociada a una cuenta de cobro de integrador. Esto es muy importante para cuando debas mandar las credenciales en cada llamada.

Crear una cuenta de cobro hija de integrador

Las cuentas hijas se crean usando una llamada especial. Esta llamada devolverá las credenciales de una nueva cuenta de cobro. Debemos guardar estas credenciales para poder generar cobros a nombre de esta nueva cuenta.

En esta llamada debemos enviar los siguientes datos:

  • Email y nombre del dueño de la cuenta. Si el correo existe en Khipu, se usará el usuario existente. Sí no, se creará un nuevo usuario y se asociará la cuenta a él.
  • País para la cuenta: El país donde operará la cuenta.
  • Datos de facturación: Datos para emitir una boleta o factura.
  • Datos de contacto: Datos para que Khipu pueda ponerse en contacto con el administrador de la cuenta de cobro.

Es muy importante saber que esta cuenta no está lista para cobrar. El proceso de creación envía un e-mail al correo indicado para que el dueño de la cuenta (el dueño del e-mail) pueda completar el proceso de pago. Solo una vez completado este proceso la cuenta podrá comenzar a operar.

Es muy importante recordar también que la llamada para crear una cuenta de cobro debe ser hecha con las credenciales de la cuenta padre. Las llamadas para generar los cobros deben ser hechas con las credenciales de las cuentas hijas.

<?php
require __DIR__ . '/vendor/autoload.php';

$configuration = new KhipuConfiguration();
$configuration->setSecret($secret);
$configuration->setReceiverId($receiver_id);
$configuration->setPlatform('demo-client', '2.0');
# $configuration->setDebug(true);

$receivers = new KhipuClientReceiversApi(new KhipuApiClient($configuration));

try {
    $response = $receivers->receiversPost('Pablo'
        , 'Pereira'
        , 'pablo@micomercio.com'
        , 'CL'
        , '123456789'
        , 'Varios'
        , 'Mi comercio'
        , '+565555555'
        , 'Mi dirección'
        , 'Mi ciudad'
        , 'Mi región'
        , 'Juan Perez'
        , 'encargado de contacto'
        ,  'contacto@micomercio.com'
        , '+566666666');
    print_r($response);

} catch (KhipuApiException $e) {
    echo print_r($e->getResponseBody(), TRUE);
}
ApiClient apiClient = new ApiClient();
apiClient.setKhipuCredentials(receiverId, secret);
ReceiversApi receiversApi = new ReceiversApi();
receiversApi.setApiClient(apiClient);

ReceiversCreateResponse response =  receiversApi.receiversPost(
        "Pablo"
        , "Pereira"
        , "pablo@micomercio.com"
        , "CL"
        , "123456789"
        , "Varios"
        , "Mi comercio"
        , "+565555555"
        , "Mi dirección"
        , "Mi ciudad"
        , "Mi región"
        , "Juan Perez"
        , "encargado de contacto"
        , "contacto@micomercio.com"
        , "+566666666");

System.out.println(response);
require 'khipu-api-client'

Khipu.configure do |c|
  c.secret = secret
  c.receiver_id = receiver_id
  c.platform = 'demo-client'
  c.platform_version = '2.0'
  #c.debugging = true
end

client = Khipu::ReceiversApi.new

response = client.receivers_post('Pablo',
                                 'Pereira',
                                 'pablo@micomercio.com',
                                 'CL', '123456789',
                                 'Varios',
                                 'Mi comercio',
                                 '+565555555',
                                 'Mi dirección',
                                 'Mi ciudad',
                                 'Mi región',
                                 'Juan Perez',
                                 'encargado de contacto',
                                 'contacto@micomercio.com',
                                 '+566666666')

 

Crear un cobro con comisión de integrador es idéntico a crear un cobro normal pero con dos detalles:

  • Se debe enviar el parámetro “integrator_fee” con el monto que recibirá el integrador. Este monto no pude ser superior al monto original menos la comisión de Khipu.
  • Las credenciales que se usan para la llamada deben ser las credenciales de la cuenta hija. Esto es porque el cobro debe quedar a nombre de esta cuenta.

El siguiente es un código de ejemplo:

 

<?php
require __DIR__ . '/vendor/autoload.php';

$configuration = new KhipuConfiguration();
$configuration->setSecret('secret-key');
$configuration->setReceiverId(receiver_id);
$configuration->setPlatform('demo-client', '2.0');
# $configuration->setDebug(true);

$client = new KhipuApiClient($configuration);
$payments = new KhipuClientPaymentsApi($client);

try {
    $opts = array(
        "integrator_fee" => 10
    );
    $response = $payments->paymentsPost('Prueba de cobro', 'CLP', 1000, $opts);
    print_r($response);
} catch (KhipuApiException $e) {
    echo print_r($e->getResponseBody(), TRUE);
}
ApiClient apiClient = new ApiClient();
apiClient.setKhipuCredentials(receiverId, "secret-key");
apiClient.setPlatform("demo-client", "2.0");
// apiClient.setDebugging(true);
PaymentsApi paymentsApi = new PaymentsApi();
paymentsApi.setApiClient(apiClient);

Map<String, Object> options = new HashMap<>();
options.put("integratorFee", 10d);

PaymentsCreateResponse response = paymentsApi.paymentsPost("Prueba de cobro", "CLP", 1000d, options);

System.out.println(response);
require 'khipu-api-client'

Khipu.configure do |c|
  c.secret = 'secret-key'
  c.receiver_id = receiver_id
  c.platform = 'demo-client'
  c.platform_version = '2.0'
  # c.debugging = true
end

client = Khipu::PaymentsApi.new
response = client.payments_post('Prueba de cobro', 'CLP', 1000, {integrator_fee: 10})
Configuration.ReceiverId = obtener-al-crear-una-cuenta-de-cobro;
Configuration.Secret = "obtener-al-crear-una-cuenta-de-cobro";
PaymentsApi a = new PaymentsApi();

try
{
    PaymentsCreateResponse response = a.PaymentsPost("Compra de prueba de la API", "CLP", 100.0
                        , integratorFee: 10.0);

    System.Console.WriteLine(response);

}
catch (ApiException e)
{
    Console.WriteLine(e);
}

En este creamos un cobro por 1000. De esos 1000, 10 serán entregados al integrador de la cuenta hija.

7.- Modificar el usuario dueño de un cobro

 
Cada cobro en Khipu tiene asociado un “responsible user” (usuario responsable) que es el dueño del cobro. Él recibe copia de los comprobantes de pago y copia de los recordatorios semanales. Si se está usando la interfaz web de Khipu, el responsable siempre es el que crea el cobro. Si más de una persona tiene acceso a la cuenta de cobro del comercio uno puede especificar usando la API quien es el dueño de cada cobro creado.

Para poder especificar un usuario como dueño de un cobro el usuario debe poder cobrar usando la cuenta del comercio.

Veamos el siguiente código de ejemplo:

 

<?php
$configuration = new KhipuConfiguration();
$configuration->setSecret('secret-key');
$configuration->setReceiverId(receiver_id);
$configuration->setPlatform('demo-client', '2.0');
# $configuration->setDebug(true);

$client = new KhipuApiClient($configuration);
$payments = new KhipuClientPaymentsApi($client);

try {
    $opts = array(
        "responsible_user_email" => "jconnor@the-future.com"
    );
    $response = $payments->paymentsPost('Prueba de cobro', 'CLP', 1000, $opts);
    print_r($response);
} catch (KhipuApiException $e) {
    echo print_r($e->getResponseBody(), TRUE);
}
ApiClient apiClient = new ApiClient();
apiClient.setKhipuCredentials(receiverId, "secret-key");
apiClient.setPlatform("demo-client", "2.0");
// apiClient.setDebugging(true);

PaymentsApi paymentsApi = new PaymentsApi();
paymentsApi.setApiClient(apiClient);

Map<String, Object> options = new HashMap<>();
options.put("responsibleUserEmail", "jconnor@the-future.com");

PaymentsCreateResponse response = paymentsApi.paymentsPost("Prueba de cobro", "CLP", 1000d, options);
require 'khipu-api-client'

Khipu.configure do |c|
  c.secret = 'secret-key'
  c.receiver_id = receiver_id
  c.platform = 'demo-client'
  c.platform_version = '2.0'
  # c.debugging = true
end

client = Khipu::PaymentsApi.new
response = client.payments_post('Prueba de cobro', 'CLP', 1000, {responsible_user_email: 'jconnor@the-future.com'})
Configuration.ReceiverId = obtener-al-crear-una-cuenta-de-cobro;
Configuration.Secret = "obtener-al-crear-una-cuenta-de-cobro";
PaymentsApi a = new PaymentsApi();

try
{
    PaymentsCreateResponse response = a.PaymentsPost("Compra de prueba de la API", "CLP", 100.0
                        , responsibleUserEmail: : "jconnor@the-future.com");

    System.Console.WriteLine(response);

}
catch (ApiException e)
{
    Console.WriteLine(e);
}

8.- Cobro con autenticación

 
Es posible crear cobros que solo puedan ser pagados usando una cuenta bancaria perteneciente a alguien en particular. Esto se hace especificando el identificador personal del usuario. Por ejemplo una cuenta bancaria en Chile está asociada a un RUT. Si se especifica un RUT en particular para un cobro, este solo podrá ser pagado utilizando una cuenta asociada a ese RUT.

Veamos un ejemplo:

 

<?php
require __DIR__ . '/vendor/autoload.php';

$configuration = new KhipuConfiguration();
$configuration->setSecret('secret-key');
$configuration->setReceiverId(receiver_id);
$configuration->setPlatform('demo-client', '2.0');
# $configuration->setDebug(true);

$client = new KhipuApiClient($configuration);
$payments = new KhipuClientPaymentsApi($client);

try {
    $opts = array(
      "fixed_payer_personal_identifier" => "12.345.678-9"
    );
    $response = $payments->paymentsPost('Prueba de cobro', 'CLP', 1000, $opts);
    print_r($response);
} catch (KhipuApiException $e) {
    echo print_r($e->getResponseBody(), TRUE);
}
ApiClient apiClient = new ApiClient();
apiClient.setKhipuCredentials(receiverId, "secret-key");
apiClient.setPlatform("demo-client", "2.0");
// apiClient.setDebugging(true);
PaymentsApi paymentsApi = new PaymentsApi();
paymentsApi.setApiClient(apiClient);

Map<String, Object> options = new HashMap<>();
options.put("fixedPayerPersonalIdentifier", "12.345.678-9");

PaymentsCreateResponse response = paymentsApi.paymentsPost("Prueba de cobro", "CLP", 1000d, options);
require 'khipu-api-client'

Khipu.configure do |c|
  c.secret = 'secret-key'
  c.receiver_id = receiver_id
  c.platform = 'demo-client'
  c.platform_version = '2.0'
  # c.debugging = true
end

client = Khipu::PaymentsApi.new
response = client.payments_post('Prueba de cobro', 'CLP', 1000, {fixed_payer_personal_identifier: '12.345.678-9'})
Configuration.ReceiverId = obtener-al-crear-una-cuenta-de-cobro;
Configuration.Secret = "obtener-al-crear-una-cuenta-de-cobro";
PaymentsApi a = new PaymentsApi();

try
{
    PaymentsCreateResponse response = a.PaymentsPost("Compra de prueba de la API", "CLP", 100.0
                        , fixedPayerPersonalIdentifier: "12.345.678-9");

    System.Console.WriteLine(response);

}
catch (ApiException e)
{
    Console.WriteLine(e);
}

9.- Reembolsar un cobro que no ha sido rendido

 
En el intervalo de tiempo entre que se realiza un pago y Khipu aún no ha entregado los fondos al comercio, es posible reembolsar el cobro, el cliente recibirá un correo electrónico explicándole que el comercio no ha podido completar la transacción y que los fondos serán devueltos a su cuenta bancaria.

Veamos un ejemplo:

 

<?php
require __DIR__ . '/vendor/autoload.php';

$configuration = new KhipuConfiguration();
$configuration->setSecret('secret-key');
$configuration->setReceiverId(receiver_id);
$configuration->setPlatform('demo-client', '2.0');
# $configuration->setDebug(true);

$client = new KhipuApiClient($configuration);
$payments = new KhipuClientPaymentsApi($client);

try {
    $payments->paymentsIdRefundsPost("id-del-pago");
    print_r($response);
} catch (KhipuApiException $e) {
    echo print_r($e->getResponseBody(), TRUE);
}
ApiClient apiClient = new ApiClient();
apiClient.setKhipuCredentials(receiverId, "secret-key");
apiClient.setPlatform("demo-client", "2.0");
// apiClient.setDebugging(true);
PaymentsApi paymentsApi = new PaymentsApi();
paymentsApi.setApiClient(apiClient);
paymentsApi.paymentsIdRefundsPost("id-del-pago");
require 'khipu-api-client'

Khipu.configure do |c|
  c.secret = 'secret-key'
  c.receiver_id = receiver_id
  c.platform = 'demo-client'
  c.platform_version = '2.0'
  # c.debugging = true
end

client = Khipu::PaymentsApi.new
response = client.payments_id_refunds_post('id-del-pago'})
Configuration.ReceiverId = obtener-al-crear-una-cuenta-de-cobro;
Configuration.Secret = "obtener-al-crear-una-cuenta-de-cobro";
PaymentsApi a = new PaymentsApi();

try
{
    SuccessResponse response = a.PaymentsIdRefundsPost("id-del-pago");

    System.Console.WriteLine(response);

}
catch (ApiException e)
{
    Console.WriteLine(e);
}

10.- Recibiendo y validando notificación de rendición por web service

Khipu permite recibir notificaciones en tu sitio web de manera automática con el detalle de cada rendición realizada hacia la cuenta corriente asociada a tu cuenta de cobro.

Configuración:

Para recibir notificaciones primero debes ingresar a tu cuenta Khipu e ir a “Opciones de la cuenta”. En la sección Notificación instantánea de rendiciones debes agregar la URL en donde tu sitio web escuchará las notificaciones y definir la versión de la API de notificaciones que quieres usar.

Ejemplo en PHP

Las notificaciones de rendición se hacen utilizando un mensaje en estándar JOSE JWS, y ensobrado gzip.

Los mensajes de las notificaciones de rendición se firman con el siguiente certificado.

Descargar el certificado de clave pública

Si estás usando una cuenta de cobro de desarrollo entonces deberás usar el certificado de desarrollo de Khipu.

Descargar el certificado de clave pública (desarrollo)

En este ejemplo se hace uso de la librería Namshi/Jose:

<?php
require_once 'vendor/autoload.php';

use NamshiJOSEJWS;

$jws_text=gzdecode($HTTP_RAW_POST_DATA);

$jws=JWS::load($jws_text);

// Leemos el certificado con la clave publica
$filename = 'khipu_signer.pem';
$fp = fopen($filename, "r");
$cert = fread($fp, filesize($filename));
fclose($fp);
$pubkey = openssl_get_publickey($cert);

$payload = $jws->getPayload();

if ($jws->isValid($public_key)) {
/*
   Si la firma del mensaje es valida se puede procesar el mensaje
*/

    $report=$payload['report'];
    $fecha_desde=$report['startDate']; // fecha de inicio de la rendición
    $fecha_hasta=$report['endDate']; //fecha de termino de la rendición
    $report_items=$report['items']; //pagos incluidos en la rendición
    foreach($report_items as $item){
       $customer=$item['customer']; //datos del pagador
       local_process($item['paymentDate'],       //fecha del pago
                     $item['paymentSubject'],    //asunto del pago
                     $item['khOperationCodeUID'],//código único de operación khipu
                     $item['merchantTxID'],      //id de transacción informado por el comercio
                     $item['customer']['customerName'], //nombre del pagador
                     $item['customer']['customerUID'],  //rut del pagador
                     $item['customer']['customerEmail'],//correo electrónico del pagador
                     $item['customer']['customerBankName'], //nombre del banco origen
                     $item['feeScheme'], //esquema de comisión
                     $item['txAmount'],  //monto de la transacción
                     $item['khipuFee']); //comisión khipu
    }
}

Dirección: Las Urbinas 53 oficina 132, Providencia, Santiago, Chile. Código postal 7510093

Dirección Argentina: Besares 1029,  Chacras de Coria, Mendoza, Argentina. Código postal 5505.