Team AI chat is mostly a UI with a seat fee attached. ChatGPT Business and Claude Team both land around $25 per user per month before anyone sends a single token - $250/month for a ten-person team, plus usage happening somewhere you do not control. Open WebUI is the self-hosted answer: a polished ChatGPT-style workspace over any OpenAI-compatible API, with the team features - accounts, role-based access, shared prompts, document RAG - built in, and no per-seat anything.
This guide deploys it properly: one container, one persistent volume, two secrets, and an optional (but strongly recommended) LiteLLM gateway in front of your model providers. Disclosure as always: Miget is our platform, and the deployment below uses our Compose Stack mechanism - though the compose file is portable and runs identically on your laptop.
What you get
- ChatGPT-style UI over any OpenAI-compatible endpoint - OpenAI directly, or any provider through a gateway
- Multi-user with RBAC: the first account created becomes admin; later signups require admin approval by default
- RAG out of the box: upload documents and chat over them - the vector store (Chroma) and database (SQLite) are embedded, no extra services
- Prompt presets, model switching, conversation sharing across the team
- No GPU required: this setup deliberately uses the API-only image - models run at your providers, not on your server
One honest note on licensing: Open WebUI uses a BSD-3-derived license with a branding-protection clause. Running it for your own team is fine; stripping the branding for white-label use requires their enterprise license.
The architecture (pleasantly boring)
Unlike n8n's queue-mode topology, Open WebUI is a single service:
| Service | Role | Public |
|---|---|---|
open-webui | chat workspace, port 5000 | yes (behind account login) |
webuidata volume | users, chats, uploaded documents, vector index - all of it | no |
Everything stateful lives in /app/backend/data on the volume. Back that up and you can rebuild the container from scratch without losing anything.
Deploy it in three steps
The template lives in the deployable.sh stacks catalogue - plain Docker Compose plus a Miget overlay.
1. Create a Compose Stack in app.miget.com pointing at https://github.com/deployable-sh/stacks, path open-webui.
2. Set two variables:
# session signing - keep it stable, or every login resets on redeploy
WEBUI_SECRET_KEY=$(openssl rand -hex 32)
# a key for your OpenAI-compatible endpoint
OPENAI_API_KEY=sk-...
By default the template points at https://api.openai.com/v1; set OPENAI_API_BASE_URL to use anything else (more on that below).
3. Deploy, then immediately create the first account - it becomes the admin. Subsequent signups sit in a pending queue until the admin approves them, which is exactly what you want on a public URL with TLS.
Local first? Same files:
git clone https://github.com/deployable-sh/stacks
cd stacks/open-webui
cp .env.example .env # set the two variables
docker compose up -d
open http://localhost:5000
The strongest setup: put LiteLLM in front
Pointing Open WebUI straight at one provider works. Pointing it at a self-hosted LiteLLM gateway is better:
- Every provider behind one base URL - OpenAI, Anthropic, Gemini, your own vLLM - switchable per conversation from the UI
- Virtual keys with budgets - give the team one key with a monthly cap instead of sharing your real provider keys
- One place to see spend across all models
The wiring is two variables on the Open WebUI app: OPENAI_API_BASE_URL=http://litellm:5000/v1 and a LiteLLM virtual key as OPENAI_API_KEY. Both stacks run side by side in the same Miget plan - the LiteLLM guide covers the gateway setup end to end, including the salt-key gotcha that cannot be undone later.
What it actually costs
The template sizes Open WebUI at 2 GiB RAM (that covers the app plus its embedded embedding models for RAG) and a 5 GB volume. On Miget that runs on the $13/month plan - and because the meter for model usage is raw token prices at your providers, the math against per-seat subscriptions is blunt:
| 10-person team, subscriptions | 10-person team, self-hosted | |
|---|---|---|
| Seats | ~$250/month (at ~$25/seat) | $0 |
| Workspace | included | $13/month |
| Model usage | included but capped/limited | raw API token prices |
For typical internal usage, raw token spend is a fraction of the seat fees - and you pick the model per task instead of being locked to one vendor's.
Production notes
WEBUI_SECRET_KEYmust stay stable. It signs sessions; rotate it and everyone gets logged out. Set it once, store it with your secrets.- Back up the volume. SQLite database, uploaded documents, and the vector index all live in
/app/backend/data. That volume is the entire state of the deployment. - Pin your image. The template tracks
ghcr.io/open-webui/open-webui:main; for a team deployment, pin a release tag and upgrade deliberately - Open WebUI ships fast. - Approve accounts, do not open signups. First account is admin; keep the default approval queue for the rest. The workspace is on a public TLS domain - account discipline is your perimeter.
- When one node stops being enough: Open WebUI supports external Postgres and external vector stores. On Miget you can add a managed Postgres in the same plan when the embedded SQLite becomes the bottleneck - for most teams that day never comes.
Frequently Asked Questions
Do I need a GPU or Ollama to run Open WebUI?
No. This setup uses the API-only image - models run at your API providers, so the server needs 2 GiB of RAM and no GPU. The :ollama image variant bundles local model serving, but that is a different (and much heavier) resource conversation.
How is this different from ChatGPT Business or Claude Team?
Those are ~$25/seat/month with the provider's models only. Self-hosted Open WebUI has no seat fees ($13/month total for the workspace), works with any OpenAI-compatible provider simultaneously, and your chats and documents stay in your own storage.
Does RAG work out of the box?
Yes - upload documents in the UI and chat over them. Embeddings and the vector index run inside the container (that is why the sizing is 2 GiB rather than 512 MiB). No external vector database needed until you scale well past a small team's usage.
Can I control what the team spends on models?
Put LiteLLM in front and hand the team a virtual key with a monthly budget. Open WebUI sees one endpoint; LiteLLM enforces limits and logs spend per key.
How do I update Open WebUI safely?
Pin a release tag, read the release notes, back up the volume, then bump the tag and redeploy. Avoid riding :main in a team deployment.
What to read next
- How to Self-Host LiteLLM - the gateway that gives this workspace budgets and every provider
- How to Self-Host n8n on Miget - the same treatment for workflow automation
- Docker Compose Stacks - how the one-step stack deployment works
- Deploy 138 Self-Hostable Stacks With deployable.sh - the catalogue this template comes from