Ollama has no built-in authentication layer, and its default bind address keeps the API on localhost. The moment you publish port 11434 or set OLLAMA_HOST to a routable address, every machine that can route to that port can list your models, run prompts on your hardware, and pull or push model files. The safe order of operations is: confirm what is actually listening, keep the bind local, put an authenticating proxy or a private network in front of it, then verify from a second machine that the unauthenticated path is rejected.
This guide is written for practitioners who already run Ollama locally and now want to reach it from a laptop, a teammate’s machine, or another service. It assumes a Linux host or a container-based deployment and basic command-line familiarity. The configuration snippets below are templates to adapt, not deployments that were tested for this article.
What “exposing” Ollama actually means
Elastic’s detection documentation states the problem plainly: Ollama binds to localhost:11434 by default but can be exposed through the OLLAMA_HOST environment variable, and because it lacks authentication, an exposed instance allows unauthenticated model theft, prompt injection, and resource hijacking. Elastic ships a rule named “Ollama API Accessed from External Network” that fires when the server accepts connections from external IP addresses. It is rated medium severity with a risk score of 47, runs every five minutes, searches the previous nine minutes of logs-endpoint.events.network-* data, and allows a maximum of 100 alerts per execution.
That framing matters because “exposing” is not one action. It can be any of the following, and each one has a different failure mode:
- Setting
OLLAMA_HOST=0.0.0.0:11434so the service listens on every interface. - Publishing the port from a container, for example mapping
11434:11434instead of127.0.0.1:11434:11434. - Placing a reverse proxy, load balancer, or tunnel in front of a localhost-bound service.
- Allowing the port through a host firewall to a broader subnet.
Only the last of those is a network control. The first three change the application’s own reachability, which is why they need to be paired with an authentication layer rather than a firewall rule alone.
Choose an exposure pattern before you change any configuration
Decide who should be able to reach the API, then pick the pattern that matches. The table below is an architectural decision aid, not a comparison of measured performance.
| Pattern | Who can reach the API | What you still have to add |
|---|---|---|
| Localhost only | Processes on the same host | Host hardening and file permissions on the model directory |
| Private overlay network (WireGuard, Tailscale, and similar) | Devices you have enrolled | Device authentication and access rules on the overlay |
| Authenticating reverse proxy on a trusted network | Clients holding a valid token | TLS, token validation, rate and size limits |
| Public tunnel or public reverse proxy | Anyone who learns the URL, unless a policy blocks them | Explicit authentication policy, plus header handling so Ollama accepts the request |
The public-tunnel case is the one most often rushed. ngrok’s own documentation for Ollama warns that putting your entire Ollama API on the public internet might expose your LLM to abuse, and recommends using a Traffic Policy to add a layer of authentication that restricts access to yourself or trusted colleagues. The documented policy example also rewrites the Host header to localhost so that Ollama accepts the requests — a detail that applies to any proxy that changes the Host header, not just ngrok.
Step 1: Confirm what is actually listening
Before changing anything, establish the current state. Run these on the host that runs Ollama:
ss -tlnp | grep 11434
# or, on systems without ss:
lsof -i :11434
echo "OLLAMA_HOST=$OLLAMA_HOST"
docker ps --format '{{.Names}}t{{.Ports}}' | grep 11434Read the local address column carefully. 127.0.0.1:11434 means the service is reachable only from the host itself. 0.0.0.0:11434 or [::]:11434 means it is listening on every interface, and the only remaining barrier is whatever firewall or routing sits in front of it. If the process is in a container, the published port in docker ps tells you whether the mapping is bound to loopback or to all interfaces.
If the service is already bound to 0.0.0.0 and you did not intend that, treat it as an incident rather than a configuration task. Elastic’s investigation guidance for this scenario starts by checking the OLLAMA_HOST environment variable to determine whether external exposure was intentional, then reviewing source IP addresses, Ollama logs for calls to /api/pull, /api/push, or /api/generate, and the contents of ~/.ollama/models/ for unexpected downloads that may indicate model poisoning.
Step 2: Keep the bind local
The default is your friend. Leave Ollama bound to 127.0.0.1:11434 and let a proxy or overlay network handle the outside world. If you have set OLLAMA_HOST to a wide address, revert it and restart the service before adding anything else.
One caveat: a proxy running in a different container from Ollama cannot reach 127.0.0.1 on the Ollama container. In that case, put both on a private Docker network and bind Ollama to its container interface, then make sure the container port is not published to the host at all. The goal is that the only route in is through the component that authenticates.
Step 3: Put an authenticating proxy in front
Since Ollama itself will not check credentials, something in front of it must. An nginx template that validates a bearer token and forwards to the local service looks like this:
# http context
map $http_authorization $ollama_authorized {
default 0;
"Bearer REPLACE_WITH_A_LONG_RANDOM_TOKEN" 1;
}
server {
listen 443 ssl;
server_name ollama.example.internal;
ssl_certificate /etc/ssl/certs/ollama.crt;
ssl_certificate_key /etc/ssl/private/ollama.key;
client_max_body_size 10m;
location / {
if ($ollama_authorized = 0) {
return 401;
}
proxy_pass http://127.0.0.1:11434;
proxy_set_header Host localhost;
proxy_buffering off;
proxy_read_timeout 600s;
}
}Three lines carry most of the weight. The map block rejects anything without the expected header. proxy_set_header Host localhost; mirrors the header rewrite that ngrok documents, because a proxy that forwards an unfamiliar Host value may cause Ollama to refuse the request. proxy_buffering off; keeps streaming responses flowing instead of being held until the response completes.
Caddy, Traefik, and most API gateways can express the same idea with a header matcher or a middleware. Whichever you choose, generate the token with a cryptographic random source, store it outside the repository, and plan to rotate it — a shared secret pasted into a chat message is not a durable control.
Step 4: Encrypt the transport or avoid the public internet entirely
A bearer token sent over plain HTTP is readable by anything on the path. Terminate TLS at the proxy, or skip the public path altogether and use a private overlay network or an SSH tunnel. ngrok’s documented setup produces an HTTPS endpoint on a reserved domain, which covers transport encryption but does not by itself restrict who may call the API.
If your clients are a handful of machines you control, a private overlay is usually less work than a public endpoint plus authentication plus monitoring. If your clients are third-party services that cannot join an overlay, the proxy route is the practical choice.
Step 5: Limit what an authenticated client can do
Authentication answers “who” but not “how much.” Add the following while you are already editing the proxy configuration:
- Rate limiting. Without it, one authenticated client can saturate the GPU and make the service unusable for everyone else — the resource-hijacking risk Elastic describes.
- Request size and timeout limits. Cap the request body and set read timeouts appropriate to your longest generation.
- Endpoint scoping. Elastic’s investigation guide names
/api/pulland/api/pushas endpoints worth reviewing in logs. If your remote clients only need inference, consider blocking model management routes at the proxy. - Origin allowlisting. Ollama’s browser-origin setting,
OLLAMA_ORIGINS, controls which web pages may call the API directly. Keep it narrow; a wildcard turns any page a user visits into a potential client. - Filesystem permissions. Restrict access to the model directory so that a compromised process on the same host cannot read or replace weights.
Step 6: Verify from outside before you trust it
Two checks catch most mistakes. First, from a second machine, confirm the unauthenticated path is refused:
curl -sS -o /dev/null -w '%{http_code}n' https://ollama.example.internal/api/tags
# expect: 401Second, confirm the direct port is not reachable at all:
nc -vz ollama-host 11434
# expect: connection refused or timeoutThen confirm the authenticated path works. The ngrok documentation demonstrates a request to the OpenAI-compatible chat endpoint, which is a useful smoke test against any proxy:
curl https://$NGROK_DOMAIN/v1/chat/completions
-H "Content-Type: application/json"
-H "Authorization: Bearer REPLACE_WITH_A_LONG_RANDOM_TOKEN"
-d '{"model":"$MODEL","messages":[{"role":"user","content":"ping"}]}'If the unauthenticated request returns 200, stop and fix the proxy before doing anything else. If the authenticated request hangs, check proxy buffering and read timeouts before assuming the model is at fault.
Monitoring: assume the control will be bypassed eventually
Detection is part of the configuration, not an afterthought. Elastic’s rule exists precisely because exposed Ollama instances are being probed in the wild; the rule’s reference list points to GreyNoise reporting on threat actors actively targeting LLMs and to MITRE ATLAS techniques AML.T0040 and AML.T0044. If you run endpoint or network telemetry, enable an equivalent rule or write a simple alert on accepted connections to port 11434 from outside your expected client set.
When an alert fires, the investigation order that Elastic recommends is worth following as written: check OLLAMA_HOST for unintended exposure, identify the source IP, review logs for /api/pull, /api/push, and /api/generate, inspect the model directory for unexpected downloads, look for outbound traffic that could be exfiltration, and check for child processes spawned by Ollama.
Limitations and common mistakes
A firewall rule is not authentication. It reduces the set of hosts that can reach the port, but every host inside the allowed range still has full, unauthenticated access to your models and your GPU. On a flat office or home network, that range is often larger than people assume.
A reverse proxy adds a hop and a new configuration surface. Streaming responses, long generations, and large model pulls all interact with buffering and timeout defaults, so test the paths your clients actually use rather than only a short health check.
Finally, a public tunnel URL is not a secret. Reserving a static domain makes the address memorable and, if it leaks, permanently discoverable. The authentication policy is what protects it — not the obscurity of the hostname.
Next step
Pick the exposure pattern that matches your clients, apply the bind and proxy changes, and run the two verification commands from a second machine. If you are unsure which pattern fits, start with localhost-only and an SSH tunnel: it costs the least to set up and is the easiest to reason about. Readers who hit an unexpected result — a 200 where a 401 was expected, a hanging stream, or a proxy that Ollama refuses — are welcome to share their environment, the exact command, and the response in the community so others can compare configurations.
FAQ
Does Ollama have built-in authentication?
No. Elastic's detection documentation states that Ollama lacks built-in authentication, which is why an exposed instance allows unauthenticated model theft, prompt injection, and resource hijacking. Any authentication has to be added in front of the service.
Is a firewall rule enough to secure port 11434?
No. A firewall narrows which hosts can reach the port, but every host inside the allowed range still gets full, unauthenticated access. Use a firewall as one layer alongside an authenticating proxy or a private overlay network.
Can ngrok be used to expose Ollama safely?
ngrok's documentation warns that putting your entire Ollama API on the public internet might expose your LLM to abuse, and recommends a Traffic Policy to add authentication restricting access to trusted people. The documented policy also rewrites the Host header to localhost so Ollama accepts the requests.
What should I check first if I think my Ollama instance is already exposed?
Follow the order in Elastic's investigation guide: check the OLLAMA_HOST environment variable to see whether external exposure was intentional, review the source IP addresses connecting, examine Ollama logs for /api/pull, /api/push, and /api/generate calls, and inspect ~/.ollama/models/ for unexpected downloads.