Quick answer: Open WebUI is a free, open-source, self-hosted ChatGPT-style interface for your local models and any OpenAI-compatible API. It auto-discovers Ollama models and adds document RAG, live web search, multi-user accounts, image generation, and a phone-friendly PWA — all running on your own hardware, all private, no fees or quotas. The only catch is a 2025 license clause that restricts rebranding it at scale; normal self-hosting is fully unrestricted.
Running a local model in a terminal is easy. But you want a real chat window — history, a model picker, drag-in PDFs, a search box, and access from your phone without sending tokens to anyone else’s server. Open WebUI is that window: a self-hosted web UI you run on your own machine that wraps your local models and remote APIs alike.
What Is Open WebUI?
Open WebUI is a browser-based front end for LLMs — a Python (FastAPI) backend with a Svelte UI, shipped as one Docker image or a pip package, designed to run entirely offline. It does not run inference itself; it’s the UI and orchestration layer that talks to a model backend over an API. That backend can be:
- Ollama, on the same box or another machine — the original and tightest integration.
- Any OpenAI-compatible endpoint — OpenRouter, Groq, Together, Mistral, local servers like llama.cpp or vLLM, or a unifying proxy like LiteLLM.
That decoupling makes it equally useful as a private front end for local-only models and as a single dashboard over a dozen cloud APIs. Docs live at docs.openwebui.com; source is on GitHub.
Is Open WebUI Free? The License Question
Yes — free and open source, with no paid tiers, token quotas, or telemetry you can’t disable. You can use it commercially. The one asterisk: in 2025 the project moved from MIT to a customized BSD-3-Clause license with an added branding-protection clause. You may not remove or alter the “Open WebUI” name and logo unless:
- Your deployment serves a small number of users (a threshold the license defines), or
- You are a contributor granted permission, or
- You obtain an enterprise license.
For a personal install, home lab, or small team, this never comes up — you run it as-is. It only matters if you intend to white-label Open WebUI at scale. Because terms evolve, read the current LICENSE file rather than any blog post — including this one. For self-hosting, Open WebUI is fully free and unrestricted.
Install in 5 Minutes
Option A: Docker (Recommended)
If Ollama already runs on the same machine, this single command starts Open WebUI and wires it up automatically:
docker run -d \
-p 3000:8080 \
--add-host=host.docker.internal:host-gateway \
-v open-webui:/app/backend/data \
--name open-webui \
--restart always \
ghcr.io/open-webui/open-webui:main
Then open http://localhost:3000. Key flags: -p 3000:8080 maps the container’s internal port 8080 to host port 3000; -v open-webui:/app/backend/data is the named volume holding all persistent state (accounts, chat history, documents) — keep it and your data survives upgrades; --add-host=host.docker.internal:host-gateway lets the container reach Ollama on the host (default http://host.docker.internal:11434); --restart always brings it back after a reboot. An :ollama tagged image bundles both if you want them in one container. For cloud APIs only, you don’t need Ollama at all.
Option B: pip (Python 3.11)
It requires Python 3.11 specifically — newer or older can fail on dependencies, so use a virtual environment pinned to 3.11:
pip install open-webui
open-webui serve
That starts the server on http://localhost:8080, with data on your local filesystem instead of a Docker volume. Docker remains the path the maintainers test most heavily.
First Run
Whichever route you take, the first account you create becomes the administrator with full rights. Claim your own admin account immediately, and for any multi-user deployment enable admin approval for new sign-ups before sharing the URL.
Connect Any Model: Ollama and OpenAI-Compatible APIs
Open WebUI speaks two model protocols at once — local models and cloud APIs side by side in the same picker. If Ollama is reachable, it lists every model you’ve pulled automatically; you can even pull new models from inside the admin settings. See the companion guide on running AI models locally with Ollama.
Under Settings → Connections, add any number of OpenAI-compatible endpoints, each with a base URL and API key:
| Provider | Base URL | What you get |
|---|---|---|
| OpenRouter | https://openrouter.ai/api/v1 |
300+ models, including free-tier ones, behind one key |
| Groq | https://api.groq.com/openai/v1 |
Very fast Llama and other open models, generous free tier |
| Google Gemini | https://generativelanguage.googleapis.com/v1beta/openai |
Gemini models via the OpenAI-compatible shim |
| LiteLLM proxy | your self-hosted proxy URL | One endpoint fronting all of the above |
The last row is the most powerful pattern. Instead of pasting four provider keys into Open WebUI, run a LiteLLM gateway, register all providers there once, and point Open WebUI at a single endpoint. LiteLLM handles routing, spend tracking, virtual keys, and fallbacks; Open WebUI just sees one tidy model list.
Beyond Chat: The Features That Matter
-
RAG over your documents. Upload PDFs, text, and Office files into a conversation or a reusable Knowledge collection, then reference them with
#in a prompt. Open WebUI chunks, embeds, and retrieves the relevant passages so answers are grounded in your files. Paste a URL after#to pull a web page in on the fly. The embedding model is configurable, including local ones so the whole pipeline stays offline. - Web search. Toggle live search on a message and the model answers with current sources. Backends include self-hosted SearXNG, Brave, Google Programmable Search, Tavily, and others, configured with an API key or URL in admin settings.
- Multi-user accounts and roles. Real RBAC (admin, user, custom groups), per-model access permissions, and admin approval for new sign-ups — a first-class feature, not an afterthought.
- Model builder, prompts, pipelines. Save custom assistants (base model + system prompt + tools + knowledge), a shared prompt library, plus Pipelines and Functions to inject custom Python (rate limiting, filtering, custom RAG, monitoring) into the request flow.
- Tools, image generation, voice. Tool calling via OpenAPI-compatible tool servers (its bridge to the Model Context Protocol ecosystem), image gen via AUTOMATIC1111/ComfyUI or a hosted API, and hands-free voice/video call modes.
- Works on your phone. It’s a PWA — open your server URL on mobile, add to home screen, and you have a native-feeling AI app talking to models on your own hardware.
Open WebUI vs LibreChat vs Lobe Chat vs AnythingLLM
| Tool | Best at | Local model support | Multi-user | License note |
|---|---|---|---|---|
| Open WebUI | All-rounder; best Ollama integration; RAG + web search + multi-user in one | Excellent (native Ollama) | Yes, with RBAC | BSD-3 + branding clause |
| LibreChat | Many cloud providers, plugins, agents; familiar ChatGPT-like UX | Good (via endpoints) | Yes | MIT |
| Lobe Chat | Most polished UI, plugin marketplace, fast setup | Good (via endpoints/Ollama) | Limited | Open source (check current) |
| AnythingLLM | Document-chat and agents; simple desktop app option | Good | Yes (workspaces) | MIT |
Open WebUI is the default pick if you run local models and want one tool that does everything, with the tightest Ollama integration. LibreChat wins if your priority is many cloud providers and a permissive MIT license for white-labeling. Lobe Chat wins on visual polish and its plugin marketplace. AnythingLLM is built around document chat and ships a desktop app — the simplest path when your core need is “talk to my documents.”
Limits and Honest Caveats
- It does not run models. With no Ollama and no API configured, it’s an empty chat box. Backend quality, speed, and cost are yours to supply — Open WebUI can’t make a slow model fast or a rate-limited tier unlimited.
- Resource footprint. The UI is lightweight, but local RAG needs an embedding model and local inference needs the usual GPU/RAM. On a small VPS with no GPU it works fine as a front end for cloud APIs; plan the backend, not just the UI.
- The branding clause. A non-issue for self-hosting and small teams, but if you plan a rebranded commercial product, read the current license or choose an MIT alternative like LibreChat or AnythingLLM.
- Security is yours. The first account is admin. An instance exposed to the internet without auth, HTTPS, and approval-gated sign-ups is a liability — put it behind a reverse proxy with TLS and never expose the raw port.
Frequently Asked Questions
Do I need Ollama to use Open WebUI?
No. Ollama gives the tightest local-model integration, but Open WebUI works with any OpenAI-compatible API. You can run it purely as a front end for OpenRouter, Groq, or a LiteLLM proxy, with no local models at all.
What is the difference between Open WebUI and Ollama?
Ollama runs the models — it’s the inference engine that downloads and serves an LLM. Open WebUI is the interface you put in front: chat history, document RAG, web search, multi-user accounts, and a model picker. Ollama is the engine, Open WebUI is the dashboard.
Can Open WebUI chat with my documents (RAG)?
Yes. Upload documents or build a Knowledge collection, then reference them with the # symbol in a prompt. The embedding model is configurable, including local models so the entire pipeline can run offline.
Is Open WebUI safe to expose to the internet?
Only if you secure it. Put it behind a reverse proxy with HTTPS, require admin approval for new accounts, and never expose the raw port unauthenticated. The first account created becomes the administrator, so claim it before sharing the URL.
Bottom Line
Open WebUI turns a model into a product — wrapping the local LLM you can already run in a terminal with conversation history, document RAG, live web search, multi-user accounts, image generation, and a phone-friendly PWA, all self-hosted and free. Running Ollama? One Docker command auto-detects your models. Juggling cloud keys? Point it at a LiteLLM gateway for one private dashboard. Building a product on top? Read the license first — self-hosting is unrestricted, but the branding clause matters at commercial scale.
Related Reads
- Ollama: Run AI Models Locally for Free — the inference engine Open WebUI was built to sit on top of
- LiteLLM: One Free API for OpenAI, Claude & 100+ LLMs — front Open WebUI with one gateway over all your provider keys
- 5 Free AI Coding Assistants for VS Code & Terminal — the developer-facing side of the same free local-AI stack
- Dify: Free Open-Source AI App Builder for Chatbots and Workflows — when you want to build apps, not just chat
- n8n: Open-Source Workflow Automation with AI Agents — wire your self-hosted AI into automated workflows
Originally published at toolfreebie.com.
Top comments (0)