Cet article s'adresse aux développeurs et aux équipes techniques qui appellent l'API Axeptio directement — depuis du code, un script, une intégration maison, ou un client HTTP comme Postman.

Axeptio authentifie vos requêtes grâce à un token Bearer de courte durée. Vous générez d'abord un jeton personnel dans l'administration Axeptio, qui vous fournit un identifiant client et une clé secrète. Vous échangez ensuite ces identifiants contre un access_token valable 1 heure, que vous transmettez dans chacune de vos requêtes.

Comment fonctionne l'authentification

Générer un jeton personnel dans l'administration Axeptio. Vous obtenez un identifiant client et une clé secrète qui identifient votre intégration.
Obtenir un access token en présentant cet identifiant client et cette clé secrète. Vous recevez un access_token valable 1 heure et un refresh_token.
Envoyer vos requêtes à l'API Axeptio en incluant l'access_token dans le header Authorization: Bearer de chacune d'elles.
Rafraîchir l'access token avant son expiration, sans avoir à ressaisir l'identifiant client et la clé secrète.

Deux durées de vie distinctes entrent en jeu. Le jeton personnel — l'identifiant client et la clé secrète — a la durée d'expiration que vous choisissez à sa création : c'est votre credential longue durée. L'access_token obtenu à partir de ce jeton expire au bout d'une heure : c'est lui que votre code doit rafraîchir automatiquement.

1. Générer un jeton personnel dans l'administration Axeptio

Connectez-vous à l'administration Axeptio.
Dans la barre de navigation, cliquez sur Compte.
Cliquez sur Préférences de sécurité — une fenêtre s'ouvre.
Dans le menu, sélectionnez Jetons personnels.
Cliquez sur Générer le jeton, donnez un nom à votre jeton et choisissez une durée d'expiration. Nous vous recommandons d'éviter l'option Jamais : un jeton qui n'expire pas reste valide indéfiniment en cas de fuite. Si vous ne savez pas quoi choisir, optez pour 90 jours pour une intégration en production, ou 7 jours pour un usage ponctuel ou un test.
Copiez l'Identifiant du client et la Clé secrète qui s'affichent — ils ne seront plus visibles après cette étape.

Conservez l'identifiant du client et la clé secrète en lieu sûr — ils ne peuvent pas être récupérés après génération. Ne les écrivez jamais en dur dans votre code : stockez-les dans des variables d'environnement.

Vous pouvez générer autant de jetons que nécessaire — le nom vous permet de les identifier. C'est utile si vous avez plusieurs environnements (développement, production) ou plusieurs intégrations : chaque jeton est indépendant, ce qui vous permet de révoquer l'accès d'une intégration spécifique sans affecter les autres.

2. Obtenir un access token

Appelez le endpoint d'authentification avec votre identifiant client et votre clé secrète. Vous recevez en retour un access_token, valable 1 heure, et un refresh_token pour le renouveler.

curl -X POST https://login.axept.io/identity/resources/auth/v2/api-token \
  -H "Content-Type: application/json" \
  -d '{ "clientId": "<CLIENT_ID>", "secret": "<SECRET>" }'

Réponse :

{
  "access_token": "eyJ...",
  "refresh_token": "dGhp...",
  "expires_in": 3600
}

3. Envoyer vos requêtes à l'API Axeptio

Incluez l'access_token dans le header Authorization de chaque requête.

curl https://api.axept.io/v1/<ENDPOINT> \
  -H "Authorization: Bearer <ACCESS_TOKEN>"

4. Rafraîchir l'access token avant son expiration

L'access_token expire après 1 heure. Avant chaque requête, vérifiez s'il est encore valide et rafraîchissez-le si nécessaire — sans avoir à ressaisir l'identifiant client et la clé secrète.

curl -X POST https://login.axept.io/identity/resources/auth/v2/api-token/token/refresh \
  -H "Content-Type: application/json" \
  -d '{ "refreshToken": "<REFRESH_TOKEN>" }'

Exemples de code complets

TypeScript / Node.js

