Home / Gidsen / Gratis LLM-API in Python

Gratis LLM-API in Python

Het officiële Python-pakket openai werkt met elke OpenAI-compatibele API. Je wijzigt de base URL en de sleutel. Deze gids gebruikt FreeLLMAPI, dat 45 gratis providertiers achter één sleutel bundelt en overschakelt naar de volgende provider wanneer een limiet een verzoek stopt. Elk voorbeeld hieronder is volledig en werkt zonder aanpassing.

Code, modelnamen en labels uit de live catalogus worden in het Engels getoond.

Installatie

Installeer FreeLLMAPI. Het draait in Docker. Open het dashboard op http://localhost:3001, voeg op de pagina Keys gratis sleutels toe van twee of meer providers en kopieer de uniforme sleutel. Installeer daarna het Python-pakket.

Je Python-code gebruikt alleen de uniforme sleutel. De providersleutels blijven in FreeLLMAPI, versleuteld in de database. Als je een providersleutel wijzigt of toevoegt, wijzig je je code niet.

Installeren

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)

Het model auto volgt je fallbackketen op het dashboard. Je kunt ook auto:fast, auto:smart of auto:reliable gebruiken, een profiel zoals auto:coding, of een vaste model-ID.

Streaming en responseheaders

Het antwoord streamen

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()

Elk antwoord heeft een header X-Routed-Via met de provider en het model dat heeft geantwoord. Om headers met de SDK te lezen, gebruik je with_raw_response en roep je parse() aan om het normale object te krijgen.

De routeringsheaders lezen

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)

Toolaanroepen

Stuur tools in de OpenAI-stijl. De router geeft ze door aan OpenAI-compatibele providers en vertaalt ze voor Gemini. Het antwoord komt voor elke provider terug in hetzelfde formaat.

Eén toolaanroep en het eindantwoord

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)

Sommige providers geven een toolaanroep als gewone tekst terug. FreeLLMAPI zet deze antwoorden om in echte tool_calls, zodat je code één formaat leest. Controleer altijd msg.tool_calls voordat je msg.content leest, want een model kan ook antwoorden zonder tool.

Gebruik een model met toolaanroepen. Deze gratis modellen ondersteunen tools en hebben vandaag de snelste gemeten snelheid:

Snelle gratis modellen met toolaanroepen
ModelGratis opContextGratis limieten (beste aanbod)ToolsVision
Qwen3.8 27BElectronHub, Groq, OVH AI Endpoints262K30 aanvragen/min
250 aanvragen/dag
70,000 tokens/min
~6M
JaJa
Nemotron 3.5 LightningElectronHub, Kilo Gateway, OpenRouter1M20 aanvragen/min
50 aanvragen/dag
50 req/day account-wide (1,000 after a $10 purchase)
JaNee
GPT-OSS 120BCloudflare Workers AI, ElectronHub, Groq +1 meer131K30 aanvragen/min
1,000 aanvragen/dag
8,000 tokens/min
200,000 tokens/dag
~6M
JaNee
GPT-OSS 20BCloudflare Workers AI, Groq, NVIDIA NIM +1 meer131K30 aanvragen/min
1,000 aanvragen/dag
8,000 tokens/min
200,000 tokens/dag
~6M
JaNee
GPT-OSS Safeguard 20BGroq131K30 aanvragen/min
1,000 aanvragen/dag
8,000 tokens/min
200,000 tokens/dag
~6M
JaNee
Gemini 3.5 Flash LiteElectronHub, Google AI Studio1M15 aanvragen/min
20 aanvragen/dag
250,000 tokens/min
~3M
JaJa
Step 3.7 FlashElectronHub256K$0.25/week shared recurring creditJaJa
Gemini 3.1 Flash-LiteDreamPrompting, Google AI Studio1M100 aanvragen/min
5,000 aanvragen/dag
500,000 tokens/dag
500K tokens/day · 5,000 req/day
JaJa
Nemotron 3.5 Lightning 30BRequesty1M200 aanvragen/dag
200 rpd
JaNee
Gemini 2.5 Flash-LiteElectronHub, Google AI Studio1M15 aanvragen/min
20 aanvragen/dag
250,000 tokens/min
~3M
JaJa

Toont 10 van 146 overeenkomende gratis modellen. Bekijk alle modellen.

Actuele gegevens uit de FreeLLMAPI-catalogus (versie 2026.11.19, gecontroleerd 2026-11-19). Gratis limieten veranderen vaak. De catalogus wordt elke dag gecontroleerd.

Asynchrone batches binnen de gratis limieten

AsyncOpenAI stuurt veel verzoeken tegelijk. Gratis tiers beperken verzoeken per minuut, dus beperk de gelijktijdigheid met een semafoor. Het voorbeeld probeert ook opnieuw wanneer alle providers hun limiet hebben bereikt.

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())

De router geeft alleen 429 terug wanneer elke sleutel in de keten zijn limiet heeft bereikt. Het antwoord heeft dan een header Retry-After. Een kleine semafoorwaarde en meer providersleutels geven de beste resultaten voor grote batches.

