View all articles
Open WebUIOllamaSelf-hostedGDPRBenchmarks

Open WebUI for a Small Office: Accounts, Models, Logs, Backups

JG
Jacobo González Jaspe
|

Reviewed:

Abstract illustration: classical columns reduced to geometric pillars, side-lit in amber. Safe and legal
Illustration generated with AI on our own machine.
This article is also available in Spanish:Open WebUI en la oficina: cuentas, modelos, registros y copias

By the end of this guide your office will have one private chat page: an account per person, only the models you chose for each group, conversations stored on a machine you own, a backup you have restored once, and a written answer to “who can read what”. You can start on the computer that already runs Ollama.

We ran every step below on 15 November 2026 against a throwaway Open WebUI 0.13.3 container with invented accounts, driving it through its API. Menu names come from the official documentation; outputs and error messages are the ones we got. The full record is in openwebui-office-walkthrough-2026-11-15.json.

Who this is for, and when not to do it

This fits an office of 3 to 30 people with one person willing to look after a Docker container.

Skip it if nobody will own updates and backups, or if the conversations will hold data so sensitive that the administrator must be technically unable to read them. Open WebUI’s own privacy page says to “treat every admin as able to read every chat”.

What you need

  • A machine that already serves a model with Ollama. A laptop or mini PC is enough to start.
  • Docker with Docker Compose.
  • About an hour, including one backup and one restore.

A note on the licence, since “open source” gets used loosely. The licence page (read 15 November 2026) describes the Open WebUI License: the BSD-3-Clause text plus a clause that forbids removing the Open WebUI branding, with an exception for deployments of up to 50 users. Using it unmodified costs nothing.

Step 1: start a pinned version

The quick start uses the :main image, a rolling build. The same page explains that :latest is that rolling build too, and that tags like :v0.13.3 never change. For an office, pin the version: you decide when to update. On 15 November 2026 the newest release was v0.13.3, published on 8 November.

YAML
services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:v0.13.3
    ports:
      - "3000:8080"
    environment:
      - WEBUI_SECRET_KEY=${WEBUI_SECRET_KEY}
      - OLLAMA_BASE_URL=http://host.docker.internal:11434
      - ENABLE_OPENAI_API=false
      - AUDIT_LOG_LEVEL=METADATA
    extra_hosts:
      - "host.docker.internal:host-gateway"
    volumes:
      - open-webui:/app/backend/data
    restart: unless-stopped

volumes:
  open-webui:
bash
echo "WEBUI_SECRET_KEY=$(openssl rand -hex 32)" > .env && chmod 600 .env
docker compose up -d
curl -s http://localhost:3000/api/version

Ours answered {"version":"0.13.3","deployment_id":""}. We started the container with the equivalent docker run flags and a bind-mounted folder instead of a named volume.

Three details matter here:

  • Set WEBUI_SECRET_KEY yourself. Without it the container writes a random key to a file outside the data volume. We recreated the container without the variable: every existing session answered 401 Unauthorized and everyone had to sign in again.
  • Most settings are read from the environment only once. After the first start they live in the database, and the environment reference calls them ConfigVar. We recreated the container with DEFAULT_USER_ROLE=user and a different OLLAMA_BASE_URL: nothing changed. Change those in the admin settings.
  • Ollama on another machine needs OLLAMA_HOST set on that machine so it listens beyond 127.0.0.1, as the Ollama FAQ explains. Ollama has no login of its own, so keep it reachable only from the Open WebUI host. Our patching checklist covers that exposure.

Step 2: first admin and the sign-up policy

Open http://localhost:3000 and create your account before sharing the address. The first account becomes the administrator, and the roles page notes that it can never be deleted. We tried: The requested action has been restricted as a security measure.

Then something that older guides (ours included) got wrong for current versions. After the first account, sign-up turned itself off. We never set ENABLE_SIGNUP=false, yet the second person to register got HTTP 403 and this message:

text
You do not have permission to access this resource. Please contact your administrator for assistance.

So you choose one of two policies:

PolicyHowWhat we saw
Admin creates each accountAdmin Panel > Users, add user with role userAccount works at once; sign-up stays closed
Colleagues register, you approveTurn sign-up on in the admin settings; default role pendingNew account gets role pending and the same message on every request until you change it to user

For ten people, create the accounts yourself and leave sign-up off. Nobody outside the office gets in by finding the URL. If you want a second factor, 0.12.0 added ENABLE_MFA, which requires an authenticator app for everyone (release notes); we did not test it.

