Passer au contenu principal
L’API Chariow implémente une limitation de débit pour garantir une utilisation équitable et maintenir la qualité du service pour tous les utilisateurs.

​
Limites par défaut

Type d’endpointLimiteFenêtre
Toutes les requêtes API100 requêtespar minute
Les limites de débit sont appliquées par clé API. Chaque clé API a son propre compteur de limite séparé.

​
En-têtes de limite de débit

Chaque réponse API inclut des en-têtes indiquant votre statut actuel de limite de débit : 
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 98
X-RateLimit-Reset: 1642089600
En-têteDescription
X-RateLimit-LimitNombre maximum de requêtes autorisées dans la fenêtre
X-RateLimit-RemainingRequêtes restantes dans la fenêtre actuelle
X-RateLimit-ResetTimestamp Unix de réinitialisation de la limite

​
Limite de débit dépassée

Lorsque vous dépassez la limite de débit, vous recevrez une réponse 429 Too Many Requests : 
{
  "message": "Trop de requêtes. Veuillez réessayer plus tard.",
  "data": [],
  "errors": []
}
La réponse inclut un en-tête Retry-After indiquant combien de temps attendre : 
HTTP/1.1 429 Too Many Requests
Retry-After: 60

​
Gérer les limites de débit

​
Backoff exponentiel

Implémentez un backoff exponentiel pour gérer gracieusement les limites de débit : 
async function fetchWithRetry(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') || 60;
      const delay = Math.min(retryAfter * 1000, Math.pow(2, attempt) * 1000);

      console.log(`Limite atteinte. Nouvel essai dans ${delay}ms...`);
      await new Promise(resolve => setTimeout(resolve, delay));
      continue;
    }

    return response;
  }

  throw new Error('Nombre maximum de tentatives dépassé');
}

​
Regroupement des requêtes

Regroupez plusieurs opérations pour réduire le nombre de requêtes : 
// Au lieu de faire 100 requêtes individuelles
for (const customerId of customerIds) {
  await getCustomer(customerId); // 100 requêtes
}

// Utilisez la pagination pour en récupérer plusieurs à la fois
const customers = await listCustomers({ per_page: 100 }); // 1 requête

​
Mise en cache

Mettez en cache les réponses pour éviter les requêtes inutiles : 
const cache = new Map();
const CACHE_TTL = 60000; // 1 minute

async function getCachedCustomer(customerId) {
  const cached = cache.get(customerId);

  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    return cached.data;
  }

  const response = await fetch(`/v1/customers/${customerId}`, {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  });

  const data = await response.json();
  cache.set(customerId, { data, timestamp: Date.now() });

  return data;
}

​
Augmenter les limites

Si vous avez besoin de limites de débit plus élevées :
  1. Plans Entreprise - Des limites plus élevées sont disponibles sur les plans entreprise
  2. Contacter le support - Demandez une augmentation temporaire pour des cas d’utilisation spécifiques
  3. Optimiser l’utilisation - Examinez votre implémentation pour des opportunités d’optimisation
Contactez [email protected] pour discuter de limites de débit plus élevées pour votre cas d’utilisation.

​
Bonnes pratiques

Suivez les en-têtes de limite de débit pour comprendre vos schémas d’utilisation et ajustez en conséquence.
Au lieu de faire du polling pour les changements, utilisez les webhooks pour recevoir des notifications en temps réel.
Mettez les requêtes en file d’attente et traitez-les à un rythme contrôlé pour éviter les pics.
Mettez en cache les données qui ne changent pas fréquemment pour réduire les appels API.