Open WebUI: What It Is, How to Install It and What It Costs

Andreas Nigg
Andreas Nigg · Co-Founder, Pondhouse Data
Published Updated 15 min read
Open WebUI: What It Is, How to Install It and What It Costs
On this page

Open WebUI is a self-hosted web interface for large language models. It looks and works much like ChatGPT, runs on your own server and connects to OpenAI, Anthropic, Ollama and any API that speaks the OpenAI format. On top of plain chat it brings knowledge bases (RAG), tools, MCP servers, web search, user groups and an admin panel. The software is free to use for any number of users; you pay for your server and for the model API you connect.

We first wrote about Open WebUI in August 2024. A lot has changed since then (the project went from v0.3 to v0.13.0 and has about 158,000 stars on GitHub), so we installed the current release in November 2026 and tried the features that matter for a company deployment: installation, the first admin account, chat with an OpenAI model, a knowledge base with a German PDF, an MCP tool server and web search. This post shows the official setup path, what worked, where people get stuck, and what the license means for you.

What Open WebUI is

Open WebUI is a Python (FastAPI) backend with a Svelte frontend, shipped as a Docker image and as a pip package. It has no models of its own. You connect it to model providers, and Open WebUI handles everything around the model:

AreaWhat Open WebUI gives you
ChatModel picker, chat history, folders, sharing, temporary chats, voice
ModelsOpenAI-compatible APIs, Anthropic, Ollama; custom "models" with their own system prompt, knowledge and tools
KnowledgeKnowledge bases with document extraction, embeddings, vector search and citations
ToolsPython tools and functions, OpenAPI tool servers, native MCP support, web search, code interpreter
CollaborationNotes, channels, comments, shared knowledge and models
AdministrationRoles, groups, granular permissions, LDAP, SSO, SCIM, analytics

Your employees get one chat interface, you decide which models, documents and tools sit behind it, and the conversations stay in your database instead of a vendor's.

Why a self-hosted, open source ChatGPT alternative?

There are three common reasons to run your own chat interface instead of buying ChatGPT or Copilot seats.

First, data control. Chats, uploaded files and knowledge bases live in your database and your storage. Which model provider sees the prompts is your choice: a model in your own Azure tenant, a provider with an EU data processing agreement, or a local model on your own GPU.

Second, model choice. Open WebUI is not tied to one vendor. In our test the same chat window offered OpenAI's gpt-5-mini and a local Qwen3 model running in Ollama, side by side.

Third, cost structure. Instead of a fixed price per seat, you pay for the server and for the tokens your users actually consume. For teams with many occasional users this is usually cheaper. For heavy users the difference shrinks, and you take on the operating work yourself.

How to install Open WebUI

The official quick start recommends Docker. According to the docs, this is the single command:

1docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data -e WEBUI_SECRET_KEY=your-secret-key --name open-webui --restart always ghcr.io/open-webui/open-webui:main

Replace your-secret-key with the output of openssl rand -hex 32. The volume open-webui holds everything: users, chats, settings, uploaded files and the vector database.

If you prefer Docker Compose, this is the docker-compose.yml from the docs:

1services:
2 open-webui:
3 image: ghcr.io/open-webui/open-webui:main
4 ports:
5 - "3000:8080"
6 volumes:
7 - open-webui:/app/backend/data
8 extra_hosts:
9 - host.docker.internal:host-gateway
10 environment:
11 - WEBUI_SECRET_KEY=your-secret-key
12 restart: unless-stopped
13
14volumes:
15 open-webui:

Start it with docker compose up -d and open http://localhost:3000. We ran exactly this setup, with the image pinned to ghcr.io/open-webui/open-webui:v0.13.0 instead of :main (more on that under pitfalls), plus an Ollama container for local models.

There are a few image variants worth knowing:

TagUse it for
:mainStandard image with local embedding and speech models (1.62 GB download according to the docs)
:slimChat with API models only, 197 MB download; RAG, speech and document extraction need external services
:cudaNVIDIA GPU support for the bundled embedding and speech models
:ollamaOpen WebUI and Ollama in one container

Open WebUI can also run without Docker. The docs list pip as an official option, for Python 3.11 or 3.12 (3.13 is not supported yet):

1pip install open-webui
2open-webui serve

The pip version listens on port 8080. Set DATA_DIR so you know where your data ends up. For production the docs recommend Docker or a Kubernetes deployment with the official Helm chart.

First start: the admin account

