Start›Ratgeber›Ollama-API: Endpunkte, OpenAI-Kompatibilität, Schlüssel und keep_alive, getestet mit v0.40.15

Einrichten · Leitfaden

Ollama-API: Endpunkte, OpenAI-Kompatibilität, Schlüssel und keep_alive, getestet mit v0.40.15

Die Ollama-API lauscht auf http://127.0.0.1:11434, sobald die App oder ollama serve läuft, ohne Schlüssel und ohne Passwort. Die eigenen Routen liegen unter /api/ (Chat, Generieren, Modelle), die OpenAI-kompatible Schicht unter /v1/: Die meisten OpenAI-Clients funktionieren, wenn Sie die Basis-URL und den Modellnamen ändern.

Gemessen und geschrieben von Local AI ScopeVeröffentlicht am Zahlen gemessen von Local AI Scope

Die Ollama-API lauscht auf http://127.0.0.1:11434, sobald die App oder ollama serve läuft, ohne Schlüssel und ohne Passwort. Die eigenen Routen liegen unter /api/ (Chat, Generieren, Modelle), die OpenAI-kompatible Schicht unter /v1/: Die meisten OpenAI-Clients funktionieren, wenn Sie die Basis-URL und den Modellnamen ändern.

Beim Lesen des Codes haben wir es nicht belassen. Am 6. November 2026 haben wir das offizielle Linux-Binary von Ollama v0.40.15 in einem Container ganz ohne Netzwerk gestartet, nur auf dem Prozessor und mit einem winzigen Modell mit 135 Millionen Parametern (smollm2:135m), und es mit Anfragen eingedeckt: native Routen, OpenAI-Routen, ein erfundener Schlüssel, fremde Origins und Routen, die zu ollama.com hinauswollen. Danach haben wir LM Studio, llama.cpp, vLLM und MLX genauso gelesen, damit Sie wissen, was jede lokale API öffnet und für wen.

OllamaOllamaProgramm-Datenblatt LM StudioLM StudioProgramm-Datenblatt

Die Ollama-API aufrufen: Adresse, Port und erste Anfrage

Ab Werk lauscht der Server auf 127.0.0.1, Port 11434: Nur Programme auf Ihrem eigenen Rechner kommen heran. Der schnellste Test ist curl http://127.0.0.1:11434/api/version, bei uns kam {"version":"0.40.15"} zurück. Ein erster Chat über die native API:

curl http://127.0.0.1:11434/api/chat -d '{
  "model": "qwen3:8b",
  "messages": [{"role": "user", "content": "Warum ist der Himmel blau?"}],
  "stream": false
}'

Achten Sie auf "stream": false. In der nativen API kommt die Antwort stückweise, solange Sie das nicht abschalten: Unser /api/generate ohne dieses Feld lieferte eine JSON-Zeile pro Stück, jede mit "done": false. Mit dem Feld bekommen Sie ein einziges JSON mit den Zeiten in Nanosekunden; die Antwort steht bei /api/chat wie oben in message.content, bei /api/generate in response. Im Test lud das 135M-Modell in 0,52 Sekunden und schrieb 16 Token. Das Modell muss vorher heruntergeladen sein (ollama pull qwen3:8b), sonst antwortet die API mit einem 404. Im Terminal zeigt ollama list, welche Modelle heruntergeladen sind; diesen und alle anderen Befehle mit echter Ausgabe finden Sie in unserem Spickzettel der Ollama-Befehle.

Im Video (auf Englisch) geht die Anfrage aus Visual Studio Code mit der Erweiterung REST Client statt curl an http://localhost:11434/api/generate, mit "stream": false, damit die Antwort in einem Stück kommt: derselbe Schalter, den wir oben erklären.

Öffnet YouTube (ohne Cookies) erst, wenn Sie auf Play drücken.

Ollama-Logo
Ollama-Logo. Die v0.40.15, am 6. November 2026 die stabile Version, bedient auf Port 11434 insgesamt 37 Routen: 24 unter /api/, 12 unter /v1/ und die Root-Route Logo: Ollama

Alle Endpunkte der Ollama-API, nativ und OpenAI-kompatibel