const AUTH_URL = "https://login.axept.io";
const AXEPTIO_API = "https://api.axept.io/v1";

interface TokenResponse {
  access_token: string;
  refresh_token: string;
  expires_in: number;
}

async function getAccessToken(clientId: string, secret: string): Promise<TokenResponse> {
  const res = await fetch(`${AUTH_URL}/identity/resources/auth/v2/api-token`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ clientId, secret }),
  });
  if (!res.ok) throw new Error(`Token fetch failed: ${res.status}`);
  return res.json();
}

async function refreshAccessToken(refreshToken: string): Promise<TokenResponse> {
  const res = await fetch(`${AUTH_URL}/identity/resources/auth/v2/api-token/token/refresh`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ refreshToken }),
  });
  if (!res.ok) throw new Error(`Token refresh failed: ${res.status}`);
  return res.json();
}

async function callAxeptioApi(accessToken: string, path: string) {
  const res = await fetch(`${AXEPTIO_API}${path}`, {
    headers: { Authorization: `Bearer ${accessToken}` },
  });
  if (!res.ok) throw new Error(`API call failed: ${res.status}`);
  return res.json();
}

// Utilisation avec rafraîchissement automatique
let token = await getAccessToken(CLIENT_ID, SECRET);

let expiresAt = Date.now() + token.expires_in * 1000;

async function apiCall(path: string) {
  // Rafraîchit 60 s avant expiration pour éviter les rejets en cas de latence réseau
  if (Date.now() > expiresAt - 60_000) {
    token = await refreshAccessToken(token.refresh_token);
    expiresAt = Date.now() + token.expires_in * 1000;
  }
  return callAxeptioApi(token.access_token, path);
}

Python

import time
import requests

AUTH_URL = "https://login.axept.io"
AXEPTIO_API = "https://api.axept.io/v1"

def get_access_token(client_id: str, secret: str) -> dict:
    res = requests.post(
        f"{AUTH_URL}/identity/resources/auth/v2/api-token",
        json={"clientId": client_id, "secret": secret},
    )
    res.raise_for_status()
    return res.json()

def refresh_access_token(refresh_token: str) -> dict:
    res = requests.post(
        f"{AUTH_URL}/identity/resources/auth/v2/api-token/token/refresh",
        json={"refreshToken": refresh_token},
    )
    res.raise_for_status()
    return res.json()

def call_axeptio_api(access_token: str, path: str) -> dict:
    res = requests.get(
        f"{AXEPTIO_API}{path}",
        headers={"Authorization": f"Bearer {access_token}"},
    )
    res.raise_for_status()
    return res.json()

# Utilisation avec rafraîchissement automatique
token = get_access_token(CLIENT_ID, SECRET)

expires_at = time.time() + token["expires_in"]

def api_call(path: str) -> dict:
    global token, expires_at
    if time.time() > expires_at - 60:  # 60 s de marge pour éviter les rejets en cas de latence réseau
        token = refresh_access_token(token["refresh_token"])
        expires_at = time.time() + token["expires_in"]
    return call_axeptio_api(token["access_token"], path)

Référence

La liste complète des endpoints disponibles est documentée dans le Swagger Axeptio (en cours de mise à jour). Pour un aperçu de ce que l'API permet de faire, consultez Utiliser l'API Axeptio.

Si vos requêtes à l'API renvoient une erreur d'authentification

Vérifiez comment votre code obtient son token. S'il envoie un username et un password, c'est la cause : cette méthode n'existe plus depuis le 10 juillet 2026 et les tokens qu'elle produisait ont été invalidés.

Générez un jeton personnel en suivant l'étape 1, puis remplacez la requête qui transmet vos username et password par celle de l'étape 2. Le reste de votre intégration reste inchangé : le header Authorization: Bearer est identique.

Besoin d'aide ?

Si vos requêtes échouent, si vos identifiants ne sont pas visibles dans l'administration Axeptio, ou pour toute autre question, n'hésitez pas à contacter notre équipe support.

Authentifier vos requêtes à l'API Axeptio