L’API d’Ollama écoute sur http://127.0.0.1:11434 dès que l’application ou ollama serve tourne, sans clé ni mot de passe. Ses routes à elle sont sous /api/ (chat, génération, modèles) et sa couche compatible OpenAI sous /v1/ : la plupart des clients OpenAI fonctionnent en changeant l’URL de base et le nom du modèle.
Nous ne nous sommes pas contentés de lire le code. Le 6 novembre 2026, nous avons lancé le binaire officiel d’Ollama v0.40.15 pour Linux dans un conteneur privé de tout réseau, sur le seul processeur, avec un minuscule modèle de 135 millions de paramètres (smollm2:135m), puis nous l’avons bombardé de requêtes : routes natives, routes OpenAI, une clé inventée, des origines étrangères et des routes qui veulent sortir vers ollama.com. Nous avons ensuite fait la même lecture pour LM Studio, llama.cpp, vLLM et MLX, pour que vous sachiez ce que chaque API locale ouvre, et à qui.
OllamaFiche logiciel
LM StudioFiche logiciel
Appeler l’API d’Ollama : adresse, port et première requête
Par défaut, le serveur écoute sur 127.0.0.1, port 11434 : seuls les programmes de votre ordinateur peuvent l’atteindre. Le test le plus rapide est curl http://127.0.0.1:11434/api/version, qui nous a répondu {"version":"0.40.15"}. Un premier échange avec l’API native :
curl http://127.0.0.1:11434/api/chat -d '{
"model": "qwen3:8b",
"messages": [{"role": "user", "content": "Pourquoi le ciel est-il bleu ?"}],
"stream": false
}'
Le "stream": false compte. Dans l’API native, la réponse arrive par morceaux tant que vous ne le coupez pas : notre /api/generate sans ce champ a renvoyé une ligne JSON par morceau, chacune avec "done": false. Avec lui, vous recevez un seul JSON avec les durées en nanosecondes ; la réponse se trouve dans message.content pour /api/chat, comme ci-dessus, et dans response pour /api/generate. Dans notre essai, le modèle de 135M s’est chargé en 0,52 seconde et a écrit 16 tokens. Le modèle doit être téléchargé avant (ollama pull qwen3:8b) ; sinon, l’API répond par un 404. Dans le terminal, ollama list indique les modèles téléchargés ; cette commande et les autres, avec leur sortie réelle, figurent dans notre aide-mémoire des commandes Ollama.
Dans cette vidéo (en anglais), la requête part vers http://localhost:11434/api/generate depuis Visual Studio Code, avec l’extension REST Client au lieu de curl, et avec "stream": false pour que la réponse arrive d’un seul bloc, le même réglage que nous expliquons plus haut.
S’ouvre sur YouTube (sans cookies) seulement si vous appuyez.

