{
  "statusCode": 400,
  "message": "customerName is required",
  "error": "Bad Request"
}

interface ApiError {
  statusCode: number;
  message: string | string[];
  error: string;
}

async function createLead(payload: Record<string, unknown>) {
  const response = await fetch("https://api.flixerpro.io/v1/api/leads", {
    method: "POST",
    headers: {
      "X-API-Key": process.env.FLIXER_API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify(payload),
  });

  if (!response.ok) {
    const err = (await response.json()) as ApiError;
    const requestId = response.headers.get("X-Request-Id");

    switch (response.status) {
      case 400:
        console.error("Validatiefout:", err.message);
        break;
      case 401:
        console.error("Ongeldige of ontbrekende API-sleutel");
        break;
      case 403:
        console.error("Sleutel mist de vereiste scope");
        break;
      default:
        console.error(`API-fout ${response.status} (request ${requestId})`);
    }
    throw new Error(
      Array.isArray(err.message) ? err.message.join(", ") : err.message,
    );
  }

  return response.json();
}

import os
import requests

class FlixerAPIError(Exception):
    def __init__(self, status_code: int, body: dict):
        self.status_code = status_code
        self.body = body
        super().__init__(body.get("message", "Onbekende fout"))

def create_lead(payload: dict) -> dict:
    response = requests.post(
        "https://api.flixerpro.io/v1/api/leads",
        headers={
            "X-API-Key": os.environ["FLIXER_API_KEY"],
            "Content-Type": "application/json",
        },
        json=payload,
        timeout=30,
    )

    if not response.ok:
        body = response.json()
        request_id = response.headers.get("X-Request-Id")
        print(f"API-fout {response.status_code} (request {request_id}): {body.get('message')}")
        raise FlixerAPIError(response.status_code, body)

    return response.json()

Poging 1: Onmiddellijk
Poging 2: Wacht 1 seconde
Poging 3: Wacht 2 seconden
Poging 4: Wacht 4 seconden

async function fetchWithRetry(
  url: string,
  options: RequestInit,
  maxRetries = 3,
  baseDelay = 1000,
): Promise<Response> {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const response = await fetch(url, options);

    // Alleen 5xx en 429 zijn de moeite van een retry waard
    if (response.ok || (response.status < 500 && response.status !== 429)) {
      return response;
    }

    if (attempt < maxRetries - 1) {
      // Backoff met jitter om "thundering herd" te voorkomen
      const delay = baseDelay * 2 ** attempt + Math.random() * 1000;
      await new Promise((resolve) => setTimeout(resolve, delay));
    }
  }
  throw new Error("Max retries bereikt");
}