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.
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:echo "WEBUI_SECRET_KEY=$(openssl rand -hex 32)" > .env && chmod 600 .env
docker compose up -d
curl -s http://localhost:3000/api/versionOurs 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_KEYyourself. 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 answered401 Unauthorizedand 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=userand a differentOLLAMA_BASE_URL: nothing changed. Change those in the admin settings. - Ollama on another machine needs
OLLAMA_HOSTset 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:
You do not have permission to access this resource. Please contact your administrator for assistance.So you choose one of two policies:
| Policy | How | What we saw |
|---|---|---|
| Admin creates each account | Admin Panel > Users, add user with role user | Account works at once; sign-up stays closed |
| Colleagues register, you approve | Turn sign-up on in the admin settings; default role pending | New 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:
| Group | Members | Read access to | What members saw |
|---|---|---|---|
| Personal (everyone) | 3 | llama3.1:8b | Only that model |
| Finanzas | 1 | qwen2.5vl:7b | Both models |
| Admin | 1 | (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_ctx4096 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=truegives 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:
| Path | What it holds |
|---|---|
webui.db | SQLite database: accounts, chats, groups, settings (53 tables in 0.13.3) |
webui.db-wal, webui.db-shm | Recent 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.log | The 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=falseandENABLE_ADMIN_EXPORT=falsethe 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:
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-webuiCheck 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:
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 -dAccounts, 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:
- Read the release notes of every version between yours and the target.
- Take the backup from step 5.
- Change the tag in the compose file, then
docker compose pull && docker compose up -d. - 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:
caddy:
image: caddy:2-alpine
ports:
- "443:443"
volumes:
- ./Caddyfile:/etc/caddy/Caddyfile:ro
- caddy-data:/data
restart: unless-stoppedchat.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:
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" 200The 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:
{"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:
timestampis Unix seconds.date -d @1794771082converts 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,/folderseach one wrote a line with the user andmodel_id. - The levels
REQUESTandREQUEST_RESPONSEadd 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:
| Item | After deletion |
|---|---|
| Sign-in and open sessions | Refused: Invalid authentication request. |
| Chats | Gone |
| Group memberships | Removed |
| Uploaded file | Still 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, date | Model | At once | First word, median (worst) | Full answer, median (worst) |
|---|---|---|---|---|
| vLLM 0.19.0, 2026-10-08 | Qwen2.5-7B-Instruct BF16 | 10 | 0.19 s (4.79 s) | 15.2 s (19.8 s) |
| Ollama 0.30.10, 1 slot, 2026-11-02 | qwen2.5:7b-instruct fp16 | 10 | 71.7 s (146.4 s) | 86.6 s (162.9 s) |
| Ollama 0.30.10, 1 slot, 2026-11-06 | qwen2.5:7b-instruct Q4_K_M | 8 | 15.87 s (31.68 s) | 20.3 s (36.14 s) |
| Ollama 0.30.10, 8 slots, 2026-11-06 | same | 8 | 0.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 see | Cause | Fix |
|---|---|---|
| A colleague has no models to pick | Models are private by default | Give their group read access (step 3) |
You do not have permission to access this resource... on registering | Sign-up closed itself after the first account | Create the account as admin, or enable sign-up (step 2) |
| Same message after registering | Role is pending | Change 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 failed | Inside the container, 127.0.0.1 is the container | Use host.docker.internal or the server’s address. Users then see an empty list and Model not found |
| Everyone signed out after recreating the container | No fixed WEBUI_SECRET_KEY | Set it once and keep it (step 1) |
| Changed a variable, nothing happened | Stored setting wins over the environment | Change it in the admin settings |
| Empty or garbled answers behind a proxy | The troubleshooting page blames WebSocket or CORS settings and quotes the log text is not an accepted origin | Set CORS_ALLOW_ORIGIN to your address. We did not reproduce this one |
Error loading SentenceTransformer... at start | OFFLINE_MODE=true on a fresh install: the embedding model was not in the cache | Start 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
- Benchmark a local model on your own machine to get your own version of the speed table.
- Keep your local AI patched: updates and exposure checks for the server behind Open WebUI.
Want this sized and installed for your team? Book a 15-minute call or see how we work in consulting.