Intermediate 12 minDaily plan

Open WebUI: managing access to documents

Sheets of paper are spread out beside a laptop on a wooden desk.

As soon as an Open WebUI instance serves multiple departments, the question is no longer just "does the model respond well?" but "who can query which documents?". Open WebUI: managing document access relies on three mechanisms (roles, groups, and the visibility of each knowledge base) that combine in ways that aren't always intuitive. This guide explains that model, offers a procedure for isolating by group, then a method for testing each account separately and looking for overlaps. It does not promise end-to-end isolation: only part of the process was observed by the editorial team, and this is stated.

By Mohamed Meguedmi·Update 2026-11-20·Tested on Windows, macOS, and Linux
!
Sources and version
The behaviors described follow the official Open WebUI permissions page (docs.openwebui.com, under Authentication & Access > RBAC > Permissions). This page could not be reviewed again at the time of writing (20/11/2026): menu labels, permission names, and API routes change from one version to the next. Note your instance's version (Settings > About) and check each point against the documentation for that version.

#Why isolate documents in Open WebUI

A knowledge base (Knowledge) in Open WebUI is a collection of files that are split into chunks and indexed. When a user references it with # in the chat, or when it's attached to a model, Open WebUI retrieves the chunks closest to the question and injects them into the context. The model can then reproduce those chunks, sometimes word for word.

The direct consequence: having access to a knowledge base means being able to read its content, even without ever opening the file. On a team instance, mixing public procedures, payslips, and supplier contracts in a single knowledge base amounts to handing all of those documents to anyone who can query it. Isolation therefore happens knowledge base by knowledge base, not file by file: a sensitive document must live in a knowledge base whose access scope matches its sensitivity.

Self-hosting solves the issue of data transfers to an external provider, not the issue of internal access. The site's GDPR guides point out that the data minimization principle also applies to coworkers: a person should only access the data they need for their role.

#Roles, groups, and knowledge base visibility

The complete kit for building your own local RAG.

Benefit from our experience and a guided path to build your local RAG and work with your own documents.

  • Lifetime online access
  • PDF + files
  • Refunded within 30 days

Access control in Open WebUI relies on three layers. Confusing them is the number one source of mistakes.

Roles
Each account has a role: administrator, user, or pending. A pending account can't do anything until an administrator approves it. An administrator manages the instance and, with the default settings, can see the workspace content of other accounts. The role is therefore a coarse barrier: it separates those who administer from those who use.
Groups
Created in the admin panel (Users > Groups section), groups serve two purposes: carrying feature permissions (being able to create knowledge bases, share, use certain features) and acting as a target when you share a resource. A user can belong to multiple groups.
Resource visibility
Every knowledge base, like every custom model, prompt, or tool, has an access setting. Private: only its owner (and administrators, depending on the setting described below) can access it, plus any explicitly added groups. Public: all users on the instance can read it. For each added group, you generally choose read or write access.

Group-based isolation therefore means keeping knowledge bases private, then adding only the relevant group or groups, with read access for most members. Write access (adding, replacing, deleting files) is reserved for a few people, ideally through a group separate from the readers.

#Permissions that add up: the default permissions trap

According to the official documentation, Open WebUI permissions are cumulative: a user gets the union of the default permissions (those that apply to all users) and those of all their groups. The broadest permission wins. There is no "deny" group that would revoke a permission granted elsewhere.

Two practical consequences. First, if the default permissions allow an action (for example, publicly sharing a knowledge base), no group can take it away from a user: you need to restrict the default, then re-enable the action only for the groups that need it. Second, membership in an additional group can only broaden access. Adding someone to the "Management" group without removing them from "Interns" gives them both scopes.

Default permissions
Configure these first, as restrictively as is reasonable: no public sharing, and limited knowledge base creation if the instance isn't a sandbox.
Group permissions
Reenable features for a subset of users: for example, a "Documentation editors" group that can create and share knowledge bases.
Per-resource access
Independent of feature permissions: being able to create knowledge bases does not give access to other people's knowledge bases. Each knowledge base's own setting determines who can read it.

#Prerequisites

