Self-hosting a private, ChatGPT-style interface used to mean stitching together half a dozen tools by hand. Open WebUI collapses that into one container. It’s the browser interface that sits on top of Ollama, OpenAI’s API, or any OpenAI-compatible endpoint, and it now carries more than 147,344 stars on GitHub, with v0.12.3 standing as GitHub’s current latest release as of October 16, 2026, a build PyPI now packages at 106.0 MB, following the v0.12.1 update that same October with Azure OpenAI Realtime support and channel apps, and the v0.12.0 release just before it with realtime voice calls, 3D avatars, and multi-factor authentication, on the heels of the v0.11.4 release, GitHub’s 171st tagged release overall, which had shipped that same August with fixes for database migrations and chat-branch persistence, the v0.11.2 patch that landed just ahead of it that same month, and v0.11.1 before both, which landed August 2026 with tool-call approvals and a new ask_user capability, on the heels of the v0.11.0 update that added a large UI redesign and built-in sub-agents back in July 2026, a number that puts it ahead of nearly every other self-hosted AI project. This tutorial walks through a full Open WebUI setup: installing Docker, deploying the container, connecting a model backend, turning on GPU acceleration, locking down user accounts, uploading documents for retrieval-augmented chat, and putting the whole stack behind HTTPS. By the end, you’ll have a working, password-protected AI chat interface running on hardware you control, plus a docker-compose.yml file you can drop onto any server to reproduce the setup in minutes.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Is Open WebUI, and Why Run It Yourself?
Open WebUI began life in 2023 as Ollama WebUI, a small front end built to give Ollama’s command-line model runner an actual browser interface. The project outgrew that name fast. Once it added support for OpenAI’s API and other OpenAI-compatible backends, the maintainers renamed it Open WebUI to match what it had become: a general-purpose, self-hosted interface for talking to almost any large language model, not just the ones running through Ollama. By November 7, 2025, that growth had reached v0.6.36, per a GitHub mirror tracking the project’s release history, setting up the accelerated 2026 release cadence covered later in this tutorial.
The numbers back up how far it’s traveled since then. The project’s GitHub repository, open-webui/open-webui, had climbed to 147,344 stars and more than 21,500 forks by July 2026, spread across 171 tagged releases as of early September 2026 and still climbing, with v0.12.3 now the latest per GitHub as of October 16, 2026, a release PyPI packages as a single 106.0 MB file, up from the v0.11.4 build that had held that title the month before, the v0.11.3 build that shipped in August 2026, the v0.11.2 patch just before it, and the v0.11.0 count a saas.pet review had logged that July. The team’s own site lists over 338 million downloads. That puts it well ahead of other self-hosted AI chat projects, including well-known names like AnythingLLM and LibreChat, both of which sit in the 40,000-to-65,000-star range on GitHub.
What you get for the setup time is a browser-based chat interface that looks and feels close to ChatGPT, except every conversation, every uploaded document, and every model you connect stays on hardware you control. You can point it at a local Ollama installation, at OpenAI’s hosted API, at other providers through compatible endpoints, or at several of these at once, and switch between them from a dropdown mid-conversation. Built-in retrieval-augmented generation lets you upload PDFs, text files, or whole folders and chat against their contents. Role-based access control means you can run it for a household or a small team without everyone sharing one login, and the full features list covers plenty more beyond what this tutorial has room to walk through step by step.
None of that comes free of trade-offs. Open WebUI isn’t licensed under a plain permissive license like MIT or BSD anymore. GitHub’s own license detector flags the repository as “Other” rather than a standard license, because the project ships under its own modified terms that require keeping Open WebUI branding visible in the interface unless you qualify for an exemption or pay for an enterprise license. For personal or internal use, that clause rarely matters. It’s still worth reading before you build a commercial product on top of it.
Prerequisites: Software, Hardware, and Accounts You’ll Need
Before starting, gather these pieces. None of them cost money, though the model backend you choose determines how much hardware you actually need. You’ll want a computer or server running Windows 10/11, macOS 13 or later, or a modern Linux distribution, with Docker installed, since that’s the deployment method this tutorial uses throughout and the one the Open WebUI project itself documents first. Plan on at least 8 GB of RAM if you’re only connecting to a cloud API like OpenAI’s, and considerably more, ideally 16 GB or above, if you plan to run models locally through Ollama on the same machine. A dedicated GPU isn’t required, but it turns local inference from usable into fast, and Step 6 covers wiring one up.
| Component | Minimum | Recommended | Notes |
|---|---|---|---|
| Operating system | Windows 10, macOS 13, any 64-bit Linux | Windows 11, macOS 14+, Ubuntu 24.04 LTS | Docker Desktop covers Windows and Mac, Linux uses Docker Engine directly |
| RAM | 8 GB (API-only use) | 16 GB or more (local models) | A 7B-class local model needs roughly 8 GB free on its own |
| Docker Engine | 24.x | 29.6.1 | Docker Desktop bundles this automatically on Windows and Mac |
| Docker Compose | v2.x | v2.40 or newer | Ships as a plugin with modern Docker installs |
| GPU (optional) | None | NVIDIA GPU with 8 GB+ VRAM | Requires the NVIDIA Container Toolkit for Docker passthrough |
| Python (pip install path only) | 3.11 | 3.11 | Open WebUI’s own docs specify this exact version to avoid dependency conflicts |
| Model backend | None yet | Ollama installed locally, or an API key from an OpenAI-compatible provider | Covered in Step 2 |
| Storage | 10 GB free | 50 GB or more | Local model weights alone can run several gigabytes each |
Budget around 75 minutes for the full walkthrough if you’re following every step, including the reverse proxy and backup sections near the end. You don’t need to create any paid accounts to get through this tutorial. An OpenAI API key is optional and only needed if you want to connect a hosted model alongside, or instead of, a local one in Step 10.
Step 1: Install Docker and Confirm Your System Is Ready
Open WebUI ships as a container, so Docker is the foundation everything else sits on. If you’re on Windows or macOS, download Docker Desktop from Docker’s official site and run through its installer, which handles the underlying virtual machine and networking setup for you. If you’re on Linux, use the official install script instead, since it’s faster than adding the repository by hand.
curl -fsSL https://get.docker.com -o install-docker.sh
sudo sh install-docker.sh
sudo usermod -aG docker $USER
newgrp dockerConfirm the install worked before moving on.
docker --version
docker compose versionBoth commands should return a version number instead of a “command not found” error. If you just added your user to the docker group, log out and back in, or run newgrp docker as shown above, since group membership doesn’t apply retroactively inside a terminal session that was already open when you ran the install script.
Step 2: Choose Your Backend: Ollama, OpenAI API, or Both
Open WebUI is only an interface. It needs something underneath it that actually runs a model, and you have two main options: Ollama for models running locally on your own hardware, or an OpenAI-compatible API for models running on someone else’s servers. Most people end up using both, local models for everyday chat and privacy-sensitive work, a hosted API for the occasional task that needs a frontier-class model their own hardware can’t run.
If you want a local backend, install Ollama first. Our separate walkthrough on how to install Ollama covers that in detail, but the short version on Linux and macOS is a single script.
curl -fsSL https://ollama.com/install.sh | sh
ollama --versionOn Windows, download the installer directly from ollama.com instead of using the script.
If you’d rather skip installing Ollama separately, Open WebUI ships a bundled image that includes Ollama inside the same container, which Step 3 covers as an alternative path. Running them as two separate containers is the more common setup, though, since it lets you update, restart, or swap out either piece without touching the other.
If you’re leaning toward a hosted API instead of, or alongside, a local model, keep your OpenAI API key or other provider credentials on hand. You’ll paste that into Open WebUI’s settings in Step 10, not now, so there’s nothing to configure yet. Just don’t lose the key before you get there.
Step 3: Deploy Open WebUI With Docker
With Docker installed and a backend decided, deploying Open WebUI itself is a single command. As a walkthrough on DeployHQ’s engineering blog puts it, “the simplest path is Docker,” and that holds up here too. The project publishes its image to GitHub Container Registry rather than Docker Hub, under three tags that matter for this tutorial: main for the standalone interface, ollama for the bundled image that includes Ollama, and cuda for GPU-ready builds. If you’re running a home-server platform like Umbrel rather than bare Docker, Umbrel maintains its own packaged build too, currently v0.11.3-patch.1 as of September 2026, which adds storage-management support for umbrelOS 2.0, and if Kubernetes is your deployment target instead, the project’s Helm chart reached v17.0.0 in October 2026, cut straight off a GitHub Actions release. Start with the standalone image if you already installed Ollama in Step 2.
docker run -d
-p 3000:8080
-v open-webui:/app/backend/data
--name open-webui
--restart always
ghcr.io/open-webui/open-webui:mainThis does four things worth understanding rather than just copying. -p 3000:8080 maps container port 8080 to port 3000 on your machine, which is where you’ll browse in a minute. -v open-webui:/app/backend/data creates a named Docker volume and mounts it at the path where Open WebUI stores its database, uploaded files, and settings, so the container can be deleted and recreated without losing anything. --name open-webui gives the container a predictable name for later commands. --restart always brings it back up automatically after a reboot or crash.
If you skipped installing Ollama separately, use the bundled image instead, which runs both processes in one container and adds a second volume for Ollama’s own model storage.
docker run -d
-p 3000:8080
-v open-webui:/app/backend/data
-v ollama:/root/.ollama
--name open-webui
--restart always
ghcr.io/open-webui/open-webui:ollamaEither way, give the container 10 to 20 seconds to finish its first boot, then check that it’s actually running.
docker psYou’re looking for output close to this:
CONTAINER ID IMAGE STATUS PORTS NAMES
a1b2c3d4e5f6 ghcr.io/open-webui/open-webui:main Up 2 minutes 0.0.0.0:3000->8080/tcp open-webuiOpen a browser and go to http://localhost:3000. The first load can take a few extra seconds while the interface finishes initializing its backend, so don’t worry if the page sits blank for a moment before the signup screen appears.
Step 4: Complete First-Run Setup and Create Your Admin Account
The first account created on a fresh Open WebUI install automatically becomes the administrator, with full access to user management, model connections, and every setting covered in the rest of this tutorial. There’s no separate admin invite process. Whoever signs up first owns the instance, which is exactly why Step 7 covers turning off public signups right afterward.
Fill in a name, email, and password on the signup screen. This account lives entirely inside Open WebUI’s own database, stored in the Docker volume from Step 3, and has nothing to do with any email provider or external identity service unless you configure single sign-on later.
Once you’re logged in, you’ll land on an empty chat screen with a model dropdown at the top that’s probably empty too, since you haven’t connected a backend from inside the interface yet. That’s expected. Head to the gear icon, then Admin Panel, then Settings, and confirm you’re looking at a Connections tab with Ollama and OpenAI sections. If you used the bundled ghcr.io/open-webui/open-webui:ollama image from Step 3, Open WebUI should detect the local Ollama instance running inside the same container automatically. If you ran Ollama as a separate container or a native install instead, you’ll point Open WebUI at it manually, which Step 5 walks through.
Step 5: Pull a Model and Send Your First Chat
If Open WebUI didn’t auto-detect your Ollama installation, connect it manually from Admin Panel > Settings > Connections. Set the Ollama API URL based on how you installed it: http://host.docker.internal:11434 on Windows and macOS, or the Docker bridge address, typically http://172.17.0.1:11434, on Linux. The Open WebUI container needs the Docker host’s address rather than localhost to reach a service running outside its own container.
With the connection set, pull a model through Ollama directly.
ollama pull llama3.2Run that from a regular terminal, not inside the Open WebUI container, since it talks to your Ollama installation directly. You should see progress output close to this while it downloads:
pulling manifest
pulling dde5aa3fc5ff... 100% |████████████████| 2.0 GB
pulling 966de95ca8a6... 100% |████████████████| 1.4 KB
verifying sha256 digest
writing manifest
successModel sizes vary widely. A smaller model like llama3.2 downloads in a few minutes on most connections, while larger ones take considerably longer and need proportionally more RAM to run. Back in the browser, refresh the page and open the model dropdown at the top of the chat screen. Your newly pulled model should appear in the list. Select it, type a question, and send it. The first response after selecting a model is often the slowest. Ollama has to load the full model into memory before it generates anything, and later messages in the same conversation respond faster because the model stays loaded.
Step 6: Turn On GPU Acceleration for Faster Inference
CPU-only inference works, but it’s slow, often several seconds per sentence on anything larger than a small model. An NVIDIA GPU changes that considerably, and Open WebUI’s bundled image has a dedicated tag built for it. You’ll need the NVIDIA Container Toolkit installed on the host first, so Docker can pass the GPU through to a container. On Ubuntu, that’s three commands.
sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart dockerConfirm Docker can see the GPU before touching Open WebUI itself.
docker run --rm --gpus all nvidia/cuda:12.4.1-base-ubuntu22.04 nvidia-smiA working setup prints your GPU’s name, driver version, and memory usage in a table. If that command fails, fix it before continuing, since Open WebUI won’t give you a clearer error message if the underlying GPU passthrough is broken. Once it works, deploy the GPU-ready image.
docker run -d
-p 3000:8080
--gpus all
-v open-webui:/app/backend/data
-v ollama:/root/.ollama
--name open-webui
--restart always
ghcr.io/open-webui/open-webui:cudaNote the --gpus all flag and the :cuda tag. You need both together. The flag alone, applied to the main or ollama tag, doesn’t enable GPU inference on its own. If you already have a container running from Step 3, stop and remove it first.
docker stop open-webui && docker rm open-webuiYour data survives this because it lives in the named volume, not inside the container itself.
Step 7: Lock Down Signups and Configure User Roles
Right after creating your admin account in Step 4, before doing anything else, turn off public signups. Every Open WebUI instance ships with open registration by default, and an instance reachable from outside your own network with signups still enabled is effectively a free account creation page for anyone who stumbles across the URL.
Go to Admin Panel > Settings > General and switch Enable Sign Up off. From that point forward, only the admin can create new accounts, from Admin Panel > Users > Add User.
For each user you add, Open WebUI supports three roles. Admin gets full settings access, matching what you have now. User gets chat access with no settings access. Pending covers anyone signed up but not yet approved, only relevant if you temporarily re-enable signups for a controlled window. Assign the lowest role that gets the job done. A household member who just wants to chat with a local model doesn’t need admin access to your model connections and API keys.
If you’re running this for more than yourself, also check Admin Panel > Settings > Users for default permission toggles, which control what a plain user role can do without admin approval, things like whether they can create their own custom models or share chats publicly. The defaults are reasonably conservative, but it’s worth a quick read rather than assuming.
Step 8: Upload Documents and Chat With RAG
Open WebUI’s built-in retrieval-augmented generation feature lets you upload documents and ask questions against their contents, without a separate vector database or any code. This runs entirely inside the same container you already have deployed.
Start a new chat and click the attachment icon near the message box, then upload a PDF, text file, or Markdown document. Open WebUI chunks the document, generates embeddings for each chunk using a local embedding model by default, and stores them in its internal vector store. Once the upload finishes, ask a question about the document’s contents directly in the chat. The model retrieves relevant chunks and answers using them as context, rather than relying purely on what it learned during training.
For anything beyond a handful of files, use Workspace > Knowledge instead of attaching documents one chat at a time. A knowledge base groups documents into a named collection you can reference from any conversation with # followed by the collection’s name, a better fit for something like a folder of product documentation or internal wiki pages you’ll query repeatedly. The v0.9.6 release in June 2026 made this considerably more usable at scale, adding incremental knowledge-base sync and folder organization so collections stay current without re-uploading everything by hand, alongside broader backend integrations like Azure AI Foundry and Valkey, and the v0.10.0 update that followed later that same June layered team folder sharing on top of it. That momentum carried into the dedicated oikb knowledge-base repository, which shipped its own v0.4.0 release on July 17, 2026, per GitHub, refining how synced collections get versioned and organized.
The default local embedding model works fine for general use, but retrieval quality on specialized or technical documents improves if you point Open WebUI at a stronger embeddings API instead. That option lives in Admin Panel > Settings > Documents, alongside chunk size and overlap settings worth tuning if you notice the model missing context that’s clearly present in an uploaded file. If you want to understand the retrieval architecture Open WebUI runs under the hood, our RAG pipeline tutorial covers the same chunk-embed-retrieve pattern in more depth, useful background if you outgrow the built-in store and want a dedicated vector database later.
Step 9: Enable Web Search Inside Chats
By default, a model in Open WebUI knows only what it learned during training plus whatever you’ve uploaded. Turning on web search closes that gap for questions about anything recent.
Go to Admin Panel > Settings > Web Search and toggle it on. You’ll need to pick a search provider and supply credentials for it. Options include hosted services with a free tier, as well as running your own SearXNG instance if you’d rather not send queries to a third party at all. SearXNG is the more private route since it’s self-hosted like everything else in this stack, though it takes an extra container and a bit more setup than pasting in an API key.
Once configured, a web search toggle appears in the message box during any chat. Turn it on for a specific question and the model runs a search, pulls back a handful of results, and cites them in its answer, rather than answering from memory alone. Leave it off for everyday chat, since search adds a few seconds of latency and isn’t needed for most questions.
Step 10: Connect Additional Models via OpenAI-Compatible APIs
Local models cover a lot of ground, but there are times you’ll want a frontier-class hosted model in the same interface, for a harder coding problem, a longer context window, or just a second opinion. Open WebUI connects to OpenAI’s API and to any other provider that exposes an OpenAI-compatible endpoint, which by 2026 covers most major providers in one form or another.
In Admin Panel > Settings > Connections, add a new OpenAI API connection. Paste your API key into the field, and if you’re connecting to a non-OpenAI provider, update the base URL to match that provider’s OpenAI-compatible endpoint instead of leaving it pointed at OpenAI’s default.
OPENAI_API_KEY=sk-your-key-here
OPENAI_API_BASE_URL=https://api.openai.com/v1Save the connection and reopen the model dropdown in a chat window. Models from every connected backend show up in the same list, local Ollama models alongside whichever hosted models you just added, so switching between a free local model and a paid hosted one is a dropdown click rather than a switch to a different app entirely.
Keep an eye on cost if you connect a paid API. Open WebUI doesn’t meter or cap hosted API usage on its own. That’s between you and the provider’s billing dashboard, so a heavy conversation with a hosted model runs up the same bill it would through any other client pointed at the same account.
Step 11: Put Open WebUI Behind a Reverse Proxy With HTTPS
Running Open WebUI on localhost:3000 is fine for testing on one machine, but reaching it from your phone or another computer on the network, let alone the wider internet, needs a domain name and a real TLS certificate. A reverse proxy handles both.
Caddy is the simplest option, since it requests and renews Let’s Encrypt certificates automatically with almost no configuration. Point a DNS A record for a subdomain, something like chat.yourdomain.com, at your server’s IP address first, then install Caddy and write a short Caddyfile.
chat.yourdomain.com {
reverse_proxy localhost:3000
}That’s the entire configuration. Start Caddy and it handles certificate issuance, renewal, and the HTTP-to-HTTPS redirect on its own.
sudo systemctl restart caddyIf you’re already running Nginx for other services, add a server block instead, and make sure to include the WebSocket upgrade headers Open WebUI needs for streaming responses.
server {
listen 443 ssl;
server_name chat.yourdomain.com;
location / {
proxy_pass http://localhost:3000;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_set_header Host $host;
}
}Skip the WebSocket headers and the interface will still load, but responses won’t stream. They’ll arrive all at once when generation finishes instead of token by token, a confusing symptom to debug if you don’t already know to look for it.
Step 12: Back Up Your Data and Set an Update Routine
Everything Open WebUI knows, every account, chat, uploaded document, and setting, lives inside the open-webui Docker volume from Step 3. Back that up on a schedule, not just when you happen to remember.
docker run --rm
-v open-webui:/data
-v $(pwd):/backup
alpine tar czf /backup/open-webui-backup-$(date +%Y%m%d).tar.gz -C /data .That command spins up a throwaway Alpine container, mounts the Open WebUI volume alongside your current directory, and writes a compressed, dated archive of everything inside it. Run it from cron on a schedule that matches how much you’d mind losing. Daily makes sense for anything with real conversation history worth keeping.
Updating is a separate habit from backing up, and skipping it for months at a time is how you end up several breaking changes behind with no clear upgrade path. The project ships fast enough that this adds up quickly: v0.7.0 landed January 9, 2026, with v0.7.2 following close behind that same month, v0.8.0 was tagged February 12, 2026 per NewReleases.io and GitHub, v0.8.6 arrived March 1, 2026 with Open Terminal integration, a companion project that has since advanced on its own release track to v0.13.0 as of September 2026 per GitHub, and v0.8.12 closed out the month on March 27, 2026 with more than 40 new features and 25% faster rendering, according to AIForAutomation.io, a cadence that held for the rest of the year too, with the August 2026 v0.11.1 release alone shipping 7 highlighted features on top of its approvals and ask_user additions, and October 2026 bringing two more jumps in quick succession: v0.12.0 landed with realtime voice calls, 3D avatars, multi-factor authentication, model version history, and a new Thinking slider, and v0.12.1 followed within weeks adding Azure OpenAI Realtime support and channel apps. Pull the latest image and recreate the container to update.
docker pull ghcr.io/open-webui/open-webui:main
docker stop open-webui
docker rm open-webui
docker run -d -p 3000:8080 -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:mainBecause your data lives in the named volume rather than the container, this sequence is safe. The new container mounts the same volume and picks up right where the old one left off. Take a backup with the command above first anyway, immediately before any update, in case a new release changes something you’d rather roll back than live with.
Putting It All Together: A Complete Open WebUI and Ollama Docker Compose Stack
Running two separate docker run commands works, but a docker-compose.yml file is the better way to manage this long-term, since it documents your entire setup in one version-controlled file and brings the whole stack up or down with a single command. Here’s a complete, working stack that combines everything from this tutorial: Open WebUI, a separate Ollama container, and persistent volumes for both.
version: "3.8"
services:
ollama:
image: ollama/ollama:latest
container_name: ollama
restart: always
ports:
- "11434:11434"
volumes:
- ollama-data:/root/.ollama
deploy:
resources:
reservations:
devices:
- driver: nvidia
count: all
capabilities: [gpu]
open-webui:
image: ghcr.io/open-webui/open-webui:main
container_name: open-webui
restart: always
ports:
- "3000:8080"
environment:
- OLLAMA_BASE_URL=http://ollama:11434
- WEBUI_SECRET_KEY=change-this-to-a-random-string
volumes:
- open-webui-data:/app/backend/data
depends_on:
- ollama
volumes:
ollama-data:
open-webui-data:A few details in this file matter more than they look. The two services share a Docker network created automatically by Compose. That’s why OLLAMA_BASE_URL can just say http://ollama:11434 instead of an IP address, using the service name that Compose’s internal DNS resolves on its own. WEBUI_SECRET_KEY should be a long random string you generate once and keep stable, since changing it invalidates every existing login session. The GPU block under ollama is optional. Delete it entirely if you’re running CPU-only, or on a machine without an NVIDIA GPU.
Save that as docker-compose.yml in its own directory, then bring up the whole stack.
docker compose up -dCompose pulls both images if you don’t already have them, creates the two named volumes, and starts both containers with the network and environment variables wired up between them. Check the logs if anything looks off.
docker compose logs -fThis single file is what you’d commit to a private git repository, copy to a new server, or hand to a teammate to reproduce your exact setup, no more juggling separate docker run commands and hoping you remember the flags correctly six months from now.
Open WebUI vs LM Studio vs AnythingLLM vs LibreChat
Open WebUI isn’t the only option for running a private AI chat interface, and it’s worth knowing where it fits before committing real time to the setup in this tutorial.
| Tool | Deployment | License | GitHub Stars | Multi-User | Built-In RAG | Primary Backends |
|---|---|---|---|---|---|---|
| Open WebUI | Self-hosted web app (Docker) | Custom, source-available | 148,000+ | Yes, role-based | Yes | Ollama, OpenAI-compatible APIs |
| LM Studio | Desktop app only | Proprietary, free to use | Closed source | No, single-user | Yes | Local GGUF/MLX models, local OpenAI-compatible server |
| AnythingLLM | Self-hosted or desktop | MIT | 64,000+ | Yes, via workspaces | Yes | Ollama, OpenAI, and other providers |
| LibreChat | Self-hosted web app (Docker) | MIT | 41,000+ | Yes | Yes, via plugins/agents | OpenAI, Anthropic, Azure, and more |
LM Studio is the fastest way to try a model on your own laptop, since it’s a single downloadable app with no containers or terminal commands involved, and our Ollama vs LM Studio vs Jan comparison covers that trade-off in more detail. What it doesn’t do is serve multiple users or run as a background service the way Open WebUI, AnythingLLM, and LibreChat all do.
AnythingLLM comes closest to Open WebUI in scope, and its MIT license is a simpler legal position than Open WebUI’s branded, source-available terms, if that distinction matters for your use case. Open WebUI’s advantage is community size and momentum: more third-party integrations, more active development, and a larger base of documentation and forum answers when something breaks.
LibreChat leans hardest into connecting many hosted providers side by side rather than local-first inference, which makes it a stronger pick if your plan is mostly hosted APIs from the start rather than models running on your own GPU.
5 Common Pitfalls When Self-Hosting Open WebUI
- Leaving signups open after the first account. This is the single most common mistake. An Open WebUI instance reachable from outside your network with signups still enabled lets anyone who finds the URL create an account. Turn it off in Step 7 right after creating your admin login, not sometime later.
- Using localhost as the Ollama URL from inside a container. Open WebUI running inside Docker can’t reach a service on your host machine through localhost, since that resolves to the container itself. Use host.docker.internal on Windows and macOS, or the Docker bridge address on Linux, as covered in Step 5.
- Skipping the WebSocket proxy headers. A reverse proxy without the Upgrade and Connection headers from Step 11 still loads the interface, but responses stop streaming and arrive all at once, a subtle bug that’s easy to miss until someone asks why it feels slower than running it locally.
- Backing up the container instead of the volume. Deleting and recreating the open-webui container is routine during updates. Deleting the open-webui named volume is not, and it takes every account, chat, and uploaded document with it. Back up the volume, as shown in Step 12, not the container.
- Assuming the default embedding model is good enough for technical documents. It works fine for general text, but dense technical or code-heavy documents often retrieve better with a stronger embeddings API swapped in through Admin Panel > Settings > Documents, covered in Step 8.
- Letting WEBUI_SECRET_KEY change on every restart. Regenerating it instead of setting it once as a fixed environment variable logs every user out and can break session handling behind a reverse proxy.
Troubleshooting: 9 Common Open WebUI Problems and Fixes
Most Open WebUI problems trace back to one of a handful of causes. Check this table before assuming something is fundamentally broken.
| Symptom | Likely Cause | Fix |
|---|---|---|
| Blank page or endless loading spinner at localhost:3000 | Container still finishing its first boot | Wait 20-30 seconds after docker run, then refresh |
| Model dropdown is empty | No backend connection configured yet | Check Admin Panel > Settings > Connections and confirm Ollama or OpenAI is reachable |
| “Connection refused” when connecting to Ollama | Wrong base URL for a containerized setup | Use host.docker.internal:11434 (Windows/Mac) or the Docker bridge IP (Linux), not localhost |
| Responses arrive all at once instead of streaming | Reverse proxy missing WebSocket headers | Add the Upgrade and Connection headers from Step 11 |
| “Invalid credentials” right after a fresh install | Browser cached an old session cookie | Clear cookies for the domain, or open the site in a private window |
| Document upload succeeds but answers ignore it | Embedding or chunking failed silently | Check Admin Panel > Settings > Documents, confirm the embedding model is reachable, then re-upload |
| GPU flag set but inference is still slow | –gpus all used without the :cuda image tag | Re-run the container using the ghcr.io/open-webui/open-webui:cuda tag from Step 6 |
| Update breaks a previously working setup | Several versions were skipped at once | Check the GitHub release notes for breaking changes, restore from the Step 12 backup if needed |
| Can’t reach the instance from another device on the network | Firewall blocking port 3000, or bound to localhost only | Confirm the port mapping in docker ps and check the host firewall rules |
If none of these match what you’re seeing, the container’s own logs are the fastest way to narrow it down.
docker logs -f open-webuiMost connection and startup errors print a clear line within the first few seconds after a request comes in, and that line usually points straight at the misconfigured piece rather than leaving you guessing.
Advanced Tips: Pipelines, Functions, and Mobile Access
Once the base setup is solid, a few extensions turn Open WebUI from a chat window into something closer to a small internal platform.
Docker itself has leaned into this space too. Docker Desktop now ships a Model Runner feature that connects directly to Open WebUI, documented on Docker’s own integration page, giving you a third way to serve local models alongside Ollama and raw llama.cpp setups. It’s worth a look if you’re already using Docker Desktop daily and would rather manage models through the same tool you use for everything else.
Pipelines and Functions extend what a model can do beyond plain text generation. A Pipeline runs as a separate service that intercepts messages before or after the model sees them, useful for things like content filtering, custom retrieval logic, or routing certain questions to a different model automatically. A Function is a lighter version of the same idea that runs inside Open WebUI itself rather than as a separate container. Both are written in Python, and the project’s own pipelines repository on GitHub has a working set of examples to start from rather than building one from scratch. The July 2026 v0.11.0 release pushed this further with built-in sub-agents alongside what Open WebUI itself describes as a single, major interface reorganization, following on from v0.10.2 that same month, which GitHub’s release listing records as the project’s last pre-reorganization build for 2026, adding streamed reasoning rendering, folder uploads, a memory toggle, and an admin-configurable choice of speech-to-text format.
For mobile access, Open WebUI is a web app first, so the reverse proxy setup from Step 11 already makes it usable from a phone’s browser. Add it to your home screen and it behaves close enough to a native app for daily use. The project also publishes a separate desktop app, packaged for users who’d rather have a standalone window than a browser tab, now at v0.0.20 following its May 6, 2026 release per GitHub.
If you’re running Open WebUI for more than yourself, single sign-on is worth setting up before you have a dozen manually created accounts to migrate. Open WebUI supports OAuth2 and OIDC providers through environment variables set on the container, which plugs into whatever identity provider your organization already uses instead of maintaining a second, separate set of credentials just for this one tool.
Finally, if you’re running several self-hosted services on the same box, whatever monitors their uptime is worth pointing at Open WebUI too. A simple uptime check against the container’s port on a five-minute interval catches an outage before a user reports the chat window won’t load.
Frequently Asked Questions About Open WebUI
Is Open WebUI free to use?
Yes. It’s free and source-available on GitHub, with no license fee for personal or small-scale internal use. The one restriction worth knowing is the branding clause in its custom license, which requires keeping the Open WebUI name visible in the interface unless you qualify for an exemption or purchase an enterprise license. That mostly matters if you’re building a commercial product on top of it rather than just running it for yourself.
Do I need a GPU to run Open WebUI?
No, not for Open WebUI itself, which is a lightweight web interface. A GPU only matters for the model backend, specifically if you’re running models locally through Ollama. CPU-only inference works but responds noticeably slower, especially on anything larger than a small model. If you’re connecting to a hosted API instead, GPU is irrelevant, since the provider handles inference on its own hardware.
Can I run Open WebUI without Docker?
Yes, using pip. Install the open-webui package with pip install open-webui, then run open-webui serve. The project’s own documentation specifies Python 3.11 for this path to avoid dependency conflicts, and Docker remains the more common, better-tested route for most users.
Is my data private if I self-host Open WebUI?
Your conversations, uploaded documents, and account data stay on whatever server you run the container on, and nothing gets sent to the Open WebUI project itself. Privacy still depends on which model backend you connect, though. A local Ollama model keeps everything on your hardware, while a hosted API connection sends your messages to that provider under their own privacy terms.
What’s the difference between Open WebUI and Ollama?
Ollama runs models. Open WebUI is the browser interface that sits on top of it, or on top of other backends like OpenAI’s API. You can use Ollama entirely from the command line without Open WebUI, and Open WebUI can connect to backends other than Ollama. They’re separate projects that happen to pair well together.
Can multiple people use the same Open WebUI instance?
Yes. Role-based access control, covered in Step 7, supports separate accounts with admin or user roles, each with its own chat history and settings. It’s a genuinely multi-user system, not a single shared login.
How do I move Open WebUI to a new server?
Back up the open-webui Docker volume using the command in Step 12, copy the resulting archive to the new server, restore it into a freshly created volume with the same name, and start the container there. Everything, accounts, chats, and settings, comes with it.
Does Open WebUI work with models other than the ones Ollama supports?
Yes. Anything reachable through an OpenAI-compatible API works, which by 2026 covers most major hosted providers in some form, alongside whatever open-weight models you can run through Ollama, llama.cpp-based servers, or other compatible backends. The dropdown in the chat window doesn’t distinguish where a model actually runs. It just shows every model your configured connections expose.
For more on running and comparing AI models yourself, see our full AI and machine learning coverage.
