Authentification

Toutes les requêtes API vers l'API TRXUp nécessitent une authentification utilisant un token Bearer et une signature. Cela garantit la sécurité et l'intégrité de vos requêtes API.

Obtenir les Identifiants API

Pour commencer avec l'API TRXUp, vous devrez obtenir vos identifiants API depuis le tableau de bord :

1. Connectez-vous à l'espace client TRXUp
2. Ouvrez Accès à l'API, sous Compte dans la barre latérale
3. Cliquez sur Créer des identifiants

Le token et le secret de signature ne sont affichés qu'une seule fois, au moment de leur création. Le secret n'est plus jamais montré — ni partiellement, ni sur cet écran. Si vous le perdez, émettez une nouvelle paire.

Ce même écran permet de restreindre la paire aux adresses IP depuis lesquelles vos propres serveurs appellent. Une requête correctement signée provenant d'ailleurs est alors refusée.

TIP

Gardez vos identifiants API sécurisés et ne les partagez jamais publiquement. Votre secret API doit être traité comme un mot de passe.

En-têtes Requis

En-tête	Description
Authorization: Bearer VOTRE_TOKEN_API	Votre token API
X-Signature: VOTRE_SIGNATURE	Signature de la requête
Content-Type: application/json	Le type de contenu doit être JSON

Calcul de la Signature

La signature est calculée en utilisant le hash SHA256 du corps de la requête concaténé avec votre secret API.

signature=$(echo -n "$requestBody$apiSecret" | sha256sum | cut -d' ' -f1)

Exemple dans Différents Langages

Bash

#!/bin/bash
API_TOKEN="votre_token_api"
API_SECRET="votre_secret_api"
REQUEST_BODY='{"service":"energy","params":{"address":"ADRESSE_TRX","energy_amount":65000,"duration":1}}'

# Calculer la signature
SIGNATURE=$(echo -n "${REQUEST_BODY}${API_SECRET}" | sha256sum | cut -d' ' -f1)

# Faire la requête API
curl -X POST "https://api.trxup.com/v1/transaction/new" \
  -H "Authorization: Bearer ${API_TOKEN}" \
  -H "X-Signature: ${SIGNATURE}" \
  -H "Content-Type: application/json" \
  -d "${REQUEST_BODY}"

Node.js

const crypto = require('crypto');
const axios = require('axios');

const apiToken = 'votre_token_api';
const apiSecret = 'votre_secret_api';
const requestBody = JSON.stringify({
  service: 'energy',
  params: {
    address: 'ADRESSE_TRX',
    energy_amount: 65000,
    duration: 1
  }
});

// Calculer la signature
const signature = crypto
  .createHash('sha256')
  .update(requestBody + apiSecret)
  .digest('hex');

// Faire la requête API
axios({
  method: 'post',
  url: 'https://api.trxup.com/v1/transaction/new',
  headers: {
    'Authorization': `Bearer ${apiToken}`,
    'X-Signature': signature,
    'Content-Type': 'application/json'
  },
  data: requestBody
})
.then(response => console.log(response.data))
.catch(error => console.error(error));

PHP

<?php
$apiToken = 'votre_token_api';
$apiSecret = 'votre_secret_api';
$requestBody = json_encode([
  'service' => 'energy',
  'params' => [
    'address' => 'ADRESSE_TRX',
    'energy_amount' => 65000,
    'duration' => 1
  ]
]);

// Calculer la signature
$signature = hash('sha256', $requestBody . $apiSecret);

// Faire la requête API
$ch = curl_init('https://api.trxup.com/v1/transaction/new');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $requestBody);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'Authorization: Bearer ' . $apiToken,
  'X-Signature: ' . $signature,
  'Content-Type: application/json'
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

Python

import hashlib
import json
import requests

api_token = 'votre_token_api'
api_secret = 'votre_secret_api'
request_body = json.dumps({
  'service': 'energy',
  'params': {
    'address': 'ADRESSE_TRX',
    'energy_amount': 65000,
    'duration': 1
  }
})

# Calculer la signature
signature = hashlib.sha256((request_body + api_secret).encode()).hexdigest()

# Faire la requête API
headers = {
  'Authorization': f'Bearer {api_token}',
  'X-Signature': signature,
  'Content-Type': 'application/json'
}

response = requests.post(
  'https://api.trxup.com/v1/transaction/new',
  headers=headers,
  data=request_body
)

print(response.json())

Signature version 2 (facultative)

La version 2 de la signature est une manière facultative et plus robuste de signer les mêmes requêtes. Vous l'activez requête par requête en envoyant l'en-tête X-Signature-Version: 2. Une requête sans cet en-tête, ou avec X-Signature-Version: 1, est vérifiée exactement comme décrit ci-dessus : les intégrations existantes n'ont donc rien à changer. La version 1 continue de fonctionner et aucune date limite n'est fixée pour passer à la version 2 ; pour les nouvelles intégrations, nous recommandons la version 2.