An up-to-date Open WebUI instance
Installed and connected to Ollama (by default on http://localhost:11434), with a working embedding model. The guide "Open WebUI with Ollama: complete guide" covers installation.
A verified backup
Reorganizing access means modifying knowledge bases that people use every day. Archive the Docker volume before you start (see "Restoring Open WebUI and Ollama after an outage").
A map of your documents
A simple table: which knowledge base, which documents, what sensitivity level, which departments need read access, who needs write access. Without it, configuration happens request by request and drifts.
Test accounts
At least one non-admin account per group to check, plus one account that belongs to no group. Tests run with an admin account prove nothing about user access.
Allowed API keys
For command-line testing, the administrator must enable API keys (admin settings); each test account generates one from Settings > Account.

#Managing document access in Open WebUI: 5 steps

  1. 01
    1. Restrict the default permissions
    In the admin panel, open the default user permissions. Disable public sharing of knowledge bases and models, and restrict knowledge base creation if not everyone needs it. Also check the role assigned to new sign-ups: "pending" prevents an account created by mistake from immediately accessing anything.
  2. 02
    2. Create the groups
    One group per document scope ("HR", "Accounting", "Support"), plus, if needed, one editors group per scope. Name them after the corresponding knowledge bases: reviewing the settings will be easier. If your groups come from a directory via OAuth or LDAP, check the documentation for your version to see how group sync is configured, and whether a group removed in the directory is also removed in Open WebUI.
  3. 03
    3. Create or reorganize the knowledge bases
    In Workspace > Knowledge, create one knowledge base per scope. Moving a sensitive document from a broad knowledge base to a restricted one requires explicitly removing it from the first: a file imported into two knowledge bases exists twice, with two access settings.
  4. 04
    4. Set access for each knowledge base
    Keep the knowledge base private, add the relevant group with read access, and the editors group with write access. Avoid adding people one by one: individual access gets lost when people leave or change roles, whereas a group stays up to date in a single place.
  5. 05
    5. Review models that carry knowledge bases
    A custom model (Workspace > Models) can have knowledge bases attached. Set the model's access at least as strictly as that of the knowledge bases it carries, and test this case specifically (see the section on overlaps).
→
One canary document per knowledge base
Add a small text file to each knowledge base containing a unique, meaningless phrase, such as TEMOIN-RH-7Q2. If this string shows up in a response obtained by an account that shouldn't be able to read the knowledge base, the leak is proven, regardless of the path it took. This is more reliable than judging whether a response "looks like" a document's content.

#Test each user's access separately

The admin interface shows what is configured, not what a user actually gets. The only conclusive check is to put yourself in each account's shoes. Two complementary methods: one private browsing window per test account (to see the lists and the chat as the user does), and API calls with each account's key (to get reproducible, timestamped HTTP status codes).

For each test account, the script below queries the list of visible knowledge bases and then one specific knowledge base, and logs the response codes. Keys are read from private files, one per account, and are never passed in plain text on the command line. The /api/v1/knowledge/ routes are the ones from the Open WebUI API; confirm them for your version. Port 3000 matches the most common Docker command (-p 3000:8080).

Terminal — HTTP codes per account
U=http://localhost:3000
KB=identifiant-de-la-base   # visible dans l'adresse de la page de la base
JOURNAL=~/owui-acces-$(date +%F).log

# Un fichier de clé par compte de test, droits 600
for compte in admin rh compta aucun-groupe; do
  CLE=$(cat ~/.config/owui-test/$compte)
  liste=$(curl -s -o /dev/null -w '%{http_code}' \
    -H "Authorization: Bearer $CLE" "$U/api/v1/knowledge/")
  base=$(curl -s -o /dev/null -w '%{http_code}' \
    -H "Authorization: Bearer $CLE" "$U/api/v1/knowledge/$KB")
  echo "$(date -Is) $compte liste=$liste base=$KB:$base"
done | tee -a "$JOURNAL"

A 200 code on the knowledge base means the account can read it through the API; a 401 or 403 code means access is denied. The list's code is usually 200 for any valid account: what matters is its contents. The following command displays the names of the knowledge bases visible to an account; depending on the version, the response is an array or an object containing an array, hence the filter that handles both cases.

Terminal — knowledge bases visible to an account
curl -s -H "Authorization: Bearer $(cat ~/.config/owui-test/compta)" \
  "$U/api/v1/knowledge/" | jq -r '(.items? // .)[] | .name'

Next, build a matrix: one row per account, one column per knowledge base, with the expected value (read, write, none) and the observed value. Any cell where the observed value is broader than expected is a defect to fix before importing real documents. Rerun the matrix after every Open WebUI update and after every group change: a setting that's correct today can be changed by a migration or a handling error.

#Overlaps to check

Denying direct access to a knowledge base isn't enough to prove that an account can't obtain its content. Several indirect paths exist in a Open WebUI instance; their behavior depends on the version and configuration, and none of them has been tested by the editorial team. They're hypotheses to test with the canary document, not confirmed vulnerabilities.

Model with an attached knowledge base
A user has access to a custom model that carries a knowledge base, but not to the knowledge base itself: do they get passages from the knowledge base by chatting with the model? To test this, ask the model a question about the canary phrase.
Direct reference by ID
The completions API accepts a list of files or collections to use as context. Can an unauthorized account that knows a knowledge base's ID reference it this way? See the test call below.
Shared chats
A chat shared via link contains the responses already generated, and therefore potentially excerpts from documents. The link can circulate outside the group. Check who can create share links and what an account that opens one can see.
Files attached in the chat
A document dropped into a chat is not a knowledge base and isn't subject to the same settings. A user in the HR group who attaches a payslip to a shared chat breaks the isolation.
Administrator access
By default, administrators can see other accounts' resources. The documentation mentions an environment variable (BYPASS_ADMIN_ACCESS_CONTROL) to change this behavior; check its name and effect for your version. In any case, an administrator retains access to the server and the database, so keep the number of administrator accounts to a minimum.
Groups inherited from the directory
With OAuth or LDAP sync, a departure or a change of department must be reflected in the groups. Test the case of an account removed from a group in the directory, after it signs in again.
Terminal — direct knowledge base reference test
# Compte qui NE doit PAS lire la base $KB
curl -s "$U/api/chat/completions" \
  -H "Authorization: Bearer $(cat ~/.config/owui-test/compta)" \
  -H "Content-Type: application/json" \
  -d '{"model":"votre-modele",
       "messages":[{"role":"user","content":"Recopie la phrase qui commence par TEMOIN."}],
       "files":[{"type":"collection","id":"'"$KB"'"}]}' \
  | grep -o 'TEMOIN-[A-Z0-9-]*' || echo "témoin absent"

