Self-Host Open WebUI on Liquid Web

Contains affiliate links. Disclosure.

TL;DR

• Open WebUI: BSD-3-Clause chat interface for LLMs (with a branding clause), ~135k GitHub stars, v0.6.5 (2026-04-25), active corporate sponsorship
• Stack: Open WebUI app + Caddy, measured 300 MB idle on 4 vCPU / 8 GB (SQLite, no separate DB container)
• Connects to Ollama (local or remote) and any OpenAI-compatible API: multi-model, RAG, image gen, voice, team workspaces
• ChatGPT Plus: $20/mo per user; Open WebUI on Liquid Web: ~$25/mo VPS, unlimited users

Open WebUI (github.com/open-webui/open-webui) is a full-featured chat interface that sits in front of language models. It does not run models itself. It connects to a model backend: either an Ollama instance (for locally hosted models like Llama 3, Mistral, Phi-3) or any OpenAI-compatible API endpoint (OpenAI, Anthropic via proxy, Groq, Together AI, etc.). The result is a ChatGPT-quality interface your whole team can use, running on your own infrastructure, with no per-seat pricing.

License note: Open WebUI ships under a BSD-3-Clause license with an additional branding clause: the code is freely usable, but the "Open WebUI" name and logo are protected. If you build a product on top and sell it to others, you cannot call it "Open WebUI." For internal team use (which is what this guide covers), there are no practical restrictions: the BSD-3-Clause grants apply fully to your self-hosted deployment. Read the full LICENSE at github.com/open-webui/open-webui before any commercial redistribution.

Open WebUI vs LibreChat: both are self-hosted chat interfaces. Open WebUI is more focused on Ollama integration and model management; LibreChat has broader built-in provider support (including assistants and plugins) but a heavier Node.js + MongoDB stack. For teams primarily using Ollama, Open WebUI is the cleaner fit.

🖥️

Liquid Web

Run this on a Managed VPS

Tested on local Docker equivalent to a Liquid Web 4 GB Managed VPS. Open WebUI's 300 MB idle footprint fits a 2 GB VPS when connecting to an external Ollama instance. If you want to run Ollama on the same server, budget for a 4 GB VPS minimum (Ollama itself needs RAM proportional to the model: Llama 3.2 3B needs ~2 GB, Llama 3 8B needs ~5 GB).

From $33/mo · 99.99% uptime SLA · Managed security · 24/7 support · Prices subject to change

View Managed VPS plans →

Prerequisites

• A Liquid Web 2 GB Managed VPS (standalone Open WebUI with external Ollama) or 4 GB+ (for Ollama on the same server). Verify pricing
• Docker Engine 25+ and Docker Compose V2
• A domain with its A record pointing to the VPS IP
• An Ollama instance (on the same server or a separate one), or an OpenAI API key
• About 20 minutes

The complete docker-compose.yml

# open-webui/docker-compose.yml
# Tested 2026-05-02 on local Docker (4 vCPU / 8 GB RAM)
# Idle: 300 MB RAM | Peak: 500 MB (RAG document indexing)
# Source: https://github.com/open-webui/open-webui — adapted for production