On the first visit, Open WebUI shows a "Get started" screen with a Create Admin Account form. The first account becomes the administrator. Right after that, sign-up switches itself off: in our instance the authentication settings showed ENABLE_SIGNUP set to false and the default role for new users set to pending.

So create the admin account before you expose the instance to anyone else. To let colleagues in, you have three options: add users yourself in the Admin Panel, turn New Sign Ups back on under Settings > Admin > Authentication (new accounts wait as "pending" until you approve them), or connect SSO through OIDC, LDAP or SCIM.

Connecting OpenAI and Ollama

Open WebUI finds models through connections under Settings > Admin > Connections. For OpenAI you click + next to "Manage OpenAI API Connections", enter https://api.openai.com/v1 and your API key. You can also pass the key as the environment variable OPENAI_API_KEY when the container starts; Open WebUI then creates the connection on the first start. We used an env file for this:

1 env_file:
2 - .env # contains OPENAI_API_KEY=sk-...

The connection worked right away, and it listed 85 models. That was the first surprise: OpenAI's model endpoint returns everything, including moderation, transcription, realtime and image models, and the very first default model in the chat picker was omni-moderation-2024-09-26. The fix is the Model IDs field in the connection's advanced settings. Enter the models you want to offer and Open WebUI shows only those.

Open WebUI connection dialog for the OpenAI API, with the model list limited to gpt-5-mini and gpt-4.1-mini

Ollama works the same way. With the official Compose file from the Open WebUI repository (which includes an Ollama service) or with OLLAMA_BASE_URL=http://ollama:11434, local models appear in the same picker. We pulled the small qwen3:0.6b model to check the connection; on CPU it answered a short question in about a second. For real work you want a larger model and a GPU, which we did not test here.

Model picker in Open WebUI with two OpenAI models, a local Ollama model and a custom model

Day-to-day chatting looks the way you expect: Markdown, tables and code render cleanly, follow-up questions are suggested under each answer, and the chat title is generated automatically.

A chat with gpt-5-mini in Open WebUI that answers with a Markdown table

Knowledge bases: chat with your documents

Knowledge bases are Open WebUI's built-in RAG. You create one under Workspace > Knowledge, upload files, and Open WebUI extracts the text, splits it into chunks, computes embeddings and stores them in a vector database. Out of the box this all happens inside the container: Chroma as vector database and sentence-transformers/all-MiniLM-L6-v2 as embedding model, with 1,000-character chunks and the top 3 chunks passed to the model. Every part can be swapped: document extraction (Tika, Docling, Azure Document Intelligence, Mistral OCR and others), the embedding provider (OpenAI, Azure OpenAI, Ollama), the vector database (pgvector, Qdrant, Milvus, Elasticsearch and more) and hybrid search with a reranker.

We created a knowledge base "HR-Richtlinien" and uploaded a two-page German PDF, a sample travel expense policy for a fictional company. Indexing took well under a second, and the file browser shows the document next to the text that was indexed.

Open WebUI knowledge base with an uploaded PDF and the document preview

In a chat, you type # and pick the knowledge base. We then asked (in German) how much mileage allowance an employee gets when driving their own car and taking two colleagues along. The policy states 0.50 euros per kilometer plus 0.15 euros per passenger, and the answer did the math correctly: 0.80 euros per kilometer, with a citation pointing to the PDF.

Open WebUI answers a question from the knowledge base and cites the PDF as source

The more practical way for a team is a custom model. Under Workspace > Models you create a "model" that is really a preset: a base model (gpt-5-mini in our case), a system prompt and one or more knowledge bases. Users then pick "Reisekosten-Assistent" in the model list instead of attaching documents themselves.

Creating a custom model in Open WebUI with gpt-5-mini, a system prompt and an attached knowledge base

This preset behaved differently from the # attachment. Since Open WebUI uses native function calling by default, the model does not get the chunks injected automatically. It calls knowledge tools instead (we saw query_knowledge_files, grep_knowledge_files and view_knowledge_file) and decides what to read. It answered our question about flights versus train trips correctly (flights only when the train takes longer than six hours), and for a question the policy does not cover (a gym subsidy) it said the documents contain nothing about it instead of making something up.

Open WebUI can extend models with tools in four ways:

  • Python tools and functions that you write or import in the workspace and that run inside Open WebUI. Functions also cover filters (modify requests and responses), pipes (custom "models") and action buttons.
  • OpenAPI tool servers: any HTTP service with an OpenAPI spec.
  • MCP servers over Streamable HTTP, natively supported since v0.6.31.
  • Built-in tools such as web search, code interpreter, memory and image generation.