Tous les endpoints de l’API d’Ollama, natifs et compatibles OpenAI
Nous les avons comptés le 6 novembre 2026 dans server/routes.go de la v0.40.15 (lignes 2383 à 2452) : 37 routes, 24 sous /api/, 12 sous /v1/ et la racine /, qui se contente de dire « Ollama is running ». Voici celles dont vous vous servirez ; la dernière colonne indique si la requête quitte votre ordinateur :
| Route | À quoi elle sert | Elle sort de votre machine ? |
|---|---|---|
/api/chat, /api/generate |
Dialoguer avec des messages, ou compléter un seul texte | Seulement avec un modèle cloud |
/api/embed |
Embeddings (/api/embeddings en est l’ancienne forme) |
Seulement avec un modèle cloud |
/api/tags, /api/ps, /api/show, /v1/models |
Modèles téléchargés, modèles en mémoire, fiche d’un modèle | Non (/api/show, seulement avec un modèle cloud) |
/api/pull, /api/push, /api/create, /api/copy, /api/delete |
Gérer les modèles | Pull et push parlent au registre de modèles, tout comme create quand il part d’un modèle que vous n’avez pas |
/api/balance, /api/usage, /api/me |
Votre compte ollama.com | Toujours |
/api/experimental/web_search, /api/experimental/web_fetch |
Recherche web et lecture de pages pour les outils | Toujours |
/v1/chat/completions, /v1/completions, /v1/responses, /v1/embeddings |
Compatibilité OpenAI | Seulement avec un modèle cloud |
/v1/messages |
Compatibilité Anthropic | Seulement avec un modèle cloud |
Le reste : l’intendance (/api/version, /api/status, les blobs dont se sert ollama create, la déconnexion), le catalogue des modèles recommandés (/api/experimental/model-recommendations), la fiche d’un modèle à la manière d’OpenAI (/v1/models/ suivi de son nom), /v1/responses/compact, /v1/systemone, 3 routes audio sous /v1/audio/ et un passage direct pour l’application de bureau Codex sous /api/codex/. Laquelle des 2 API choisir ? La native réunit les réglages propres à Ollama : options (num_ctx, température), keep_alive et les durées. Celle de /v1/ existe pour que le code écrit pour OpenAI, ou un outil qui ne parle qu’OpenAI, fonctionne sans rien changer d’autre. L’une et l’autre répondent avec les mêmes modèles.
L’API compatible OpenAI d’Ollama, depuis Python
Pointez le client officiel d’OpenAI vers votre machine et donnez-lui une clé quelconque : lui l’exige, Ollama l’ignore. La documentation d’Ollama écrit d’ailleurs api_key='ollama' avec le commentaire « required but ignored » (obligatoire mais ignorée). Voici le code exécuté avec le paquet officiel openai 3.46.0 pour Python, avec qwen3:8b à la place de notre modèle d’essai, la question traduite et sans notre limite 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": "Cite une planète."}],
)
print(r.choices[0].message.content)
Avec notre modèle d’essai, la réponse est arrivée en 0,16 seconde, client.models.list() a renvoyé les modèles présents sur le serveur et stream=True a livré la réponse par morceaux. En curl, c’est pareil : la requête part vers /v1/chat/completions avec -H "Content-Type: application/json" et un corps à la manière d’OpenAI. Par rapport aux serveurs d’OpenAI, 2 choses changent. Le nom du modèle est l’étiquette d’Ollama (qwen3:8b), et /v1/models vous dit lesquels vous avez ; un nom inconnu reçoit un 404 avec not_found_error, exactement comme l’attend un client OpenAI. Le contexte reste celui d’Ollama, choisi selon votre mémoire graphique, et l’API /v1/ n’accepte pas num_ctx : il se règle côté serveur avec OLLAMA_CONTEXT_LENGTH. En prime, une route /v1/messages parle le format d’Anthropic, et elle a répondu elle aussi.
S’ouvre sur YouTube (sans cookies) seulement si vous appuyez. Plus de vidéos sur sa fiche →
Au milieu de ce tutoriel, environ de la 7e à la 11e minute, Tim montre l’API HTTP en action : ollama serve sur le port 11434, un script Python avec requests qui appelle /api/chat et affiche la réponse au fil de l’eau, puis le paquet ollama pour Python, qui cache la partie HTTP. La vidéo est en anglais ; le reste couvre l’installation, la ligne de commande et les Modelfile.
Quels endpoints d’Ollama appellent ollama.com, et comment OLLAMA_NO_CLOUD les coupe
Une API locale qui appelle l’extérieur mérite sa propre section. Dans la v0.40.15, il y en a 2 sortes. Certaines routes vont toujours vers ollama.com : /api/balance et /api/usage relaient vers https://ollama.com:443, jettent l’en-tête Authorization de l’appelant et signent la requête avec la clé de votre ordinateur (~/.ollama/id_ed25519) ; la recherche et la lecture de pages expérimentales font de même pour les outils. Les autres ne sortent que si le nom du modèle se termine par :cloud ou -cloud (gpt-oss:120b-cloud, par exemple) : la requête part vers la même route d’ollama.com au lieu d’aller à votre carte graphique. C’est le cas des 6 routes d’inférence de /v1/ (chat/completions, completions, embeddings, responses, messages et systemone) et de /v1/models/ suivie d’un nom de modèle, et, côté natif, de /api/chat, /api/generate, /api/embed (et de son ancienne forme) et /api/show.
Nous l’avons vérifié dans le conteneur sans réseau. Sans aucun réglage, /api/balance, /api/usage et 2 chats avec des modèles cloud (gpt-oss:20b-cloud par /v1/chat/completions, gpt-oss:120b-cloud par /api/chat) sont revenus avec un 502 et une erreur qui donne en toutes lettres l’adresse visée : https://ollama.com:443 suivie de la même route. Au démarrage, le serveur a aussi tenté 2 appels de son propre chef : le catalogue des modèles recommandés et une liste de modèles cloud. Avec OLLAMA_NO_CLOUD=1, les 4 mêmes requêtes ont reçu un 403 sans même essayer (« ollama cloud is disabled: balance is unavailable », « … remote model is unavailable »), le journal a affiché Ollama cloud disabled: true et les 2 appels du démarrage ont disparu. Le seul qu’il ne coupe pas est /api/me, la consultation du compte que fait l’application de bureau à l’ouverture.

