Crear orden

Al crear una orden, se genera automáticamente un enlace único. Este enlace permite al comprador acceder a una interfaz donde puede seleccionar entre varios métodos de pago, como tarjeta de crédito, débito y, próximamente, QR.

BASE URL:

https://checkout.developers.ar.ua.la/v2/api

¡Aviso importante! Para usar este endpoint necesitas un token de autorización.

Parámetros

POST /checkout

Headers	Tipo	Descripción
Authorization	Bearer	Token de autorización.

Body json:

{
    "amount": "3005",
    "description": "Descripción de la venta",
    "callback_fail": "https://www.google.com/search?q=failed",
    "callback_success": "https://www.google.com/search?q=success",
    "notification_url": "https://www.notificationurl.com",
    "external_reference": "external_reference"
}

Campo	Tipo	Descripción	Requerido
amount	string	Monto total que será cobrado en el checkout.	Sí
description	string	Descripción de la orden, esta figurará en el checkout.	Sí
callback_fail	string	Link de redirección de pago fallido.	Sí
callback_success	string	Link de redirección de pago exitoso.	Sí
notification_url	string	Link de notificación de estado.	No
external_reference	string	Puedes usar este atributo para enviar referencias de tu orden como puede serlo un ID.	No

Ejemplos

Terminal

curl --location --request POST 'https://checkout.developers.ar.ua.la/v2/api/checkout' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer [[accessToken]]' \
  --data-raw '{
    "amount": "10.90",
    "description": "Venta",
    "notification_url": "[[notification_url]]",
    "callback_fail": "[[url_fail]]",
    "callback_success": "[[url_success]]",
    "external_reference": "[[external_reference]]"
  }'

index.js

class CheckoutClient {
    constructor(accessToken) {
        this.url = 'https://checkout.developers.ar.ua.la/v2/api/checkout';
        this.accessToken = accessToken;
    }
 
