Dit artikel is bestemd 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 token met korte geldigheidsduur. U genereert eerst een persoonlijk token in het Axeptio-beheer, waarmee u een client-ID en geheime sleutel verkrijgt. Vervolgens wisselt u deze referenties in voor een access_token die 1 uur geldig is, die u in elk van uw verzoeken doorgeeft.

Hoe verificatie werkt

Genereer een persoonlijk token in het Axeptio-beheer. U ontvangt een client-ID en geheime sleutel die uw integratie identificeren.
Verkrijg een access token door deze client-ID en geheime sleutel in te dienen. U ontvangt een access_token die 1 uur geldig is en een refresh_token.
Stuur uw verzoeken naar de Axeptio API door de access_token op te nemen in de Authorization: Bearer-header van elk verzoek.
Vernieuw de access token voordat deze vervalt, zonder de client-ID en geheime sleutel opnieuw in te voeren.

Twee verschillende geldigheidsduren zijn van toepassing. Het persoonlijke token — de client-ID en geheime sleutel — heeft de geldigheidsduur die u bij het maken ervan kiest: dit is uw langetermijn-referentie. De access_token die uit dit token wordt verkregen, verloopt na één uur: dit is degene die uw code automatisch moet vernieuwen.

1. Genereer een persoonlijk token in het Axeptio-beheer

Meld u aan bij het Axeptio-beheer.
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. We raden u aan de optie Nooit te vermijden: een token dat niet vervalt, blijft voor onbepaalde tijd geldig in geval van datalekking. Als u niet zeker weet wat u moet kiezen, kiest u 90 dagen voor een productie-integratie of 7 dagen voor incidenteel gebruik of testen.
Kopieer de Client-ID en Geheime sleutel die worden weergegeven — deze zijn niet meer zichtbaar na deze stap.

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

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

2. Verkrijg een access token

Roep het verificatie-eindpunt aan met uw client-ID en geheime sleutel. U ontvangt in return een access_token, geldig voor 1 uur, en een refresh_token om dit 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. Stuur uw verzoeken naar de Axeptio API

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

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

4. Vernieuw de access token voordat deze vervalt

De access_token verloopt na 1 uur. Controleer vóór elk verzoek of deze nog geldig is en vernieuw 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 verval 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 (wordt bijgewerkt). Raadpleeg De Axeptio API gebruiken voor een overzicht van wat de API kan doen.

Als uw API-verzoeken een verificatiefout retourneren

Controleer hoe uw code het token verkrijgt. Als het een gebruikersnaam en wachtwoord verzendt, is dat de oorzaak: 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 en vervang vervolgens het verzoek dat uw gebruikersnaam en wachtwoord doorgeeft door het verzoek uit stap 2. De rest van uw integratie blijft ongewijzigd: de Authorization: Bearer-header is identiek.

Hulp nodig?

Als uw verzoeken mislukken, als uw referenties niet zichtbaar zijn in het Axeptio-beheer, of voor enige andere vraag, neem dan gerust contact op met ons ondersteuningsteam.

Uw API-verzoeken bij Axeptio verifiëren