Inicio›Guías›API de Ollama: endpoints, compatibilidad con OpenAI, claves y keep_alive, probados en la v0.40.15

Instalar · Guía

API de Ollama: endpoints, compatibilidad con OpenAI, claves y keep_alive, probados en la v0.40.15

La API de Ollama escucha en http://127.0.0.1:11434 en cuanto la aplicación o ollama serve están en marcha, sin clave y sin contraseña. Sus rutas propias van bajo /api/ (chat, generación, modelos) y su capa compatible con OpenAI, bajo /v1/: la mayoría de los clientes de OpenAI funcionan cambiando la URL base y el nombre del modelo.

Medido y escrito por Local AI ScopePublicado el Cifras medidas por Local AI Scope

La API de Ollama escucha en http://127.0.0.1:11434 en cuanto la aplicación o ollama serve están en marcha, sin clave y sin contraseña. Sus rutas propias van bajo /api/ (chat, generación, modelos) y su capa compatible con OpenAI, bajo /v1/: la mayoría de los clientes de OpenAI funcionan cambiando la URL base y el nombre del modelo.

No nos quedamos en leer el código. El 6 de noviembre de 2026 arrancamos el binario oficial de Ollama v0.40.15 para Linux dentro de un contenedor sin ninguna red, solo con el procesador y un modelo diminuto de 135 millones de parámetros (smollm2:135m), y lo acribillamos a peticiones: rutas nativas, rutas de OpenAI, una clave inventada, orígenes ajenos y rutas que quieren salir a ollama.com. Después hicimos la misma lectura con LM Studio, llama.cpp, vLLM y MLX, para que sepas qué abre cada API local y a quién.

OllamaOllamaFicha del programa LM StudioLM StudioFicha del programa

Cómo llamar a la API de Ollama: dirección, puerto y primera petición

De fábrica, el servidor escucha en 127.0.0.1, puerto 11434: solo llegan los programas de tu propio ordenador. La comprobación más rápida es curl http://127.0.0.1:11434/api/version, que en nuestra prueba respondió {"version":"0.40.15"}. Un primer chat con la API nativa:

curl http://127.0.0.1:11434/api/chat -d '{
  "model": "qwen3:8b",
  "messages": [{"role": "user", "content": "¿Por qué el cielo es azul?"}],
  "stream": false
}'

Fíjate en el "stream": false. En la API nativa la respuesta llega a trozos salvo que lo apagues: nuestro /api/generate sin ese campo devolvió una línea JSON por trozo, cada una con "done": false. Con él recibes un único JSON con los tiempos en nanosegundos; la respuesta va en message.content en /api/chat, como arriba, y en response en /api/generate. En la prueba, el modelo de 135M cargó en 0,52 segundos y escribió 16 tokens. El modelo tiene que estar descargado antes (ollama pull qwen3:8b); si no lo está, la API contesta con un 404. Desde la terminal, ollama list te dice qué modelos tienes bajados; ese comando y el resto, con su salida real, están en nuestra chuleta de comandos de Ollama.

En el vídeo (en inglés) la petición va a http://localhost:11434/api/generate desde Visual Studio Code, con la extensión REST Client en vez de curl, y con "stream": false para que la respuesta llegue de una vez, el mismo interruptor del que te hablamos arriba.

Se abre en YouTube (sin cookies) solo si pulsas.

Logotipo de Ollama
Logotipo de Ollama. Su v0.40.15, la estable el 6 de noviembre de 2026, sirve 37 rutas en el puerto 11434: 24 bajo /api/, 12 bajo /v1/ y la raíz Logotipo: Ollama

Todos los endpoints de la API de Ollama, nativos y compatibles con OpenAI

Los contamos el 6 de noviembre de 2026 en server/routes.go de la v0.40.15 (líneas 2383 a 2452): 37 rutas, 24 bajo /api/, 12 bajo /v1/ y la raíz /, que solo dice «Ollama is running». Estas son las que vas a usar, y la última columna dice si la petición sale de tu ordenador:

Ruta Para qué sirve ¿Sale de tu ordenador?
/api/chat, /api/generate Chatear con mensajes o completar un único texto Solo con un modelo de la nube
/api/embed Embeddings (/api/embeddings es la forma antigua) Solo con un modelo de la nube
/api/tags, /api/ps, /api/show, /v1/models Modelos descargados, modelos en memoria y detalles de uno No (/api/show, solo con un modelo de la nube)
/api/pull, /api/push, /api/create, /api/copy, /api/delete Gestionar modelos Pull y push hablan con el registro de modelos, y create también cuando parte de un modelo que no tienes
/api/balance, /api/usage, /api/me Tu cuenta de ollama.com Siempre
/api/experimental/web_search, /api/experimental/web_fetch Buscar en la web y leer páginas para las herramientas Siempre
/v1/chat/completions, /v1/completions, /v1/responses, /v1/embeddings Compatibilidad con OpenAI Solo con un modelo de la nube
/v1/messages Compatibilidad con Anthropic Solo con un modelo de la nube

