What Is Open WebUI and How Do You Self-Host It?

Open WebUI is a self-hosted web interface for chatting with large language models. You run it on your own machine or server, point it at one or more model backends (such as Ollama or any OpenAI-compatible API), and use a browser-based chat UI that stays under your control. It fits best when you want a ChatGPT-style interface for local or private models, need to switch between multiple models, or want document upload and user accounts without sending data to a third-party chat service.

What Open WebUI actually is

Open WebUI is the front end, not the model. It does not include an LLM by itself. Instead, it connects to a backend that serves models, and it gives you a richer interface than a raw API or a bare Ollama endpoint.

That distinction matters because it explains most setup problems. If Open WebUI loads but no models appear, the issue is almost always the backend connection, not the UI.

Layer	What it does	Examples
Interface	Chat UI, model picker, accounts, document upload	Open WebUI
Backend	Serves the actual models over an API	Ollama, OpenAI-compatible endpoints
Model	Generates the responses	Llama, Mistral, Qwen, hosted models

Compared with a raw Ollama or OpenAI-compatible API, Open WebUI adds conversation history, a model selector, user management, and file-based context. Compared with a hosted chat product, it keeps the interface and your data on infrastructure you control.

Typical use cases

Local LLM chat: run models through Ollama and talk to them in a browser instead of the terminal.
Multi-model switching: keep several models available and change between them per conversation.
Self-hosted privacy: keep prompts, uploads, and chat history on your own machine or server.
Shared access: create user accounts so more than one person can use the same instance.

How to install and run it

The most common setup is Docker, because it bundles the app and its dependencies. The general flow is: install Docker, run the Open WebUI container, make sure it can reach your model backend, then open it in a browser.

Docker-based setup

Install Docker on the machine that will host the interface.
Have a model backend ready. For local models, that usually means Ollama running and reachable. For hosted models, you need an OpenAI-compatible endpoint and its API key.
Run the Open WebUI container, exposing its web port and pointing it at your backend. The exact image tag, port, and environment variable names are given in the official documentation — use those rather than guessing, since they change between releases.
Open the web UI in your browser at the host and port you exposed.
Create the first account. The first user to sign up typically becomes the administrator, so do this before exposing the instance to others.
Confirm models appear in the model selector. If they do, the backend connection works.

Connecting a backend

Ollama: point Open WebUI at the Ollama service. The key detail is that the address must be reachable from inside the Open WebUI container, which is not always the same as localhost on the host.
OpenAI-compatible endpoints: supply the base URL and API key in the connection settings. Any service that speaks the OpenAI API format can usually be added this way.

Key features

Model management: see available models and choose one per conversation.
RAG / document upload: attach files so the model can use their content as context.
User accounts: separate logins, useful for shared or team instances.
Extensibility: the project describes connecting any model and extending with code.

Common setup pitfalls

No models showing up: the backend is unreachable from the container. Check the address from the container's perspective, not the host's.
Connection refused to Ollama: Ollama may be listening only on the host loopback. It needs to accept connections from the container's network.
Can't reach the UI: the port isn't published, or a firewall blocks it.
First account already taken: someone else claimed the admin account. Reset or recreate the instance before wider exposure.
Uploads not affecting answers: the document pipeline or the selected model may not support the context you expect.

Deciding whether to use it

Choose Open WebUI if you want a self-hosted chat interface over models you already run or access, and you're comfortable with Docker and basic networking. Skip it if you only need a quick terminal chat with one local model, or if you don't want to maintain a running service. The setup cost is mostly in the backend connection, so budget time for that rather than the UI itself.