A role change does not sign anyone out. The roles page points to “Sign out all devices” in the user’s edit dialog for that.

Step 3: groups and which models each group sees

Connect Ollama first if you did not set the variable: Settings > Connections > Manage Ollama API Connections, as the Ollama connection page shows.

With Ollama connected and nothing else touched, our administrator saw all 14 models on the server. Each of the three ordinary users saw zero. Models are private until you grant access, so an empty model list on a colleague’s first day is the default, not a fault.

Create groups under Admin Panel > Users > Groups. Permissions add up: a person gets the global defaults plus whatever any of their groups grants, and there is no “deny” (permissions page). Then edit each model and give a group read access (groups page). This is the layout we tested:

GroupMembersRead access toWhat members saw
Personal (everyone)3llama3.1:8bOnly that model
Finanzas1qwen2.5vl:7bBoth models
Admin1(no grant needed)All 14

A user who asked for a model without a grant got Model not found, both on the chat endpoint and on the built-in Ollama proxy. The restriction is enforced on the server and does not depend on what the menu shows.

  • Set the context size on the model entry. We put num_ctx 4096 in the entry’s advanced parameters, and Ollama loaded the model with a 4,096-token context. Leave it unset and Ollama uses its own default, and context costs memory for every slot. We measured that in how much memory context costs.
  • BYPASS_MODEL_ACCESS_CONTROL=true gives every user every model. Use it only if the table above is more than you need.

The default permissions we found for ordinary users: file upload, chat delete, chat export, sharing links and temporary chats on; creating workspace models, knowledge bases and tools off; API keys off. Review them once under Groups > Default Permissions.

Step 4: where chats and uploads are stored

Everything lives in the folder mounted at /app/backend/data. Ours contained:

PathWhat it holds
webui.dbSQLite database: accounts, chats, groups, settings (53 tables in 0.13.3)
webui.db-wal, webui.db-shmRecent writes not yet merged into webui.db
uploads/Uploaded files, named <id>_<original name>
vector_db/Document search index
cache/Generated audio and images
audit.logThe audit trail, if enabled

Passwords are stored as bcrypt hashes. Chats and files are not encrypted by the application: the privacy page recommends an encrypted disk for that.

Who can read a chat, as we tested it:

  • A colleague opening someone else’s chat by its address got We could not find what you're looking for :/.
  • The administrator could list and open any user’s chat, and download the whole database.
  • With ENABLE_ADMIN_CHAT_ACCESS=false and ENABLE_ADMIN_EXPORT=false the administrator got HTTP 401 on all three. These two are plain environment switches and did apply on restart.

The documentation is frank that those switches set the interface’s behaviour and are no security boundary: whoever controls the host, the volume or the backups can read everything.

Step 5: back up, and restore once

Open WebUI runs SQLite in write-ahead mode. Recent changes sit in webui.db-wal, and that has two consequences we saw directly.

The admin “database download” can be badly out of date. It sends webui.db as it is on disk. Our first download, minutes after creating four accounts and two chats, contained zero users and zero chats. The environment reference says the same: it is not the recommended way to back up.

Do not open the live database with other tools. After one admin download, we opened webui.db with sqlite3 from a second process while the server ran. The server was left writing to a deleted WAL file, and a chat saved afterwards (HTTP 200) was gone after a restart. We reproduced it once more in a controlled run; either action alone did no harm. One run per case, cause not established: take it as a warning, not a diagnosis.

The backup that worked is the simple one, with the container stopped:

bash
docker compose stop open-webui
docker run --rm -v open-webui:/data:ro -v "$PWD":/backup alpine \
  tar czf /backup/open-webui-$(date +%F).tgz -C /data .
docker compose start open-webui

Check the volume’s real name with docker volume ls; Compose usually prefixes it with the project name. Even after a clean stop, our folder still held a non-empty webui.db-wal, so copy the whole folder and never webui.db alone.

To restore, we emptied the folder, extracted the archive and started the container with the same WEBUI_SECRET_KEY:

bash
docker compose down
docker run --rm -v open-webui:/data -v "$PWD":/backup:ro alpine \
  sh -c 'rm -rf /data/* && tar xzf /backup/open-webui-2026-11-15.tgz -C /data'
docker compose up -d

Accounts, chats, groups and settings were back, and sessions opened before the backup still worked. Keep the .env file with the backup.

Step 6: updates