OLLAMA_HOST, OLLAMA_ORIGINS et keep_alive
OLLAMA_HOST fixe l’adresse d’écoute (par défaut 127.0.0.1:11434, envconfig/config.go). OLLAMA_HOST=127.0.0.1:11435 le déplace sur un autre port ; OLLAMA_HOST=0.0.0.0:11434 l’ouvre à toutes les interfaces réseau, toujours sans mot de passe, et le serveur cesse alors aussi de contrôler l’en-tête Host. Tant qu’il écoute sur 127.0.0.1, ce contrôle refoule les noms qu’il ne connaît pas : notre requête avec un Host inventé (atacante.example) a reçu un 403, la même avec localhost:11434 un 200. Il accepte les adresses locales et privées, localhost, le nom de l’ordinateur et les noms qui finissent par .localhost, .local ou .internal. Les programmes clients lisent eux aussi OLLAMA_HOST : mettez la même valeur des deux côtés. Dans Docker, l’image fixe 0.0.0.0 et le contrôle de l’en-tête Host s’éteint : ce qui change en conteneur.
OLLAMA_ORIGINS, c’est le CORS, la liste des pages web que votre navigateur laisse passer. D’office, elle contient localhost, 127.0.0.1 et 0.0.0.0 sur n’importe quel port, plus app://, file://, tauri:// et les schémas de VS Code. Dans notre essai, http://localhost:3000 et file:// sont passés ; un site sans rapport (https://ejemplo.com dans notre essai), une chrome-extension:// et l’origine null ont reçu un 403. Votre variable s’ajoute à cette liste, elle ne la remplace pas : OLLAMA_ORIGINS=chrome-extension://* ollama serve fait entrer les extensions de Chrome et garde le reste. Les 26 variables du serveur, avec leur valeur par défaut mesurée sur la v0.40.16 et l’endroit où les définir sur chaque système, sont dans notre guide des variables d’environnement d’Ollama.
keep_alive décide combien de temps un modèle reste en mémoire après avoir répondu. Dans la v0.40.15, par défaut, 5 minutes (KeepAlive() dans envconfig/config.go ; l’aide d’Ollama indique "5m"), et nous l’avons vu à l’œuvre : une réponse à 07:43:05 UTC, et /api/ps affichait expires_at à 07:48:05. Il accepte une durée ("10m", "1h"), un nombre de secondes, un nombre négatif pour garder le modèle chargé indéfiniment, ou 0 pour le décharger aussitôt : {"model": "smollm2:135m", "keep_alive": 0} est revenu avec "done_reason": "unload" et /api/ps était vide. Dans la requête, il l’emporte sur le OLLAMA_KEEP_ALIVE du serveur, et /v1/chat/completions l’accepte aussi, comme champ supplémentaire propre à Ollama : dans le client OpenAI pour Python, extra_body={"keep_alive": "30m"}. Un gros modèle qui se décharge toutes les 5 minutes fait patienter la question suivante le temps de se recharger : si votre application interroge le modèle toutes les 10 minutes, demandez "keep_alive": "30m".
L’API et le serveur de LM Studio : port 1234, jetons et CORS
LM Studio est un logiciel fermé : tout ce qui suit vient de sa documentation officielle, lue le 6 novembre 2026 pour la 0.4.28, la version stable ce jour-là. Le serveur se lance depuis l’onglet Developer ou avec lms server start, et écoute sur localhost:1234. Parmi les dialectes qu’il parle : celui d’OpenAI sous /v1/ (/v1/chat/completions, /v1/responses, /v1/embeddings, /v1/completions, /v1/models), celui d’Anthropic sur /v1/messages et sa propre API REST sous /api/v1/, qui sait aussi charger, décharger et télécharger des modèles. Le Python ci-dessus fonctionne en changeant 2 choses : base_url="http://localhost:1234/v1" et le nom du modèle, l’identifiant qu’affiche LM Studio.

