Startseite / Anleitungen / Kostenlose LLM-API in Python

Kostenlose LLM-API in Python

Das offizielle Python-Paket openai funktioniert mit jeder OpenAI-kompatiblen API. Sie ändern die Base URL und den Schlüssel. Diese Anleitung verwendet FreeLLMAPI, das 45 kostenlose Anbieter-Stufen hinter einem Schlüssel bündelt und zum nächsten Anbieter wechselt, wenn ein Limit eine Anfrage stoppt. Jedes Beispiel unten ist vollständig und läuft so, wie es ist.

Code, Modellnamen und Bezeichnungen aus dem Live-Katalog werden auf Englisch angezeigt.

Einrichtung

Installieren Sie FreeLLMAPI. Es läuft in Docker. Öffnen Sie das Dashboard unter http://localhost:3001, fügen Sie auf der Seite Keys kostenlose Schlüssel von zwei oder mehr Anbietern hinzu und kopieren Sie den einheitlichen Schlüssel. Installieren Sie danach das Python-Paket.

Ihr Python-Code verwendet nur den einheitlichen Schlüssel. Die Anbieter-Schlüssel bleiben in FreeLLMAPI und sind in dessen Datenbank verschlüsselt. Wenn Sie einen Anbieter-Schlüssel ändern oder hinzufügen, ändern Sie Ihren Code nicht.

Installation

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)

Das Modell auto folgt Ihrer Fallback-Kette im Dashboard. Sie können außerdem auto:fast, auto:smart oder auto:reliable verwenden, ein Profil wie auto:coding oder eine feste Modell-ID.

Streaming und Antwort-Header

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

Jede Antwort hat einen Header X-Routed-Via mit dem Anbieter und dem Modell, die geantwortet haben. Um Header mit dem SDK zu lesen, verwenden Sie with_raw_response und rufen parse() auf, um das normale Objekt zu erhalten.

Die Routing-Header lesen

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)

Tool-Aufrufe

Senden Sie tools im OpenAI-Stil. Der Router leitet sie an OpenAI-kompatible Anbieter weiter und übersetzt sie für Gemini. Die Antwort kommt für jeden Anbieter im gleichen Format zurück.

Ein Tool-Aufruf und die finale Antwort

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)

Manche Anbieter geben einen Tool-Aufruf als einfachen Text zurück. FreeLLMAPI wandelt diese Antworten in echte tool_calls um, daher liest Ihr Code ein einziges Format. Prüfen Sie immer msg.tool_calls, bevor Sie msg.content lesen, denn ein Modell kann auch ohne Tool antworten.

Verwenden Sie ein Modell mit Tool-Aufrufen. Diese kostenlosen Modelle unterstützen Tools und haben heute die schnellste gemessene Geschwindigkeit:

Schnelle kostenlose Modelle mit Tool-Aufrufen
ModellKostenlos beiKontextKostenlose Limits (bestes Angebot)ToolsBildverarbeitung
Qwen3.8 27BElectronHub, Groq, OVH AI Endpoints262K30 Anfragen/Min.
250 Anfragen/Tag
70,000 Token/Min.
~6M
JaJa
Nemotron 3.5 LightningElectronHub, Kilo Gateway, OpenRouter1M20 Anfragen/Min.
50 Anfragen/Tag
50 req/day account-wide (1,000 after a $10 purchase)
JaNein
GPT-OSS 120BCloudflare Workers AI, ElectronHub, Groq +1 weitere131K30 Anfragen/Min.
1,000 Anfragen/Tag
8,000 Token/Min.
200,000 Token/Tag
~6M
JaNein
GPT-OSS 20BCloudflare Workers AI, Groq, NVIDIA NIM +1 weitere131K30 Anfragen/Min.
1,000 Anfragen/Tag
8,000 Token/Min.
200,000 Token/Tag
~6M
JaNein
GPT-OSS Safeguard 20BGroq131K30 Anfragen/Min.
1,000 Anfragen/Tag
8,000 Token/Min.
200,000 Token/Tag
~6M
JaNein
Gemini 3.5 Flash LiteElectronHub, Google AI Studio1M15 Anfragen/Min.
20 Anfragen/Tag
250,000 Token/Min.
~3M
JaJa
Step 3.7 FlashElectronHub256K$0.25/week shared recurring creditJaJa
Gemini 3.1 Flash-LiteDreamPrompting, Google AI Studio1M100 Anfragen/Min.
5,000 Anfragen/Tag
500,000 Token/Tag
500K tokens/day · 5,000 req/day
JaJa
Nemotron 3.5 Lightning 30BRequesty1M200 Anfragen/Tag
200 rpd
JaNein
Gemini 2.5 Flash-LiteElectronHub, Google AI Studio1M15 Anfragen/Min.
20 Anfragen/Tag
250,000 Token/Min.
~3M
JaJa

