Vanaf 6 juli 2026 zullen tokens gegenereerd door het oude verificatiesysteem ongeldig zijn en zal het niet meer mogelijk zijn om een toegangstoken voor de Axeptio API te genereren via gebruikersnaam en wachtwoord. De huidige verificatie-eindpunten zullen worden afgeschaft. Elke aanroep naar de Axeptio API met een token gegenereerd door het oude systeem zal worden afgewezen — ongeacht of dit via code, een script of een tool zoals Postman is. Als dit op u van toepassing is, werkt u uw verificatiemethode bij door de onderstaande stappen te volgen.

Op wie is dit van toepassing?

Dit artikel is voor u relevant als u de Axeptio API rechtstreeks aanroept — via code, een script, uw integraties, een tool zoals Postman of elke andere HTTP-client.

Als u alleen het Axeptio-beheer gebruikt en de API niet rechtstreeks aanroept, hoeft u geen actie ondernemen.

Waarom deze wijziging?

Axeptio migreert het verificatiesysteem naar Frontegg. Deze migratie vormt de technische basis voor komende nieuwe functies: MFA, Social login, SSO en audit-logboeken. Dit maakt ook robuuster en gedetailleerder API-toegangsbeheer mogelijk.

Wat gebeurt er als u niet migreert

Vanaf 6 juli 2026 zal elke aanroep naar de Axeptio API met het oude verificatiesysteem worden afgewezen. Uw reeds gepubliceerde toestemmingsbanners worden niet beïnvloed — alleen programmatische integraties zullen niet meer werken.

Wat verandert

Het eindpunt voor het verkrijgen van een Bearer-token verandert, evenals de bijbehorende referenties, maar de manier waarop u het token in uw aanvragen doorgeeft blijft hetzelfde — een header Authorization: Bearer. Wat praktisch verandert: u verkrijgt nu een kortstondig token van Frontegg in ruil voor een Client ID en Secret, in plaats van een langdurig token via uw gebruikersnaam en wachtwoord.

	Voor	Na
Eindpunt	POST /auth/local/signin	POST https://login.axept.io/identity/resources/auth/v2/api-token
Referenties	gebruikersnaam + wachtwoord	clientId + secret
Geldigheidsduur	Langdurig	1 uur — automatisch vernieuwen
Transmissie	Authorization: Bearer	Authorization: Bearer (ongewijzigd)

Overzicht van de werkstroom

Genereer API-toegang in het Axeptio-beheer. U ontvangt een Client ID en Secret die uw integratie identificeren.
Vraag een token aan bij Frontegg door uw Client ID en Secret in te dienen. U ontvangt in ruil daarvoor een access_token, geldig gedurende 1 uur.
Roep de Axeptio API aan door dit token in de header Authorization: Bearer van elk verzoek op te nemen.
Vernieuw het token voor het verloopt via het daarvoor bestemde eindpunt, zonder de Client ID en Secret opnieuw in te voeren.

1. Genereer API-toegang in het Axeptio-beheer

Meld u aan bij het Axeptio-beheer.
Ga naar Instellingen → API-toegang.
Kopieer uw Client ID en uw Secret.

Bewaar uw secret op een veilige plaats — het kan niet worden opgehaald na generatie. Schrijf het nooit hardcoded in uw code: sla het op in een omgevingsvariabele.

2. Vraag een token aan bij Frontegg

Roep het Frontegg-eindpunt aan met uw Client ID en Secret. U ontvangt in ruil daarvoor een access_token, geldig gedurende 1 uur, en een refresh_token om het te vernieuwen.

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

Respons:

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

3. Roep de Axeptio API aan

Neem de access_token op in de header Authorization van elk verzoek.

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

4. Vernieuw het token voor het verloopt

Het token verloopt na 1 uur. Controleer voor elke aanroep of het nog geldig is en vernieuw het indien nodig — zonder de Client ID en Secret opnieuw in te voeren.

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

Volledige codevoorbeelden

TypeScript / Node.js

const FRONTEGG_URL = process.env.FRONTEGG_URL;

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

async function getAccessToken(clientId: string, secret: string): Promise<FronteggTokenResponse> {
  const res = await fetch(`${FRONTEGG_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<FronteggTokenResponse> {
  const res = await fetch(`${FRONTEGG_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(`https://api.axept.io/v1${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

FRONTEGG_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"{FRONTEGG_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"{FRONTEGG_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)

Naslaginformatie

De volledige lijst met beschikbare eindpunten is gedocumenteerd in de Axeptio Swagger.

Hulp nodig?

Als uw aanroepen na de migratie mislukken, als uw referenties niet zichtbaar zijn in het Axeptio-beheer, of voor andere vragen, aarzel niet om contact op te nemen met ons ondersteuningsteam.

Om door te gaan met het gebruik van de Axeptio API vanaf 6 juli 2026