The updating page warns that database migrations are one-way: rolling back the image does not undo them. The release notes for 0.13.0 and 0.13.1 both announce schema changes. So the order is fixed:

  1. Read the release notes of every version between yours and the target.
  2. Take the backup from step 5.
  3. Change the tag in the compose file, then docker compose pull && docker compose up -d.
  4. Check /api/version, sign in, open an old chat.

If it goes wrong, restore the backup with the old tag. We did not test an upgrade between versions; this procedure is the documented one.

Step 7: HTTPS on the office network

Passwords should not cross the office Wi-Fi in clear text, and browsers only allow the microphone over HTTPS. Caddy does this in a few lines. Add it to the same compose file and remove the ports entry from Open WebUI:

YAML
  caddy:
    image: caddy:2-alpine
    ports:
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile:ro
      - caddy-data:/data
    restart: unless-stopped
text
chat.office.lan {
	tls internal
	reverse_proxy open-webui:8080
}

Declare caddy-data under volumes: and point chat.office.lan at the server in your router’s DNS. With Caddy 2.11.4 in front of our test instance, /api/version answered over HTTPS and the WebSocket handshake returned 101 with no extra configuration.

tls internal makes Caddy its own certificate authority. Each computer must trust its root certificate, stored in Caddy’s data folder under pki/authorities/local, or browsers will show a warning (Caddy documentation).

Open WebUI printed this at start: WARNING: CORS_ALLOW_ORIGIN IS SET TO '*' - NOT RECOMMENDED FOR PRODUCTION DEPLOYMENTS. The HTTPS reference says to set WEBUI_URL and CORS_ALLOW_ORIGIN to your address, plus WEBUI_SESSION_COOKIE_SECURE=true. We did not test those three.

Step 8: what is logged and how to read it

There are two logs.

The container log (docker compose logs open-webui) has one line per request, in UTC, with the path and status but no user name:

text
2026-11-15 19:32:30.787 | INFO | uvicorn.protocols.http.httptools_impl:send:482 - 172.17.0.1:46674 - "POST /api/v1/auths/signin HTTP/1.1" 200

The audit log is off by default. AUDIT_LOG_LEVEL=METADATA writes one JSON object per line to audit.log in the data folder. This is ours for the deletion of a user, shortened:

JSON
{"timestamp": 1794771082, "user": {"email": "admin@oficina.test", "role": "admin", "name": "Admin Prueba"},
 "audit_level": "METADATA", "verb": "DELETE", "request_uri": "http://127.0.0.1:38080/api/v1/users/332123ae-…",
 "source_ip": "172.17.0.1", "model_id": null, "request_object": "", "response_object": ""}

What we learned reading it:

  • timestamp is Unix seconds. date -d @1794771082 converts it.
  • It records who did what and from where: account creation, role changes, group and model edits, uploads, deletions. At this level it holds no message text.
  • Sign-in lines carry an empty user, so they show the time and address only.
  • Chat requests are excluded by default. With AUDIT_EXCLUDED_PATHS=/chats,/folders each one wrote a line with the user and model_id.
  • The levels REQUEST and REQUEST_RESPONSE add the bodies, meaning the prompts and answers (hardening page). That copies your staff’s conversations into a second file, so have a reason you can explain to them.

Step 9: remove a user and their data

Deleting a user is in Admin Panel > Users. We deleted one who owned a chat, an uploaded file and two group memberships:

ItemAfter deletion
Sign-in and open sessionsRefused: Invalid authentication request.
ChatsGone
Group membershipsRemoved
Uploaded fileStill there, in the database and in uploads/

The file stayed until the administrator deleted it by its id. So before you delete someone, list their files (or have them clear Settings > Data Controls > Manage Files), and remember that older backups still contain everything. If they want a copy first, they can export their chats from that same menu.

Data protection, stated plainly

This is information, not legal advice. Article numbers refer to the GDPR on EUR-Lex, all in force.

  • You are the controller. The company decides why and how the chats are processed (Art. 4(7)). With a self-hosted install and a local model there is no provider acting as processor for the conversations.
  • Tell your staff (Art. 13): what is stored, for how long, and that the administrator can technically read chats.
  • Retention (Art. 5(1)(e)): data is kept no longer than needed. We found no retention or auto-delete setting in the environment reference or in 0.13.3, so pick a period, write it down and delete by hand on a schedule. Temporary chats, which an admin can enforce per group, are never saved.
  • Access and erasure requests (Arts. 15 and 17) must be answered within one month (Art. 12(3)). Steps 4 and 9 are your tools: export, delete the user, delete their files, let old backups expire.
  • Records and security (Arts. 30 and 32): add the chat service to your record of processing. The under-250-employees exception in Art. 30(5) does not cover processing that is not occasional.
  • In Spain, Article 87 of Organic Law 3/2018 lets an employer access content on work devices only to check compliance with duties and protect the devices’ integrity, under usage criteria made known to staff beforehand. Reading someone’s chats belongs in those criteria, with a stated reason. Art. 88 GDPR lets each country add employment rules, so check yours.

