Dit artikel is bedoeld voor ontwikkelaars en technische teams die de Axeptio API rechtstreeks aanroepen — vanuit code, een script, een aangepaste integratie of een HTTP-client zoals Postman.

Axeptio verifieert uw verzoeken met behulp van een kortdurige Bearer-token. U genereert eerst een persoonlijk token in de Axeptio-beheermodule, wat u een client-ID en een geheime sleutel geeft. Vervolgens wisselt u deze inloggegevens in voor een access_token die 1 uur geldig is, welke u in elk van uw verzoeken opneemt.

Hoe verificatie werkt

Genereer een persoonlijk token in de Axeptio-beheermodule. U ontvangt een client-ID en een geheime sleutel die uw integratie identificeren.
Haal een access token op door deze client-ID en geheime sleutel in te dienen. U ontvangt een access_token geldig voor 1 uur en een refresh_token.
Verzend uw verzoeken naar de Axeptio API door de access_token in de Authorization: Bearer header van elk verzoek op te nemen.
Ververs de access token voordat deze verloopt, zonder de client-ID en geheime sleutel opnieuw in te voeren.

Er zijn twee verschillende geldigheidsduren van toepassing. Het persoonlijke token — de client-ID en geheime sleutel — heeft de geldigheidsduur die u bij aanmaak kiest: dit is uw langdurige inloggegevenspaar. De access_token verkregen uit dit token verloopt na één uur: dit is degene die uw code automatisch moet vernieuwen.

1. Genereer een persoonlijk token in de Axeptio-beheermodule

Meld u aan bij de Axeptio-beheermodule.
Klik in de navigatiebalk op Account.
Klik op Beveiligingsvoorkeuren — een venster wordt geopend.
Selecteer in het menu Persoonlijke tokens.
Klik op Token genereren, geef uw token een naam en kies een geldigheidsduur. Wij raden u aan om de optie Nooit te vermijden: een token dat nooit verloopt blijft voor onbepaalde tijd geldig in geval van een lek. Als u niet zeker bent wat u moet kiezen, selecteer 90 dagen voor een productie-integratie, of 7 dagen voor eenmalig gebruik of testen.
Kopieer de Client-ID en Geheime sleutel die worden weergegeven — deze zullen na deze stap niet meer zichtbaar zijn.

Bewaar de client-ID en geheime sleutel op een veilige plaats — deze kunnen niet worden opgehaald na generatie. Schrijf ze nooit hard in uw code: sla ze op in omgevingsvariabelen.

U kunt zoveel tokens genereren als nodig — de naam stelt u in staat deze te identificeren. Dit is handig als u meerdere omgevingen (ontwikkeling, productie) of meerdere integraties heeft: elk token is onafhankelijk, waardoor u de toegang van een specifieke integratie kunt intrekken zonder de andere te beïnvloeden.

2. Haal een access token op

Roep het verificatie-eindpunt aan met uw client-ID en geheime sleutel. U ontvangt een access_token, geldig voor 1 uur, en een refresh_token om deze 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>" }'

Antwoord:

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

3. Verzend uw verzoeken naar de Axeptio API

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

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

4. Ververs de access token voordat deze verloopt

De access_token verloopt na 1 uur. Controleer vóór elk verzoek of deze nog geldig is en ververs deze indien nodig — zonder de client-ID en geheime sleutel 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 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();
}

// Gebruik met automatische vernieuwing
let token = await getAccessToken(CLIENT_ID, SECRET);

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

async function apiCall(path: string) {
  // Vernieuwt 60 s vóór verloop om afwijzingen vanwege netwerklatentie te voorkomen
  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()

# Gebruik met automatische vernieuwing
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 marge om afwijzingen vanwege netwerklatentie te voorkomen
        token = refresh_access_token(token["refresh_token"])
        expires_at = time.time() + token["expires_in"]
    return call_axeptio_api(token["access_token"], path)

Referentie

De volledige lijst met beschikbare eindpunten is gedocumenteerd in de Axeptio Swagger (momenteel bijgewerkt), ook beschikbaar in OpenAPI-indeling voor uw tools: all.swagger.json. Voor een overzicht van wat de API kan doen, raadpleeg Gebruik de Axeptio API.

Als uw API-verzoeken een verificatiefout retourneren

Controleer hoe uw code zijn token verkrijgt. Als het een gebruikersnaam en wachtwoord verzendt, is dat het probleem: deze methode bestaat niet meer sinds 10 juli 2026 en de tokens die deze produceerde, zijn ongeldig gemaakt.

Genereer een persoonlijk token door stap 1 te volgen, vervang vervolgens het verzoek dat uw gebruikersnaam en wachtwoord verzendt door het verzoek uit stap 2. De rest van uw integratie blijft ongewijzigd: de Authorization: Bearer header is identiek.

Hebt u hulp nodig?

Als uw verzoeken mislukken, als uw inloggegevens niet zichtbaar zijn in de Axeptio-beheermodule, of voor andere vragen, neem dan contact op met ons ondersteuningsteam.

Uw API-verzoeken bij Axeptio verifiëren