The separate Pipelines server from our 2024 post is deprecated; functions inside Open WebUI replace it.

To test MCP we connected Microsoft's public Learn MCP server. Under Settings

Admin > Integrations > External Tool Servers you add a connection, switch the type to MCP Streamable HTTP, enter https://learn.microsoft.com/api/mcp, choose "None" as authentication and click verify.

Adding the Microsoft Learn MCP server in Open WebUI as MCP Streamable HTTP connection

Note the yellow warning in the dialog: the Open WebUI team calls MCP support experimental and points to OpenAPI as the more reliable option. In our test it worked without problems. After enabling the tool in the chat, gpt-5-mini searched and fetched the Microsoft documentation four times and answered our question about SharePoint list limits (30 million items per list, 5,000 items list view threshold) with links to both source pages.

gpt-5-mini in Open WebUI uses the Microsoft Learn MCP server and answers with links to the documentation

Two restrictions to know: only admins can add MCP servers (users can at most add their own OpenAPI servers, if you allow it), and Open WebUI speaks Streamable HTTP only. For MCP servers that run over stdio, the project offers mcpo, a proxy that exposes them as OpenAPI. If you want to give Open WebUI access to your own systems, our guide to building an MCP server with FastMCP shows how to write one; for Open WebUI, run it with FastMCP's HTTP (Streamable HTTP) transport.

Web search needs a search provider. Most providers (Google PSE, Brave, Tavily, SearXNG and many more) need an API key or your own server. The DuckDuckGo option works without a key and is the quickest way to try the feature; it is not available in the slim image. With it enabled, gpt-5-mini found the current Open WebUI release on GitHub and cited the page.

If you want to connect Open WebUI to workflows in other systems, our guide on integrating n8n with Open WebUI shows how to call an n8n agent from the chat. For a dedicated RAG engine with deeper document parsing, see RAGFlow, which can also sit behind Open WebUI.

Users, groups and permissions

User management was the weakest part of Open WebUI in 2024. It now has three roles (admin, user, pending), groups, and a long list of permissions per group: access to models, knowledge, prompts and tools in the workspace, sharing rights, and chat features such as file upload, temporary chats or deleting messages. Knowledge bases, models and tools carry their own access control, so you can give the "Finanzen" group its knowledge base and nobody else.

Group permissions in Open WebUI with switches for workspace access and sharing

For larger organizations, the docs cover LDAP, OIDC single sign-on (for example with Microsoft Entra ID), SCIM provisioning, and horizontal scaling with PostgreSQL, Redis and shared storage.

License: what "open source" means for Open WebUI

Since v0.6.6 (April 2025), Open WebUI no longer uses the plain BSD-3-Clause license. The Open WebUI License is BSD-3 plus a branding clause. Clause 4 reads:

  1. Notwithstanding any other provision of this License, and as a material condition of the rights granted herein, licensees are strictly prohibited from altering, removing, obscuring, or replacing any "Open WebUI" branding, including but not limited to the name, logo, or any visual, textual, or symbolic identifiers that distinguish the software and its interfaces, in any deployment or distribution, except in the following circumstances: (i) deployments or distributions where the total number of end users (defined as individual natural persons with direct access to the application) does not exceed fifty (50) within any rolling thirty (30) day period; (ii) the licensee has obtained specific prior written permission from the copyright holder; or (iii) where the licensee has obtained a duly executed enterprise license expressly permitting such modification. For all other cases, any removal or alteration of the "Open WebUI" branding shall constitute a material breach of license.

In practice:

  • You may use, modify and redistribute Open WebUI for any purpose, including commercial use, at any number of users.
  • Above 50 users within 30 days, the name and logo must stay visible. Replacing them with your company's branding requires an enterprise license.
  • Code up to v0.6.5 remains BSD-3. The license page explicitly invites you to fork from that version if you need fully permissive terms, but then you lose all later features and fixes.
  • New contributions require a contributor license agreement.

The Open WebUI License is not an OSI-approved open source license, and GitHub shows it as "Other". For an internal company deployment that keeps the logo, nothing changes. It matters for agencies and software vendors who want to sell Open WebUI under their own name.

Pricing: what does Open WebUI cost?

Open WebUI itself costs nothing. According to the enterprise sales page, it is "free, open, and self-hosted with no cap on the number of users". There is no paid cloud version and no published price list.

Your real costs are:

