Calcolatore limite di rate API
Con un limite di 100 chiamate al minuto, inviarne 350 richiede 4 finestre: tre lotti da 100 e uno da 50, a 60 secondi di distanza, per almeno 180 secondi in tutto. Pianifichi importazioni, sincronizzazioni o caricamenti massivi senza superare il limite del fornitore. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Limite di frequenza
- 100
- Richieste desiderate
- 350
- Secondi della finestra
- 60
- Finestre necessarie
- 4
- Dimensione del lotto
- 100
- Dimensione dell'ultimo lotto
- 50
- Lotti completi
- 3
Restituisce quante finestre Le servono, la dimensione massima di batch che non supera mai il limite, la dimensione del batch parziale finale, il ritardo da inserire tra gli avvii dei batch, il tempo minimo di orologio se avvia il primo batch immediatamente e l'equivalente massimo di richieste al secondo.
Come finestre, batch e ritardo La tengono sotto il limite
Un limite di rate di R richieste per finestra di lunghezza W secondi significa che, in qualsiasi finestra scorrevole o fissa di W secondi, il fornitore accetterà al massimo R chiamate andate a buon fine. Quando Le servono D richieste totali e D è maggiore di R, non può inviare tutto in una volta. Il piano sicuro è inviare al massimo R richieste nella prima finestra, attendere che sia trascorsa una finestra intera, inviare le successive R e ripetere fino a esaurire il resto.
Il numero di finestre richieste è il ceiling di D diviso per R. Se D è trecentocinquanta e R è cento, Le servono quattro finestre: tre batch pieni di cento e un batch finale di cinquanta. Il ritardo tra gli avvii dei batch è uguale a W quando serve più di una finestra, e zero quando ne basta una sola.
Il tempo minimo trascorso è allora (finestre meno uno) volte W, perché il primo batch può partire all'istante zero e l'ultimo parte dopo le attese precedenti. Questo modello coincide con le euristiche comuni di finestra fissa e token-bucket usate nelle librerie client: è intenzionalmente conservativo per le finestre fisse e un solido primo budget per i token bucket quando non ricarica a metà burst.
Domande frequenti
Quale ritardo devo attendere tra i batch?
Quando basta una sola finestra, il ritardo è zero.
Cosa succede se il limite di rate è zero o negativo?
Un limite di rate non positivo non è un budget valido e la chiamata non viene addebitata.
Quante finestre servono per 350 chiamate con un limite di 100?
Quattro. Si divide 350 per 100 e si arrotonda per eccesso: tre lotti completi da 100 e un ultimo lotto da 50. L'ultimo è più piccolo, quindi non supera mai il limite.
Qual è il tempo minimo per completare tutto il lavoro?
Il numero di finestre meno una, moltiplicato per la durata della finestra. Con 4 finestre da 60 secondi sono 180 secondi, perché il primo lotto parte subito e solo le attese aggiungono tempo.
Il calcolatore invia le chiamate al posto mio?
No. Non contatta mai il servizio. Dimensiona solo il calendario, così è il suo programma a inviare ogni lotto e ad attendere la pausa indicata prima del successivo.
Strumenti correlati
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo 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)Esempio di richiesta
{
"rate_limit": 100,
"desired_requests": 350
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.api_rate_limit_calc",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |
Note tecniche
Le API pubbliche e private pubblicano quasi sempre un limite di rate, ad esempio cento richieste al minuto o mille all'ora. Chi deve inviare più traffico di quanto una singola finestra consenta deve suddividere il lavoro in batch e attendere tra di essi affinché il fornitore non risponda HTTP 429 né revochi le credenziali. Questo calcolatore di budget del limite di rate API accetta il massimo di richieste per finestra, il totale di richieste che Lei intende inviare e, in opzione, la durata della finestra in secondi. I limiti di rate non positivi falliscono con invalid_input e non vengono addebitati.
Come finestre, batch e ritardo La tengono sotto il limite
Il calcolatore non chiama l'API remota; dimensiona soltanto il Suo calendario affinché il Suo client possa dormire tra i batch.
Contratto di ingresso, campi di risposta e regole di validazione
Invii in POST un corpo JSON con rate_limit, un intero positivo di richieste consentite per finestra; desired_requests, un intero non negativo di chiamate che intende effettuare; e opzionalmente window_seconds, una lunghezza finita positiva di quella finestra in secondi che vale sessanta per impostazione predefinita se omessa. Ogni campo può arrivare come numero JSON o come stringa numerica. Campi mancanti, valori non finiti, desired_requests frazionario, rate_limit frazionario e qualsiasi rate_limit non strettamente positivo falliscono con invalid_input e un messaggio che nomina il campo. In caso di successo il corpo ripete rate_limit, desired_requests e window_seconds, poi restituisce windows_needed, batch_size (massimo di richieste per batch pieno, uguale a rate_limit quando resta lavoro), last_batch_size (il batch parziale finale, oppure un batch pieno quando D divide esattamente), full_batches (quanti batch usano la dimensione massima prima del resto), delay_between_batches_seconds, min_elapsed_seconds, max_requests_per_second come rate_limit diviso per window_seconds, e una breve stringa di formula che riafferma la regola del ceiling. Esempio: rate_limit cento, desired_requests trecentocinquanta, window_seconds sessanta produce quattro finestre, batch di cento, ultimo batch cinquanta, ritardo sessanta secondi e minimo trascorso centottanta secondi. Zero desired_requests restituisce zero finestre e zero ritardo senza errore, utile per pianificatori in dry-run.
Dove un calcolatore di budget del limite API rende
Alimentare quel conteggio più il limite di rate del fornitore in questo calcolatore produce un calendario di attesa che può inserire in un loop di worker senza tempeste di 429 per tentativi ed errori. I product manager che stimano quanto durerà un export massivo possono convertire un conteggio di documenti in tempo di orologio prima di promettere al cliente una finestra lo stesso giorno. La validazione fallita non consuma saldo. Gli script di integrazione che riempiono webhook, reindicizzano documenti di ricerca o migrano tenant spesso conoscono il conteggio totale degli elementi prima di iniziare. Gli strumenti di osservabilità e di chaos possono affermare che un generatore di carico sintetico non supera mai max_requests_per_second derivato dal limite pubblicato. Tenga la logica di calendario nel Suo client; usi questo endpoint come unica fonte di verità dell'aritmetica così che mobile, edge worker e job CI pianifichino allo stesso modo.
Casi di integrazione
Migrazioni massive e job di backfill
Suddivida un conteggio noto di richieste in batch sicuri rispetto al limite di rate e dorma delay_between_batches_seconds tra ogni avvio di batch.
Stime di SLA e runbook
Converta i limiti di rate del fornitore in min_elapsed_seconds affinché i piani di reperibilità e gli ETA al cliente coincidano con il throttle reale.
Tetti di load-test e traffico sintetico
Derivare max_requests_per_second da rate_limit e window_seconds prima di configurare generatori che non devono attivare le protezioni di produzione.
Domande tecniche
Come calcolo quante finestre mi servono per un limite di rate API?
Invii rate_limit (richieste intere positive per finestra), desired_requests (chiamate totali) e opzionalmente window_seconds (predefinito 60). windows_needed è ceil(desired_requests / rate_limit).
Il calcolatore chiama la mia API o dorme al posto mio?
No. Restituisce solo i numeri del calendario. Il Suo client invia i batch e applica il ritardo.
Quanto costa il calcolatore di limite di rate API?
Lo strumento nel browser è gratuito. Le richieste API usano il saldo prepagato KIT a $0.002 per chiamata riuscita; l'input non valido non viene addebitato.