El resto: intendencia (/api/version, /api/status, los blobs que usa ollama create, cerrar sesión), el catálogo de modelos recomendados (/api/experimental/model-recommendations), los detalles de un modelo al estilo de OpenAI (/v1/models/ y su nombre), /v1/responses/compact, /v1/systemone, 3 rutas de audio bajo /v1/audio/ y un paso directo para la aplicación de escritorio de Codex bajo /api/codex/. ¿Cuál de las 2 API usar? La nativa te da los mandos de Ollama en un solo sitio: options (num_ctx, temperatura), keep_alive y los tiempos. La de /v1/ existe para que el código que ya escribiste para OpenAI, o una herramienta que solo habla OpenAI, funcione sin tocar nada más. Ambas responden con los mismos modelos.

La API compatible con OpenAI de Ollama, desde Python

Apunta el cliente oficial de OpenAI a tu máquina y dale una clave cualquiera: él la exige, Ollama la ignora. La propia documentación de Ollama escribe api_key='ollama' con el comentario «required but ignored» (obligatoria pero ignorada). Este es el código que ejecutamos con el paquete oficial openai 3.46.0 para Python, con qwen3:8b en lugar de nuestro modelo de prueba, la pregunta traducida y sin nuestro tope 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": "Dime un planeta."}],
)
print(r.choices[0].message.content)

Con nuestro modelo de prueba respondió en 0,16 segundos, client.models.list() devolvió los modelos descargados en el servidor y stream=True mandó la respuesta a trozos. Con curl es igual: la petición va a /v1/chat/completions con -H "Content-Type: application/json" y un cuerpo al estilo de OpenAI. Frente a los servidores de OpenAI cambian 2 cosas. El nombre del modelo es la etiqueta de Ollama (qwen3:8b), y /v1/models te dice cuáles tienes; un nombre desconocido recibe un 404 con not_found_error, tal y como lo espera un cliente de OpenAI. El contexto sigue siendo el de Ollama, elegido según tu memoria gráfica, y la API /v1/ no admite num_ctx: se fija en el servidor con OLLAMA_CONTEXT_LENGTH. Y de regalo, una ruta /v1/messages habla el formato de Anthropic, y también respondió en la prueba.

Se abre en YouTube (sin cookies) solo si pulsas. Más vídeos en su ficha →

En mitad de este tutorial, más o menos del minuto 7 al 11, Tim enseña la API HTTP en marcha: ollama serve en el puerto 11434, un script de Python con requests que llama a /api/chat e imprime la respuesta según llega, y después el paquete ollama para Python, que esconde la parte HTTP. El resto del vídeo va de la instalación, la línea de comandos y los Modelfile. Está en inglés.

Qué endpoints de Ollama llaman a ollama.com, y cómo los corta OLLAMA_NO_CLOUD

Una API local que llama fuera merece su propio apartado. En la v0.40.15 hay 2 tipos. Unas rutas van siempre a ollama.com: /api/balance y /api/usage reenvían a https://ollama.com:443, tiran la cabecera Authorization de quien llama y firman la petición con la clave de tu ordenador (~/.ollama/id_ed25519), y la búsqueda y la lectura de páginas experimentales hacen lo mismo para las herramientas. Las otras solo salen cuando el nombre del modelo acaba en :cloud o -cloud (gpt-oss:120b-cloud, por ejemplo): la petición va a la misma ruta de ollama.com en vez de a tu tarjeta gráfica. Les pasa a las 6 rutas de inferencia de /v1/ (chat/completions, completions, embeddings, responses, messages y systemone) y a /v1/models/ seguida del nombre de un modelo, y en la API nativa a /api/chat, /api/generate, /api/embed (con su forma antigua) y /api/show.

