IT ▾
Ottieni la chiave API

Chiamate API Unlimited AI: spiegazione dei limiti di velocità

Puoi effettuare chiamate API illimitate? Non ci sono quote mensili per questa API, ma esistono due limiti di velocità: richieste al minuto e richieste simultanee. Ecco cosa significano in pratica e come scrivere codice che li rispetti.

Aggiornato

Punti chiave

  • Una chiave completa permette 300 richieste al minuto e 8 richieste concorrenti; una chiave di prova ne permette 60 e 2.
  • 429 con codice rate_limited significa troppe richieste al minuto; il codice concurrency indica troppe richieste simultanee.
  • Una richiesta in streaming occupa il suo slot di concorrenza fino alla fine dello streaming.
  • Usa un semaforo di 8 e riprova i 429 con backoff, rispettando Retry-After.
Otto corsie di pacchetti dati in coda attraverso un unico cancello, illustrazione dei limiti di velocità e concorrenza API
Bilancia del saldo che pesa cubetti di token luminosi contro monete, illustrando il costo API per token

I due limiti, affiancati

Per chiamate API illimitate nel senso di "nessun tetto mensile", sei coperto: la fatturazione è prepagata e per token, senza quote di chiamate. Ciò che limita il throughput è una coppia di limiti di velocità che proteggono le GPU condivise.

Tipo di chiaveRichieste al minutoRichieste concorrenti
Chiave completa3008
Chiave di prova602

Altri limiti fissi: corpo della richiesta fino a 8 MB e finestra di contesto di 100.000 token (prompt più completamento). Si applicano per richiesta, non al minuto.

I due limiti di velocità sono indipendenti. Puoi superare il limite di concorrenza inviando solo 20 richieste al minuto se ognuna richiede molto tempo, e puoi superare il limite per minuto con chiamate molto veloci e brevi.

Cosa significano i numeri per carichi di lavoro reali

Un modo rapido per dimensionare il tuo carico di lavoro è la legge di Little: richieste concorrenti = tasso di arrivo x durata media.

  • Chatbot, 100 utenti attivi. Se ognuno invia un messaggio ogni 60 secondi, sono 100 richieste al minuto, ben sotto le 300. Ogni risposta richiede circa 10 secondi, quindi la concorrenza media è (100 / 60) x 10, circa 17. Questo supera 8, quindi serve una coda, non solo un ciclo di retry.
  • Batch di 10.000 prompt brevi. A 300 al minuto il tempo minimo di esecuzione è 10.000 / 300 = 33,3 minuti. Per raggiungere 300 al minuto con 8 slot, le chiamate devono durare in media 1,6 secondi (8 x 60 / 300). Chiamate più lunghe spostano il collo di bottiglia sulla concorrenza: a 8 secondi per chiamata, 8 slot danno 60 chiamate al minuto e il lavoro richiede circa 167 minuti.
  • Sviluppatore singolo in scripting. Una o due richieste alla volta non si avvicinano a nessuno dei due limiti.

La lezione è che per le generazioni lunghe, la concorrenza è quasi sempre il limite che si raggiunge per primo. Le risposte brevi colpiscono invece il soffitto per minuto.

Lettura delle intestazioni dei limiti di velocità

Ogni risposta trasporta intestazioni che puoi registrare o usare per adattare il comportamento:

  • X-RateLimit-Limit-Requests: il tuo limite per minuto.
  • X-RateLimit-Limit-Concurrency: il tuo limite di concorrenza.
  • X-Balance-USD: credito residuo.
  • X-Request-Id: cita questo ID al supporto se qualcosa sembra errato.

Con l'SDK Python di OpenAI, usa il wrapper della risposta grezza per vederle:

from openai import OpenAI

client = OpenAI(base_url="https://api.unlimitedaiapi.com/v1", api_key="YOUR_KEY")

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Reply with one word."}],
)
print(raw.headers.get("X-RateLimit-Limit-Requests"))
print(raw.headers.get("X-RateLimit-Limit-Concurrency"))
print(raw.headers.get("X-Balance-USD"))
completion = raw.parse()
print(completion.choices[0].message.content)

Controlla questi valori all'avvio e dimensiona il tuo pool di worker dal valore di concorrenza invece di fissare 8. In questo modo lo stesso codice funziona sia per una chiave di prova che per una chiave completa.

Cosa ti dice un 429

Superare un limite restituisce HTTP 429 con un codice di errore:

  • rate_limited: troppe richieste al minuto. Rallenta.
  • concurrency: troppe richieste in corso. Attendi che una termini.

L'API restituisce anche 429 con un'intestazione Retry-After: 5 quando è temporaneamente sovraccarica. In ogni caso la risposta corretta è la stessa: attendi, poi riprova, usando il valore dell'intestazione se presente.

Un errore comune con lo streaming: una richiesta in streaming occupa il suo slot di concorrenza fino alla fine del flusso. Se un client apre uno streaming e poi smette di leggere, o un'interfaccia utente lascia le connessioni in sospeso, quegli slot restano occupati. Chiudi sempre gli streaming che abbandoni.

Un runner batch che rispetta entrambi i limiti

Questo script mantiene al massimo 8 richieste in corso, distanzia gli avvi per restare sotto le 300 richieste al minuto e riprova con backoff esponenziale in caso di 429. Regola CONCURRENCY e RPM per una chiave di prova.