If the canary string appears, the knowledge base is leaking through this path: remove the knowledge base from the models accessible to this account and report the behavior to the project along with your version number. If it doesn't appear, the test is only negative for this version, this model, and this account. A model may also refuse to answer or paraphrase, so review the full response rather than just searching for the string.

!
No guaranteed isolation
Even with a clean access matrix, Open WebUI is not a certified document management solution. For data covered by professional secrecy or health data, a separate instance per scope (distinct containers, volumes, and accounts) is still easier to demonstrate than group-based isolation within a single instance.

#Troubleshooting

A user can't see a knowledge base shared with their group
Check that they're actually a member of the group (and not of a group with the same name), then that they've logged back in. Open a new conversation: the list offered with # is built when the conversation opens.
A user can see a knowledge base they shouldn't
Check in this order: a knowledge base switched to public, a broad group added by mistake, membership in a second group, an overly broad default permission. Because permissions are cumulative, the cause is almost always something added, not a missing removal.
The API test returns 401 for every account
API keys disabled by the admin, a key copied with a space, or the wrong URL. First test the admin account on a knowledge base it owns.
The API tests pass, but the chat shows the knowledge base
Compare with the same account in a private browsing window, with no admin session open in the same browser. Accidentally testing with an admin session is the most common cause of false results.
Settings changed after an update
Migrations can rename or reorganize permissions. Rerun the full matrix and reread the release notes for the installed release.

#What was verified, and what wasn't

On 30/10/2026, the editorial team ran an isolated Open WebUI Docker image, with no network access or GPU, using two dummy accounts. A private, empty knowledge base created by the admin account was requested via the API: HTTP 200 for the admin, HTTP 401 for the user account. This is the only direct observation in this guide. The exact image version is not given here.

Not tested: a knowledge base containing documents, groups and group-based sharing, write permissions, public sharing, models attached to a knowledge base, direct reference by ID, shared chats, directory-based group sync, or a full audit of the instance. The scripts in this guide are provided as a method; their results on your instance are the only ones that matter. No search volume was measured for the target query.

i
What the 30/10/2026 test proves
That a user account, on this image and with no group settings at all, cannot read through the API a private knowledge base created by an admin. It proves nothing about the chat, models, groups, or the contents of a non-empty knowledge base.

#Go further

Open WebUI with Ollama: complete guide
Installation, accounts, and basic interface settings: https://quelllm.fr/guide/open-webui-ollama-tutoriel
Deploy an AI chatbot for your team on the intranet
Reverse proxy, authentication, and operating a multi-user instance: https://quelllm.fr/guide/deployer-chatbot-ia-equipe-intranet
Local RAG with Ollama without coding
How knowledge bases work in the interface: https://quelllm.fr/guide/rag-local-ollama-sans-coder
Primary source
Open WebUI, official documentation, Authentication & Access > RBAC > Permissions: https://docs.openwebui.com/features/authentication-access/rbac/permissions/ (not reviewed as of 20/11/2026; check against your installed version).
Did this guide help you?

Feedback, an error, or a clarification? Let us know—it improves the guide for everyone.