Lo comprobamos en el contenedor sin red. Sin tocar nada, /api/balance, /api/usage y 2 chats con modelos de la nube (gpt-oss:20b-cloud por /v1/chat/completions y gpt-oss:120b-cloud por /api/chat) volvieron con un 502 y un error que muestra la dirección a la que intentaban llegar: https://ollama.com:443 y la misma ruta. Al arrancar, el servidor intentó además 2 llamadas suyas: el catálogo de modelos recomendados y una lista de modelos de la nube. Con OLLAMA_NO_CLOUD=1, las mismas 4 peticiones recibieron un 403 sin intentarlo siquiera («ollama cloud is disabled: balance is unavailable», «… remote model is unavailable»), el registro imprimió Ollama cloud disabled: true y las 2 llamadas del arranque desaparecieron. La que no corta es /api/me, la consulta de cuenta que hace la aplicación de escritorio al abrirse.

Chip M4 de Apple
Chip Apple M4. En un Mac, la aplicación de Ollama arranca sola el servidor en 127.0.0.1:11434, y la API queda ahí para cualquier programa del ordenador Imagen: Apple

OLLAMA_HOST, OLLAMA_ORIGINS y keep_alive

OLLAMA_HOST fija dónde escucha el servidor (por defecto 127.0.0.1:11434, envconfig/config.go). OLLAMA_HOST=127.0.0.1:11435 lo pasa a otro puerto; OLLAMA_HOST=0.0.0.0:11434 lo abre a todas las interfaces de red, tampoco con contraseña, y entonces el servidor deja además de comprobar la cabecera Host. Mientras escucha en 127.0.0.1, esa comprobación echa a los nombres que no conoce: nuestra petición con Host: atacante.example recibió un 403 y la misma con localhost:11434, un 200. Acepta direcciones locales y privadas, localhost, el nombre del propio ordenador y los nombres terminados en .localhost, .local o .internal. Los programas cliente también leen OLLAMA_HOST, así que pon el mismo valor en los dos lados. Dentro de Docker la imagen pone 0.0.0.0 y la comprobación de Host se apaga: qué cambia en un contenedor.

OLLAMA_ORIGINS es el CORS, la lista de páginas web a las que tu navegador deja pasar. De serie incluye localhost, 127.0.0.1 y 0.0.0.0 en cualquier puerto, más app://, file://, tauri:// y los esquemas de VS Code. En la prueba pasaron http://localhost:3000 y file://; https://ejemplo.com, una chrome-extension:// y el origen null recibieron un 403. Tu variable se suma a esa lista, no la sustituye: OLLAMA_ORIGINS=chrome-extension://* ollama serve deja entrar a las extensiones de Chrome y conserva lo demás. Las 26 variables del servidor, con su valor por defecto medido en la v0.40.16 y dónde ponerlas en cada sistema, están en nuestra guía de variables de entorno de Ollama.

keep_alive decide cuánto tiempo se queda un modelo en memoria después de responder. En la v0.40.15, por defecto, 5 minutos (KeepAlive() en envconfig/config.go; la propia ayuda de Ollama dice "5m"), y lo vimos pasar: una respuesta a las 07:43:05 UTC y /api/ps con expires_at a las 07:48:05. Admite una duración ("10m", "1h"), un número de segundos, un número negativo para dejarlo cargado para siempre o 0 para descargarlo en el acto: {"model": "smollm2:135m", "keep_alive": 0} volvió con "done_reason": "unload" y /api/ps se quedó vacío. En la petición manda sobre el OLLAMA_KEEP_ALIVE del servidor, y /v1/chat/completions también lo acepta, como campo extra propio de Ollama: en el cliente de OpenAI para Python, extra_body={"keep_alive": "30m"}. Un modelo grande que se descarga cada 5 minutos hace esperar a la siguiente pregunta mientras vuelve a cargar: si tu aplicación pregunta una vez cada 10 minutos, pide "keep_alive": "30m" y ahórrale el viaje.

La API y el servidor de LM Studio: puerto 1234, tokens y CORS

LM Studio es de código cerrado, así que todo este apartado sale de su documentación oficial, leída el 6 de noviembre de 2026 para la 0.4.28, la estable ese día. El servidor se arranca desde la pestaña Developer o con lms server start, y escucha en localhost:1234. Entre los dialectos que habla: el de OpenAI bajo /v1/ (/v1/chat/completions, /v1/responses, /v1/embeddings, /v1/completions, /v1/models), el de Anthropic en /v1/messages y su propia API REST bajo /api/v1/, que además carga, descarga de memoria y baja modelos. El Python de arriba funciona cambiando 2 cosas: base_url="http://localhost:1234/v1" y el nombre del modelo, el identificador que enseña LM Studio.

Ajustes del servidor de LM Studio con Require Authentication activado y Serve on Local Network apagado
Ajustes del servidor de LM Studio con Require Authentication encendido y Serve on Local Network apagado: el servidor solo atiende a este ordenador, y solo con token Imagen: LM Studio

