Calculateur limite de débit API
Avec une limite de 100 appels par minute, en envoyer 350 demande 4 fenêtres : trois lots de 100 et un de 50, espacés de 60 secondes, soit 180 secondes au minimum. Planifiez imports, synchronisations ou reprises de données sans dépasser la limite du fournisseur. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Limite de débit
- 100
- Demandes souhaitées
- 350
- Secondes de la fenêtre
- 60
- Fenêtres nécessaires
- 4
- Taille du lot
- 100
- Taille du dernier lot
- 50
- Lots complets
- 3
Il renvoie combien de fenêtres vous avez besoin, la taille de lot maximale qui ne dépasse jamais la limite, la taille du lot partiel final, le délai à insérer entre les démarrages de lots, le temps minimal d'horloge si vous lancez le premier lot immédiatement, et l'équivalent maximal de requêtes par seconde.
Comment fenêtres, lots et délai vous maintiennent sous la limite
Une limite de débit de R requêtes par fenêtre de longueur W secondes signifie que, dans toute fenêtre glissante ou fixe de W secondes, le fournisseur acceptera au plus R appels réussis. Lorsque vous avez besoin de D requêtes au total et que D est supérieur à R, vous ne pouvez pas tout envoyer d'un coup. Le plan sûr consiste à envoyer au plus R requêtes dans la première fenêtre, attendre qu'une fenêtre complète se soit écoulée, envoyer les R suivantes, et répéter jusqu'à épuisement du reste.
Le nombre de fenêtres requises est le plafond de D divisé par R. Si D vaut trois cent cinquante et R cent, vous avez besoin de quatre fenêtres : trois lots complets de cent et un lot final de cinquante. Le délai entre les démarrages de lots est égal à W lorsqu'il faut plus d'une fenêtre, et zéro lorsqu'une seule fenêtre suffit.
Le temps minimal écoulé est alors (fenêtres moins un) fois W, car le premier lot peut démarrer à l'instant zéro et le dernier démarre après les attentes précédentes. Ce modèle correspond aux heuristiques courantes de fenêtre fixe et de token-bucket utilisées dans les bibliothèques clientes : il est volontairement conservateur pour les fenêtres fixes et un premier budget solide pour les token buckets lorsque vous ne rechargez pas en plein burst.
Questions fréquentes
Quel délai dois-je attendre entre les lots ?
Lorsqu'une seule fenêtre suffit, le délai est zéro.
Que se passe-t-il si la limite de débit est nulle ou négative ?
Une limite de débit non positive n'est pas un budget valide et l'appel n'est pas facturé.
Combien de fenêtres faut-il pour 350 appels avec une limite de 100 ?
Quatre. On divise 350 par 100 et on arrondit au-dessus : trois lots complets de 100 et un dernier lot de 50. Ce dernier est plus petit, il ne dépasse donc jamais la limite.
Quelle est la durée minimale de tout le traitement ?
Le nombre de fenêtres moins une, multiplié par la durée d'une fenêtre. Avec 4 fenêtres de 60 secondes, cela fait 180 secondes, car le premier lot part tout de suite et seules les attentes ajoutent du temps.
Le calculateur envoie-t-il les appels à ma place ?
Non. Il ne contacte jamais le service. Il dimensionne seulement le planning : c'est votre propre programme qui envoie chaque lot et respecte la pause indiquée avant le suivant.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/dev/api-rate-limit-calc \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"rate_limit":100,"desired_requests":350}'const res = await fetch("https://api.kit.forhosting.com/dev/api-rate-limit-calc", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"rate_limit": 100,
"desired_requests": 350
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/api-rate-limit-calc",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"rate_limit": 100,
"desired_requests": 350
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/api-rate-limit-calc", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"rate_limit":100,"desired_requests":350}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"rate_limit":100,"desired_requests":350}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/api-rate-limit-calc", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"rate_limit": 100,
"desired_requests": 350
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.api_rate_limit_calc",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Les API publiques et privées publient presque toujours une limite de débit, par exemple cent requêtes par minute ou mille par heure. Les ingénieurs qui doivent envoyer plus de trafic qu'une seule fenêtre n'autorise doivent découper le travail en lots et attendre entre eux pour que le fournisseur ne renvoie pas HTTP 429 ni ne révoque les identifiants. Ce calculateur de budget de limite de débit d'API accepte le maximum de requêtes par fenêtre, le nombre total de requêtes que vous prévoyez d'envoyer et, en option, la durée de la fenêtre en secondes. Les limites de débit non positives échouent avec invalid_input et ne sont pas facturées.
Comment fenêtres, lots et délai vous maintiennent sous la limite
Le calculateur n'appelle pas l'API distante ; il dimensionne seulement votre planning pour que votre propre client puisse dormir entre les lots.
Contrat d'entrée, champs de réponse et règles de validation
Envoyez en POST un corps JSON avec rate_limit, un entier positif de requêtes autorisées par fenêtre ; desired_requests, un entier non négatif d'appels que vous comptez faire ; et optionnellement window_seconds, une longueur finie positive de cette fenêtre en secondes qui vaut soixante par défaut si elle est omise. Chaque champ peut arriver comme nombre JSON ou comme chaîne numérique. Les champs manquants, les valeurs non finies, desired_requests fractionnaire, rate_limit fractionnaire et tout rate_limit qui n'est pas strictement positif échouent avec invalid_input et un message qui nomme le champ. En cas de succès le corps renvoie rate_limit, desired_requests et window_seconds, puis windows_needed, batch_size (maximum de requêtes par lot complet, égal à rate_limit tant qu'il reste du travail), last_batch_size (le lot partiel final, ou un lot complet lorsque D divise exactement), full_batches (combien de lots utilisent la taille maximale avant le reste), delay_between_batches_seconds, min_elapsed_seconds, max_requests_per_second comme rate_limit divisé par window_seconds, et une courte chaîne de formule qui reformule la règle du plafond. Exemple : rate_limit cent, desired_requests trois cent cinquante, window_seconds soixante donne quatre fenêtres, lot de cent, dernier lot cinquante, délai soixante secondes et minimum écoulé cent quatre-vingts secondes. Zéro desired_requests renvoie zéro fenêtre et zéro délai sans erreur, ce qui est utile pour les planificateurs en dry-run.
Où un calculateur de budget de limite d'API se justifie
Fournir ce total plus la limite de débit du fournisseur à ce calculateur produit un planning de sommeil que vous pouvez insérer dans une boucle de worker sans tempêtes de 429 par essais successifs. Les chefs de produit qui estiment la durée d'un export massif peuvent convertir un nombre de documents en temps d'horloge avant de promettre au client une fenêtre le jour même. Une validation échouée ne consomme pas de solde. Les scripts d'intégration qui remplissent des webhooks, réindexent des documents de recherche ou migrent des tenants connaissent souvent le total d'éléments avant de démarrer. Les outils d'observabilité et de chaos peuvent affirmer qu'un générateur de charge synthétique ne dépasse jamais max_requests_per_second dérivé de la limite publiée. Gardez la logique de planning dans votre client ; utilisez ce endpoint comme source unique de vérité pour l'arithmétique afin que mobiles, edge workers et jobs CI planifient de la même façon.
Cas d'intégration
Migrations massives et tâches de rattrapage
Découpez un volume connu de requêtes en lots sûrs par rapport à la limite de débit et dormez delay_between_batches_seconds entre chaque démarrage de lot.
Estimations SLA et runbooks
Convertissez les limites de débit du fournisseur en min_elapsed_seconds pour que les plans d'astreinte et les ETA clients correspondent au vrai frein.
Plafonds de test de charge et trafic synthétique
Déduisez max_requests_per_second à partir de rate_limit et window_seconds avant de configurer des générateurs qui ne doivent pas déclencher les garde-fous de production.
Questions techniques
Comment calculer le nombre de fenêtres pour une limite de débit d'API ?
Envoyez rate_limit (requêtes entières positives par fenêtre), desired_requests (total d'appels) et optionnellement window_seconds (défaut 60). windows_needed vaut ceil(desired_requests / rate_limit).
Le calculateur appelle-t-il mon API ou dort-il à ma place ?
Non. Il renvoie seulement les chiffres du planning. Votre client envoie les lots et applique le délai.
Combien coûte le calculateur de limite de débit d'API ?
L'outil navigateur est gratuit. Les requêtes API utilisent le solde prépayé KIT à $0.002 par appel réussi ; une entrée invalide n'est pas facturée.