Là où il va plus loin qu’Ollama, c’est la clé. Par défaut, il n’en demande aucune, comme Ollama, mais les réglages du serveur ont un interrupteur Require Authentication, et Manage Tokens permet de créer des jetons avec leurs propres permissions ; dès lors, chaque requête porte Authorization: Bearer suivi du jeton (le client OpenAI envoie son api_key dans ce même en-tête : c’est donc là que va le jeton). Le CORS est coupé tant que vous ne lancez pas le serveur avec --cors ou ne cochez pas Enable CORS, et l’adresse reste 127.0.0.1 sauf avec --bind 0.0.0.0 ou Serve on Local Network, que sa documentation conseille d’accompagner d’un jeton. L’équivalent de keep_alive chez LM Studio s’appelle ttl : un modèle chargé à la demande par l’API se décharge après 60 minutes d’inactivité, et un modèle chargé avec lms load reste en place.

Ollama, LM Studio, llama.cpp, vLLM et MLX : leurs API locales côte à côte
llama.cppFiche logiciel
vLLMFiche logiciel
MLX (mlx-lm)Fiche logiciel
Les 5 parlent OpenAI sous /v1/ : un programme écrit pour l’un se branche sur un autre en changeant le port et le nom du modèle. Tout le reste les distingue. Lu dans le code de chaque version stable le 6 novembre 2026 (LM Studio, dans sa documentation ; Ollama, de nouveau le 10 novembre 2026 dans la v0.40.16 ; llama.cpp, de nouveau le 13 novembre 2026 dans la v1.0.0, avec le même port, la même adresse et le même réglage CORS par défaut) :
| Programme (version) | Port | Écoute sur | Clé d’API | CORS par défaut | Appels de son propre chef |
|---|---|---|---|---|---|
| Ollama (v0.40.16) | 11434 | 127.0.0.1 | Aucune : celle que vous envoyez est ignorée | localhost, 127.0.0.1, 0.0.0.0 et applications locales | Catalogue de modèles toutes les 4 heures, liste de modèles cloud au démarrage et routes cloud (sauf /api/me), le tout coupé par OLLAMA_NO_CLOUD ; l’application de bureau cherche aussi des mises à jour toutes les heures et consulte votre compte à l’ouverture, sans moyen de l’en empêcher |
| LM Studio (0.4.28) | 1234 | 127.0.0.1 | Jetons avec permissions, désactivés par défaut | Coupé | Vérification des mises à jour et mise à jour automatique des moteurs ; pas de télémétrie, selon son éditeur |
| llama.cpp (v1.0.0) | 9931 | 127.0.0.1 | --api-key |
Toute origine | Aucun |
| vLLM (0.33.0) | 8000 | 0.0.0.0 | --api-key, qui ne couvre qu’une partie des routes |
Fermé | Statistiques d’usage activées par défaut, toutes les 10 minutes |
| mlx-lm (0.32.2) | 8080 | 127.0.0.1 | Aucune | Toute origine | Aucun ; les téléchargements de modèles passent par la bibliothèque de Hugging Face |
3 lignes méritent un second regard. vLLM est le seul à écouter d’office sur toutes les interfaces réseau : sur un serveur doté d’une adresse publique et sans pare-feu devant, son port 8000 est ouvert à qui le trouve, et sa propre page de sécurité prévient que --api-key ne protège que certains groupes de routes. llama.cpp renvoie au navigateur n’importe quelle origine : la première page web venue peut parler à un llama-server sans clé ; avec --api-key, tout la réclame sauf /health et son interface web. Et mlx-lm ouvre le CORS à tout le monde sans aucune clé, ce qui va très bien sur votre propre Mac et nulle part ailleurs.

Si Ollama n’est pas encore installé, notre guide pour démarrer Ollama en local part de zéro et explique le tunnel SSH qui permet de l’atteindre depuis un autre ordinateur sans l’ouvrir. Si l’API répond mais pas le modèle, Ollama ne fonctionne pas réunit les solutions, et si les réponses tournent court, la longueur de contexte dans Ollama explique num_ctx. Pour les 2 autres serveurs : démarrer LM Studio en local et llama.cpp ne fonctionne pas.