Gezählt haben wir sie am 6. November 2026 in server/routes.go der v0.40.15 (Zeilen 2383 bis 2452): 37 Routen, 24 unter /api/, 12 unter /v1/ und die Root-Route /, die nur „Ollama is running“ meldet. Das sind die, die Sie benutzen werden; die letzte Spalte sagt, ob die Anfrage Ihren Rechner verlässt:

Route Wofür Verlässt sie den Rechner?
/api/chat, /api/generate Chat mit Nachrichten oder Vervollständigen eines einzelnen Textes Nur mit einem Cloud-Modell
/api/embed Embeddings (/api/embeddings ist die ältere Form) Nur mit einem Cloud-Modell
/api/tags, /api/ps, /api/show, /v1/models Heruntergeladene Modelle, Modelle im Speicher, Details zu einem Modell Nein (/api/show nur mit einem Cloud-Modell)
/api/pull, /api/push, /api/create, /api/copy, /api/delete Modelle verwalten Pull und Push sprechen mit der Modell-Registry, ebenso create, wenn es von einem Modell ausgeht, das Sie noch nicht haben
/api/balance, /api/usage, /api/me Ihr Konto bei ollama.com Immer
/api/experimental/web_search, /api/experimental/web_fetch Websuche und Seitenabruf für Werkzeuge Immer
/v1/chat/completions, /v1/completions, /v1/responses, /v1/embeddings OpenAI-Kompatibilität Nur mit einem Cloud-Modell
/v1/messages Anthropic-Kompatibilität Nur mit einem Cloud-Modell

Der Rest: Verwaltung (/api/version, /api/status, die Blobs hinter ollama create, Abmelden), der Katalog empfohlener Modelle (/api/experimental/model-recommendations), die Details eines Modells im OpenAI-Stil (/v1/models/ plus Name), /v1/responses/compact, /v1/systemone, 3 Audio-Routen unter /v1/audio/ und eine Weiterleitung für die Codex-Desktop-App unter /api/codex/. Welche der 2 APIs nehmen? Die native bündelt die Stellschrauben von Ollama: options (num_ctx, Temperatur), keep_alive und die Zeitangaben. Die unter /v1/ gibt es, damit Code, den Sie schon für OpenAI geschrieben haben, oder ein Werkzeug, das nur OpenAI spricht, ohne weitere Änderung läuft. Beide antworten mit denselben Modellen.

Die OpenAI-kompatible API von Ollama aus Python

Richten Sie den offiziellen OpenAI-Client auf Ihren Rechner und geben Sie ihm einen beliebigen Schlüssel: Der Client verlangt einen, Ollama ignoriert ihn. Die Dokumentation von Ollama schreibt selbst api_key='ollama' mit dem Kommentar „required but ignored“ (Pflicht, aber ignoriert). Das ist der Code, den wir mit dem offiziellen Paket openai 3.46.0 für Python ausgeführt haben, mit qwen3:8b statt unseres Testmodells, übersetzter Frage und ohne unser Limit max_tokens=12:

from openai import OpenAI

client = OpenAI(base_url="http://127.0.0.1:11434/v1", api_key="ollama")

r = client.chat.completions.create(
    model="qwen3:8b",
    messages=[{"role": "user", "content": "Nenne einen Planeten."}],
)
print(r.choices[0].message.content)

Mit unserem Testmodell kam die Antwort nach 0,16 Sekunden, client.models.list() lieferte die auf dem Server vorhandenen Modelle, und mit stream=True kam die Antwort in Stücken. Mit curl geht es genauso: Die Anfrage geht an /v1/chat/completions, mit -H "Content-Type: application/json" und einem Body im OpenAI-Stil. Gegenüber den Servern von OpenAI ändern sich 2 Dinge. Der Modellname ist das Ollama-Tag (qwen3:8b), und /v1/models zeigt, welche Sie haben; ein unbekannter Name bekommt ein 404 mit not_found_error, genau wie es ein OpenAI-Client erwartet. Der Kontext bleibt der von Ollama, gewählt nach Ihrem Grafikspeicher, und die API unter /v1/ nimmt kein num_ctx an: Das stellen Sie auf dem Server mit OLLAMA_CONTEXT_LENGTH ein. Als Zugabe spricht eine Route /v1/messages das Format von Anthropic, und auch sie hat im Test geantwortet.