Donde va más allá que Ollama es en la clave. De fábrica no pide ninguna, igual que Ollama, pero los ajustes del servidor tienen el interruptor Require Authentication, y en Manage Tokens creas tokens con sus propios permisos; a partir de ahí cada petición lleva Authorization: Bearer y el token (el cliente de OpenAI manda su api_key en esa misma cabecera, así que el token va ahí). El CORS está apagado salvo que lo arranques con --cors o marques Enable CORS, y la dirección es 127.0.0.1 salvo que uses --bind 0.0.0.0 o Serve on Local Network, que su documentación recomienda acompañar de un token. El equivalente de keep_alive en LM Studio es ttl: un modelo que la API carga bajo demanda se descarga tras 60 minutos sin uso, y uno cargado con lms load se queda.

Ajustes del servidor de LM Studio con Serve on Local Network activado, puerto 1234
Ajustes del servidor de LM Studio con Serve on Local Network encendido, puerto 1234: el servidor atiende también a otros ordenadores, y ahí es donde el token se gana el sueldo Imagen: LM Studio

Ollama, LM Studio, llama.cpp, vLLM y MLX: sus API locales, cara a cara

llama.cppllama.cppFicha del programa vLLMFicha del programa MLX (mlx-lm)MLX (mlx-lm)Ficha del programa

Los 5 hablan OpenAI bajo /v1/, así que un programa escrito para uno se apunta a otro cambiando el puerto y el nombre del modelo. Lo que los separa es todo lo demás. Leído en el código de cada versión estable el 6 de noviembre de 2026 (LM Studio, en su documentación; Ollama, otra vez el 10 de noviembre de 2026 en la v0.40.16; llama.cpp, otra vez el 13 de noviembre de 2026 en la v1.0.0, con el mismo puerto, la misma dirección y el mismo CORS por defecto):

Programa (versión) Puerto Escucha en Clave de API CORS de fábrica Llamadas propias
Ollama (v0.40.16) 11434 127.0.0.1 Ninguna: la que mandes se ignora localhost, 127.0.0.1, 0.0.0.0 y aplicaciones locales Catálogo de modelos cada 4 horas, una lista de modelos de la nube al arrancar y las rutas de la nube (salvo /api/me), todo se corta con OLLAMA_NO_CLOUD; la aplicación de escritorio busca además actualizaciones cada hora y consulta tu cuenta al abrirse, y ninguna de las 2 cosas se puede apagar
LM Studio (0.4.28) 1234 127.0.0.1 Tokens con permisos, apagados de serie Apagado Comprobación de actualizaciones y actualización automática de motores; sin telemetría, según su fabricante
llama.cpp (v1.0.0) 9931 127.0.0.1 --api-key Cualquier origen Ninguna
vLLM (0.33.0) 8000 0.0.0.0 --api-key, que solo cubre parte de las rutas Cerrado Estadísticas de uso encendidas de serie, cada 10 minutos
mlx-lm (0.32.2) 8080 127.0.0.1 Ninguna Cualquier origen Ninguna; las descargas de modelos pasan por la librería de Hugging Face

3 filas merecen una segunda mirada. vLLM es el único que escucha de fábrica en todas las interfaces de red: en un servidor con dirección pública y sin cortafuegos delante, su puerto 8000 queda abierto para quien lo encuentre, y su propia página de seguridad avisa de que --api-key solo protege algunos grupos de rutas. llama.cpp le devuelve al navegador cualquier origen, así que cualquier página web que visites puede hablar con un llama-server sin clave; con --api-key, todo menos /health y su interfaz web la pide. Y mlx-lm abre el CORS a todo el mundo y no tiene clave alguna, lo que en tu propio Mac va bien y en ningún otro sitio.

La interfaz web integrada del servidor de llama.cpp, con un chat nuevo y el menú de herramientas abierto
La interfaz web integrada de llama-server, que en la v0.9.0 se sirve en el mismo puerto 9931 que su API compatible con OpenAI Captura: ggml-org / llama.cpp

Si aún no tienes Ollama instalado, nuestra guía para usar Ollama en local empieza desde cero y explica el túnel SSH para llegar a él desde otro ordenador sin abrirlo. Si la API responde pero el modelo no, en Ollama no funciona tienes los arreglos, y si las respuestas se quedan cortas, la longitud de contexto en Ollama explica num_ctx. Para los otros 2 servidores: LM Studio en local y llama.cpp no funciona.