# How to install Open WebUI, the open source chat interface > Open WebUI installs two ways: a Docker one-liner or pip. Both put a self-hosted chat interface in front of your own models. The commands come straight from Open WebUI's own docs, followed by the upkeep they create. Beyond the chat layer, Kortix is the open-source AI Operating System. URL: https://openwebuialternative.com/how-to-install-open-web-ui ## The install commands Each command is copied from Open WebUI's own quick-start or its repository, with the source on every panel. ### Docker `terminal` ```sh openssl rand -hex 32 docker 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 ``` Source: https://docs.openwebui.com/getting-started/quick-start/ ### Python (pip) `terminal` ```sh pip install open-webui open-webui serve ``` Source: https://github.com/open-webui/open-webui ### GPU (CUDA) `terminal` ```sh docker run -d -p 3000:8080 --gpus all --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:cuda ``` Source: https://github.com/open-webui/open-webui ## What you are installing Open WebUI is an open source, self-hosted chat interface. It is a web app you run on your own machine that puts one interface in front of your models, whether those are local Ollama models or any OpenAI-compatible API. Around the model it adds accounts, saved chats, document search and admin controls, and it keeps all of that in a database you host. Installing it means running that web app and pointing it at a model endpoint, and the model stays wherever it already runs. Docker is the officially supported path and the one the project recommends for most people ([quick-start](https://docs.openwebui.com/getting-started/quick-start/)); pip suits a low-resource or manual setup. A self-hosted instance is a service on your network, so who can reach it and how it is secured is part of the job ([is Open WebUI safe](/is-open-web-ui-safe)). If you are still choosing between chat interfaces, [the alternatives round-up](/best-open-webui-alternatives) compares them. ## Prerequisites and the steps, in order Two things decide the install: the tools on your host and how the instance reaches a model. 1. Docker. On the Docker path, install Docker first. Generate the secret key with `openssl rand -hex 32`, then run the one-liner in the Docker panel. The command mounts the `open-webui` volume at `/app/backend/data`, and that volume is where chats, users and settings live. The project's own warning is to never run without it. 2. Python. On the pip path, use Python 3.11, then `pip install open-webui` and `open-webui serve`. The server answers on port 8080. 3. The model endpoint. If the models run on the same machine, install Ollama and let the Docker command reach it through `host.docker.internal`. Otherwise point the instance at the API URL of a hosted provider. 4. A GPU, only for local inference. The `:cuda` image runs models on an NVIDIA GPU and needs the CUDA support the project documents for Linux or WSL. Over a hosted API there is no GPU step. Open the UI on its port, create the first admin account, and point the instance at the endpoint. From there it runs until you upgrade it. ## What the install leaves for the team The commands are the easy part. A running instance becomes somebody's job. - Uptime: it has to be reachable when people want it, so someone watches it and restarts it. - Storage: the `open-webui` volume holds every chat, account and setting, so it needs backups, and the default SQLite database eventually wants Postgres. - Access: accounts, groups and permissions decide who reaches which models, and a public instance is a login surface to defend. - Upgrades: `:main` is a rolling tag, so an update means pulling a new image while keeping the volume. - Secrets: `WEBUI_SECRET_KEY` has to stay fixed. Lose it and every recreated instance logs everyone out. - The backend: it is a chat interface over a model, and the work still has to happen somewhere. If the point of the instance is to reach a model, Kortix removes it: Kortix runs agents on their own cloud computers and lands the work as a change request you review. It is the leading open-source alternative to Claude Cowork and ChatGPT Work. Read [Kortix vs Open WebUI](/kortix-vs-open-webui) for how the two differ, or [migrate from Open WebUI](/migrate-from-open-web-ui) if you are leaving a self-run instance. [Self-hosting](/self-hosting) covers running the platform on your own hardware. ## Questions before you install Short answers about the Open WebUI install, each sourced from its own docs. ### Does Open WebUI need Docker? No. Docker is the officially supported method, and the pip path needs only Python 3.11. Both run the same chat interface; only the packaging differs. ### Does Open WebUI need a GPU? Only when the models run locally. Over a hosted API there is no GPU involved. The `:cuda` image accelerates local inference on an NVIDIA GPU and needs the CUDA support the project documents for Linux or WSL ([repository](https://github.com/open-webui/open-webui)). ### Where does Open WebUI store its data? In the `open-webui` Docker volume, mounted at `/app/backend/data`. Your chats, users and settings live there and survive updates. The default setup is SQLite with local file storage; PostgreSQL and S3 are options for larger deployments. ### How do I keep it updated? `:main` is a rolling image rebuilt from the main branch, so an update is a new image pull on the same volume. Note that `:latest` follows `:main` and is not the newest stable release. ## Put the work on a cloud computer. Kortix runs the agents and lands the work as a change request you review. [Try Kortix](https://kortix.com)