Öffnet YouTube (ohne Cookies) erst, wenn Sie auf Play drücken. Mehr Videos im Datenblatt →

Etwa in der Mitte dieses Tutorials, ungefähr von Minute 7 bis Minute 11, zeigt Tim die HTTP-API im Einsatz: ollama serve auf Port 11434, ein Python-Skript mit requests, das /api/chat aufruft und die Antwort ausgibt, während sie hereinkommt, und danach das Paket ollama für Python, das den HTTP-Teil versteckt. Das Video ist auf Englisch; der Rest behandelt Installation, Kommandozeile und Modelfiles.

Welche Ollama-Endpunkte ollama.com anrufen, und wie OLLAMA_NO_CLOUD sie stoppt

Eine lokale API, die nach draußen telefoniert, verdient einen eigenen Abschnitt. In der v0.40.15 gibt es 2 Arten. Manche Routen gehen immer zu ollama.com: /api/balance und /api/usage leiten an https://ollama.com:443 weiter, verwerfen den Authorization-Header des Aufrufers und signieren die Anfrage mit dem Schlüssel Ihres Rechners (~/.ollama/id_ed25519); die experimentelle Websuche und der Seitenabruf tun dasselbe für Werkzeuge. Die anderen gehen nur hinaus, wenn der Modellname auf :cloud oder -cloud endet (zum Beispiel gpt-oss:120b-cloud): Dann landet die Anfrage auf derselben Route bei ollama.com statt auf Ihrer Grafikkarte. Das betrifft die 6 Inferenz-Routen unter /v1/ (chat/completions, completions, embeddings, responses, messages und systemone) und /v1/models/ mit einem Modellnamen dahinter, in der nativen API außerdem /api/chat, /api/generate, /api/embed (samt älterer Form) und /api/show.

Geprüft haben wir das im Container ohne Netzwerk. Ohne jede Einstellung kamen /api/balance, /api/usage und 2 Chats mit Cloud-Modellen (gpt-oss:20b-cloud über /v1/chat/completions, gpt-oss:120b-cloud über /api/chat) mit einem 502 zurück, und die Fehlermeldung nennt die Adresse, die sie erreichen wollten: https://ollama.com:443 plus dieselbe Route. Beim Start versuchte der Server zudem 2 eigene Aufrufe: den Katalog empfohlener Modelle und eine Liste der Cloud-Modelle. Mit OLLAMA_NO_CLOUD=1 bekamen dieselben 4 Anfragen ein 403, ohne es überhaupt zu versuchen („ollama cloud is disabled: balance is unavailable“, „… remote model is unavailable“), das Log meldete Ollama cloud disabled: true, und die 2 Aufrufe beim Start blieben aus. Nicht erfasst wird /api/me, die Kontoabfrage, die die Desktop-App beim Öffnen stellt.

Apple-Chip M4
Apple-M4-Chip. Auf dem Mac startet die Ollama-App den Server auf 127.0.0.1:11434 von selbst, und die API steht dann jedem Programm auf dem Rechner offen Bild: Apple

OLLAMA_HOST, OLLAMA_ORIGINS und keep_alive

OLLAMA_HOST legt fest, wo der Server lauscht (Standard 127.0.0.1:11434, envconfig/config.go). OLLAMA_HOST=127.0.0.1:11435 verlegt ihn auf einen anderen Port; OLLAMA_HOST=0.0.0.0:11434 öffnet ihn für alle Netzwerkschnittstellen, weiterhin ohne Passwort, und dann prüft der Server auch den Host-Header nicht mehr. Solange er auf 127.0.0.1 lauscht, weist diese Prüfung unbekannte Namen ab: Unsere Anfrage mit einem erfundenen Host (atacante.example) bekam ein 403, dieselbe mit localhost:11434 ein 200. Durch kommen lokale und private Adressen, localhost, der Name des eigenen Rechners und Namen, die auf .localhost, .local oder .internal enden. Auch Client-Programme lesen OLLAMA_HOST; setzen Sie also auf beiden Seiten denselben Wert. In Docker setzt das Image 0.0.0.0, und die Host-Prüfung entfällt: was sich im Container ändert.

