API LLM gratuita in Python
Il pacchetto Python ufficiale openai funziona con qualsiasi API compatibile con OpenAI. Lei cambia il base URL e la chiave. Questa guida usa FreeLLMAPI, che raccoglie 45 livelli gratuiti di provider dietro una sola chiave e passa al provider successivo quando un limite blocca una richiesta. Ogni esempio qui sotto è completo e funziona così com'è.
Codice, nomi dei modelli ed etichette del catalogo in tempo reale sono mostrati in inglese.
Configurazione
Installi FreeLLMAPI. Funziona in Docker. Apra la dashboard all'indirizzo http://localhost:3001, aggiunga chiavi gratuite di due o più provider nella pagina Keys e copi la chiave unificata. Poi installi il pacchetto Python.
Il Suo codice Python usa solo la chiave unificata. Le chiavi dei provider restano in FreeLLMAPI, cifrate nel suo database. Se cambia o aggiunge una chiave di provider, non deve cambiare il codice.
Installazione
curl -fsSL https://freellmapi.co/install.sh | bash
python3 -m pip install -U openai
export FREELLMAPI_API_KEY=<unified-key>client.py
import os
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:3001/v1",
api_key=os.environ["FREELLMAPI_API_KEY"],
max_retries=3, # the SDK retries 429, 408, 409 and 5xx errors
timeout=60,
)
resp = client.chat.completions.create(
model="auto",
messages=[{"role": "user", "content": "Name three uses of Python in one line."}],
)
print(resp.choices[0].message.content)Il modello auto segue la catena di fallback impostata nella dashboard. Può usare anche auto:fast, auto:smart o auto:reliable, un profilo come auto:coding, oppure un ID di modello fisso.
Streaming e intestazioni di risposta
Trasmetta la risposta
from client import client
stream = client.chat.completions.create(
model="auto:fast",
messages=[{"role": "user", "content": "Write a haiku about Python."}],
stream=True,
)
for chunk in stream:
if chunk.choices:
print(chunk.choices[0].delta.content or "", end="", flush=True)
print()Ogni risposta ha un'intestazione X-Routed-Via con il provider e il modello che hanno risposto. Per leggere le intestazioni con l'SDK, usi with_raw_response e chiami parse() per ottenere l'oggetto normale.
Legga le intestazioni di instradamento
from client import client
raw = client.chat.completions.with_raw_response.create(
model="auto",
messages=[{"role": "user", "content": "hi"}],
)
print("Served by:", raw.headers.get("x-routed-via"))
print("Failed attempts:", raw.headers.get("x-fallback-attempts", "0"))
print(raw.parse().choices[0].message.content)Chiamate di strumenti
Invii tools nello stile OpenAI. Il router li passa ai provider compatibili con OpenAI e li traduce per Gemini. La risposta torna nello stesso formato per ogni provider.
Una chiamata di strumento e la risposta finale
import json
from client import client
tools = [{
"type": "function",
"function": {
"name": "get_exchange_rate",
"description": "Get the exchange rate between two currencies.",
"parameters": {
"type": "object",
"properties": {
"base": {"type": "string"},
"quote": {"type": "string"},
},
"required": ["base", "quote"],
},
},
}]
messages = [{"role": "user", "content": "How many euros is 250 US dollars?"}]
first = client.chat.completions.create(model="auto", messages=messages, tools=tools)
msg = first.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = {"base": args["base"], "quote": args["quote"], "rate": 0.92} # your real lookup
messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
final = client.chat.completions.create(model="auto", messages=messages, tools=tools)
print(final.choices[0].message.content)
else:
print(msg.content)Alcuni provider restituiscono una chiamata di strumento come testo semplice. FreeLLMAPI converte queste risposte in tool_calls reali, così il Suo codice legge un solo formato. Controlli sempre msg.tool_calls prima di leggere msg.content, perché un modello può anche rispondere senza uno strumento.
Usi un modello con chiamate di strumenti. Questi modelli gratuiti supportano gli strumenti e hanno oggi la velocità misurata più alta:
| Modello | Gratis su | Contesto | Limiti gratuiti (offerta migliore) | Strumenti | Visione |
|---|---|---|---|---|---|
| Qwen3.8 27B | ElectronHub, Groq, OVH AI Endpoints | 262K | 30 richieste/min 250 richieste/giorno 70,000 token/min ~6M | Sì | Sì |
| Nemotron 3.5 Lightning | ElectronHub, Kilo Gateway, OpenRouter | 1M | 20 richieste/min 50 richieste/giorno 50 req/day account-wide (1,000 after a $10 purchase) | Sì | No |
| GPT-OSS 120B | Cloudflare Workers AI, ElectronHub, Groq +1 altri | 131K | 30 richieste/min 1,000 richieste/giorno 8,000 token/min 200,000 token/giorno ~6M | Sì | No |
| GPT-OSS 20B | Cloudflare Workers AI, Groq, NVIDIA NIM +1 altri | 131K | 30 richieste/min 1,000 richieste/giorno 8,000 token/min 200,000 token/giorno ~6M | Sì | No |
| GPT-OSS Safeguard 20B | Groq | 131K | 30 richieste/min 1,000 richieste/giorno 8,000 token/min 200,000 token/giorno ~6M | Sì | No |
| Gemini 3.5 Flash Lite | ElectronHub, Google AI Studio | 1M | 15 richieste/min 20 richieste/giorno 250,000 token/min ~3M | Sì | Sì |
| Step 3.7 Flash | ElectronHub | 256K | $0.25/week shared recurring credit | Sì | Sì |
| Gemini 3.1 Flash-Lite | DreamPrompting, Google AI Studio | 1M | 100 richieste/min 5,000 richieste/giorno 500,000 token/giorno 500K tokens/day · 5,000 req/day | Sì | Sì |
| Nemotron 3.5 Lightning 30B | Requesty | 1M | 200 richieste/giorno 200 rpd | Sì | No |
| Gemini 2.5 Flash-Lite | ElectronHub, Google AI Studio | 1M | 15 richieste/min 20 richieste/giorno 250,000 token/min ~3M | Sì | Sì |
Mostrati 10 di 146 modelli gratuiti corrispondenti. Vedi tutti i modelli.
Dati in tempo reale dal catalogo FreeLLMAPI (versione 2026.11.19, verificato il 2026-11-19). I limiti gratuiti cambiano spesso. Il catalogo viene verificato ogni giorno.
Lotti asincroni entro i limiti gratuiti
AsyncOpenAI invia molte richieste nello stesso momento. I livelli gratuiti limitano le richieste al minuto, quindi limiti la concorrenza con un semaforo. L'esempio riprova anche quando tutti i provider sono al limite.
batch.py
import asyncio
import os
import openai
from openai import AsyncOpenAI
client = AsyncOpenAI(
base_url="http://localhost:3001/v1",
api_key=os.environ["FREELLMAPI_API_KEY"],
max_retries=2,
)
limit = asyncio.Semaphore(4) # at most 4 requests at a time
async def summarize(text: str) -> str:
async with limit:
for attempt in range(5):
try:
resp = await client.chat.completions.create(
model="auto:fast",
messages=[
{"role": "system", "content": "Summarize in one sentence."},
{"role": "user", "content": text},
],
)
return resp.choices[0].message.content
except openai.RateLimitError as err:
header = err.response.headers.get("retry-after", "")
wait = int(header) if header.isdigit() else 2 ** attempt
await asyncio.sleep(min(wait, 60))
return "ERROR: rate limited"
async def main():
docs = [f"Document {i}: Python is a programming language." for i in range(20)]
results = await asyncio.gather(*(summarize(d) for d in docs))
for r in results:
print(r)
await client.close()
asyncio.run(main())Il router restituisce 429 solo quando ogni chiave della catena è al limite. La risposta contiene allora un'intestazione Retry-After. Un valore basso del semaforo e più chiavi di provider danno i risultati migliori per i lotti grandi.
Scelga una stringa di modello per ogni compito
La stringa del modello indica al router come scegliere un modello. Può usare una stringa diversa in ogni chiamata. Non deve cambiare la dashboard.
| Compito | Stringa del modello | Motivo |
|---|---|---|
| Risposte di chat per gli utenti | auto | Segue la catena di fallback che ha impostato nella dashboard |
| Classificazione, estrazione, riassunti brevi | auto:fast | Ordina i modelli attivi per velocità misurata |
| Domande difficili, revisione del codice, pianificazione | auto:smart | Ordina i modelli attivi per intelligenza |
| Processi pianificati che devono terminare | auto:reliable | Ordina i modelli attivi per tasso di successo recente |
| Una catena separata per una sola app | auto:<profile> | Usa una catena di fallback con nome |
| Test che devono essere ripetibili | Un ID di modello fisso | Lo stesso modello ogni volta, ma si ferma al limite di quel modello |
Per vedere quali modelli le Sue chiavi possono chiamare ora, richieda l'elenco dei modelli con un filtro. L'elenco completo contiene anche modelli per cui non c'è ancora una chiave.
Elenchi i modelli che possono rispondere ora
import os
import httpx
r = httpx.get(
"http://localhost:3001/v1/models",
params={"execution_status": "ready"},
headers={"Authorization": f"Bearer {os.environ['FREELLMAPI_API_KEY']}"},
timeout=30,
)
r.raise_for_status()
for m in r.json()["data"]:
print(m["id"])Un modello con lo stato exhausted ha delle chiavi, ma tutte sono al limite in questo momento. Lo stato si cancella quando finiscono i periodi di attesa. Un modello con lo stato needsKey non ha una chiave attiva.
Per una conversazione, invii un'intestazione X-Session-Id con extra_headers. FreeLLMAPI mantiene allora quella conversazione su un modello per 30 minuti. Senza l'intestazione, usa un hash del primo messaggio dell'utente come chiave di sessione.
Embedding
Calcoli l'embedding del testo
from client import client
resp = client.embeddings.create(
model="bge-m3", # one embedding family
input=["Python is a programming language.", "A snake is a reptile."],
)
print(len(resp.data), "vectors of", len(resp.data[0].embedding), "dimensions")Il failover degli embedding non cambia mai il modello. Passa solo tra provider che servono la stessa famiglia, quindi i Suoi vettori restano compatibili. Il valore auto usa la famiglia predefinita che ha impostato nella dashboard.
Invii molti testi in una sola lista input. Una richiesta con 32 testi usa una richiesta dal limite gratuito, non 32. Mantenga ogni testo sotto il massimo di input della famiglia. Salvi il nome della famiglia insieme ai vettori, così in seguito calcolerà l'embedding delle query con la stessa famiglia.
Errori e soluzioni
| Eccezione | Causa | Soluzione |
|---|---|---|
openai.AuthenticationError | Chiave unificata errata | Copi di nuovo la chiave dalla pagina Keys |
openai.APIConnectionError | FreeLLMAPI non è in esecuzione, oppure la porta è errata | Apra http://localhost:3001 nel browser |
openai.NotFoundError | Il base URL non contiene /v1 | Usi http://localhost:3001/v1 |
openai.RateLimitError | Tutte le chiavi della catena sono al limite | Aggiunga provider, abbassi la concorrenza, attenda Retry-After |
openai.BadRequestError con auto:name | Il nome del profilo non esiste | Controlli il nome del profilo nella dashboard |
openai.UnprocessableEntityError (422) con immagini | Nessun modello di visione è nella Sua catena | Attivi un modello di visione nella catena di fallback |
I livelli gratuiti non hanno SLA. La latenza cambia durante la giornata. I modelli più forti raggiungono per primi i limiti giornalieri, e molti limiti si ripristinano a mezzanotte UTC. Non usi un gateway gratuito per un servizio che deve rispondere entro un tempo fisso.
Domande frequenti
Esiste un'API LLM gratuita per Python?
Sì. Molti provider hanno livelli gratuiti che funzionano con il pacchetto Python openai. FreeLLMAPI li combina dietro un solo base URL e una sola chiave, con failover tra i provider.
Come uso la libreria Python openai con un base URL diverso?
Passi base_url a OpenAI() oppure AsyncOpenAI(), per esempio base_url="http://localhost:3001/v1". Passi la chiave del gateway come api_key.
Come gestisco gli errori di limite di frequenza in Python?
Imposti max_retries sul client. Intercetti openai.RateLimitError, legga l'intestazione Retry-After e attenda. Limiti la concorrenza con un semaforo asyncio.
Lo streaming funziona con le API LLM gratuite in Python?
Sì. Passi stream=True e legga chunk.choices[0].delta.content. FreeLLMAPI trasmette nel formato OpenAI per ogni provider.
Posso usare Python asincrono con un'API LLM gratuita?
Sì. Usi AsyncOpenAI con lo stesso base_url e la stessa chiave. Mantenga piccolo il numero di richieste parallele, perché i livelli gratuiti limitano le richieste al minuto.
Guide correlate
- Base URL di API gratuite compatibili con OpenAI
- API LLM gratuita per LangChain
- Free LLM API per agenti IA
- API LLM gratuita con function calling
- Rate limit delle Free LLM API
Fonti
- OpenAI Python SDK README (async, retries, raw responses, errors) (verificato il 20 November 2026)
- FreeLLMAPI docs: REST API (chat, streaming, tool calling, embeddings, headers) (verificato il 20 November 2026)
- FreeLLMAPI docs: degraded mode and failover (verificato il 20 November 2026)