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

> A complete Open WebUI 0.13 setup for a small office, run step by step on a test instance: accounts, model access by group, logs, backups and GDPR duties.

- Published: 2026-10-27
- Updated: 2026-11-15
- Author: Jacobo González Jaspe
- Language: en
- Tags: Open WebUI, Ollama, Self-hosted, GDPR, Benchmarks
- Canonical URL: https://vorluxai.com/en/blog/open-webui-office-accounts-models-logs-en/
- Source: VORLUX AI (J4SGON S.L.), https://vorluxai.com/

---

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](https://vorluxai.com/en/blog/install-ollama-first-local-llm-en/).

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](https://vorluxai.com/data/measurements/openwebui-office-walkthrough-2026-11-15.json).

> **TL;DR**
> * Open WebUI 0.13.3 gives you accounts, groups, per-group model access and an audit log. A new user sees **no models** until you grant them, and sign-up closes itself after the first account.
> * On our hardware, ten simultaneous requests to a 7B model each got a full answer in about 15 seconds with vLLM. With Ollama at one slot, the same ten queued for over a minute.
> * Verdict: **Buy nothing yet.** Start on the machine you have. Back up with the container stopped, and write down your retention period: the software does not have one.

## 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](https://docs.openwebui.com/security/chat-data-privacy-and-encryption) 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](https://docs.openwebui.com/license) (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](https://docs.openwebui.com/getting-started/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](https://github.com/open-webui/open-webui/releases/tag/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](https://docs.openwebui.com/reference/env-configuration) 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](https://docs.ollama.com/faq) explains. Ollama has no login of its own, so keep it reachable only from the Open WebUI host. Our [patching checklist](https://vorluxai.com/en/blog/keep-your-local-ai-patched-ollama-security-checklist-en/) 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](https://docs.openwebui.com/features/authentication-access/rbac/roles) 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:

| 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](https://github.com/open-webui/open-webui/releases/tag/v0.12.0)); 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](https://docs.openwebui.com/getting-started/quick-start/connect-a-provider/starting-with-ollama) 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](https://docs.openwebui.com/features/authentication-access/rbac/permissions)). Then edit each model and give a group read access ([groups page](https://docs.openwebui.com/features/authentication-access/rbac/groups)). 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_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](https://vorluxai.com/en/blog/ollama-context-length-memory-measured-en/).
* **`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:

| 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=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](https://docs.openwebui.com/getting-started/updating) 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](https://caddyserver.com/docs/automatic-https)).

Open WebUI printed this at start: `WARNING: CORS_ALLOW_ORIGIN IS SET TO '*' - NOT RECOMMENDED FOR PRODUCTION DEPLOYMENTS.` The [HTTPS reference](https://docs.openwebui.com/reference/https/) 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](https://docs.openwebui.com/getting-started/advanced-topics/hardening#audit-logging)). 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](https://eur-lex.europa.eu/eli/reg/2016/679/oj), 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](https://www.boe.es/eli/es/lo/2018/12/05/3/con) 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](https://vorluxai.com/en/blog/gdpr-article-25-local-ai-privacy-by-design-2026-en/).

## 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](https://vorluxai.com/data/measurements/openwebui-concurrency-2026-10-08.json) and [ollama-concurrency-prime-2026-11-02.json](https://vorluxai.com/data/measurements/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](https://vorluxai.com/data/measurements/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](https://vorluxai.com/en/blog/ollama-vs-vllm-small-office-measured-en/). 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](https://docs.openwebui.com/troubleshooting/connection-error) 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](https://vorluxai.com/en/blog/how-much-vram-local-llm-en/). A much larger model, such as the one in our [Llama 3.3 70B review](https://vorluxai.com/en/blog/llama-3-3-70b-local-review-what-it-takes-to-run-en/), 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](https://vorluxai.com/en/blog/benchmark-local-model-own-machine-30-minutes-en/) to get your own version of the speed table.
* [Keep your local AI patched](https://vorluxai.com/en/blog/keep-your-local-ai-patched-ollama-security-checklist-en/): updates and exposure checks for the server behind Open WebUI.

Want this sized and installed for your team? [Book a 15-minute call](https://vorluxai.com/en/contact/) or see [how we work in consulting](https://vorluxai.com/en/consulting/).
