API LLM gratuit în Python
Pachetul Python oficial openai funcționează cu orice API compatibil cu OpenAI. Schimbați adresa de bază și cheia. Acest ghid folosește FreeLLMAPI, care grupează 45 niveluri gratuite de la furnizori în spatele unei singure chei și trece la următorul furnizor când o limită oprește o cerere. Fiecare exemplu de mai jos este complet și rulează așa cum este.
Codul, numele modelelor și etichetele live din catalog sunt afișate în engleză.
Configurare
Instalați FreeLLMAPI. Rulează în Docker. Deschideți panoul de control la http://localhost:3001, adăugați chei gratuite de la doi sau mai mulți furnizori în pagina Keys și copiați cheia unificată. Apoi instalați pachetul Python.
Codul dvs. Python folosește doar cheia unificată. Cheile furnizorilor rămân în FreeLLMAPI, criptate în baza sa de date. Dacă schimbați sau adăugați o cheie de furnizor, nu trebuie să schimbați codul.
Instalare
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)Modelul auto urmează lanțul dvs. de rezervă din panoul de control. Puteți folosi și auto:fast, auto:smart sau auto:reliable, un profil precum auto:coding sau un ID fix de model.
Streaming și antete de răspuns
Transmiteți răspunsul în flux
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()Fiecare răspuns are un antet X-Routed-Via cu furnizorul și modelul care au răspuns. Ca să citiți antetele cu SDK-ul, folosiți with_raw_response și apelați parse() ca să obțineți obiectul normal.
Citiți antetele de rutare
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)Apel de instrumente
Trimiteți tools în stilul OpenAI. Routerul le transmite furnizorilor compatibili OpenAI și le traduce pentru Gemini. Răspunsul revine în același format pentru fiecare furnizor.
Un apel de instrument și răspunsul final
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)Unii furnizori returnează un apel de instrument ca text simplu. FreeLLMAPI convertește aceste răspunsuri în tool_calls reale, deci codul dvs. citește un singur format. Verificați întotdeauna msg.tool_calls înainte să citiți msg.content, pentru că un model poate răspunde și fără un instrument.
Folosiți un model cu apel de instrumente. Aceste modele gratuite acceptă instrumente și au cea mai rapidă viteză măsurată astăzi:
| Model | Gratuit pe | Context | Limite gratuite (cea mai bună ofertă) | Instrumente | Viziune |
|---|---|---|---|---|---|
| Qwen3.8 27B | ElectronHub, Groq, OVH AI Endpoints | 262K | 30 cereri/min 250 cereri/zi 70,000 tokeni/min ~6M | Da | Da |
| Nemotron 3.5 Lightning | ElectronHub, Kilo Gateway, OpenRouter | 1M | 20 cereri/min 50 cereri/zi 50 req/day account-wide (1,000 after a $10 purchase) | Da | Nu |
| GPT-OSS 120B | Cloudflare Workers AI, ElectronHub, Groq +1 în plus | 131K | 30 cereri/min 1,000 cereri/zi 8,000 tokeni/min 200,000 tokeni/zi ~6M | Da | Nu |
| GPT-OSS 20B | Cloudflare Workers AI, Groq, NVIDIA NIM +1 în plus | 131K | 30 cereri/min 1,000 cereri/zi 8,000 tokeni/min 200,000 tokeni/zi ~6M | Da | Nu |
| GPT-OSS Safeguard 20B | Groq | 131K | 30 cereri/min 1,000 cereri/zi 8,000 tokeni/min 200,000 tokeni/zi ~6M | Da | Nu |
| Gemini 3.5 Flash Lite | ElectronHub, Google AI Studio | 1M | 15 cereri/min 20 cereri/zi 250,000 tokeni/min ~3M | Da | Da |
| Step 3.7 Flash | ElectronHub | 256K | $0.25/week shared recurring credit | Da | Da |
| Gemini 3.1 Flash-Lite | DreamPrompting, Google AI Studio | 1M | 100 cereri/min 5,000 cereri/zi 500,000 tokeni/zi 500K tokens/day · 5,000 req/day | Da | Da |
| Nemotron 3.5 Lightning 30B | Requesty | 1M | 200 cereri/zi 200 rpd | Da | Nu |
| Gemini 2.5 Flash-Lite | ElectronHub, Google AI Studio | 1M | 15 cereri/min 20 cereri/zi 250,000 tokeni/min ~3M | Da | Da |
Se afișează 10 din 146 modele gratuite care se potrivesc. Vezi toate modelele.
Date live din catalogul FreeLLMAPI (versiunea 2026.11.19, verificat 2026-11-19). Limitele gratuite se schimbă des. Catalogul este verificat în fiecare zi.
Loturi async în limitele gratuite
AsyncOpenAI trimite multe cereri în același timp. Nivelurile gratuite limitează cererile pe minut, deci limitați concurența cu un semafor. Exemplul reîncearcă și atunci când fiecare furnizor a atins limita.
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())Routerul returnează 429 doar când fiecare cheie din lanț a atins limita. Răspunsul are atunci un antet Retry-After. O valoare mică pentru semafor și mai mulți furnizori de chei dau cele mai bune rezultate pentru loturi mari.
Alegeți un șir de model pentru fiecare sarcină
Șirul de model îi spune routerului cum să aleagă un model. Puteți folosi un șir diferit în fiecare apel. Nu trebuie să schimbați panoul de control.
| Sarcină | Șir de model | Motiv |
|---|---|---|
| Răspunsuri de chat pentru utilizatori | auto | Urmează lanțul de rezervă pe care l-ați setat în panoul de control |
| Clasificare, extragere, rezumate scurte | auto:fast | Ordonează modelele activate după viteza măsurată |
| Întrebări dificile, revizuire de cod, planificare | auto:smart | Ordonează modelele activate după inteligență |
| Job-uri programate care trebuie să se termine | auto:reliable | Ordonează modelele activate după rata recentă de succes |
| Un lanț separat pentru o aplicație | auto:<profile> | Folosește un lanț de rezervă cu nume |
| Teste care trebuie să fie repetabile | Un ID fix de model | Același model de fiecare dată, dar se oprește la limita acelui model |
Ca să vedeți ce modele pot răspunde acum cheile dvs., cereți lista de modele cu un filtru. Lista completă conține și modele pentru care nu există încă o cheie.
Listați modelele care pot răspunde acum
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 model cu starea exhausted are chei, dar toate sunt la o limită acum. Starea dispare când se termină perioadele de răcire. Un model cu starea needsKey nu are nicio cheie activată.
Pentru o conversație, trimiteți un antet X-Session-Id cu extra_headers. FreeLLMAPI păstrează apoi acea conversație pe același model timp de 30 de minute. Fără antet, folosește un hash al primului mesaj al utilizatorului drept cheie a sesiunii.
Embeddings
Calculați embeddings pentru text
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")Failover-ul pentru embeddings nu schimbă niciodată modelul. Trece doar între furnizorii care servesc aceeași familie, deci vectorii dvs. rămân compatibili. Valoarea auto folosește familia implicită pe care ați setat-o în panoul de control.
Trimiteți multe texte într-o singură listă input. O cerere cu 32 de texte folosește o cerere din limita gratuită, nu 32. Păstrați fiecare text sub intrarea maximă a familiei. Salvați numele familiei împreună cu vectorii, ca mai târziu să calculați interogările cu aceeași familie.
Erori și remedieri
| Excepție | Cauză | Remediere |
|---|---|---|
openai.AuthenticationError | Cheie unificată greșită | Copiați din nou cheia din pagina Keys |
openai.APIConnectionError | FreeLLMAPI nu rulează, sau portul este greșit | Deschideți http://localhost:3001 în browser |
openai.NotFoundError | Adresa de bază nu are /v1 | Folosiți http://localhost:3001/v1 |
openai.RateLimitError | Toate cheile din lanț au atins limita | Adăugați furnizori, micșorați concurența, așteptați Retry-After |
openai.BadRequestError cu auto:name | Profilul cu acest nume nu există | Verificați numele profilului în panoul de control |
openai.UnprocessableEntityError (422) cu imagini | Niciun model de viziune nu este în lanțul dvs. | Activați un model de viziune în lanțul de rezervă |
Nivelurile gratuite nu au SLA. Latența se schimbă în timpul zilei. Cele mai puternice modele ating primele limitele zilnice, iar multe limite se resetează la miezul nopții UTC. Nu folosiți un gateway gratuit pentru un serviciu care trebuie să răspundă într-un timp fix.
Întrebări frecvente
Există un API LLM gratuit pentru Python?
Da. Mulți furnizori au niveluri gratuite care funcționează cu pachetul Python openai. FreeLLMAPI le combină în spatele unei singure adrese de bază și al unei singure chei, cu failover între furnizori.
Cum folosesc biblioteca Python openai cu o altă adresă de bază?
Transmiteți base_url către OpenAI() sau AsyncOpenAI(), de exemplu base_url="http://localhost:3001/v1". Transmiteți cheia gateway-ului ca api_key.
Cum gestionez erorile de limită de cereri în Python?
Setați max_retries pe client. Prindeți openai.RateLimitError, citiți antetul Retry-After și așteptați. Limitați concurența cu un semafor asyncio.
Funcționează streaming-ul cu API-urile LLM gratuite în Python?
Da. Transmiteți stream=True și citiți chunk.choices[0].delta.content. FreeLLMAPI face streaming în formatul OpenAI pentru fiecare furnizor.
Pot folosi Python async cu un API LLM gratuit?
Da. Folosiți AsyncOpenAI cu aceeași base_url și aceeași cheie. Păstrați numărul de cereri paralele mic, pentru că nivelurile gratuite limitează cererile pe minut.
Ghiduri înrudite
- URL-uri de bază gratuite compatibile OpenAI
- Free LLM API pentru LangChain
- Free LLM API pentru agenți AI
- API LLM gratuit cu apeluri de funcții
- Limite de rată pentru Free LLM API
Surse
- OpenAI Python SDK README (async, retries, raw responses, errors) (verificat 20 November 2026)
- FreeLLMAPI docs: REST API (chat, streaming, tool calling, embeddings, headers) (verificat 20 November 2026)
- FreeLLMAPI docs: degraded mode and failover (verificat 20 November 2026)