The case for running AI locally is straightforward: your files stay on your machine, they never leave your network, no company’s servers see your personal documents or photos, and the model can’t phone home. It’s a genuine privacy upgrade over sending sensitive content to a cloud API.
But “local” doesn’t mean “private” if the local service is listening on a port that anyone on the internet can reach. And in January 2026, security researchers discovered that this is not a hypothetical.
What Researchers Found in January 2026
In a joint investigation, security firms SentinelOne and Censys scanned the internet for exposed AI infrastructure. Among their findings: 175,108 Ollama server instances publicly reachable across 130 countries, the majority with no authentication in front of them.
Ollama is an open-source tool that lets you run large language models locally — models like LLaMA, Mistral, Gemma, and others. It’s popular among developers and privacy-conscious users who want to run AI tools without sending data to OpenAI, Google, or Anthropic.
An Ollama server exposes an HTTP API on port 11434. The API allows any client to:
- Send prompts to the running model
- Load and unload models
- View which models are installed
- Query the server’s capabilities
An exposed Ollama API requires no authentication by default. If your Ollama server is reachable from the internet, anyone who finds it can interact with your local AI as freely as you can.
How Servers End Up Exposed
Ollama’s default configuration binds to 127.0.0.1 — the loopback interface. On this setting, the API is only accessible from the machine itself. A default installation of Ollama is not publicly exposed.
Exposure happens through configuration changes that are common in legitimate use cases:
Docker with network bridging: Running Ollama in a Docker container with default bridge networking can expose the API to the host network. Configuration guides for Ollama in Docker sometimes show settings that bind the API to 0.0.0.0, making it listen on all network interfaces. Users copying these configurations sometimes do so without understanding what the bind address change means for network reachability.
Remote access setups: Many users run Ollama on a home server or NAS and want to access it from other devices on their local network, or while traveling. Setting the bind address to 0.0.0.0 achieves this — but if the server’s port is also forwarded through a router or exposed via a cloud tunnel service (Cloudflare Tunnel, ngrok, Tailscale exit nodes), the API becomes internet-reachable.
Home lab cloud exposure: Privacy-oriented users who self-host applications often expose services via reverse proxies. If Ollama is added to a reverse proxy configuration without requiring authentication, it becomes accessible through the proxy’s public domain.
The 175,108 servers found by researchers weren’t necessarily maliciously misconfigured. Many were likely set up by people who understood they were running a local AI server and wanted convenient access, without fully modeling what “access” looks like from the internet’s perspective.
Why This Matters for Personal Files
The risk isn’t just that someone can run prompts on your AI. The risk is what you’ve been feeding your AI.
A local AI model running on your personal machine is typically used to work with personal content: drafting documents, summarizing files, answering questions about your notes, searching your photo library descriptions, organizing your downloads folder. The whole point is that it can see your personal files.
If your Ollama server is publicly exposed, an attacker who finds it can reconstruct your personal context through the model. They can ask the model to:
- Summarize what it knows about you
- Retrieve cached context from previous sessions (if the model has memory features enabled)
- Process files you present as prompts that contain your personal data
Some Ollama setups also include plugins or tool-use configurations that allow the model to read local files directly. In those configurations, an exposed API is not just access to the model — it’s access to the model’s file system permissions.
Even without direct file access, an attacker with access to your Ollama API can run inference tasks against your model in bulk, consuming your hardware resources, and potentially observing patterns in what you’ve previously fed the model through residual context.
The Specific Configurations That Create Exposure
If you’re running Ollama, the following patterns create a publicly exposed server:
OLLAMA_HOST=0.0.0.0 without a firewall rule: Binding to all interfaces exposes the API on every network interface your machine has — Ethernet, Wi-Fi, and any virtual interfaces. If any of those interfaces are internet-reachable, the API is exposed.
Docker with -p 11434:11434 port mapping: Publishing port 11434 to the host without a binding IP maps the port to the host’s default interface. On many Linux configurations, this bypasses firewall rules managed by ufw or iptables.
Port forwarding on a router: If you’ve port-forwarded 11434 on your home router for external access, the API is reachable from the internet with no authentication.
Reverse proxy without authentication: If you’ve placed Ollama behind nginx, Caddy, or Traefik to access it via a domain name, and haven’t added basic authentication or IP allowlisting to the proxy configuration, the Ollama API is publicly accessible via your domain.
What “No Authentication” Means in Practice
Ollama does not include a built-in authentication mechanism. There is no username and password, no API key requirement, no token-based auth. The assumption in Ollama’s design is that the API is running on your local machine for your use.
When that assumption breaks down — because the server is network-accessible — there is nothing between an external request and the model’s full API.
Contrast this with commercial AI APIs: OpenAI, Anthropic, Google, and others require authenticated requests with API keys. Those keys are the access control mechanism. Ollama has no equivalent.
How to Check If Your Server Is Exposed
If you’re running Ollama and want to verify your exposure status:
Check your bind address: The environment variable OLLAMA_HOST controls where Ollama listens. If it’s set to 0.0.0.0 or any specific IP address other than 127.0.0.1, your API is accessible beyond the loopback interface.
Test from outside your network: From a separate network (a mobile data connection), attempt to reach http://[your-external-IP]:11434. If you get a response, your server is publicly accessible.
Use Shodan or Censys: Both services index internet-accessible ports. Searching for your IP or domain on these services will show what’s reachable from the internet.
Review firewall rules: Check that your system firewall (ufw, iptables, Windows Firewall) has a rule blocking external access to port 11434 even if Ollama is listening on 0.0.0.0.
How to Secure an Ollama Server You Want to Access Remotely
If you legitimately need to access Ollama from outside your home network, the secure pattern is:
Use a VPN or SSH tunnel: Connect to your home network via WireGuard or OpenVPN first, then access Ollama over the private network address. Your Ollama server stays bound to localhost or the local network; the VPN is the authentication and encryption layer.
Use Tailscale or a similar mesh VPN: Tailscale creates a private overlay network between your devices. You can access your home Ollama server from anywhere by connecting to your Tailscale network, without exposing the port to the public internet.
Add authentication to a reverse proxy: If you must expose Ollama through a public reverse proxy, add HTTP basic authentication or client certificate authentication at the proxy layer. Most reverse proxies (nginx, Caddy, Traefik) make this straightforward. This is a fallback if VPN access isn’t practical.
Apply firewall allowlisting: If you have a fixed IP address at your remote access location (an office, for example), you can allowlist that IP in your firewall rules.
None of these require technical skills beyond what setting up Ollama in the first place requires. They do require thinking about the network security question before assuming the default configuration is safe.
The Broader Local AI Security Gap
Ollama is not the only local AI tool with this pattern. Open WebUI, LM Studio’s server mode, AnythingLLM, Jan, and similar tools expose HTTP APIs for the same reasons — convenient developer access and easy integration with other applications. Many of them have the same default-open, no-authentication pattern.
The 175,108 exposed Ollama instances is likely a fraction of the total exposed AI infrastructure across all local tools. The researchers specifically scanned for Ollama; they didn’t enumerate every local AI server on the internet.
The privacy argument for local AI is substantively correct: running models locally eliminates the data exposure that comes with sending your content to cloud providers. But that argument assumes the local server is actually local. A misconfigured server that’s internet-accessible isn’t providing the privacy benefit — it’s just changing who can access your personal content from a well-resourced cloud company to anyone who knows how to run a Shodan search.
What This Means for Your Privacy Posture
If you run local AI tools and haven’t verified your network configuration, doing so is more urgent than most other privacy measures you might be considering.
Updating your browser privacy settings or switching from Gmail to a privacy-focused email provider is a marginal improvement if you’re simultaneously running an unauthenticated AI server accessible to the entire internet — an AI that has context about your personal files, your notes, your documents.
The local AI privacy promise holds when the AI is actually local. Confirming that takes ten minutes and a simple network check. It’s worth doing before the next time you feed a sensitive document to your local model.