Kies een modelstring voor elke taak

De modelstring vertelt de router hoe een model wordt gekozen. Je kunt in elke aanroep een andere string gebruiken. Je hoeft het dashboard niet te wijzigen.

TaakModelstringReden
Chatantwoorden voor gebruikersautoVolgt de fallbackketen die je op het dashboard instelt
Classificatie, extractie, korte samenvattingenauto:fastRangschikt ingeschakelde modellen op gemeten snelheid
Moeilijke vragen, codereview, planningauto:smartRangschikt ingeschakelde modellen op intelligentie
Geplande taken die moeten slagenauto:reliableRangschikt ingeschakelde modellen op het recente slagingspercentage
Een aparte keten voor één appauto:<profile>Gebruikt een benoemde fallbackketen
Tests die herhaalbaar moeten zijnEen vaste model-IDElke keer hetzelfde model, maar het stopt bij de limiet van dat model

Om te zien welke modellen je sleutels nu kunnen aanroepen, vraag je de modellijst op met een filter. De volledige lijst bevat ook modellen waarvoor nog geen sleutel is.

De modellen tonen die nu kunnen antwoorden

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"])

Een model met de status exhausted heeft sleutels, maar alle sleutels hebben nu een limiet bereikt. De status verdwijnt wanneer de wachttijden voorbij zijn. Een model met de status needsKey heeft geen ingeschakelde sleutel.

Voor een gesprek stuur je een header X-Session-Id met extra_headers. FreeLLMAPI houdt dat gesprek dan 30 minuten op één model. Zonder de header gebruikt het een hash van het eerste gebruikersbericht als sessiesleutel.

Embeddings

Tekst embedden

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")

Embedding-failover wijzigt het model nooit. Het schakelt alleen over tussen providers die dezelfde familie bedienen, zodat je vectoren compatibel blijven. De waarde auto gebruikt de standaardfamilie die je op het dashboard instelt.

Stuur veel teksten in één lijst input. Eén verzoek met 32 teksten gebruikt één verzoek van de gratis limiet, niet 32. Houd elke tekst onder de maximale invoer van de familie. Bewaar de familienaam bij je vectoren, zodat je later queries met dezelfde familie embedt.

Fouten en oplossingen

UitzonderingOorzaakOplossing
openai.AuthenticationErrorOnjuiste uniforme sleutelKopieer de sleutel opnieuw van de pagina Keys
openai.APIConnectionErrorFreeLLMAPI draait niet, of de poort is onjuistOpen http://localhost:3001 in de browser
openai.NotFoundErrorDe base URL heeft geen /v1Gebruik http://localhost:3001/v1
openai.RateLimitErrorAlle sleutels in de keten hebben hun limiet bereiktVoeg providers toe, verlaag de gelijktijdigheid, wacht op Retry-After
openai.BadRequestError met auto:nameDe profielnaam bestaat nietControleer de profielnaam op het dashboard
openai.UnprocessableEntityError (422) met afbeeldingenEr staat geen visiemodel in je ketenSchakel een visiemodel in de fallbackketen in

Gratis tiers hebben geen SLA. De latentie verandert gedurende de dag. De sterkste modellen bereiken hun dagelijkse limieten het eerst, en veel limieten worden om middernacht UTC gereset. Gebruik een gratis gateway niet voor een dienst die binnen een vaste tijd moet antwoorden.

Gebruik elk van deze met één sleutel. FreeLLMAPI is een open-source router die u zelf host. Die zet al deze gratis tarieven achter één eindpunt dat compatibel is met OpenAI. Bij een snelheidslimiet schakelt de router automatisch over. Bekijk de catalogus of live gaan.

Veelgestelde vragen

Is er een gratis LLM-API voor Python?

Ja. Veel providers hebben gratis tiers die werken met het openai-pakket voor Python. FreeLLMAPI combineert ze achter één base URL en één sleutel, met failover tussen providers.

Hoe gebruik ik de openai-bibliotheek voor Python met een andere base URL?

Geef base_url door aan OpenAI() of AsyncOpenAI(), bijvoorbeeld base_url="http://localhost:3001/v1". Geef je gatewaysleutel door als api_key.

Hoe ga ik in Python om met fouten door ratelimieten?

Stel max_retries in op de client. Vang openai.RateLimitError op, lees de header Retry-After en wacht. Beperk de gelijktijdigheid met een asyncio-semafoor.

Werkt streaming in Python met gratis LLM-API's?

Ja. Geef stream=True door en lees chunk.choices[0].delta.content. FreeLLMAPI streamt in het OpenAI-formaat voor elke provider.

Kan ik asynchroon Python gebruiken met een gratis LLM-API?

Ja. Gebruik AsyncOpenAI met dezelfde base_url en sleutel. Houd het aantal parallelle verzoeken klein, want gratis tiers beperken verzoeken per minuut.

Gerelateerde gidsen

Bronnen

Alle gidsen · Bekijk alle gratis modellen