Skip to content

Open WebUI

Self-hosted, multi-user web interface for chatting with models behind OpenAI-compatible or Ollama endpoints, with retrieval over documents, roles and groups, and sign-in through local accounts, LDAP or OIDC.

ID open-webui
Layer ui
Version v0.13.4
Tiers T1, T2, T3
Requires nothing
License Open WebUI License
Evidence docs
Last verified 2026-11-21
  • Many people need one chat interface over models that are served inside the network: the documentation connects it to Ollama (OLLAMA_BASE_URL, with the bundled-Ollama image as the all-in-one option) and to OpenAI-compatible endpoints (OPENAI_API_BASE_URL), and the interface has roles, groups, API keys and retrieval over uploaded documents.
  • Sign-in must work without an external identity provider, or against a directory or an OIDC provider on the internal network: the authentication page lists local email and password accounts (‘No external identity provider required’), LDAP, SSO/OIDC (Google, Microsoft, Okta, Keycloak or any OIDC provider), SCIM 2.0 provisioning and two-factor sign-in, and states no license requirement for them (see the caveats).
  • The Open WebUI name and logo must be changed or removed and the deployment has more than 50 end users in a rolling 30-day period, and no enterprise license or written permission is available: the license forbids it (see the caveats).
  • More than one replica is needed and PostgreSQL, a Redis-protocol store, a client-server vector database and shared file storage cannot all be provided: the scaling guide marks all four as required for multiple instances (see the caveats).
  • License (question 1): the repository publishes the release under the Open WebUI License, which GitHub reports as NOASSERTION. Its text at the tag is a BSD-3-Clause-style license with an added condition 4: licensees may not alter, remove, obscure or replace any Open WebUI branding (name, logo, visual, textual or symbolic identifiers) in any deployment or distribution, except (i) when the total number of end users, meaning individual natural persons with direct access to the application, does not exceed fifty within any rolling thirty-day period, (ii) with specific prior written permission from the copyright holder, or (iii) with a duly executed enterprise license permitting it; any other removal or alteration is a material breach. The license page says the clause takes effect with v0.6.6 (19 April 2025), that code up to and including v0.6.5 stays BSD-3-Clause, and that the full LICENSE text controls; its summary box says branding rules apply to ‘larger deployments (50+ users, aggregate)’, which differs from the license text ‘fifty (50) or fewer’ by one boundary case. Use the product with its branding intact and no enterprise license; plan for a license or written permission before white-labeling above 50 users.
  • Paid features (question 2 and procedure step F): local accounts, LDAP, OIDC/SSO, SCIM and two-factor sign-in are described on the authentication pages without any license requirement, and the enterprise page lists only white-labeling and rebranding, support and the enterprise-exclusive Terminals and Tether as needing an enterprise license; this design does not rely on those. The free edition has no license check. An enterprise LICENSE_KEY, if one is set, is checked at startup by posting to https://api.openwebui.com and https://licenses.api.openwebui.com (source code, backend/open_webui/utils/auth.py), with a LICENSE_BLOB_PATH fallback in the same code; the documentation does not say how an enterprise license works offline, so ask the vendor before relying on one in a disconnected network. license_server is false because the edition this entry covers needs none.
  • More than one replica (question 3, the T3 default): the scaling guide’s defaults are embedded SQLite on a local volume, embedded ChromaDB, local file storage and one Uvicorn worker, with no external database or Redis required. For more than one instance it requires all of the following: PostgreSQL (DATABASE_URL; SQLite is not supported for multiple instances, and Open WebUI does not migrate data between the two databases, so decide before production data exists), Redis (REDIS_URL and WEBSOCKET_MANAGER=redis on every instance), a client-server vector database (VECTOR_DB=pgvector or another; the default embedded ChromaDB crashes under concurrent writes; the slim image supports only PGVector), shared file storage (a shared filesystem mounted at the same path on every replica, or S3, GCS or Azure Blob object storage), and the same WEBUI_SECRET_KEY on every replica (otherwise login loops and 401 errors). Run one worker per replica, let one process run database migrations, and upgrade by scaling to one replica first. Because a single instance works without these, they are not in requires; a design with more than one UI replica must add postgresql and valkey to the blueprint and the transfer manifest.
  • PostgreSQL for Open WebUI: the pgvector option needs the pgvector extension in the database (the troubleshooting guide names ‘a PostgreSQL DATABASE_URL with the pgvector extension’); the postgresql entry of this catalog lists the plain postgres image and says nothing about pgvector, and the Open WebUI documentation names no PostgreSQL image for it, so this entry picks none. Each worker process holds several connection pools; the scaling guide gives the formula (2 x (DATABASE_POOL_SIZE + DATABASE_POOL_MAX_OVERFLOW) + PGVector pool) x UVICORN_WORKERS x replicas and says to keep it below max_connections.
  • Redis (the scaling guide, quoted as a caveat, not a requirement for one instance): the guide recommends Redis for a small team (under 50 users, single instance) because ‘signing out does not revoke the session token’ without it; the token stays valid until JWT_EXPIRES_IN passes (default four weeks). Password changes and Sign out all devices work without Redis; the alternative is a shorter JWT_EXPIRES_IN. Redis also holds sign-in rate limiting and OAuth token refresh locks. The guide says: ‘Open WebUI uses ordinary Redis commands, so a Redis-protocol server such as Valkey or Dragonfly works with the same settings. Neither is part of what Open WebUI tests.’ So the valkey entry of this catalog fits as the Redis-protocol store; set the Redis server timeout and a high maxclients (10000 or more) as the guide says to avoid connection exhaustion.
  • Offline: OFFLINE_MODE=true does not make the installation offline by itself; it stops update checks and model downloads. Chat needs a local model server, retrieval needs local embeddings and extraction, and the sign-in method must stay reachable on the isolated network (an external identity provider will not be). Network isolation is separate (the hardening and offline guides). The hardening guide also says the retrieval web loader refuses private addresses by default (ENABLE_RAG_LOCAL_WEB_FETCH=false).
  • Changing from the documented defaults: the offline-mode guide says its steps are a community contribution and not supported by the Open WebUI team.