OLLAMA_ORIGINS ist CORS, die Liste der Webseiten, die Ihr Browser durchlässt. Ab Werk stehen darauf localhost, 127.0.0.1 und 0.0.0.0 auf jedem Port, dazu app://, file://, tauri:// und die Schemata von VS Code. Im Test kamen http://localhost:3000 und file:// durch; eine fremde Website (im Test https://ejemplo.com), eine chrome-extension:// und der Origin null bekamen ein 403. Ihre Variable ergänzt diese Liste, sie ersetzt sie nicht: OLLAMA_ORIGINS=chrome-extension://* ollama serve lässt Chrome-Erweiterungen herein und behält den Rest. Alle 26 Servervariablen mit ihrem in v0.40.16 gemessenen Standardwert und wo Sie sie auf jedem System setzen, finden Sie in unserem Ratgeber zu den Ollama Environment Variables.

keep_alive bestimmt, wie lange ein Modell nach der Antwort im Speicher bleibt. In der v0.40.15 sind 5 Minuten Standard (KeepAlive() in envconfig/config.go, die Hilfe von Ollama nennt "5m"), und wir haben es beobachtet: eine Antwort um 07:43:05 UTC, und /api/ps zeigte expires_at um 07:48:05. Erlaubt sind eine Dauer ("10m", "1h"), eine Zahl in Sekunden, eine negative Zahl, damit das Modell dauerhaft geladen bleibt, oder 0, um es sofort zu entladen: {"model": "smollm2:135m", "keep_alive": 0} kam mit "done_reason": "unload" zurück, und /api/ps war leer. In der Anfrage schlägt der Wert das OLLAMA_KEEP_ALIVE des Servers, und auch /v1/chat/completions nimmt ihn an, als eigenes Zusatzfeld von Ollama: im OpenAI-Client für Python als extra_body={"keep_alive": "30m"}. Ein großes Modell, das sich alle 5 Minuten entlädt, lässt die nächste Frage warten, bis es wieder geladen ist: Fragt Ihre App alle 10 Minuten, setzen Sie "keep_alive": "30m".

API und Server von LM Studio: Port 1234, Tokens und CORS

LM Studio ist Closed Source, deshalb stammt alles in diesem Abschnitt aus der offiziellen Dokumentation, gelesen am 6. November 2026 für die 0.4.28, an diesem Tag die stabile Version. Der Server startet im Developer-Tab oder mit lms server start und lauscht auf localhost:1234. Zu den Dialekten, die er spricht, gehören OpenAI unter /v1/ (/v1/chat/completions, /v1/responses, /v1/embeddings, /v1/completions, /v1/models), Anthropic unter /v1/messages und eine eigene REST-API unter /api/v1/, die Modelle auch laden, entladen und herunterladen kann. Das Python-Beispiel oben läuft, wenn Sie 2 Dinge ändern: base_url="http://localhost:1234/v1" und den Modellnamen, also die Kennung, die LM Studio anzeigt.

Servereinstellungen von LM Studio mit aktiviertem Require Authentication und ausgeschaltetem Serve on Local Network
Servereinstellungen von LM Studio mit eingeschaltetem Require Authentication und ausgeschaltetem Serve on Local Network: Der Server antwortet nur diesem Rechner, und nur mit Token Bild: LM Studio

Weiter als Ollama geht LM Studio beim Schlüssel. Ab Werk verlangt es keinen, wie Ollama, aber die Servereinstellungen haben den Schalter Require Authentication, und unter Manage Tokens legen Sie Tokens mit eigenen Berechtigungen an; danach trägt jede Anfrage Authorization: Bearer und das Token (der OpenAI-Client schickt seinen api_key in genau diesem Header, also gehört das Token dorthin). CORS ist aus, solange Sie nicht mit --cors starten oder Enable CORS anhaken, und die Adresse bleibt 127.0.0.1, außer mit --bind 0.0.0.0 oder Serve on Local Network, wozu die Dokumentation ein Token empfiehlt. Das Gegenstück zu keep_alive heißt bei LM Studio ttl: Ein Modell, das die API bei Bedarf lädt, wird nach 60 Minuten ohne Nutzung entladen; eines, das mit lms load geladen wurde, bleibt.