Cost itemWhat drives it
ServerA small VM is enough for API models; the docs measured about 300 MiB RAM for the idle slim image. Local models need GPUs.
Model usageTokens at your provider (OpenAI, Azure OpenAI, Anthropic, ...) or the hardware for local models
OperationsUpdates, backups, monitoring, SSO setup, user support
Enterprise license (optional)Only if you need white-labeling, enterprise-only components or a support contract

Enterprise licenses are sold in tiers "from branding and licensing through to support agreements, faster response, onboarding, security review, and a dedicated point of contact for production", priced on request via the sales page. Two components are enterprise-only according to the docs: Terminals, which provisions a separate workspace container per user, and Tether.

Open WebUI vs LibreChat

LibreChat is the other big self-hosted chat interface. Both cover the basics well; the differences are in license, setup and focus.

Open WebUILibreChat
LicenseOpen WebUI License (BSD-3 plus branding clause)MIT
Version (Nov 2026)v0.13.0v0.8.8
Minimal setupOne container, SQLite and Chroma built inCompose stack with MongoDB, Meilisearch, pgvector, RAG API and admin panel
Model providersOpenAI-compatible APIs, Anthropic, OllamaOpenAI, Azure, Anthropic, Google, Bedrock, custom endpoints
RAGBuilt-in knowledge bases, many extraction engines and vector databasesSeparate RAG API service with pgvector
MCPNative, Streamable HTTP, added by adminsSupported for agents
UsersRoles, groups, granular permissions, LDAP, OIDC, SCIMAdmin panel with users, groups and roles; OAuth2, LDAP, email
Own brandingUp to 50 users or with enterprise licenseAllowed

Choose Open WebUI if you want the quickest path to a working internal chat with knowledge bases, Ollama support and fine-grained permissions. Choose LibreChat if you need an MIT license (for example to rebrand and resell it) or a strong focus on agents across many cloud providers.

Pitfalls and how to avoid them

Pin the version

The docs use the :main tag, which always points to the latest release. Open WebUI ships releases every one or two weeks, and v0.13.0 alone contains database schema changes; the changelog recommends a backup before updating. Use a version tag like v0.13.0, back up the volume, then update deliberately.

Set WEBUI_SECRET_KEY

Without a fixed key, every recreated container signs all users out. According to the MCP docs, OAuth-connected MCP tools also break on restart ("Error decrypting tokens").

Filter the model list

An OpenAI key brings in dozens of models, including ones that cannot chat. Restrict the connection with Model IDs and set a default model, or users will start chats with a moderation model.

Check the embedding model for non-English documents

The default all-MiniLM-L6-v2 is a small model trained mainly on English text. Our German test document worked, but it was only two pages. For larger German collections, switch to a multilingual embedding model (for example OpenAI's text-embedding-3-small or a multilingual model in Ollama) under Settings > Admin > Documents, then reindex.

Tool calling needs a capable model

With native function calling, which is the default, knowledge attached to a custom model is only used if the model calls the knowledge tools. The docs warn that weak models may ignore tools; small local models are the usual suspects.

Treat plugins as code

Tools and functions run arbitrary Python on your server, and MCP servers act with the connected user's permissions. Only install what you have read, and keep the default that only admins can add MCP servers.

Our assessment

Open WebUI has grown from a nice Ollama frontend into a platform you can roll out to a company. In our test, the official Docker setup was running in minutes, and every feature we tried worked on the first attempt: knowledge bases with citations, an MCP server, web search and group permissions. The project moves fast, which is good for features and means work for whoever operates it.

It is a good fit for an internal AI chat with your own documents and models, especially if data location matters and you are fine keeping the Open WebUI logo. Plan for the operating side: updates, backups, SSO and a decision about which models and embedding settings to use. If your users mainly need chat inside Microsoft 365 and you do not need your own models or documents in the loop, a managed product like Microsoft 365 Copilot or ChatGPT Business saves you the operating work.

If you are planning a self-hosted chat platform with your own knowledge bases or MCP tools, our AI consulting team in Vorarlberg can help with architecture, model choice and rollout.

Interested in building high-quality AI agent systems?

We prepared a comprehensive guide based on cutting-edge research for how to build robust, reliable AI agent systems that actually work in production. This guide covers:

  • Understanding the 14 systematic failure modes in multi-agent systems
  • Evidence-based best practices for agent design
  • Structured communication protocols and verification mechanisms
Andreas Nigg

About the author

Andreas Nigg

Co-Founder, Pondhouse Data

Andreas has spent more than eight years building data applications. At Pondhouse Data he designs and ships AI systems and integrates them into complex, real-world environments.