Crear token de acceso

Acceso a los entornos de prueba y producción

Las credenciales de acceso, tanto para los entornos productivo como de prueba, se encuentran en el correo de bienvenida, así como en las aplicaciones móviles y web.

¿Todavía no las solicitaste? Podes solicitarlas desde la web o aplicación de Ualá, ingresando a Ualá Bis.

⚠️

Recordá que estas son privadas, que no se deben compartir y que ninguna persona del equipo de Ualá las va a solicitar.

Token de Acceso

Todas nuestras integraciones requieren de la generación de un token para realizar consultas HTTP.

BASE URL:

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

Parámetros

POST /auth/token

Body json:

{
    "username": "username",
    "client_id": "5qqGKGm4AaawnAJ0J6xluc6AWdQBvLW6",
    "client_secret_id": "cLp1iGEB-PA6KtL4Hi7tocsopP2pZxzaBLciOCApWH92e9_Jloe8CD2ilM63NppG",
    "grant_type": "client_credentials"
}

Campo	Tipo	Descripción	Requerido
username	string	Nombre del usuario de la cuenta Ualá	Sí
client_id	string	ID del usuario registrado	Sí
client_secret_id	string	ID secreto generado por la aplicación	Sí
grant_type	string	Tipo de operación a realizar para obtener un token	Sí

Ejemplos

Terminal

curl --location --request POST 'https://auth.developers.ar.ua.la/v2/api/auth/token' \
--header 'Content-Type: application/json' \
--data-raw '{
  "username" : "[[username]]",
  "client_id" : "[[client_id]]",
  "client_secret_id" : "[[client_secret_id]]",
  "grant_type" : "client_credentials"
}'

index.js

class AuthClient {
  constructor(username, clientId, clientSecretId, grantType = "client_credentials") {
    this.url = 'https://auth.developers.ar.ua.la/v2/api/auth/token';
    this.payload = {
      username: username,
      client_id: clientId,
      client_secret_id: clientSecretId,
      grant_type: grantType
    };
  }
 
  async getToken() {
    const options = {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(this.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 username = 'username';
const clientId = 'clientId';
const clientSecretId = 'clientSecretId';
 
const authClient = new AuthClient(username, clientId, clientSecretId);
 
authClient.getToken()
  .then(token => {
    console.log('Token:', token);
  })
  .catch(error => {
    console.error('Error:', error);
  });

main.php

class AuthClient {
    private $url;
    private $payload;
 
    /**
     * Constructor de AuthClient
     *
     * @param string $username Nombre de usuario.
     * @param string $clientId ID del cliente.
     * @param string $clientSecretId ID secreto del cliente.
     * @param string $grantType Tipo de concesión (por defecto "client_credentials").
     */
    public function __construct($username, $clientId, $clientSecretId, $grantType = "client_credentials") {
        $this->url = 'https://auth.developers.ar.ua.la/v2/api/auth/token';
        $this->payload = [
            'username' => $username,
            'client_id' => $clientId,
            'client_secret_id' => $clientSecretId,
            'grant_type' => $grantType
        ];
    }
 
    /**
     * Obtiene el token de autenticación.
     *
     * @return array|null Datos del token en formato array o null en caso de error.
     */
    public function getToken() {
        $ch = curl_init($this->url);
 
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($this->payload));
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Content-Type: application/json'
        ]);
 
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 
        if (curl_errno($ch)) {
            $this->handleError(curl_error($ch));
            curl_close($ch);
            return null;
        }
 
        curl_close($ch);
 
        if ($httpCode != 200) {
            $this->handleError("HTTP error! Status: " . $httpCode);
            return null;
        }
 
        return json_decode($response, true);
    }
 
    /**
     * Maneja los errores de la solicitud.
     *
     * @param string $error Mensaje de error.
     */
    private function handleError($error) {
        // Implementa manejo de errores o logueo aquí
        echo 'Error: ' . $error . PHP_EOL;
    }
}
 
// Uso del constructor
$username = 'username'; // Reemplaza con el nombre de usuario real
$clientId = 'clientId'; // Reemplaza con el ID del cliente real
$clientSecretId = 'clientSecretId'; // Reemplaza con el ID secreto del cliente real
 
$authClient = new AuthClient($username, $clientId, $clientSecretId);
 
$tokenData = $authClient->getToken();
 
if ($tokenData !== null) {
    echo 'Token:';
    print_r($tokenData);
} else {
    echo 'Error occurred.';
}

main.py

#!/usr/bin/env/python
# -*- coding: utf-8 -*-
 
import json
try:
    import requests
except ImportError:
    print('[!] Please install the requests library')
    print('[!] Example: pip install requests')
    exit(1)
 
AUTH_URL = 'https://auth.developers.ar.ua.la'
TOKEN_URL = f'{AUTH_URL}/v2/api/auth/token'
 
class Auth:
 