Image Hardware Digest
ghcr.io/open-webui/open-webui:v0.13.4 any not pinned

What the software tries to fetch while it runs, and how to stage it instead.

  • Models the standard images bring with them: the Dockerfile at the tag downloads the default embedding model sentence-transformers/all-MiniLM-L6-v2, the auxiliary embedding model TaylorAI/bge-micro-v2, the faster-whisper model base and the tiktoken encoding cl100k_base at image build time (source code), and the quick-start page says :main bundles the speech-to-text and embedding models. These are in the non-slim images (v0.13.4, -cuda, -cuda126, -ollama); the slim image has none (the page says it never downloads a model). The paths are below /app/backend/data/cache (SENTENCE_TRANSFORMERS_HOME, WHISPER_MODEL_DIR and TIKTOKEN_CACHE_DIR in the Dockerfile).
  • Models and caches you must stage when you choose something else: a different embedding, reranking or Whisper model. The offline-mode tutorial downloads them on a connected machine with huggingface_hub snapshot_download and copies the cache to /app/backend/data/cache/embedding/models/ (embedding) and /app/backend/data/cache/whisper/models/ (Whisper), keeping the structure, then sets RAG_EMBEDDING_MODEL or WHISPER_MODEL to the matching identifier. A reranking model is prepared the same way. With an external embedding provider (RAG_EMBEDDING_ENGINE set to ollama, openai or azure_openai) none of these is needed.
  • Hugging Face traffic at start and use: while RAG_EMBEDDING_MODEL_AUTO_UPDATE is true, every start with the default SentenceTransformers engine contacts Hugging Face to check the model, even when it is cached, and the server does not accept connections until that finishes (environment variable reference). Switch: OFFLINE_MODE=true, which disables Hugging Face Hub downloads, version update checks and the automatic updates of the embedding, reranking and Whisper models, and sets HF_HUB_OFFLINE=1 and the three *_AUTO_UPDATE flags to false; the tutorial lists them anyway (OFFLINE_MODE=true, HF_HUB_OFFLINE=1, RAG_EMBEDDING_MODEL_AUTO_UPDATE=false, RAG_RERANKING_MODEL_AUTO_UPDATE=false, WHISPER_MODEL_AUTO_UPDATE=false). With HF_HUB_OFFLINE=1 a missing model cannot be downloaded, so a fresh install without models starts but fails at the first document upload or retrieval with ‘No embedding model is loaded’.
  • Python packages for tools and functions: a tool or function that declares requirements in its frontmatter gets them installed with pip at load time; OFFLINE_MODE skips these installs, so the packages must already be in the image (environment variable reference). ENABLE_PIP_INSTALL_FRONTMATTER_REQUIREMENTS=false also turns the installs off (hardening guide).
  • Slim image only: the token text splitter downloads its tiktoken encoding on first use, so use the character splitter; the code interpreter makes the browser fetch its Python packages from cdn.jsdelivr.net, so leave it off in a disconnected network or use a standard image (quick-start page). Standard images bundle those packages according to the same page.
  • Content extraction and web loading: PDFs and Office files in the slim image need Tika, Docling or another extraction service; the default pypdf extractor runs inside the standard image. Services you add (Tika, Docling, embedding, web search) are new outbound destinations; keep them on the internal network.

