IT ▾

Cos'è il limite di richieste API? Limiti, retry, contesto

Un limite di richieste fissa la quantità massima di traffico che una chiave può inviare a un'API in un dato lasso di tempo. Questa pagina spiega cos'è un limite di richieste API nella pratica, come gestirlo nel codice e quali sono i limiti di questa API.

Aggiornato

Cancello con otto corsie che lasciano passare pacchetti di luce, illustra i limiti di richieste e la concorrenza dell'API

Punti chiave

  • Un limite di richieste limita le richieste al minuto o quelle in corso, così un singolo client non può sovraccaricare il servizio.
  • I limiti di richieste non sono equivalenti alla finestra di contesto: uno limita il traffico, l'altro limita la dimensione di una singola richiesta.
  • Chiave completa: 8 richieste concorrenti e 300 al minuto. Chiave di prova: 2 concorrenti e 60 al minuto.
  • Gestisci i limiti con un limite di concorrenza, retry con backoff e un'occhiata alle intestazioni di risposta.

Cos'è un limite di richieste

Quindi, cos'è un limite di richieste API? È una regola che stabilisce quante chiamate può effettuare un account o una chiave in una finestra temporale, o quante possono essere eseguite contemporaneamente. Se lo superi, il server rifiuta le chiamate in eccesso invece di servirle. La maggior parte delle API HTTP segnala questo stato con il codice 429 (Too Many Requests), e molte aggiungono un'intestazione che indica quando riprovare. Controlla la documentazione di ogni servizio per il suo comportamento esatto.

I limiti esistono perché un server di modelli ha una quantità fissa di risorse di calcolo. Senza di essi, uno script in un ciclo stretto potrebbe rallentare tutti gli altri. Per te come sviluppatore significano due cose: il tuo codice deve prevedere i rifiuti e recuperarne, e il tuo design dovrebbe distribuire il lavoro invece di lanciarlo tutto insieme.

I tre tipi di limite che incontrerai

I fornitori mescolano e abbinano queste opzioni, quindi leggi quali si applicano alla tua chiave.

TipoCosa contaEffetto tipico
Richieste al minutoChiamate avviate in un minuto mobileI picchi vengono rifiutati anche se ogni chiamata è piccola
ConcorrenzaChiamate in corso nello stesso momentoI worker paralleli oltre il limite vengono rifiutati o accodati
Quota di token o spesaToken o denaro utilizzati al minuto, al giorno o al mesePrompt grandi raggiungono il limite prima di quelli piccoli

La concorrenza è più importante per i modelli linguistici rispetto alle API ordinarie, perché un singolo completamento può richiedere diversi secondi. Dieci worker che aspettano una lunga risposta tengono occupati dieci slot per tutto il tempo.

I limiti di questa API

Questa API limita le richieste al minuto e la concorrenza, per chiave:

Tipo di chiaveRichieste concorrentiRichieste al minuto
Chiave completa (con credito)8300
Chiave di prova260

Vale la pena conoscere altri due numeri. Il corpo della richiesta massimo è 8 MB, e ogni risposta trasporta intestazioni che puoi leggere: X-Request-Id per identificare una chiamata quando chiedi aiuto, X-Balance-USD per il tuo credito residuo, e X-RateLimit-Limit-Requests e X-RateLimit-Limit-Concurrency per i limiti che si applicano alla tua chiave. Puoi vederli con curl:

curl -i https://api.abliteratedapi.com/v1/chat/completions   -H "Authorization: Bearer $ABLITERATED_API_KEY"   -H "Content-Type: application/json"   -d '{"model":"uncensored","max_tokens":5,"messages":[{"role":"user","content":"Hi"}]}'

I limiti sono gli stessi indipendentemente dal client che usi; l'API è compatibile con OpenAI, quindi qualsiasi SDK OpenAI funziona una volta modificato il base URL in https://api.abliteratedapi.com/v1.

Quale limite colpirai effettivamente?

Dividi i due numeri. Una chiave completa può eseguire 8 richieste alla volta e 300 al minuto, che è una media di 5 al secondo. Per raggiungere 300 al minuto con solo 8 in corso, ogni chiamata dovrebbe terminare in 1,6 secondi in media (8 x 60 / 300). Le risposte da un modello linguistico di solito richiedono più tempo di quello quando sono più di poche frasi, quindi su una chiave completa il limite di concorrenza tende a farsi sentire per primo.

Prendi un caso ipotetico in cui la chiamata media dura 10 secondi. Otto slot ti danno allora 8 x 60 / 10 = 48 richieste al minuto, ben sotto 300. La stessa logica su una chiave di prova: 2 slot e 60 al minuto significano che sono necessarie chiamate sotto i 2 secondi prima che il limite al minuto diventi rilevante. Queste durate sono un'illustrazione, non una misurazione. Misura le tue chiamate e inserisci il valore reale.

Il consiglio pratico: dimensiona il tuo pool di worker al limite di concorrenza, non al limite di richieste, e lascia che il limite al minuto agisca come rete di sicurezza.

Come gestire i limiti nel codice

Tre abitudini coprono quasi ogni caso.

  1. Limita la concorrenza tu stesso. Un semaforo dimensionato al tuo limite di concorrenza significa che raramente vieni rifiutato.
  2. Riprova con backoff esponenziale e jitter. Attendi 1 secondo, poi 2, poi 4, aggiungendo una frazione casuale così molti worker non riprovano in sincrono. Ferma dopo alcuni tentativi.
  3. Non riprovare ciecamente. Una richiesta malformata o una chiave errata fallirà ogni volta. Riprova solo su limiti di richieste ed errori temporanei del server.