    async createCheckout(amount, description, notificationUrl, callbackFail, callbackSuccess, externalReference) {
        const payload = {
            amount: amount,
            description: description,
            notification_url: notificationUrl,
            callback_fail: callbackFail,
            callback_success: callbackSuccess,
            external_reference: externalReference,
        };
 
        const options = {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${this.accessToken}`,
            },
            body: JSON.stringify(payload),
        };
 
        try {
            const response = await fetch(this.url, options);
 
            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }
 
            const data = await response.json();
            return data;
        } catch (error) {
            console.error('Error:', error);
            throw error;
        }
    }
}
 
// Uso del constructor
const accessToken = 'your-access-token'; // Reemplaza con tu token de acceso
const checkoutClient = new CheckoutClient(accessToken);
 
checkoutClient.createCheckout(
    '10.90',                   // Monto del checkout
    'Venta',                   // Descripción del checkout
    'your-notification-url',   // Reemplaza con la URL de notificación
    'your-fail-url',           // Reemplaza con la URL de fallo
    'your-success-url',        // Reemplaza con la URL de éxito
    'your-external-reference'  // Reemplaza con la referencia externa
)
    .then(data => {
        console.log('Success:', data);
    })
    .catch(error => {
        console.error('Error:', error);
    });

main.php

class CheckoutClient {
    private $url;
    private $accessToken;
 
    /**
     * Constructor de CheckoutClient
     *
     * @param string $accessToken Token de acceso para la API.
     */
    public function __construct($accessToken) {
        $this->url = 'https://checkout.developers.ar.ua.la/v2/api/checkout';
        $this->accessToken = $accessToken;
    }
 
    /**
     * Crea un checkout en la API.
     *
     * @param string $amount Monto del checkout.
     * @param string $description Descripción de la venta.
     * @param string $notificationUrl URL de notificación.
     * @param string $callbackFail URL de fallo.
     * @param string $callbackSuccess URL de éxito.
     * @param string $externalReference Referencia externa.
     * @return array Respuesta de la API como un array.
     * @throws Exception En caso de error en la solicitud o respuesta HTTP.
     */
    public function createCheckout($amount, $description, $notificationUrl, $callbackFail, $callbackSuccess, $externalReference) {
        $payload = json_encode([
            'amount' => $amount,
            'description' => $description,
            'notification_url' => $notificationUrl,
            'callback_fail' => $callbackFail,
            'callback_success' => $callbackSuccess,
            'external_reference' => $externalReference,
        ]);
 
        $headers = [
            'Content-Type: application/json',
            'Authorization: Bearer ' . $this->accessToken,
        ];
 
        $ch = curl_init($this->url);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
 
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 
        if ($response === false || $httpCode !== 200) {
            throw new Exception('HTTP error! Status: ' . $httpCode . ' Response: ' . $response);
        }
 
        curl_close($ch);
 
        return json_decode($response, true);
    }
}
 
// Uso del constructor
$accessToken = 'your-access-token'; // Reemplaza con tu token de acceso
$checkoutClient = new CheckoutClient($accessToken);
 
try {
    $result = $checkoutClient->createCheckout(
        '10.90',                  // Monto
        'Venta',                  // Descripción
        'your-notification-url',  // URL de notificación
        'your-fail-url',          // URL de fallo
        'your-success-url',       // URL de éxito
        'your-external-reference' // Referencia externa
    );
 
    echo 'Success: ' . print_r($result, true);
} catch (Exception $e) {
    echo 'Error: ' . $e->getMessage();
}

main.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
import json
try:
   import requests
except ImportError:
   print('[!] Please install the requests library')
   print('[!] Example: pip install requests')
   exit(1)
 
CHECKOUT_URL = 'https://checkout.developers.ar.ua.la'
PAYMENT_URL = f'{CHECKOUT_URL}/v2/api/checkout'
 
 
class Checkout:
   def __init__(self, amount: str, description: str, notification_url: str, callback_fail: str, callback_success: str, external_reference: str):
       """
       Constructor para inicializar los datos de un checkout.
 
       :param amount: Monto del checkout.
       :param description: Descripción de la venta.
       :param notification_url: URL para notificaciones.
       :param callback_fail: URL en caso de fallo.
       :param callback_success: URL en caso de éxito.
       :param external_reference: Referencia externa única.
       """
       self.amount = amount
       self.description = description
       self.notification_url = notification_url
       self.callback_fail = callback_fail
       self.callback_success = callback_success
       self.external_reference = external_reference
 
   def to_dict(self) -> dict:
       """
       Convierte el objeto Checkout en un diccionario.
       :return: Diccionario con los datos del checkout.
       """
       return vars(self)
 
   def to_json(self) -> str:
       """
       Convierte el objeto Checkout en un JSON.
       :return: JSON con los datos del checkout.
       """
       return json.dumps(self.to_dict())
 
   def checkout(self, access_token: str):
       """
       Realiza el checkout llamando a la API con los datos.
 
       :param access_token: Token de acceso para la API.
       :return: Respuesta de la API como diccionario.
       :raises Exception: En caso de errores durante la solicitud.
       """
       try:
           headers = {
               'Content-Type': 'application/json',
               'Accept': 'application/json',
               'Authorization': f'Bearer {access_token}',
           }
 
           response = requests.post(
               PAYMENT_URL,
               data=self.to_json(),
               headers=headers,
           )
 
           if response.status_code != 200:
               raise Exception(f'[!] HTTP error {response.status_code}: {response.text}')
 
           return response.json()
 
       except requests.exceptions.RequestException as e:
           raise Exception(f'[!] Checkout error: {e}')
 
 
if __name__ == '__main__':
   # Reemplaza estos valores con los reales
   checkout = Checkout(
       amount='10.90',
       description='Venta',
       notification_url='your-notification-url',
       callback_fail='your-fail-url',
       callback_success='your-success-url',
       external_reference='your-external-reference',
   )
 
   token = 'your-access-token'  # Reemplaza con tu token de acceso
 
   try:
       response = checkout.checkout(token)
       print('Success:', response)
   except Exception as e:
       print('Error:', str(e))

main.go

package main
 
import (
   "bytes"
   "encoding/json"
   "fmt"
   "net/http"
)
 
const checkoutUrl = "https://checkout.developers.ar.ua.la"
 
// Genera la URL completa del endpoint de pagos
var paymentUrl = fmt.Sprintf("%s/v2/api/checkout", checkoutUrl)
 
// Estructuras para el manejo de datos
type (
   // Checkout contiene los datos necesarios para realizar un pago
   Checkout struct {
   	Amount            string `json:"amount"`
   	Description       string `json:"description"`
   	NotificationURL   string `json:"notification_url"`
   	CallbackFail      string `json:"callback_fail"`
   	CallbackSuccess   string `json:"callback_success"`
   	ExternalReference string `json:"external_reference"`
   }
 
   // Links contiene las URLs relevantes en la respuesta
   Links struct {
   	CheckoutLink string `json:"checkout_link"`
   	Success      string `json:"success"`
   	Failed       string `json:"failed"`
   }
 
   // Response representa la estructura de la respuesta de la API
   Response struct {
   	UUID              string `json:"uuid"`
   	Status            string `json:"status"`
   	ExternalReference string `json:"external_reference"`
   	Links             Links  `json:"links"`
   	Amount            int    `json:"amount"`
   }
 
   // Process define un comportamiento para procesar pagos
   Process interface {
   	Pay(token string) (Response, error)
   }
)
 
// Convierte el objeto Checkout en un JSON
func (checkout *Checkout) toJson() ([]byte, error) {
   return json.Marshal(checkout)
}
 
// Realiza el pago llamando al endpoint de la API
func (checkout *Checkout) Pay(token string) (Response, error) {
   var response Response
 
   // Configurar el encabezado de autorización
   accessToken := fmt.Sprintf("Bearer %s", token)
 
   // Convertir los datos del Checkout a JSON
   data, err := checkout.toJson()
   if err != nil {
   	return response, fmt.Errorf("error serializando los datos: %v", err)
   }
 
   // Crear una solicitud HTTP POST
   request, err := http.NewRequest("POST", paymentUrl, bytes.NewBuffer(data))
   if err != nil {
   	return response, fmt.Errorf("error creando la solicitud HTTP: %v", err)
   }
 
   // Configurar los encabezados de la solicitud
   request.Header.Set("Content-Type", "application/json")
   request.Header.Set("Authorization", accessToken)
 
   // Crear un cliente HTTP y enviar la solicitud
   client := &http.Client{}
   resp, err := client.Do(request)
   if err != nil {
   	return response, fmt.Errorf("error realizando la solicitud HTTP: %v", err)
   }
   defer resp.Body.Close()
 
   // Validar el código de respuesta HTTP
   if resp.StatusCode != http.StatusOK {
   	return response, fmt.Errorf("error: código de respuesta HTTP %d", resp.StatusCode)
   }
 
   // Decodificar la respuesta JSON
   if err = json.NewDecoder(resp.Body).Decode(&response); err != nil {
   	return response, fmt.Errorf("error decodificando la respuesta: %v", err)
   }
 
   return response, nil
}
 
func main() {
   // Configurar los datos del checkout
   checkout := Checkout{
   	Amount:            "10.90",
   	Description:       "Venta",
   	NotificationURL:   "your-notification-url",
   	CallbackFail:      "your-fail-url",
   	CallbackSuccess:   "your-success-url",
   	ExternalReference: "your-external-reference",
   }
 
   // Token de acceso (reemplaza con un token válido)
   token := "your-access-token"
 
   // Realizar el pago
   response, err := checkout.Pay(token)
   if err != nil {
   	fmt.Printf("Error al procesar el pago: %v\n", err)
   } else {
   	fmt.Printf("Respuesta del servidor: %+v\n", response)
   }
}

Respuestas

{
    "uuid": "613d8938-8dab-41fd-9905-09d52e5312d0",
    "amount": 3005,
    "status": "PENDING",
    "external_reference": "09d52e5312d009d52e5312d09905",
    "links": {
        "checkout_link": "https://uala-checkout.com/orders/66fe0b6e3c4cd5253c65a80e547",
        "success": "https://www.google.com/search?q=success",
        "failed": "https://www.google.com/search?q=failed"
    }
}

Campos erroneos

{
    "code": "request_error",
    "message": "Invalid request payload",
    "errors": [
    "Invalid amount format. Amount must have only positive numbers and a single point",
    "Check notification_url attribute value",
    "Check callback_fail attribute value",
    "Check description attribute value",
    "Provide a valid token with active client_id",
    "Check external_reference attribute value",
    ]
}

Acceso denegado

{
    "message": "Unauthorized"
}

Token invalido

{
    "code": "response_error",
    "message": "Invalid account. Check your token value"
}

Token expirado

{
    "message": "User is not authorized to access this resource with an explicit deny"
}

Error interno

{
    "code": "api_error",
    "message": "Something bad happened. Please try again"
}