Home / Guide / API LLM gratuita in Python

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:

Modelli gratuiti veloci con chiamate di strumenti
ModelloGratis suContestoLimiti gratuiti (offerta migliore)StrumentiVisione
Qwen3.8 27BElectronHub, Groq, OVH AI Endpoints262K30 richieste/min
250 richieste/giorno
70,000 token/min
~6M
SìSì
Nemotron 3.5 LightningElectronHub, Kilo Gateway, OpenRouter1M20 richieste/min
50 richieste/giorno
50 req/day account-wide (1,000 after a $10 purchase)
SìNo
GPT-OSS 120BCloudflare Workers AI, ElectronHub, Groq +1 altri131K30 richieste/min
1,000 richieste/giorno
8,000 token/min
200,000 token/giorno
~6M
SìNo
GPT-OSS 20BCloudflare Workers AI, Groq, NVIDIA NIM +1 altri131K30 richieste/min
1,000 richieste/giorno
8,000 token/min
200,000 token/giorno
~6M
SìNo
GPT-OSS Safeguard 20BGroq131K30 richieste/min
1,000 richieste/giorno
8,000 token/min
200,000 token/giorno
~6M
SìNo
Gemini 3.5 Flash LiteElectronHub, Google AI Studio1M15 richieste/min
20 richieste/giorno
250,000 token/min
~3M
SìSì
Step 3.7 FlashElectronHub256K$0.25/week shared recurring creditSìSì
Gemini 3.1 Flash-LiteDreamPrompting, Google AI Studio1M100 richieste/min
5,000 richieste/giorno
500,000 token/giorno
500K tokens/day · 5,000 req/day
SìSì
Nemotron 3.5 Lightning 30BRequesty1M200 richieste/giorno
200 rpd
SìNo
Gemini 2.5 Flash-LiteElectronHub, Google AI Studio1M15 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.

CompitoStringa del modelloMotivo
Risposte di chat per gli utentiautoSegue la catena di fallback che ha impostato nella dashboard
Classificazione, estrazione, riassunti breviauto:fastOrdina i modelli attivi per velocità misurata
Domande difficili, revisione del codice, pianificazioneauto:smartOrdina i modelli attivi per intelligenza
Processi pianificati che devono terminareauto:reliableOrdina i modelli attivi per tasso di successo recente
Una catena separata per una sola appauto:<profile>Usa una catena di fallback con nome
Test che devono essere ripetibiliUn ID di modello fissoLo 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

EccezioneCausaSoluzione
openai.AuthenticationErrorChiave unificata errataCopi di nuovo la chiave dalla pagina Keys
openai.APIConnectionErrorFreeLLMAPI non è in esecuzione, oppure la porta è errataApra http://localhost:3001 nel browser
openai.NotFoundErrorIl base URL non contiene /v1Usi http://localhost:3001/v1
openai.RateLimitErrorTutte le chiavi della catena sono al limiteAggiunga provider, abbassi la concorrenza, attenda Retry-After
openai.BadRequestError con auto:nameIl nome del profilo non esisteControlli il nome del profilo nella dashboard
openai.UnprocessableEntityError (422) con immaginiNessun modello di visione è nella Sua catenaAttivi 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.

Usa ognuno di questi modelli con una sola chiave. FreeLLMAPI è un router open source self-hosted che mette tutti questi piani gratuiti dietro un unico endpoint compatibile con OpenAI e passa al successivo quando uno raggiunge il limite di frequenza. Sfoglia il catalogo oppure inizia.

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

Fonti

Tutte le guide · Sfoglia tutti i modelli gratuiti