No license server is contacted.

What How to turn it off
Analytics and telemetry switches of bundled libraries (Scarf analytics, DO_NOT_TRACK, ChromaDB anonymized telemetry): the documentation does not describe any phone-home feature; the Dockerfile at the tag (source code, not a documentation page) already sets SCARF_NO_ANALYTICS=true, DO_NOT_TRACK=true and ANONYMIZED_TELEMETRY=false in the image, and .env.example sets the same three. Keep SCARF_NO_ANALYTICS=true, DO_NOT_TRACK=true and ANONYMIZED_TELEMETRY=false (set in the official images, in .env.example for other installs).
Version update check: the server asks https://api.github.com/repos/open-webui/open-webui/releases/latest (URL from source code, backend/open_webui/main.py), on by default in release builds (the official images built from main or a release tag, and the pip package), with a one-second timeout; the interface then shows an update notice or ‘Could not check for updates’. ENABLE_VERSION_UPDATE_CHECK=false, or OFFLINE_MODE=true (which sets it to false).
Open WebUI Community sharing: options that let users send chats, models, prompts, tools, functions, skills and usage statistics to the Open WebUI Community and links to community content; on by default; the documentation describes them as share options in the interface, not as an automatic report (hardening guide and environment variable reference). ENABLE_COMMUNITY_SHARING=false
External avatars: the profile-image endpoints redirect the browser to an external http(s) image URL stored in a profile, which exposes the viewer’s IP address, User-Agent and Referer to that host; on by default (hardening guide). A ‘Gravatar’ button in the profile settings makes the user’s avatar a www.gravatar.com URL (source code of the settings component, user-initiated). ENABLE_PROFILE_IMAGE_URL_FORWARDING=false (read at startup only).
OpenTelemetry export of traces, metrics and logs to a collector you name: off by default (ENABLE_OTEL=False; with only the master switch set nothing is exported), so it sends nothing unless an operator turns it on. Leave ENABLE_OTEL=false (the default); signals are ENABLE_OTEL_TRACES, ENABLE_OTEL_METRICS and ENABLE_OTEL_LOGS.
CUSTOM_NAME (legacy branding variable): the environment variable reference says it ‘Sets WEBUI_NAME but polls api.openwebui.com for metadata’. From source code (backend/open_webui/config.py at the tag, not from a documentation page): when CUSTOM_NAME is set, the server requests https://api.openwebui.com/api/v1/custom/<CUSTOM_NAME> at start and, if the answer has a logo or splash image, downloads it from api.openwebui.com (or the URL given) and writes it as the favicon and the splash image. Off while CUSTOM_NAME is unset, which is the default. Leave CUSTOM_NAME unset (the default).

