Calculateur token bucket
Un seau de 10 jetons qui en contient 5 et se recharge de 2 par seconde en a 8 disponibles après 1,5 seconde : une rafale de 3 passe et en laisse 5. Saisissez vos valeurs pour voir l'autorisation ou le refus et l'attente. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Capacité
- 10
- Taux de recharge
- 2
- Jetons
- 5
- Temps écoulé
- 1,5
- Nombre d'appels
- 3
- Jetons disponibles
- 8
- Jetons restants
- 5
- Jetons consommés
- 3
- Déficit
- 0
Vous conservez un seau de jetons jusqu'à une capacité fixe, vous le rechargez à un rythme constant et vous dépensez des jetons lorsqu'une requête ou une rafale arrive. Ce calculateur de limite de débit token bucket accepte la capacité, le taux de recharge en jetons par seconde, le solde actuel de jetons, le nombre de secondes écoulées depuis la dernière mise à jour et le nombre de jetons dont la prochaine rafale a besoin. Il recharge le seau avec un plafond strict à la capacité, décide d'autoriser ou de refuser, indique les jetons restants après la décision et, lorsque la rafale est refusée, calcule combien de temps vous devez attendre pour accumuler assez de jetons—ou vous signale que la requête ne pourra jamais être satisfaite car elle dépasse la capacité ou la recharge est nulle.
Comment le seau décide
Un token bucket conserve un solde de jetons qui ne dépasse jamais une capacité fixe. Le temps ajoute des jetons à un débit de recharge régulier, et chaque rafale dépense autant de jetons qu'elle coûte. Pour décider, le calculateur recharge d'abord : il ajoute au solde actuel les secondes écoulées multipliées par le débit et plafonne le résultat à la capacité. C'est ce que l'on peut dépenser à cet instant. S'il couvre le coût, la rafale est autorisée et le coût est déduit. Dans l'exemple, 5 jetons plus 1,5 seconde à 2 par seconde font 8 : une rafale de 3 passe et il en reste 5. C'est vous qui fournissez le temps écoulé, donc les mêmes valeurs donnent toujours la même réponse.
À quoi il sert et les erreurs courantes
Il sert à comparer le quota d'une passerelle ou un limiteur de votre propre code à une référence, à expliquer une conception lors d'une revue ou à préparer des simulations de charge. Il est surtout utile dans les cas limites où les limiteurs écrits à la main se trompent : un seau déjà plein, une recharge partielle et une rafale plus grande que le plafond. Une erreur courante consiste à oublier le plafond, ce qui laisse le solde grimper sans fin après une longue pause et autorise des rafales bien plus grosses que prévu. Une autre consiste à traiter une rafale plus grande que la capacité comme une simple affaire de patience : aucune attente ne la fera tenir, et le calculateur le dit.
Questions fréquentes
Combien de jetons sont disponibles après une pause ?
Ajoutez aux jetons actuels les secondes écoulées multipliées par le débit de recharge, puis plafonnez le résultat à la capacité. Avec 5 jetons, un débit de 2 par seconde et 1,5 seconde écoulée, vous en avez 8, à condition que la capacité le permette.
Combien de temps attendre quand une rafale est refusée ?
Le calculateur divise le déficit, c'est-à-dire les jetons manquants, par le débit de recharge. Le résultat donne les secondes d'attente avant que la rafale tienne dans le seau.
Quand une rafale ne peut-elle jamais passer ?
Quand elle coûte plus de jetons que le seau ne peut en contenir, ou quand le débit de recharge est nul et que le seau n'en a pas déjà assez. Dans les deux cas, le calculateur l'indique clairement au lieu de donner un temps d'attente.
Que signifient concrètement la capacité et le débit de recharge ?
La capacité est la plus grosse rafale que le seau accepte d'un coup, son plafond. Le débit de recharge, en jetons par seconde, est le rythme régulier que vous pouvez tenir dans la durée une fois cette rafale dépensée.
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/token-bucket \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"capacity":10,"refill_rate":2,"tokens":5,"elapsed":1.5,"request_count":3}'const res = await fetch("https://api.kit.forhosting.com/dev/token-bucket", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"capacity": 10,
"refill_rate": 2,
"tokens": 5,
"elapsed": 1.5,
"request_count": 3
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/token-bucket",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"capacity": 10,
"refill_rate": 2,
"tokens": 5,
"elapsed": 1.5,
"request_count": 3
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/token-bucket", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"capacity":10,"refill_rate":2,"tokens":5,"elapsed":1.5,"request_count":3}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"capacity":10,"refill_rate":2,"tokens":5,"elapsed":1.5,"request_count":3}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/token-bucket", 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
{
"capacity": 10,
"refill_rate": 2,
"tokens": 5,
"elapsed": 1.5,
"request_count": 3
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.token_bucket",
"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
Le limiteur de débit token bucket est le modèle de référence derrière le throttling d'API, les quotas de passerelle et la contre-pression côté client. Le même module pur et déterministe alimente l'outil gratuit du navigateur et le chemin API, afin que revues de conception, scripts de test de charge et simulateurs de production ne divergent jamais sur les cas limites : seau plein, recharge partielle ou requête plus grande que le plafond de rafale.
Comment l'algorithme token bucket décide d'autoriser ou de refuser
Le token bucket stocke un solde de jetons non négatif qui ne dépasse jamais la capacité. Le temps écoulé est fourni par l'appelant pour que le calcul reste déterministe—aucune horloge murale n'est lue—, ainsi les mêmes entrées produisent toujours la même décision, le même solde restant et les mêmes secondes d'attente sur les runtimes et les goldens. Entre deux contrôles, les jetons s'accumulent à refill_rate jetons par seconde pendant la durée elapsed, puis le solde est plafonné avec min(capacity, tokens + elapsed multiplié par refill_rate). Cette valeur plafonnée est tokens_available : ce que vous pouvez dépenser immédiatement. Une rafale qui coûte request_count jetons est autorisée lorsque tokens_available vaut au moins request_count ; en cas d'autorisation, tokens_remaining devient tokens_available moins request_count et tokens_consumed égale request_count. En cas de refus, aucun jeton n'est dépensé : tokens_remaining reste à tokens_available, tokens_consumed vaut zéro et deficit égale request_count moins tokens_available. Le temps d'attente est deficit divisé par refill_rate lorsque la recharge est positive et que la requête ne dépasse pas la capacité ; sinon la requête ne pourra pas non plus être satisfaite plus tard (can_satisfy est false), ce qui couvre à la fois un coût au-dessus du plafond de rafale et un seau figé avec recharge nulle. La capacité est la marge de rafale : un seau plein de dix avec une recharge lente laisse encore passer un pic de dix jetons, c'est pourquoi les passerelles choisissent capacity pour les pics et refill_rate pour le trafic moyen soutenu.
Contrat d'entrée, champs de réponse et erreurs de validation
Envoyez un corps JSON avec cinq nombres finis obligatoires. capacity doit être strictement positif et représente le maximum de jetons que le seau peut contenir après recharge. refill_rate doit être supérieur ou égal à zéro et se mesure en jetons par seconde ; zéro signifie que le seau ne se remplit plus une fois vide. tokens est le solde avant d'appliquer cet intervalle elapsed et doit être non négatif ; les valeurs au-dessus de capacity sont acceptées puis plafonnées lors du calcul de tokens_available après recharge. elapsed est le nombre de secondes depuis la dernière mise à jour et doit être non négatif. request_count est le nombre de jetons dont cette rafale a besoin et doit être strictement positif. Champs manquants, chaînes non numériques, NaN, Infinity et signes hors plage échouent avec invalid_input en nommant le champ et ne sont pas facturés. En cas de succès le corps renvoie les cinq entrées, puis tokens_available après recharge, allowed en booléen, tokens_remaining après la décision de dépense, tokens_consumed, deficit, wait_seconds (zéro si autorisé ou si la requête ne peut jamais passer), can_satisfy et une courte chaîne formula qui reformule la règle de mise à jour. Exemple : capacity dix, refill_rate deux par seconde, tokens cinq, elapsed une seconde et demie, request_count trois produit tokens_available huit (cinq plus trois de recharge, encore sous la capacité), allowed true, tokens_remaining cinq et wait_seconds zéro. Un second appel qui demande neuf jetons avec les mêmes huit disponibles est refusé avec deficit un et wait_seconds d'une demi-seconde à deux jetons par seconde.
Où un calculateur token bucket apporte une vraie valeur
Les auteurs d'edge et de passerelle utilisent le calculateur comme oracle en implémentant des seaux Redis ou en mémoire, en comparant leur machine d'états locale à ce résultat en forme fermée pour des entrées identiques. Les formateurs et les entretiens SRE s'en servent pour montrer qu'un token bucket n'est pas un leaky bucket pur : les rafales sont autorisées jusqu'à capacity, puis la recharge régulière restaure de la marge. Une validation échouée ne consomme pas de solde. Les équipes produit d'API dimensionnent capacity et recharge avant de publier un quota : elles testent des valeurs candidates et des tailles de rafale pour voir si les pics légitimes passent tandis que les inondations abusives attendent. Les bancs de test de charge et les scripts de chaos appellent le même endpoint pur pour affirmer qu'un client synthétique qui respecte wait_seconds ne dépense jamais au-delà de la limite documentée. Comme l'implémentation est pure parse de niveau A, chaque appel réussi coûte le prix de base publié $0.002 sans jetons de modèle ni réseau sortant. Gardez les requêtes compactes, figez dans les tests les champs numériques arrondis, et vous obtenez des réponses reproductibles d'autorisation et d'attente pour documents de conception, exemples de SDK et essais en production sans déployer un service complet de limitation de débit.
Cas d'intégration
Dimensionnement de quota API et de rafale
Ajustez capacity et refill_rate face à des rafales réalistes de request_count pour que les limites produit laissent passer les pics légitimes tout en bornant le trafic soutenu.
Oracles de test de charge et de back-off client
Pilotez des clients synthétiques avec le wait_seconds renvoyé et vérifiez qu'ils ne dépassent jamais le contrat token-bucket documenté en scénarios concurrents.
Contrôles croisés d'implémentation de passerelle
Comparez des machines d'états de seau Redis ou en processus à ce calculateur déterministe pour les mêmes entrées capacity, recharge, tokens, elapsed et coût.
Questions techniques
Comment fonctionne le calculateur de limite de débit token bucket ?
Il calcule tokens_available = min(capacity, tokens + elapsed × refill_rate), autorise la rafale lorsque cette valeur est au moins request_count, soustrait en cas d'autorisation, et sinon renvoie deficit et wait_seconds = deficit / refill_rate lorsque la recharge peut finir par couvrir le coût.
Quelles unités utiliser pour refill_rate et elapsed ?
Utilisez la même unité de temps pour les deux : refill_rate est en jetons par seconde et elapsed en secondes. Convertir les deux en millisecondes ne fonctionne que si vous restez cohérent ; l'API ne convertit pas les unités pour vous.
Que se passe-t-il si request_count est plus grand que capacity ?
La rafale est refusée avec can_satisfy false et wait_seconds à zéro. Une seule requête qui demande plus de jetons que le seau ne pourra jamais contenir ne passera jamais, même avec une recharge complète.
tokens peut-il être supérieur à capacity en entrée ?
Oui. Le calculateur accepte une valeur tokens non négative au-dessus de capacity et ne plafonne qu'après avoir appliqué la recharge sur elapsed, comme les implémentations courantes qui stockent un compteur non borné jusqu'à la prochaine mise à jour.
Quel est le coût du calculateur token bucket ?
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.