Token-Bucket-Rechner
Ein Eimer mit 10 Token, der 5 enthält und 2 pro Sekunde nachfüllt, hat nach 1,5 Sekunden 8 verfügbar, also geht ein Burst von 3 durch und lässt 5 übrig. Geben Sie Ihre Werte ein und sehen Sie Erlaubnis oder Ablehnung samt Wartezeit. Kostenlos in Ihrem Browser.
- Kostenlos
- Läuft in Ihrem Browser
- Ohne Anmeldung
- Ihre Daten bleiben auf Ihrem Gerät
Im Browser ausführen – kostenlos
Rechenbeispiel
- Kapazität
- 10
- Auffüllrate
- 2
- Tokens
- 5
- Verstrichene Zeit
- 1,5
- Anzahl der Anfragen
- 3
- Verfügbare Tokens
- 8
- Verbleibende Tokens
- 5
- Verbrauchte Tokens
- 3
- Defizit
- 0
Sie halten einen Eimer mit Tokens bis zu einer festen Kapazität, füllen ihn mit gleichmäßiger Rate nach und verbrauchen Tokens, wenn eine Anfrage oder ein Burst eintrifft. Dieser Token-Bucket-Ratenlimit-Rechner nimmt Kapazität, Auffüllrate in Tokens pro Sekunde, den aktuellen Token-Stand, die seit der letzten Aktualisierung verstrichenen Sekunden und den Token-Bedarf des nächsten Bursts entgegen. Er füllt den Eimer mit harter Kappung an der Kapazität auf, entscheidet über Erlauben oder Ablehnen, meldet die verbleibenden Tokens nach der Entscheidung und berechnet bei Ablehnung, wie lange Sie auf genug Tokens warten müssen—oder zeigt an, dass die Anfrage nie erfüllbar ist, weil sie die Kapazität übersteigt oder die Auffüllrate null ist.
Wie der Eimer entscheidet
Ein Token-Bucket hält einen Bestand an Token, der nie über eine feste Kapazität steigt. Die Zeit fügt mit einer gleichmäßigen Nachfüllrate Token hinzu, und jeder Burst verbraucht so viele Token, wie er kostet. Zur Entscheidung füllt der Rechner zuerst auf: Er addiert zum aktuellen Bestand die vergangenen Sekunden mal die Rate und begrenzt das Ergebnis auf die Kapazität. Das ist, was gerade ausgegeben werden kann. Deckt es die Kosten, wird der Burst erlaubt und die Kosten werden abgezogen. Im Beispiel ergeben 5 Token plus 1,5 Sekunden bei 2 pro Sekunde zusammen 8, also geht ein Burst von 3 durch und 5 bleiben. Die vergangene Zeit geben Sie selbst an, deshalb liefern gleiche Werte immer dieselbe Antwort.
Wofür er nützt und typische Fehler
Damit prüfen Sie das Kontingent eines Gateways oder einen Begrenzer in Ihrem eigenen Code gegen eine Referenz, erklären ein Design in einem Review oder bereiten Lastsimulationen vor. Besonders hilfreich ist er bei Grenzfällen, an denen handgeschriebene Begrenzer scheitern: ein bereits voller Eimer, ein teilweises Nachfüllen und ein Burst über der Obergrenze. Ein häufiger Fehler ist, die Begrenzung zu vergessen; dann wächst der Bestand nach einer langen Pause unbegrenzt und erlaubt viel größere Bursts als gewollt. Ein anderer ist, einen Burst über der Kapazität als reine Geduldsfrage zu behandeln: Kein Warten lässt ihn passen, und der Rechner sagt das.
Häufige Fragen
Wie viele Token sind nach einer Pause verfügbar?
Addieren Sie zu den aktuellen Token die vergangenen Sekunden mal die Nachfüllrate und begrenzen Sie das Ergebnis auf die Kapazität. Mit 5 Token, einer Rate von 2 pro Sekunde und 1,5 vergangenen Sekunden haben Sie 8, sofern die Kapazität so weit reicht.
Wie lange muss ich warten, wenn ein Burst abgelehnt wird?
Der Rechner teilt das Defizit, also die fehlenden Token, durch die Nachfüllrate. Das Ergebnis sind die Sekunden, bis genug Token für den Burst im Eimer liegen.
Wann kann ein Burst nie erlaubt werden?
Wenn er mehr Token kostet, als der Eimer je fassen kann, oder wenn die Nachfüllrate null ist und der Eimer nicht schon genug enthält. In beiden Fällen sagt der Rechner das klar, statt eine Wartezeit anzugeben.
Was bedeuten Kapazität und Nachfüllrate in der Praxis?
Die Kapazität ist der größte Burst, den der Eimer auf einmal zulässt, also seine Obergrenze. Die Nachfüllrate in Token pro Sekunde ist das gleichmäßige Tempo, das Sie dauerhaft halten können, sobald dieser Burst verbraucht ist.
Verwandte Tools
Für Entwickler — API-Zugang
Alles auf dieser Seite ist auch per API verfügbar. Dieser Abschnitt richtet sich an Teams, die es in ihre eigenen Systeme einbinden möchten; alle anderen nutzen einfach das Tool oben.
Endpunkt
Authentifizierung per Bearer-Token. Ein einziger POST stellt die Aufgabe in die Warteschlange; das Ergebnis erhalten Sie per Webhook oder über einen signierten Link.
Aufruf aus Ihrem 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)Beispiel-Anfrage
{
"capacity": 10,
"refill_rate": 2,
"tokens": 5,
"elapsed": 1.5,
"request_count": 3
}Beispiel-Antwort
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.token_bucket",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}Die API arbeitet asynchron: Sie erhalten sofort eine task_id. Polling ist mit 1 Anfrage pro Sekunde erlaubt.
Preis
Der Preis steht auf der Seite – keine Tokens, keine Credits. Fehlgeschlagene Aufgaben werden nicht berechnet.
Fehler
| HTTP | Code | Bedeutung |
|---|---|---|
401 | unauthorized | Der API-Schlüssel fehlt oder ist ungültig – prüfen Sie den Authorization-Header (Bearer). |
402 | insufficient_balance | Ihr Guthaben reicht für diese Aufgabe nicht aus – Aufladungen verfallen nicht. |
404 | unknown_type | Unbekannter Aufgabentyp – prüfen Sie das Feld „type“ gegen den Katalog. |
429 | rate_limited | Zu viele Anfragen – warten Sie kurz; Polling ist mit 1 Anfrage pro Sekunde erlaubt. |
Technische Hinweise
Ein Token-Bucket-Ratenbegrenzer ist das Standardmodell hinter API-Throttling, Gateway-Kontingenten und clientseitigem Backpressure. Dasselbe reine, deterministische Modul speist das kostenlose Browser-Werkzeug und den API-Pfad, sodass Entwurfsreviews, Lasttestskripte und Produktionssimulatoren bei Grenzfällen wie vollem Eimer, teilweiser Auffüllung oder Anfragen über der Burst-Obergrenze nie auseinanderlaufen.
Wie der Token-Bucket-Algorithmus Erlauben oder Ablehnen entscheidet
Der Token Bucket speichert einen nichtnegativen Token-Saldo, der die Kapazität nie überschreitet. Die verstrichene Zeit liefert der Aufrufer, damit die Mathematik deterministisch bleibt—es wird keine Wanduhr gelesen—, sodass dieselben Eingaben über Runtimes und Goldens hinweg stets dieselbe Entscheidung, denselben Restsaldo und dieselben Warte-Sekunden ergeben. Zwischen Prüfungen sammeln sich Tokens mit refill_rate Tokens pro Sekunde über die Dauer elapsed, danach wird der Saldo mit min(capacity, tokens + elapsed mal refill_rate) begrenzt. Dieser begrenzte Wert ist tokens_available—was Sie jetzt ausgeben können. Ein Burst, der request_count Tokens kostet, wird erlaubt, wenn tokens_available mindestens request_count beträgt; bei Erlauben wird tokens_remaining zu tokens_available minus request_count und tokens_consumed entspricht request_count. Bei Ablehnen werden keine Tokens verbraucht: tokens_remaining bleibt bei tokens_available, tokens_consumed ist null und deficit ist request_count minus tokens_available. Die Wartezeit ist deficit geteilt durch refill_rate, wenn die Auffüllung positiv ist und die Anfrage die Kapazität nicht übersteigt; sonst ist die Anfrage auch später nicht erfüllbar (can_satisfy ist false)—das deckt sowohl Kosten über der Burst-Obergrenze als auch einen eingefrorenen Eimer mit Auffüllrate null ab. Die Kapazität ist der Burst-Spielraum: ein voller Eimer mit zehn und langsamer Auffüllung lässt trotzdem einen einzelnen Zehn-Token-Spike durch, weshalb Gateways capacity für Spitzen und refill_rate für den anhaltenden Durchschnitt wählen.
Eingabevertrag, Antwortfelder und Validierungsfehler
Senden Sie einen JSON-Body mit fünf erforderlichen endlichen Zahlen. capacity muss größer als null sein und ist die maximale Token-Menge, die der Eimer nach dem Auffüllen halten kann. refill_rate muss größer oder gleich null sein und wird in Tokens pro Sekunde gemessen; null bedeutet, dass der Eimer sich nach dem Leeren nie erholt. tokens ist der Saldo vor Anwendung dieses elapsed-Intervalls und muss nichtnegativ sein; Werte über capacity werden akzeptiert und beim Berechnen von tokens_available nach dem Auffüllen gekappt. elapsed sind Sekunden seit der letzten Aktualisierung und muss nichtnegativ sein. request_count ist der Token-Bedarf dieses Bursts und muss größer als null sein. Fehlende Felder, nichtnumerische Zeichenketten, NaN, Infinity und unzulässige Vorzeichen scheitern mit invalid_input unter Angabe des Feldes und werden nicht berechnet. Bei Erfolg spiegelt der Body die fünf Eingaben wider und liefert tokens_available nach dem Auffüllen, allowed als Booleschen Wert, tokens_remaining nach der Ausgabenentscheidung, tokens_consumed, deficit, wait_seconds (null wenn erlaubt oder wenn die Anfrage nie durchkommt), can_satisfy und eine kurze formula-Zeichenkette mit der Aktualisierungsregel. Beispiel: capacity zehn, refill_rate zwei pro Sekunde, tokens fünf, elapsed eineinhalb, request_count drei ergibt tokens_available acht (fünf plus drei aus Auffüllung, noch unter Kapazität), allowed true, tokens_remaining fünf und wait_seconds null. Ein zweiter Aufruf mit neun Tokens bei denselben acht verfügbaren wird mit deficit eins und wait_seconds von einer halben Sekunde bei zwei Tokens pro Sekunde abgelehnt.
Wo ein Token-Bucket-Rechner echten Nutzen stiftet
Edge- und Gateway-Autoren nutzen den Rechner als Orakel beim Implementieren von Redis- oder In-Memory-Buckets und vergleichen ihre lokale Zustandsmaschine mit diesem geschlossenen Ergebnis für identische Eingaben. Lehrende und SRE-Interviews zeigen damit, dass Token Bucket nicht dasselbe ist wie ein reiner Leaky Bucket: Bursts sind bis zur Kapazität erlaubt, danach stellt die gleichmäßige Auffüllung Spielraum wieder her. Fehlgeschlagene Validierung wird nicht berechnet. API-Produktteams dimensionieren capacity und Auffüllung, bevor sie ein Kontingent freigeben: Sie setzen Kandidatenzahlen und Beispiel-Burstgrößen ein, um zu sehen, ob legitime Spitzen durchkommen, während missbräuchliche Fluten warten. Lasttest-Harnesses und Chaos-Skripte rufen denselben reinen Endpunkt auf, um zu prüfen, dass ein synthetischer Client, der wait_seconds folgt, nie über das dokumentierte Limit hinaus ausgibt. Weil die Implementierung reines Parse-Tier-A ist, kostet jeder erfolgreiche Aufruf den veröffentlichten Basispreis $0.002 ohne Modell-Tokens und ohne ausgehendes Netzwerk. Halten Sie Anfragen klein, pinnen Sie gerundete Zahlenfelder in Tests und erhalten Sie reproduzierbare Erlaubnis- und Warteantworten für Design-Dokumente, SDK-Beispiele und Produktions-Trockenläufe, ohne einen vollständigen Ratenlimit-Dienst aufzusetzen.
Integrationsbeispiele
API-Kontingent und Burst-Dimensionierung
Abstimmen von capacity und refill_rate auf realistische request_count-Bursts, damit Produktlimits legitime Spitzen zulassen und den Dauerverkehr weiterhin begrenzen.
Lasttest- und Client-Back-off-Orakel
Synthetische Clients mit dem gelieferten wait_seconds steuern und prüfen, dass sie den dokumentierten Token-Bucket-Vertrag in parallelen Szenarien nie überschreiten.
Quervergleich der Gateway-Implementierung
Redis- oder In-Process-Bucket-Zustandsmaschinen mit diesem deterministischen Rechner für dieselben capacity-, Auffüll-, tokens-, elapsed- und Kosten-Eingaben vergleichen.
Technische Fragen
Wie funktioniert der Token-Bucket-Ratenlimit-Rechner?
Er berechnet tokens_available = min(capacity, tokens + elapsed × refill_rate), erlaubt den Burst, wenn dieser Wert mindestens request_count beträgt, subtrahiert bei Erlauben und liefert sonst deficit sowie wait_seconds = deficit / refill_rate, wenn die Auffüllung den Bedarf später decken kann.
Welche Einheiten soll ich für refill_rate und elapsed verwenden?
Verwenden Sie für beide dieselbe Zeiteinheit: refill_rate ist Tokens pro Sekunde und elapsed sind Sekunden. Beide auf Millisekunden zu skalieren funktioniert nur bei konsistenter Nutzung; die API rechnet Einheiten nicht für Sie um.
Was passiert, wenn request_count größer als capacity ist?
Der Burst wird mit can_satisfy false und wait_seconds null abgelehnt. Eine einzelne Anfrage, die mehr Tokens braucht, als der Eimer jemals halten kann, kommt nie durch, auch nicht bei voller Auffüllung.
Darf tokens bei der Eingabe größer als capacity sein?
Ja. Der Rechner akzeptiert einen nichtnegativen tokens-Wert über capacity und kapppt erst nach der Auffüllung über elapsed—wie gängige Implementierungen, die bis zur nächsten Aktualisierung einen ungekappeten Zähler speichern.
Was kostet der Token-Bucket-Rechner?
Das Browser-Werkzeug ist kostenlos. API-Anfragen nutzen das vorausbezahlte KIT-Guthaben zu $0.002 pro erfolgreichem Aufruf; ungültige Eingaben werden nicht berechnet.