Offline behavior is documented but not verified: the entry author did not run Open WebUI. Images: the quick-start page lists the variants :main (the ‘Standard image (recommended). Everything included’, with the embedding and speech-to-text models baked in; the Dockerfile at the tag confirms the models), :slim, :cuda, :cuda126 and :ollama, says ‘Choose one variant; slim does not combine with CUDA or bundled Ollama’, and names pinned tags of the form vX.Y.Z and vX.Y.Z-variant. The documentation says to choose one variant, and this entry lists the recommended one, ghcr.io/open-webui/open-webui:v0.13.4 (compressed about 1.62 GB for :main on 2026-10-16 per the page; it runs on any hardware). The other four exist for v0.13.4 on ghcr.io (checked in the registry) and are not listed, so the transfer manifest does not carry them: (1) ghcr.io/open-webui/open-webui:v0.13.4-cuda (CUDA 12.8) puts Open WebUI’s own embedding, reranking and Whisper models on an NVIDIA GPU, and that GPU memory is not counted by the design’s sizing; carry it instead of the standard image only when the design gives Open WebUI a GPU (the page says chat replies are not faster; the GPUs in this design belong to the inference engine). (2) ghcr.io/open-webui/open-webui:v0.13.4-cuda126 is the same image built against CUDA 12.6. (3) ghcr.io/open-webui/open-webui:v0.13.4-slim is about 197 MB compressed on 2026-10-16 per the page, has no local models, and works as a chat front end with the default SQLite and local file storage; retrieval, however, needs PostgreSQL with the pgvector extension (the scaling guide says the slim image supports only PGVector, its default VECTOR_DB, and that it requires an external embedding engine because it has no local embedding or reranking models: https://docs.openwebui.com/getting-started/advanced-topics/scaling; the quick-start page lists the embedding provider and PostgreSQL with pgvector as what slim needs for documents, knowledge and RAG, and says retrieval fails with 503 without them), PDFs and Office files need an extraction service, and the same page lists the features that stay unavailable. (4) ghcr.io/open-webui/open-webui:v0.13.4-ollama bundles Ollama in the container, which would add a second inference engine next to the one the design chooses (see the ollama entry). The page says Open WebUI has no ROCm image (‘There is no ROCm image of Open WebUI’; with an AMD GPU run :main and give the GPU to Ollama’s rocm image), and the documentation names no Intel image. Also not listed: the alias 0.13.4 (same digest as v0.13.4 in the registry), the rolling tags :main, :latest, :dev, :dev-cuda and the short tags :slim, :cuda, :cuda126, :ollama, which follow main, the :git-<sha> tags, the :X.Y tag, and the Docker Hub mirror openwebui/open-webui (a subset of the same images). Alternative routes, not carry items: pip install open-webui (PyPI package open-webui, then open-webui serve; Python 3.11 or 3.12, pyproject requires >= 3.11 and < 3.13; the page says Python 3.13 is not supported; ffmpeg is not brought by pip), and the Helm chart from https://open-webui.github.io/helm-charts (chart open-webui/open-webui; with default values it also deploys Ollama, Pipelines and a Redis instance, and the documentation names no image tags for them here, so none are listed). Data lives in /app/backend/data; set WEBUI_SECRET_KEY and keep it stable (a new key logs everyone out). The image listens on 8080. The Dockerfile puts the baked-in models below /app/backend/data/cache, so a bind mount of an empty host directory over /app/backend/data would hide them (inference from the Dockerfile paths, not tested). The documentation says OFFLINE_MODE governs only the connections Open WebUI makes on its own behalf: configured model APIs, OAuth providers, web search, tool servers and object storage still work when the network allows them, so isolate the network separately.

For running the tool itself, these skills go further than the catalog:

Read on 2026-11-21 (the CUSTOM_NAME entry of the environment variable reference was re-read on 2026-11-22). Version v0.13.4 is the latest GitHub release (published 2026-11-17, not a prerelease); the image tags v0.13.4, v0.13.4-slim, v0.13.4-cuda, v0.13.4-cuda126 and v0.13.4-ollama exist on ghcr.io (checked on that date through the registry’s token-authenticated manifest endpoint, ghcr.io/v2/open-webui/open-webui/manifests/<tag>, which answers 401 without a token and so is not in sources; the GitHub package page for the image returned 502 on 2026-11-22). Documentation pages on docs.openwebui.com were opened live where the sources list the docs.openwebui.com address; the pages listed as files of the open-webui/docs repository at commit 307b3ad (the repository state on 2026-11-21, the source of the same published site) were read as files. Statements that come from source code of the release tag rather than from a documentation page say so in their text (telemetry switches in the Dockerfile, the update-check URL, the license-key check, what the image bakes in at build time, the Gravatar button). The offline behavior was not run: it is documented but not verified in a disconnected network. The offline-mode and Valkey tutorials are marked by the documentation as community contributions not supported by the Open WebUI team; the official scaling and hardening guides carry the same points for the statements that rely on them.

Sources:

Source of this page: skills/airgap-architect/catalog/components/open-webui.toml.