Acasă / Ghiduri / API LLM gratuit în Python

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:

Modele gratuite rapide cu apel de instrumente
ModelGratuit peContextLimite gratuite (cea mai bună ofertă)InstrumenteViziune
Qwen3.8 27BElectronHub, Groq, OVH AI Endpoints262K30 cereri/min
250 cereri/zi
70,000 tokeni/min
~6M
DaDa
Nemotron 3.5 LightningElectronHub, Kilo Gateway, OpenRouter1M20 cereri/min
50 cereri/zi
50 req/day account-wide (1,000 after a $10 purchase)
DaNu
GPT-OSS 120BCloudflare Workers AI, ElectronHub, Groq +1 în plus131K30 cereri/min
1,000 cereri/zi
8,000 tokeni/min
200,000 tokeni/zi
~6M
DaNu
GPT-OSS 20BCloudflare Workers AI, Groq, NVIDIA NIM +1 în plus131K30 cereri/min
1,000 cereri/zi
8,000 tokeni/min
200,000 tokeni/zi
~6M
DaNu
GPT-OSS Safeguard 20BGroq131K30 cereri/min
1,000 cereri/zi
8,000 tokeni/min
200,000 tokeni/zi
~6M
DaNu
Gemini 3.5 Flash LiteElectronHub, Google AI Studio1M15 cereri/min
20 cereri/zi
250,000 tokeni/min
~3M
DaDa
Step 3.7 FlashElectronHub256K$0.25/week shared recurring creditDaDa
Gemini 3.1 Flash-LiteDreamPrompting, Google AI Studio1M100 cereri/min
5,000 cereri/zi
500,000 tokeni/zi
500K tokens/day · 5,000 req/day
DaDa
Nemotron 3.5 Lightning 30BRequesty1M200 cereri/zi
200 rpd
DaNu
Gemini 2.5 Flash-LiteElectronHub, Google AI Studio1M15 cereri/min
20 cereri/zi
250,000 tokeni/min
~3M
DaDa

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 modelMotiv
Răspunsuri de chat pentru utilizatoriautoUrmează lanțul de rezervă pe care l-ați setat în panoul de control
Clasificare, extragere, rezumate scurteauto:fastOrdonează modelele activate după viteza măsurată
Întrebări dificile, revizuire de cod, planificareauto:smartOrdonează modelele activate după inteligență
Job-uri programate care trebuie să se termineauto:reliableOrdonează modelele activate după rata recentă de succes
Un lanț separat pentru o aplicațieauto:<profile>Folosește un lanț de rezervă cu nume
Teste care trebuie să fie repetabileUn ID fix de modelAcelaș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țieCauzăRemediere
openai.AuthenticationErrorCheie unificată greșităCopiați din nou cheia din pagina Keys
openai.APIConnectionErrorFreeLLMAPI nu rulează, sau portul este greșitDeschideți http://localhost:3001 în browser
openai.NotFoundErrorAdresa de bază nu are /v1Folosiți http://localhost:3001/v1
openai.RateLimitErrorToate cheile din lanț au atins limitaAdăugați furnizori, micșorați concurența, așteptați Retry-After
openai.BadRequestError cu auto:nameProfilul cu acest nume nu existăVerificați numele profilului în panoul de control
openai.UnprocessableEntityError (422) cu imaginiNiciun 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.

Folosiți fiecare dintre aceste modele printr-o singură cheie. FreeLLMAPI este un router open-source, găzduit de dumneavoastră, care pune toate aceste niveluri gratuite în spatele unui singur endpoint compatibil cu OpenAI și trece la alt furnizor când un furnizor este limitat la rată. Vezi catalogul sau trece live.

Î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

Surse

Toate ghidurile · Vezi toate modelele gratuite