Ce qu'apporte la version 2 :

• La signature est liée à l'endpoint. La méthode et le chemin font partie de ce qui est signé : une requête signée pour /v1/subscription/check ne peut donc pas être rejouée vers /v1/subscription/stop.
• Elle expire au bout de 5 minutes. L'horodatage signé doit être à 300 secondes au plus de l'horloge du serveur.
• Chaque requête signée n'est acceptée qu'une seule fois. Le nonce signé ne peut pas être réutilisé : une requête interceptée ne peut donc pas être rejouée.

En-têtes Requis (version 2)

En-tête	Description
Authorization: Bearer YOUR_API_TOKEN	Votre token API, comme en version 1
X-Signature-Version: 2	Sélectionne la version 2 de la signature pour cette requête
X-Timestamp: 1761040800	Heure Unix actuelle en secondes, sous forme d'entier décimal
X-Nonce: 7f3c9a12b4e8d05c	Une valeur unique pour chaque requête : 8 à 128 caractères parmi A–Z a–z 0–9 . _ ~ - (un UUID ou au moins 16 caractères hexadécimaux aléatoires conviennent). Ne réutilisez jamais un nonce
X-Signature: YOUR_SIGNATURE	Signature de la requête, calculée comme ci-dessous
Content-Type: application/json	Le type de contenu doit être JSON

Calcul de la Signature (version 2)

X-Signature est le HMAC-SHA256, en hexadécimal minuscule, de la chaîne suivante, avec votre secret API comme clé :

METHOD + "\n" + PATH + "\n" + X-Timestamp + "\n" + X-Nonce + "\n" + BODY

• METHOD vaut POST (tous les endpoints /v1 utilisent POST).
• PATH est le chemin de la requête exactement tel qu'envoyé, sans l'hôte et sans query string, par exemple /v1/transaction/new.
• X-Timestamp et X-Nonce sont exactement les valeurs des en-têtes que vous envoyez.
• BODY correspond aux octets bruts exacts du corps de la requête (une chaîne vide si le corps est vide). Signez les octets que vous envoyez : si le JSON est sérialisé de nouveau après la signature, celle-ci ne correspondra pas.
• "\n" est un unique saut de ligne (0x0A). Il n'y a pas de saut de ligne après le corps.

Le serveur vérifie d'abord la signature, puis que X-Timestamp ne s'écarte pas de plus de 300 secondes (5 minutes) de sa propre horloge, dans un sens comme dans l'autre, et enfin que votre compte n'a pas déjà utilisé ce nonce (les nonces sont conservés environ 11 minutes). Gardez l'horloge de votre serveur synchronisée par NTP. Une nouvelle tentative est une nouvelle requête : elle exige un nouvel horodatage, un nouveau nonce et une nouvelle signature.

Vecteur de Test

Vérifiez votre code avec ces valeurs avant d'appeler l'API :

Entrée	Valeur
Secret API	your_api_secret
Méthode	POST
Chemin	/v1/transaction/new
X-Timestamp	1761040800
X-Nonce	7f3c9a12b4e8d05c
Corps	{"service":"energy","params":{"address":"TRX_ADDRESS","energy_amount":65000,"duration":1}}

La chaîne à signer (cinq lignes, sans saut de ligne après la dernière) :

POST
/v1/transaction/new
1761040800
7f3c9a12b4e8d05c
{"service":"energy","params":{"address":"TRX_ADDRESS","energy_amount":65000,"duration":1}}

X-Signature attendue :

56576e1faecaca2b2533bee6124e7ece2b023665addb2f2e79b8ac83bf8104e8

Erreurs (version 2)

Une vérification échouée renvoie la même réponse HTTP 401 qu'en version 1, avec "code": 1. Une signature, un horodatage ou un nonce erroné ou absent, ou un X-Signature-Version autre que 1 ou 2, reçoit le message habituel Incorrect token or signature. Ce n'est qu'après une signature valide que deux messages plus précis peuvent apparaître :

• X-Timestamp is N seconds from this server's clock; at most 300 either way is accepted — votre horloge est décalée : synchronisez-la par NTP.
• This X-Nonce was already used; every request needs a new one — générez un nouveau nonce pour chaque requête, y compris pour les nouvelles tentatives.

Exemples de la Version 2 dans Différents Langages

Bash

#!/bin/bash
API_TOKEN="your_api_token"
API_SECRET="your_api_secret"
REQUEST_PATH="/v1/transaction/new"
REQUEST_BODY='{"service":"energy","params":{"address":"TRX_ADDRESS","energy_amount":65000,"duration":1}}'