    def __init__(self, username: str, client_id: str, client_secret_id: str, grant_type: str) -> None:
        self.username = username
        self.client_id = client_id
        self.client_secret_id = client_secret_id
        self.grant_type = grant_type
 
    def to_dict(self) -> dict:
        return vars(self)
 
    def to_json(self) -> str:
        return json.dumps(self.to_dict())
 
    def get_token(self):
        try:
            headers = {
                'Content-Type': 'application/json',
                'Accept': 'application/json'
            }
            session = requests.Session()
            response = session.post(
                TOKEN_URL,
                self.to_json(),
                headers=headers)
            return response.json()
        except requests.exceptions.RequestException as e:
            raise e('[!] Error while getting token')
 
	if **name** == '**main**':
	auth = Auth(
		username='USERNAME',
		client_id='CLIENT_ID',
		client_secret_id='CLIENT_SECRET_ID_KEY',
		grant_type='client_credentials'
	)
	response = auth.get_token()
	print(json.dumps(response, indent=4))

main.go

package main
import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
)
 
const authUrl = "https://auth.developers.ar.ua.la"
 
var tokenUrl = fmt.Sprintf("%s/v2/api/auth/token", authUrl)
 
type (
	// Auth struct
	Auth struct {
		Username       string `json:"username"`
		ClientID       string `json:"client_id"`
		ClientSecretID string `json:"client_secret_id"`
		GrantType      string `json:"grant_type"`
	}
	// Token Response struct
	Response struct {
		AccessToken string `json:"access_token"`
		ExpiresIn   int    `json:"expires_in"`
		TokenType   string `json:"token_type"`
	}
 
	TokenAuth interface {
		GetToken() (Response, error)
	}
)
 
func (auth *Auth) toJson() ([]byte, error) {
	return json.Marshal(auth)
}
 
func (auth *Auth) GetToken() (Response, error) {
	var token Response
	data, err := auth.toJson()
	if err != nil {
		return token, err
	}
	resp, err := http.Post(tokenUrl, "application/json", bytes.NewBuffer(data))
	if err != nil {
		return token, err
	}
	defer resp.Body.Close()
	if err = json.NewDecoder(resp.Body).Decode(&token); err != nil {
		return token, err
	}
	return token, err
}
 
func main() {
	auth := Auth{
		Username:       "USERNAME",
		ClientID:       "CLIENT_ID",
		ClientSecretID: "CLIENT_SECRET_ID_KEY",
		GrantType:      "client_credentials",
	}
	token, err := auth.GetToken()
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(token)
	}
}

Respuestas

{
    "access_token": "eyJhbGciOiJSUzI1NiIsRrb5cCI6IkpXVCIsImtpZCI6Ik5Ua01mWF82QVhWbnLHQTVLWF8zYyJ9.eyJpc3MiOiJodHRLWFwcC1zdGFnZS51cy5hdXRoMC5jb21vIiwic3ViIjoiNXFxR0tHbTRFYWF3bkFIMEo2eGx1YzZBV2RRQnZMVzNAY2xpZW50cyIsImF1ZC8vdWFsYS1hcmctYXBwLXN0YWdlLnVzLmF1dGgwLmNvbS9hcGkvdjIvIiwiaWF0IjoxNjU0NTE4MTk4LCJleHAiOjE2NTQ2MDQ1OTgsImF6cCI6IjVxcUdLR200RWFhd25BSDBKNnhsdWM2QVdkUUJ2TFczIiwic2NvcGUiOiJjcmVhdGU6Y2xpZW50X2dyYW50cyIsImd0eSI6ImNsaWVudC1jcmVkZW50aWFscyJ9.f4otnnYF60E1j_TfdBXf0WeDkGDKJcOPB9zNXPoAShpAYOk3Z6HWXuSxFQysIt6yh0csfGbt24uBVQcZKiA_iJGoQPf0j2PPZdsbpZsbUJ",
    "expires_in": 86400,
    "token_type": "Bearer"
}

Campo	Tipo	Descripción
access_token	string	Token de acceso generado
expires_in	number	Tiempo de vida del token previo a su expiración expresado en segundos
token_type	string	Tipo de token

Campos erroneos

{
    "code": "request_error",
    "message": "Invalid request payload.",
    "errors": [
    "Provide a valid username.",
    "Provide a valid client_id.",
    "Provide a valid client_secret_id.",
    "Provide a valid grant_type (Ex: client_credentials)."
    ]
}

Usuario inexistente:

{
    "code": "response_error",
    "message": "Invalid username"
}

Id de cliente inválido:

{
    "code": "response_error",
    "message": "The provided client id does not correspond to any active user"
}

Error interno:

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