Servereinstellungen von LM Studio mit aktiviertem Serve on Local Network, Port 1234
Servereinstellungen von LM Studio mit eingeschaltetem Serve on Local Network, Port 1234: Der Server antwortet auch anderen Rechnern, und genau dafür ist ein Token da Bild: LM Studio

Ollama, LM Studio, llama.cpp, vLLM und MLX: ihre lokalen APIs im Vergleich

llama.cppllama.cppProgramm-Datenblatt vLLMProgramm-Datenblatt MLX (mlx-lm)MLX (mlx-lm)Programm-Datenblatt

Alle 5 sprechen OpenAI unter /v1/, ein Programm für das eine lässt sich also mit anderem Port und Modellnamen auf das andere umstellen. Was sie trennt, ist alles andere. Gelesen im Code der jeweiligen stabilen Version am 6. November 2026 (LM Studio in seiner Dokumentation; Ollama erneut am 10. November 2026 in v0.40.16; llama.cpp erneut am 13. November 2026 in v1.0.0, mit demselben Standard-Port, derselben Standard-Adresse und derselben CORS-Voreinstellung):

Programm (Version) Port Lauscht auf API-Schlüssel CORS ab Werk Eigene Aufrufe
Ollama (v0.40.16) 11434 127.0.0.1 Keiner: Ein mitgeschickter wird ignoriert localhost, 127.0.0.1, 0.0.0.0 und lokale Apps Modellkatalog alle 4 Stunden, eine Liste der Cloud-Modelle beim Start und die Cloud-Routen (außer /api/me), alles abschaltbar mit OLLAMA_NO_CLOUD; die Desktop-App sucht zudem stündlich nach Updates und fragt beim Öffnen Ihr Konto ab, beides lässt sich nicht abschalten
LM Studio (0.4.28) 1234 127.0.0.1 Tokens mit Berechtigungen, ab Werk aus Aus Update-Prüfung und automatische Engine-Updates; keine Telemetrie, laut Hersteller
llama.cpp (v1.0.0) 9931 127.0.0.1 --api-key Jeder Origin Keine
vLLM (0.33.0) 8000 0.0.0.0 --api-key, der nur einen Teil der Routen abdeckt Geschlossen Nutzungsstatistik ab Werk an, alle 10 Minuten
mlx-lm (0.32.2) 8080 127.0.0.1 Keiner Jeder Origin Keine; Modell-Downloads laufen über die Bibliothek von Hugging Face

3 Zeilen verdienen einen zweiten Blick. vLLM lauscht als Einziger ab Werk auf allen Netzwerkschnittstellen: Auf einem Server mit öffentlicher Adresse und ohne Firewall davor steht sein Port 8000 jedem offen, der ihn findet, und seine eigene Sicherheitsseite warnt, dass --api-key nur einige Gruppen von Routen schützt. llama.cpp spiegelt dem Browser jeden Origin zurück, also kann jede Webseite, die Sie besuchen, ohne Schlüssel mit einem llama-server reden; mit --api-key verlangt alles außer /health und der Weboberfläche den Schlüssel. Und mlx-lm öffnet CORS für alle und hat gar keinen Schlüssel, was auf Ihrem eigenen Mac in Ordnung ist und nirgends sonst.

Die eingebaute Weboberfläche des llama.cpp-Servers mit einem neuen Chat und geöffnetem Werkzeugmenü
Die eingebaute Weboberfläche von llama-server, in der v0.9.0 auf demselben Port 9931 wie seine OpenAI-kompatible API Screenshot: ggml-org / llama.cpp

Wenn Ollama noch nicht installiert ist, beginnt unsere Anleitung, Ollama lokal auszuführen, bei null und erklärt den SSH-Tunnel, mit dem Sie es von einem anderen Rechner erreichen, ohne es zu öffnen. Wenn die API antwortet, das Modell aber nicht, hilft Ollama funktioniert nicht, und wenn Antworten abgeschnitten werden, erklärt die Kontextlänge in Ollama das num_ctx. Für die anderen 2 Server: LM Studio lokal und llama.cpp funktioniert nicht.