⚠️ Dit artikel is in bewerking. Sommige informatie kan wijzigen voordat de migratiedatum aankomt.

Vanaf 6 juli 2026 zullen tokens die gegenereerd zijn door het oude verificatiesysteem ongeldig worden, en is het niet langer mogelijk om een API-toegangstoken van Axeptio te genereren via gebruikersnaam en wachtwoord. De huidige verificatie-endpoints zullen verouderd zijn. Alle aanroepen naar de Axeptio API met een token die gegenereerd is door het oude systeem zullen worden geweigerd — of dit nu vanuit code, een script of een hulpprogramma zoals Postman is. Als dit op u van toepassing is, werk uw verificatiemethode bij door de onderstaande stappen te volgen.

Wie heeft hiermee te maken?

Dit artikel is relevant voor u als u de Axeptio API rechtstreeks aanroept — vanuit code, een script, uw integraties, een hulpprogramma zoals Postman, of een ander HTTP-clientprogramma.

Als u alleen Axeptio-beheer gebruikt en de API niet rechtstreeks aanroept, is geen actie van uw zijde vereist.

Waarom deze wijziging?

Axeptio migreert zijn verificatiesysteem naar Frontegg. Deze migratie legt de technische basis voor aankomende nieuwe functies: MFA, sociale aanmeldingen, SSO en auditlogboeken. Het biedt ook robuuster en nauwkeuriger API-toegangsbeheer.

Wat gebeurt er als u niet migreert

Vanaf 6 juli 2026 zullen alle aanroepen naar de Axeptio API die gebruikmaken van het oude verificatiesysteem worden geweigerd. Uw reeds gepubliceerde toestemmingsbanners worden niet beïnvloed — alleen programmatische integraties zullen niet meer functioneren.

Wat verandert

Het endpoint om een Bearer-token te verkrijgen verandert, evenals de bijbehorende inloggegevens, maar de manier waarop u het token in uw aanvragen verzendt, blijft hetzelfde — een Authorization: Bearer-header. Praktisch gezien verandert het volgende: u haalt nu een token met korte levensduur op van Frontegg in ruil voor een client-ID en geheim, in plaats van een token met lange levensduur via uw gebruikersnaam en wachtwoord.

	Voor	Na
Endpoint	POST /auth/local/signin	POST /identity/resources/auth/v2/api-token
Inloggegevens	gebruikersnaam + wachtwoord	clientId + secret
Levensduur	Lange duur	1 uur — automatisch vernieuwen
Verzending	Authorization: Bearer	Authorization: Bearer (ongewijzigd)

Overzicht van de procedure

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

1. Genereer een API-toegang in Axeptio-beheer

Meld u aan bij Axeptio-beheer.
Ga naar Instellingen → API-toegang.
Kopieer uw client-ID en uw geheim.

Bewaar uw geheim op een veilige plaats — het kan niet worden opgehaald na het genereren. Voer het nooit hardcoded in uw code in: sla het op in een omgevingsvariabele.

2. Vraag een token aan bij Frontegg

Roep het Frontegg-endpoint aan met uw client-ID en geheim. U ontvangt een access_token die 1 uur geldig is, en een refresh_token om deze te vernieuwen.

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

Antwoord:

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

3. Roep de Axeptio API aan

Voeg de access_token in de Authorization-header van elk verzoek op.

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. Voordat u een aanroep doet, controleert u of het nog geldig is en vernieuwt u het indien nodig — zonder de client-ID en het geheim opnieuw in te voeren.

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

Complete 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://<FRONTEGG_URL>"
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 endpoints staat gedocumenteerd in Axeptio Swagger.

Hulp nodig?

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

Om de Axeptio-API na 6 juli 2026 te blijven gebruiken