services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:v0.6.5
    restart: unless-stopped
    environment:
      # Point to your Ollama instance.
      # Same Compose stack: http://ollama:11434
      # Separate server: http://YOUR_SERVER_IP:11434
      OLLAMA_BASE_URL: ${OLLAMA_BASE_URL:-http://ollama:11434}
      # Optional: connect OpenAI or any OpenAI-compatible API as well
      OPENAI_API_KEY: ${OPENAI_API_KEY:-}
      # Required: generate with 'openssl rand -hex 32'
      WEBUI_SECRET_KEY: ${WEBUI_SECRET_KEY}
      # Enable authentication (critical for production)
      WEBUI_AUTH: "true"
      # New users require admin approval before first login.
      # Change to 'user' if you want open self-registration.
      DEFAULT_USER_ROLE: pending
    volumes:
      - webui_data:/app/backend/data
    networks:
      - webui_net
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:8080/health || exit 1"]
      interval: 15s
      timeout: 5s
      retries: 5

  caddy:
    image: caddy:2-alpine
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
      - "443:443/udp"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile:ro
      - caddy_data:/data
      - caddy_config:/config
    depends_on:
      open-webui:
        condition: service_healthy
    networks:
      - webui_net

volumes:
  webui_data:
  caddy_data:
  caddy_config:

networks:
  webui_net:
    driver: bridge

Production upgrade: PostgreSQL for multi-user teams

The Compose file above uses SQLite (Open WebUI's default). SQLite handles dozens of concurrent users without trouble. For larger teams or if you want a separate backup target for user data, switch to PostgreSQL by adding a db service and the WEBUI_DB_URL environment variable:

# Add to services:
  db:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_DB: openwebui
      POSTGRES_USER: openwebui
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - db_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U openwebui -d openwebui"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - webui_net

# Add to open-webui environment:
      WEBUI_DB_URL: postgresql://openwebui:${POSTGRES_PASSWORD}@db:5432/openwebui

# Add depends_on to open-webui:
    depends_on:
      db:
        condition: service_healthy

# Add to volumes:
  db_data:

Caddyfile

# Caddyfile — Open WebUI reverse proxy
ai.yourdomain.com {
    reverse_proxy open-webui:8080 {
        health_uri /health
        health_interval 15s
    }

    encode gzip

    header {
        Strict-Transport-Security "max-age=31536000; includeSubDomains"
        X-Frame-Options SAMEORIGIN
        X-Content-Type-Options nosniff
    }
}

.env file

# .env — keep out of version control

# Ollama backend URL.
# Same Docker Compose stack: http://ollama:11434
# Separate server: http://YOUR_SERVER_IP:11434
OLLAMA_BASE_URL=http://ollama:11434

# OpenAI API key (optional — leave blank if using Ollama only)
OPENAI_API_KEY=

# Required: generate a secret key with: openssl rand -hex 32
WEBUI_SECRET_KEY=

# PostgreSQL password (only needed if you switch to PostgreSQL)
POSTGRES_PASSWORD=change-me-strong-password

First-run setup

# 1. Generate the secret key
openssl rand -hex 32  # paste into WEBUI_SECRET_KEY in .env

# 2. Start the stack
docker compose up -d

# 3. Verify all services are healthy
docker compose ps

# 4. Check logs if anything looks off
docker compose logs open-webui --tail 30

# 5. Visit https://ai.yourdomain.com
#    The first user to sign up becomes the admin automatically.
#    Sign up with your admin email — no approval step for the first account.

# 6. Add your Ollama model backend:
#    Settings → Connections → Ollama → verify the URL resolves
#    Pull models from the Open WebUI interface: Models → Pull a model from Ollama.com

# 7. (Optional) Invite team members:
#    Settings → Users → Pending → Approve each new user
#    Or change DEFAULT_USER_ROLE=user in .env for open registration

Verify the stack

# All services should be Up and healthy
docker compose ps

# Health endpoint
curl -s https://ai.yourdomain.com/health
# {"status":"ok"}

# Resource usage
docker stats --no-stream

Runtime footprint

Measured 2026-05-02 on local Docker (4 vCPU / 8 GB RAM), Open WebUI v0.6.5 standalone with SQLite.

Service	Idle RAM	Peak RAM (RAG indexing)
open-webui	280 MB	475 MB
caddy	15 MB	20 MB
Total	300 MB	500 MB

These numbers are for Open WebUI itself. They do not include Ollama. Ollama's RAM usage is dominated by the loaded model: expect an additional 2 GB for Llama 3.2 3B, 5 GB for Llama 3 8B, and 10+ GB for Llama 3 70B (quantized). If you run Ollama on the same VPS, size accordingly.

Upgrading Open WebUI

# Check github.com/open-webui/open-webui/releases for the latest version

# Update the image tag in docker-compose.yml (line: image: ghcr.io/open-webui/open-webui:v0.6.5)
# or pin the version via an env var if you prefer

# Pull the new image
docker compose pull open-webui

# Restart with the new version (database migrations run automatically)
docker compose up -d open-webui

# Verify
docker compose ps
docker compose logs open-webui --tail 20

Cost vs cloud alternative

	ChatGPT Plus	Claude.ai Pro	Open WebUI on Liquid Web
Monthly cost	$20/mo per user	$20/mo per user	~$25/mo VPS (unlimited users)
Model choice	GPT-4o, o1	Claude Sonnet 4.6 / Opus 4.7	Any Ollama model + any OpenAI-compatible API
Data leaves your servers?	Yes	Yes	No (for Ollama models)
Team workspaces	✓ (Teams plan, $30/mo)	✗	✓
RAG / document upload	✓	✓	✓
Image generation	✓ (DALL-E 3)	✗	✓ (via Automatic1111/ComfyUI)
Voice input	✓	✗	✓
API access	✓	✓	✓ (Ollama API passthrough)
License	Proprietary	Proprietary	BSD-3-Clause (+ branding clause)

VPS pricing subject to change, so verify at liquidweb.com/vps-hosting/managed-vps/.

When this isn't right for you

• You need a frontier model like Claude Opus 4.7 or Sonnet 4.6 specifically. Open WebUI can route to these APIs via OPENAI_API_KEY, but you still pay the API usage costs. At high usage, API costs exceed the $20/mo ChatGPT Plus flat fee. Open WebUI's strongest value proposition is when you're running local Ollama models (where there's no per-token cost) or you need a unified interface across multiple providers.
• Your team needs SSO / SAML / Active Directory integration. Open WebUI's built-in auth supports OAuth (Google, Microsoft, GitHub) but not enterprise SAML or LDAP. If your org requires LDAP/Active Directory, put an identity proxy (Authentik or Authelia) in front.
• You want to run large models (70B+) locally. A standard VPS is not the right host. You need dedicated GPU hardware. Liquid Web's GPU servers are the appropriate tier for 70B+ model hosting.
• Your team is non-technical and needs managed updates. Open WebUI releases frequently. Someone needs to pull new images periodically and test for regressions. If that overhead isn't acceptable, the hosted ChatGPT Teams plan ($30/mo/user) bundles model updates, uptime, and support.

Exit strategy

# Export chat history via the Open WebUI interface:
# Settings → General → Export Data
# This exports all conversations as a JSON file.

# Back up the application data volume
docker run --rm \
  -v open-webui_webui_data:/source:ro \
  -v $(pwd):/backup \
  alpine tar czf /backup/webui_data_backup.tar.gz -C /source .

# If using PostgreSQL, also dump the database
docker compose exec db pg_dump -U openwebui openwebui > openwebui_export.sql

Open WebUI stores conversations, user accounts, model configurations, RAG documents, and workspace settings in the webui_data volume. The exported JSON from the UI is human-readable and importable into any OpenAI-compatible chat application.

Frequently Asked Questions

Yes. Set `OPENAI_API_KEY` in your `.env` and leave `OLLAMA_BASE_URL` blank (or point it at a non-existent host). Open WebUI will show GPT-4o, GPT-4 Turbo, and other OpenAI models in the model selector. You can also configure multiple providers simultaneously: mix local Ollama models with OpenAI, Groq, or any OpenAI-compatible endpoint from the Settings → Connections panel.

Open WebUI ships under a BSD-3-Clause license with an additional branding clause: the code grants are permissive, but the 'Open WebUI' name and logo are protected, so you cannot build a competing product and call it Open WebUI or use the official logo. For self-hosting on your own VPS for your own team, this restriction has zero practical effect. You can use, modify, and deploy the software without restriction. The branding clause only matters if you're building a commercial product sold to third parties.

Open WebUI supports system prompts at multiple levels. For a global default: Settings → Interface → System Prompt, which applies to all new conversations unless overridden. For per-model defaults: navigate to the model in the Models panel → edit → set a model-level system prompt. Users can also set their own per-conversation system prompts. Admins can lock system prompts for specific models to prevent users from overriding them.

Yes. Open WebUI implements RAG entirely on the server side. It splits uploaded documents into chunks, embeds them (using a local embedding model via Ollama, or OpenAI embeddings), stores vectors in ChromaDB inside the `webui_data` volume, and retrieves relevant chunks at query time. To use local embeddings: Settings → Documents → Embedding Model → select an Ollama model (e.g. `nomic-embed-text`). No external API calls are made. Supported formats: PDF, DOCX, TXT, Markdown, CSV, and more.

Open WebUI itself is lightweight (300 MB idle). The bottleneck is the model backend (Ollama or API), not Open WebUI. With an external API (OpenAI/Groq), a single instance can handle hundreds of concurrent users, since Open WebUI just routes requests. With local Ollama, throughput is limited by the GPU/CPU handling inference: a single Llama 3 8B instance processes one request at a time by default (Ollama v0.3+ supports limited parallelism). For teams over ~20 simultaneous active users on local models, consider running multiple Ollama instances behind a load balancer.