Usos avanzados:

Tabla de contenidos

  1. Enviar un correo electrónico de cobro
  2. Crear un cobro y distribuirlo usando su URL
  3. Crear un cobro con fecha de expiración
  4. Enviar información del comercio para usar en la conciliación
  5. Eliminar un pago antes que el pagador termine
  6. Comercios integradores
  7. Modificar el usuario dueño de un cobro
  8. Cobro con autenticación
  9. Reembolsar cobro no rendido aún
  10. Recibiendo y validando notificación de rendición. Notificaciones por web service

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 “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:

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

$client = new Khipu\ApiClient($configuration);
$payments = new Khipu\Client\PaymentsApi($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 (\Khipu\ApiException $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 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);
    }
        

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 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:

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

$client = new Khipu\ApiClient($configuration);
$payments = new Khipu\Client\PaymentsApi($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 (\Khipu\ApiException $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 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);
    }
        

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.

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

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

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

$client = new Khipu\ApiClient($configuration);
$payments = new Khipu\Client\PaymentsApi($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 (\Khipu\ApiException $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 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);
        }
            

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:

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

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

$client = new Khipu\ApiClient($configuration);
$payments = new Khipu\Client\PaymentsApi($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 (\Khipu\ApiException $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 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.

Eliminar un pago antes que el pagador termine

En algunas ocaciones es necesario borrar un cobro que se ha generado, por ejemplo si nos quedamos sin stock o si encontramos algún problema para entragar 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:

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

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

$client = new Khipu\ApiClient($configuration);
$payments = new Khipu\Client\PaymentsApi($client);

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

} catch (\Khipu\ApiException $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);
    }

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.

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

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

$receivers = new Khipu\Client\ReceiversApi(new Khipu\ApiClient($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 (\Khipu\ApiException $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 identico 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:

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

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

$client = new Khipu\ApiClient($configuration);
$payments = new Khipu\Client\PaymentsApi($client);

try {
    $opts = array(
        "integrator_fee" => 10
    );
    $response = $payments->paymentsPost('Prueba de cobro', 'CLP', 1000, $opts);
    print_r($response);
} catch (\Khipu\ApiException $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 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.

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. El 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:

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

$client = new Khipu\ApiClient($configuration);
$payments = new Khipu\Client\PaymentsApi($client);

try {
    $opts = array(
        "responsible_user_email" => "jconnor@the-future.com"
    );
    $response = $payments->paymentsPost('Prueba de cobro', 'CLP', 1000, $opts);
    print_r($response);
} catch (\Khipu\ApiException $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 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);
    }

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:

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

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

$client = new Khipu\ApiClient($configuration);
$payments = new Khipu\Client\PaymentsApi($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 (\Khipu\ApiException $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 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);
    }

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 explicandole que el comercio no ha podido completar la transacción y
que los fondos serán devueltos a su cuenta bancaria.

Veamos un ejemplo:

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

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

$client = new Khipu\ApiClient($configuration);
$payments = new Khipu\Client\PaymentsApi($client);

try {
    $payments->paymentsIdRefundsPost("id-del-pago");
    print_r($response);
} catch (\Khipu\ApiException $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);
    }
            

Recibiendo y validando notificación de rendición por web service

khipu permite recibir notificaciónes 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 instantanea 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.

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

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

require_once 'vendor/autoload.php';

use Namshi\JOSE\JWS;

$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'],//codigo unico 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 comision
                     $item['txAmount'],  //monto de la transacción
                     $item['khipuFee']); //comisión khipu
    }
}