L'SDK Python ufficiale di OpenAI già riprova su 429 ed errori del server con backoff, e lo controlli con max_retries. Combinato con un semaforo, un lavoro batch appare così:

import asyncio
import os
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://api.abliteratedapi.com/v1",
    api_key=os.environ["ABLITERATED_API_KEY"],
    max_retries=5,
)
sem = asyncio.Semaphore(8)   # use 2 on a trial key

async def ask(prompt):
    async with sem:
        r = await client.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": prompt}],
        )
        return r.choices[0].message.content

async def main():
    prompts = [f"Give one short fact about the number {n}." for n in range(40)]
    answers = await asyncio.gather(*(ask(p) for p in prompts))
    print(len(answers), "answers")

asyncio.run(main())

Quaranta prompt passano, mai più di otto alla volta. Se costruisci il tuo client, inserisci le stesse due idee: un limite sulle chiamate in corso e un ritardo di retry che cresce.

I limiti di richieste non sono la finestra di contesto

Le persone spesso confondono i due, perché entrambi producono errori quando chiedi troppo. Un limite di richieste controlla quante richieste fai. La finestra di contesto controlla quanto può essere grande una singola richiesta.

Su questa API la finestra di contesto è di 100.000 token, contando prompt e completamento insieme. Se il tuo prompt è di 95.000 token, al massimo 5.000 sono lasciati per la risposta. Il parametro max_tokens è opzionale: non inserirlo e il completamento può usare tutto ciò che la finestra ha lasciato. Impostarlo è comunque una buona abitudine quando sai che la risposta dovrebbe essere breve, perché i token di output costano $0,50 per 1M contro $0,15 per 1M per l'input. Un prompt completo di 95.000 token costa 95.000 x 0,15 / 1.000.000 = $0,01425 di input.

Un limite di richieste non restringe la finestra di contesto, e un contesto grande non consuma limiti di richieste extra. Ogni chiamata è una richiesta, indipendentemente dalle sue dimensioni, finché il corpo resta sotto 8 MB.

Streaming e limiti di richieste

Con stream: true la risposta arriva tramite eventi server-sent, token per token, e i dati di utilizzo arrivano alla fine. Una chiamata in streaming occupa ancora uno slot di concorrenza fino al termine dello stream, quindi un lettore lento che mantiene le connessioni aperte tiene occupati gli slot più a lungo del previsto. Chiudi gli stream che non ti servono più.

Errori comuni

  • Nessun limite di worker. Un pool di thread con 50 worker contro un limite di 8 significa che la maggior parte delle chiamate viene rifiutata. Abbina il pool al limite di concorrenza.
  • Retry immediati. Riprovare subito dopo un rifiuto aggiunge carico nel momento peggiore. Aspetta, e aspetta sempre più a lungo ogni volta.
  • Trattare ogni errore come un limite di richieste. Un timeout, una chiave non valida e un corpo della richiesta troppo grande richiedono ciascuno una correzione diversa. Registra il codice di stato e l'intestazione X-Request-Id.
  • Condividere una sola chiave per tutto. Un job batch notturno e una funzione di chat live sulla stessa chiave competono per gli stessi 8 slot. Usa chiavi separate, oppure pianifica il batch per le ore di minore attività.
  • Ignorare gli stream lenti. Un client che smette di leggere ma mantiene la connessione aperta occupa ancora uno slot.

Aggiungi un contatore per le chiamate rifiutate ai tuoi log. Se rimane a zero, il tuo limite è impostato correttamente. Se aumenta, riduci la dimensione del pool prima di aggiungere retry.

Pianificazione in base ai limiti

I limiti di richiesta e il budget sono collegati. Otto slot al massimo possono consumare credito rapidamente, quindi decidi quanto sei disposto a spendere prima di avviare un job. Il prezzo è a consumo, con credito che non scade mai e senza addebito per le richieste fallite o rifiutate. Leggi la pagina dei prezzi per le tariffe e i bonus di ricarica, e la guida rapida per i parametri della richiesta. Per testare la logica di ritentativo in modo sicuro, ottieni una chiave API e usa il credito di prova, che non richiede carta. Ricorda solo che funziona con i limiti inferiori della prova.

Domande e risposte

Cosa succede quando supero un limite di richieste?

Il server rifiuta le richieste in eccesso, solitamente con HTTP 429, e il tuo codice dovrebbe aspettare e riprovare. Rallenta o riduci il parallelismo fino a quando gli errori cessano.

Quali sono i limiti di questa API?

Una chiave completa permette 8 richieste concorrenti e 300 richieste al minuto. Una chiave di prova permette 2 richieste concorrenti e 60 al minuto.

Un limite di richieste è uguale alla finestra di contesto?

No. Un limite di richieste controlla quante richieste puoi inviare nel tempo. La finestra di contesto, 100.000 token qui, controlla quanto può essere grande una singola richiesta e la sua risposta.

Come vedo i miei limiti da una risposta?

Leggi le intestazioni di risposta X-RateLimit-Limit-Requests e X-RateLimit-Limit-Concurrency. L'intestazione X-Balance-USD mostra il tuo credito residuo, e X-Request-Id identifica una chiamata specifica.

Le richieste rifiutate costano denaro?

No. Le richieste fallite o rifiutate non vengono addebitate su questa API.

La tua chiave è a un modulo di distanza

Crea un account, copia la chiave, modifica l'URL di base. È tutta la configurazione.

Ottieni la chiave API