import asyncio, random
from openai import AsyncOpenAI, RateLimitError

client = AsyncOpenAI(base_url="https://api.unlimitedaiapi.com/v1", api_key="YOUR_KEY", max_retries=0)
CONCURRENCY, RPM = 8, 300
sem = asyncio.Semaphore(CONCURRENCY)
interval = 60 / RPM  # 0.2 s between starts

async def call(prompt, attempt=0):
    async with sem:
        try:
            r = await client.chat.completions.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
            )
            return r.choices[0].message.content
        except RateLimitError as e:
            if attempt >= 6:
                raise
            wait = float(e.response.headers.get("Retry-After", 5)) + random.random()
            await asyncio.sleep(wait * (1.5 ** attempt))
    return await call(prompt, attempt + 1)

async def main(prompts):
    tasks = []
    for p in prompts:
        tasks.append(asyncio.create_task(call(p)))
        await asyncio.sleep(interval)
    return await asyncio.gather(*tasks)

results = asyncio.run(main(["Summarise: ..."] * 50))

Il semaforo viene rilasciato durante l'attesa su un 429, così altri task continuano a procedere. Impostare max_retries=0 sul client impedisce all'SDK di effettuare le proprie ritentative nascoste oltre alle tue.

Consigli di progettazione per alto volume

  • Usa una coda, non espandere in parallelo. Una coda di lavoro con 8 worker è meglio che generare un thread per richiesta e riprovare.
  • Aggiungi jitter. Se molti worker fanno backoff per lo stesso tempo, tornano tutti insieme e collidono di nuovo.
  • Limita l'output. Impostare max_tokens riduce la durata della chiamata, aumentando il throughput effettivo sotto il limite di concorrenza.
  • Preferisci prompt meno numerosi ma più grandi quando il compito lo permette, ad esempio classificando 20 elementi per richiesta invece che uno. Questo riduce il numero di richieste di 20 volte. Attenzione alla finestra di 100.000 token.
  • Monitora il costo insieme alla velocità. A $0,15 per 1M token di input e $0,50 per 1M token di output, un lavoro di 10.000 richieste con 2.000 token in input e 300 in output costa $4,50. Vedi la pagina dei prezzi per importi di ricarica e bonus.

Se i limiti della chiave completa sono troppo bassi per il tuo prodotto, dillo attraverso la pagina di supporto indicando il tuo tasso di richieste atteso e la lunghezza media dell'output.

Errori comuni che sembrano limiti

Alcuni fallimenti sembrano limitazioni di velocità ma hanno un'altra causa.

Tempeste di retry

Un client che riprova istantaneamente su ogni 429 peggiora il problema. Dieci worker che riprovano senza ritardo mantengono il contatore per minuto al massimo, quindi nessuno di loro ha successo. Il backoff con jitter non è opzionale ad alto volume.

Contare le richieste, non i tentativi

I tuoi retry contano come richieste. Se il tuo piano è 300 al minuto e il 20% delle chiamate viene riprovato, la tua domanda reale è 360. Bilancialo eseguendo il loop iniziale circa all'80% del limite, ad esempio 240 al minuto.

Timeout che annullano il lavoro

Se il tuo client si arrende dopo 30 secondi ma il server sta ancora generando, potresti aprire una richiesta di sostituzione mentre la prima tiene ancora uno slot. Imposta i timeout del client sopra la tua generazione attesa più lunga, o riduci max_tokens.

Test manuale rapido

Per vedere un limite attivarsi intenzionalmente con una chiave di prova, lancia tre richieste nello stesso momento:

for i in 1 2 3; do
  curl -s -o /dev/null -w "%{http_code}
" https://api.unlimitedaiapi.com/v1/chat/completions     -H "Authorization: Bearer YOUR_KEY" -H "Content-Type: application/json"     -d '{"model":"uncensored","messages":[{"role":"user","content":"Write a 300 word story."}]}' &
done; wait

Su una chiave di prova (2 concorrenti) dovresti vedere due risposte 200 e una 429.

Prossimi passi

Ottieni una chiave nella pagina delle chiavi API; il credito di prova in un clic è sufficiente per testare la tua logica di ritentativa contro i veri 429, dato che i limiti della chiave di prova sono 60 al minuto e 2 concorrenti, facili da raggiungere appositamente. La documentazione elenca ogni endpoint, e le note su LangChain e agent mostrano come limitare la concorrenza all'interno dei framework agent, dove un'attività utente può generare più chiamate parallele.

Domande e risposte

Esiste un limite giornaliero o mensile alle chiamate API?

No. La fatturazione è prepagata per token e non esiste un limite di chiamate. Si applicano solo i limiti per minuto e di concorrenza.

Cosa succede quando supero 300 richieste al minuto?

L’API risponde con HTTP 429 e codice di errore rate_limited. Attendi e riprova, usando l’intestazione Retry-After se presente.

Perché ricevo un errore di concorrenza con un traffico ridotto?

Le generazioni lunghe e gli stream aperti mantengono uno slot fino al termine. Otto richieste lente sono sufficienti a riempire una chiave completa, quindi limita max_tokens e chiudi gli stream inutilizzati.

Le risposte 429 vengono fatturate?

No. Le richieste fallite o rifiutate non vengono addebitate.

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