# A new timestamp and nonce for every request
TIMESTAMP=$(date +%s)
NONCE=$(openssl rand -hex 16)

# Calculate signature: METHOD\nPATH\nTIMESTAMP\nNONCE\nBODY, no trailing newline
SIGNATURE=$(printf '%s\n%s\n%s\n%s\n%s' "POST" "$REQUEST_PATH" "$TIMESTAMP" "$NONCE" "$REQUEST_BODY" \
  | openssl dgst -sha256 -hmac "$API_SECRET" | awk '{print $NF}')

# Make API request
curl -X POST "https://api.trxup.com${REQUEST_PATH}" \
  -H "Authorization: Bearer ${API_TOKEN}" \
  -H "X-Signature-Version: 2" \
  -H "X-Timestamp: ${TIMESTAMP}" \
  -H "X-Nonce: ${NONCE}" \
  -H "X-Signature: ${SIGNATURE}" \
  -H "Content-Type: application/json" \
  -d "${REQUEST_BODY}"

Node.js

const crypto = require('crypto');
const axios = require('axios');

const apiToken = 'your_api_token';
const apiSecret = 'your_api_secret';
const requestPath = '/v1/transaction/new';
const requestBody = JSON.stringify({
  service: 'energy',
  params: {
    address: 'TRX_ADDRESS',
    energy_amount: 65000,
    duration: 1
  }
});

// A new timestamp and nonce for every request
const timestamp = Math.floor(Date.now() / 1000).toString();
const nonce = crypto.randomUUID();

// Calculate signature: METHOD\nPATH\nTIMESTAMP\nNONCE\nBODY
const payload = ['POST', requestPath, timestamp, nonce, requestBody].join('\n');
const signature = crypto
  .createHmac('sha256', apiSecret)
  .update(payload)
  .digest('hex');

// Make API request (send exactly the body that was signed)
axios({
  method: 'post',
  url: 'https://api.trxup.com' + requestPath,
  headers: {
    'Authorization': `Bearer ${apiToken}`,
    'X-Signature-Version': '2',
    'X-Timestamp': timestamp,
    'X-Nonce': nonce,
    'X-Signature': signature,
    'Content-Type': 'application/json'
  },
  data: requestBody
})
.then(response => console.log(response.data))
.catch(error => console.error(error));

PHP

<?php
$apiToken = 'your_api_token';
$apiSecret = 'your_api_secret';
$requestPath = '/v1/transaction/new';
$requestBody = json_encode([
  'service' => 'energy',
  'params' => [
    'address' => 'TRX_ADDRESS',
    'energy_amount' => 65000,
    'duration' => 1
  ]
]);

// A new timestamp and nonce for every request
$timestamp = (string) time();
$nonce = bin2hex(random_bytes(16));

// Calculate signature: METHOD\nPATH\nTIMESTAMP\nNONCE\nBODY
$payload = implode("\n", ['POST', $requestPath, $timestamp, $nonce, $requestBody]);
$signature = hash_hmac('sha256', $payload, $apiSecret);

// Make API request (send exactly the body that was signed)
$ch = curl_init('https://api.trxup.com' . $requestPath);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $requestBody);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'Authorization: Bearer ' . $apiToken,
  'X-Signature-Version: 2',
  'X-Timestamp: ' . $timestamp,
  'X-Nonce: ' . $nonce,
  'X-Signature: ' . $signature,
  'Content-Type: application/json'
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

Python

import hashlib
import hmac
import json
import time
import uuid
import requests

api_token = 'your_api_token'
api_secret = 'your_api_secret'
request_path = '/v1/transaction/new'
# Compact separators: the same bytes as the test vector and the other examples
request_body = json.dumps({
  'service': 'energy',
  'params': {
    'address': 'TRX_ADDRESS',
    'energy_amount': 65000,
    'duration': 1
  }
}, separators=(',', ':'))

# A new timestamp and nonce for every request
timestamp = str(int(time.time()))
nonce = uuid.uuid4().hex

# Calculate signature: METHOD\nPATH\nTIMESTAMP\nNONCE\nBODY
payload = '\n'.join(['POST', request_path, timestamp, nonce, request_body])
signature = hmac.new(api_secret.encode(), payload.encode(), hashlib.sha256).hexdigest()

# Make API request (send exactly the bytes that were signed)
headers = {
  'Authorization': f'Bearer {api_token}',
  'X-Signature-Version': '2',
  'X-Timestamp': timestamp,
  'X-Nonce': nonce,
  'X-Signature': signature,
  'Content-Type': 'application/json'
}

response = requests.post(
  'https://api.trxup.com' + request_path,
  headers=headers,
  data=request_body.encode()
)

print(response.json())