Es werden 10 von 146 passenden kostenlosen Modellen angezeigt. Alle Modelle ansehen.

Live-Daten aus dem FreeLLMAPI-Katalog (Version 2026.11.19, geprüft 2026-11-19). Kostenlose Limits ändern sich oft. Der Katalog wird jeden Tag geprüft.

Asynchrone Stapel innerhalb der kostenlosen Limits

AsyncOpenAI sendet viele Anfragen gleichzeitig. Kostenlose Stufen begrenzen Anfragen pro Minute. Begrenzen Sie daher die Parallelität mit einem Semaphore. Das Beispiel wiederholt außerdem den Aufruf, wenn alle Anbieter ihr Limit erreicht haben.

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

Der Router gibt nur dann 429 zurück, wenn jeder Schlüssel in der Kette sein Limit erreicht hat. Die Antwort enthält dann einen Header Retry-After. Ein kleiner Wert für den Semaphore und mehr Anbieter-Schlüssel liefern bei großen Stapeln die besten Ergebnisse.

Für jede Aufgabe einen Modellstring wählen

Der Modellstring sagt dem Router, wie er ein Modell auswählt. Sie können in jedem Aufruf einen anderen String verwenden. Das Dashboard müssen Sie dafür nicht ändern.

AufgabeModellstringGrund
Chat-Antworten für BenutzerautoFolgt der Fallback-Kette, die Sie im Dashboard festgelegt haben
Klassifikation, Extraktion, kurze Zusammenfassungenauto:fastOrdnet aktivierte Modelle nach gemessener Geschwindigkeit
Schwierige Fragen, Code-Review, Planungauto:smartOrdnet aktivierte Modelle nach Intelligenz
Geplante Aufträge, die fertig werden müssenauto:reliableOrdnet aktivierte Modelle nach der jüngsten Erfolgsquote
Eine eigene Kette für eine Appauto:<profile>Verwendet eine benannte Fallback-Kette
Tests, die wiederholbar sein müssenEine feste Modell-IDJedes Mal dasselbe Modell, aber es stoppt am Limit dieses Modells

Um zu sehen, welche Modelle Ihre Schlüssel jetzt aufrufen können, fragen Sie die Modellliste mit einem Filter ab. Die vollständige Liste enthält auch Modelle, für die es noch keinen Schlüssel gibt.

Die Modelle auflisten, die jetzt antworten können

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

Ein Modell mit dem Status exhausted hat Schlüssel, aber alle sind gerade am Limit. Der Status verschwindet, wenn die Sperrzeiten enden. Ein Modell mit dem Status needsKey hat keinen aktivierten Schlüssel.

Für ein Gespräch senden Sie einen Header X-Session-Id mit extra_headers. FreeLLMAPI hält dieses Gespräch dann 30 Minuten lang auf einem Modell. Ohne den Header verwendet es einen Hash der ersten Benutzernachricht als Sitzungsschlüssel.

Embeddings

Text einbetten

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

