Limites de Taux

HTTP/1.1 200 OK
X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 847
X-RateLimit-Reset: 1710936000

{
  "success": false,
  "error": {
    "code": "API_RATE_LIMIT_EXCEEDED",
    "message": "Limite de taux dépassée. Veuillez patienter avant de faire plus de requêtes.",
    "details": {
      "retryAfter": 30,
      "limit": 1000,
      "reset": "2024-03-20T10:01:00Z"
    },
    "timestamp": "2024-03-20T10:00:30.000Z",
    "requestId": "req_5f2b8c9d1e"
  }
}

const response = await fetch("https://api.oquira.com/v1/business/queues", {
  headers: { Authorization: `Bearer ${apiKey}` },
});

const remaining = response.headers.get("X-RateLimit-Remaining");
if (remaining < 100) {
  console.warn(`Limite de taux basse : ${remaining} requêtes restantes`);
}

async function apiCallWithRetry(url, options, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const response = await fetch(url, options);

    if (response.status === 429) {
      const retryAfter = response.headers.get("Retry-After") || 30;
      const delay = Math.pow(2, attempt) * 1000; // Backoff exponentiel
      await new Promise((resolve) => setTimeout(resolve, delay));
      continue;
    }

    return response;
  }
  throw new Error("Nombre maximum de tentatives dépassé");
}

const cache = new Map();
const CACHE_TTL = 60000; // 1 minute

async function getCachedData(key, fetchFn) {
  const cached = cache.get(key);
  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    return cached.data;
  }

  const data = await fetchFn();
  cache.set(key, { data, timestamp: Date.now() });
  return data;
}

# Au lieu de plusieurs appels :
# curl -X GET "https://api.oquira.com/v1/business/services/srv_1" ...
# curl -X GET "https://api.oquira.com/v1/business/services/srv_2" ...
# curl -X GET "https://api.oquira.com/v1/business/services/srv_3" ...

# Utilisez un seul appel de liste avec des filtres :
curl -X GET "https://api.oquira.com/v1/business/services?ids=srv_1,srv_2,srv_3" \
  -H "X-API-Key: votre_cle_api"

class RequestQueue {
  constructor(maxPerSecond = 10) {
    this.queue = [];
    this.interval = 1000 / maxPerSecond;
    this.processing = false;
  }

  async add(requestFn) {
    return new Promise((resolve, reject) => {
      this.queue.push({ requestFn, resolve, reject });
      this.process();
    });
  }

  async process() {
    if (this.processing || this.queue.length === 0) return;
    this.processing = true;

    const { requestFn, resolve, reject } = this.queue.shift();
    try {
      const result = await requestFn();
      resolve(result);
    } catch (error) {
      reject(error);
    }

    setTimeout(() => {
      this.processing = false;
      this.process();
    }, this.interval);
  }
}

{
  "success": false,
  "error": {
    "code": "QUOTA_EXCEEDED",
    "message": "Quota mensuel d'appels API dépassé",
    "details": {
      "limit": 10000,
      "used": 10000,
      "resetsAt": "2024-04-01T00:00:00Z"
    }
  }
}