For privacy by design in general, see our note on Article 25 and local AI.

What we measured: how many people one box serves

Open WebUI does not run the model. It forwards each chat to the backend, so the backend sets the speed. Three of our own runs, all on NVIDIA DGX Spark machines (GB10, 128 GB unified memory):

Backend, dateModelAt onceFirst word, median (worst)Full answer, median (worst)
vLLM 0.19.0, 2026-10-08Qwen2.5-7B-Instruct BF16100.19 s (4.79 s)15.2 s (19.8 s)
Ollama 0.30.10, 1 slot, 2026-11-02qwen2.5:7b-instruct fp161071.7 s (146.4 s)86.6 s (162.9 s)
Ollama 0.30.10, 1 slot, 2026-11-06qwen2.5:7b-instruct Q4_K_M815.87 s (31.68 s)20.3 s (36.14 s)
Ollama 0.30.10, 8 slots, 2026-11-06same80.26 s (0.47 s)7.37 s (7.54 s)

The first two rows asked for 250 tokens from a 384-token office prompt, three repetitions per level: openwebui-concurrency-2026-10-08.json and ollama-concurrency-prime-2026-11-02.json. The last two asked for 200 tokens with a 4,096-token context: ollama-parallel-keep-alive-2026-11-06.json. In that run, eight slots raised the loaded model from 4.75 GB to 6.53 GB.

The reading: one 7B model serves ten people drafting emails, if the backend answers in parallel. With Ollama that means setting OLLAMA_NUM_PARALLEL; at one slot, requests wait in line. We compare both backends in Ollama or vLLM for a small office. These requests went straight to the backend, so they do not include Open WebUI’s own overhead, which we have not measured.

When it fails

What you seeCauseFix
A colleague has no models to pickModels are private by defaultGive their group read access (step 3)
You do not have permission to access this resource... on registeringSign-up closed itself after the first accountCreate the account as admin, or enable sign-up (step 2)
Same message after registeringRole is pendingChange the role to user
WebUI could not connect to Ollama, and in the log Cannot connect to host 127.0.0.1:11434 ... Connect call failedInside the container, 127.0.0.1 is the containerUse host.docker.internal or the server’s address. Users then see an empty list and Model not found
Everyone signed out after recreating the containerNo fixed WEBUI_SECRET_KEYSet it once and keep it (step 1)
Changed a variable, nothing happenedStored setting wins over the environmentChange it in the admin settings
Empty or garbled answers behind a proxyThe troubleshooting page blames WebSocket or CORS settings and quotes the log text is not an accepted originSet CORS_ALLOW_ORIGIN to your address. We did not reproduce this one
Error loading SentenceTransformer... at startOFFLINE_MODE=true on a fresh install: the embedding model was not in the cacheStart once without it if you need document search. Chat worked regardless

Limits and what we did not test

  • Everything went through the API. We did not click through the web interface, so menu paths are the documentation’s.
  • Four accounts, not thirty. No PostgreSQL, LDAP, single sign-on or MFA.
  • Document upload worked, but we did not test searching documents.
  • No upgrade from an older version, and no restricted CORS or secure cookies behind the proxy.
  • Long documents change the speed picture. Our runs sent short prompts; test with your real files, and size the memory first. A much larger model, such as the one in our Llama 3.3 70B review, will serve far fewer people at once.

FAQ

Can the administrator read my chats? By default, yes. The switch in step 4 hides them in the product, but whoever manages the server can still read the database.

Can we use ChatGPT or another cloud model through it? Open WebUI can connect to OpenAI-compatible services. Our compose file turns that off with ENABLE_OPENAI_API=false, so nothing leaves the building by accident.

Next steps

Want this sized and installed for your team? Book a 15-minute call or see how we work in consulting.

Diagram
Share: LinkedIn X
Veredicto semanal

Get new guides before anyone else

Subscribe and we tell you when new guides, templates and workflows go up. One email a week, no spam.

Already published: 102 guides and 25 templates. All free, no signup.

Bonus: the local-AI starter pack PDF when you subscribe
Once a week No spam Unsubscribe anytime

See what you get