Das Embedding-Failover wechselt nie das Modell. Es wechselt nur zwischen Anbietern, die dieselbe Familie bereitstellen, daher bleiben Ihre Vektoren kompatibel. Der Wert auto verwendet die Standardfamilie, die Sie im Dashboard festgelegt haben.

Senden Sie viele Texte in einer Liste input. Eine Anfrage mit 32 Texten verbraucht eine Anfrage aus dem kostenlosen Limit, nicht 32. Halten Sie jeden Text unter dem Maximum an Eingabe der Familie. Speichern Sie den Familiennamen zusammen mit Ihren Vektoren, damit Sie Abfragen später mit derselben Familie einbetten.

Fehler und Lösungen

AusnahmeUrsacheLösung
openai.AuthenticationErrorFalscher einheitlicher SchlüsselKopieren Sie den Schlüssel erneut von der Seite Keys
openai.APIConnectionErrorFreeLLMAPI läuft nicht oder der Port ist falschÖffnen Sie http://localhost:3001 im Browser
openai.NotFoundErrorDie Base URL hat kein /v1Verwenden Sie http://localhost:3001/v1
openai.RateLimitErrorAlle Schlüssel in der Kette haben ihr Limit erreichtFügen Sie Anbieter hinzu, senken Sie die Parallelität oder warten Sie auf Retry-After
openai.BadRequestError mit auto:nameDer Profilname existiert nichtPrüfen Sie den Profilnamen im Dashboard
openai.UnprocessableEntityError (422) mit BildernIn Ihrer Kette ist kein Vision-ModellAktivieren Sie ein Vision-Modell in der Fallback-Kette

Kostenlose Stufen haben kein SLA. Die Latenz ändert sich im Laufe des Tages. Die stärksten Modelle erreichen ihre Tageslimits zuerst, und viele Limits werden um Mitternacht UTC zurückgesetzt. Verwenden Sie kein kostenloses Gateway für einen Dienst, der innerhalb einer festen Zeit antworten muss.

Nutzen Sie alle diese Modelle über einen einzigen Schlüssel. FreeLLMAPI ist ein Open-Source-Router, den Sie selbst hosten. Er stellt alle diese kostenlosen Angebote hinter einem einzigen OpenAI-kompatiblen Endpunkt bereit und wechselt zum nächsten Anbieter, wenn ein Anbieter das Limit erreicht. Katalog ansehen oder Jetzt starten.

Häufig gestellte Fragen

Gibt es eine kostenlose LLM-API für Python?

Ja. Viele Anbieter haben kostenlose Stufen, die mit dem Python-Paket openai funktionieren. FreeLLMAPI kombiniert sie hinter einer Base URL und einem Schlüssel, mit Failover zwischen den Anbietern.

Wie verwende ich die Python-Bibliothek openai mit einer anderen Base URL?

Übergeben Sie base_url an OpenAI() oder AsyncOpenAI(), zum Beispiel base_url="http://localhost:3001/v1". Übergeben Sie Ihren Gateway-Schlüssel als api_key.

Wie behandle ich Rate-Limit-Fehler in Python?

Setzen Sie max_retries am Client. Fangen Sie openai.RateLimitError ab, lesen Sie den Header Retry-After und warten Sie. Begrenzen Sie die Parallelität mit einem asyncio-Semaphore.

Funktioniert Streaming in Python mit kostenlosen LLM-APIs?

Ja. Übergeben Sie stream=True und lesen Sie chunk.choices[0].delta.content. FreeLLMAPI streamt für jeden Anbieter im OpenAI-Format.

Kann ich asynchrones Python mit einer kostenlosen LLM-API verwenden?

Ja. Verwenden Sie AsyncOpenAI mit derselben base_url und demselben Schlüssel. Halten Sie die Zahl paralleler Anfragen klein, weil kostenlose Stufen Anfragen pro Minute begrenzen.

Verwandte Anleitungen

Quellen

Alle Anleitungen · Alle kostenlosen Modelle ansehen