How Collabora Online SSO works when the WOPI host signs users in
In a WOPI setup, the WOPI host signs users in and issues a short-lived access token that Collabora Online uses to open and save a document. Collabora Online does not run the staff login in this model, so the single sign-on work you plan happens mostly on the host side. If your staff already sign in to Nextcloud or another host with a corporate account, the goal is that the same person reaches the editor without a second login. The host decides who is authenticated, and the editor acts on the token it receives for each file. That split means the design questions belong to the host team as much as to the editor team.
Single sign-on is usually configured with SAML or OpenID Connect on the host side. The identity provider authenticates the user to the host, and the host's group membership then controls two things: whether a user can open documents in the editor at all, and whether that user can edit or only view. The Nextcloud administration manual describes group-based limits of this kind for Nextcloud Office, letting administrators choose which groups may use the editor and which groups may edit. Map your directory groups to these roles before the pilot, and confirm with your host version which attributes or claims carry group data and how group names are matched.
Three things make this harder than it looks. First, the access token is short-lived, so a long editing session can outlast the token it started with. Confirm how your host version refreshes or re-requests tokens during an open session, and what a user sees when that refresh fails. Second, the editor loads the document from a different origin than the host page, so browser cross-origin rules, cookies and TLS settings must work for both. The Nextcloud manual recommends using the same protocol for the host and the Collabora server URL, preferably HTTPS. Third, identities can disagree. The name or user ID the host sends may not match the author name the editor displays for comments and edits, which affects audit trails and document ownership.
Before you commit to a design, run a pilot with a small group that includes one user with edit rights and one with view-only rights. Confirm the token lifetime and refresh behavior in writing with your host vendor for the exact version you run, and test a session that lasts longer than the token. Check that the WOPI allow list accepts requests only from your Collabora servers, and that the identity seen in the editor matches the identity in the host audit log. Record which group changes take effect immediately and which require a new session, so support staff know what to tell users.
Which components carry identity in a Collabora Online deployment
Users sign in to Collabora Online through the identity of the WOPI host, so the sign-in path runs through several components. Five of them decide who can open a document and who can edit it: the host, its SSO connector, its group rules, the coolwsd server, and the allow list and server URL that link the host to Collabora.
The WOPI host
The WOPI host, such as Nextcloud, owns the user session and the file permissions. When a user opens a document, the host checks that user and issues the access token that Collabora Online uses to open the file. Identity therefore starts in the host, and the editor inherits it. Check which user identifier the host passes along for each person and whether the host's account records match the people who should be editing.
SSO connector on the host
The host's SAML or OpenID Connect connector handles sign-in with your identity provider and establishes the session the host uses to request editing. Configure it in the host with the identity provider details your security team supplies, and confirm that the attributes or claims include the user identifier and group membership the host needs. Test sign-in with one account from each group that will use the editor.
Group rules for edit and view
The Nextcloud administration manual describes limiting which groups can use the editor and which groups can edit, as opposed to only view. This is where most access decisions are made. Map each business role to a group in the identity provider, then decide which groups open the editor at all and which may save changes. Confirm how nested or inherited groups are handled, and test a view-only account before go-live.
The coolwsd server
coolwsd is the Collabora Online server process that receives WOPI requests from the host and runs the editing sessions. It relies on the host to pass along authorized requests, so the host configuration and the server must agree. Confirm which coolwsd instance each host points to, that every instance is reachable from the host network, and that each instance runs a current signed package from Collabora.
WOPI allow list and server URL
The WOPI allow list defines which hosts may send WOPI requests to Collabora Online, and the server URL is the address the host uses to reach Collabora. The Nextcloud administration manual recommends restricting WOPI requests to the IP addresses of the Collabora servers. It also recommends using the same protocol for the Collabora server URL as for the Nextcloud installation, preferably HTTPS. Recheck both values after any change to addresses, DNS or the reverse proxy.
Which identity model fits your Collabora Online rollout
This table compares four ways to decide who can open and edit documents in Collabora Online, from host-local accounts to a group-only model. Read each row against your own sign-in landscape, then use the operational cost and confirmation columns to shortlist options before you scope the work. The main takeaway is that Collabora Online itself does not hold user accounts, so most of the identity effort sits in the WOPI host and in the group rules you maintain there.
| Model | When it fits | Operational cost | Confirm with the host vendor |
|---|---|---|---|
| Nextcloud local accounts | Small or contained user base where Nextcloud is already the only sign-in point and no central identity provider is required | Low setup effort, but account lifecycle, password resets and offboarding are handled manually in Nextcloud | Which Nextcloud Office group settings control editor access and edit rights, and how tokens expire for sessions |
| Nextcloud with SAML or OpenID Connect | Organizations with a central identity provider that must govern access to documents and editing | Ongoing work to keep attribute mapping, group sync and certificate or client secret rotation working, plus token and session troubleshooting | Supported SSO apps and versions, how group claims reach Nextcloud, and whether group membership is refreshed at each sign-in |
| Another WOPI host with its own SSO | Editing is needed inside a platform other than Nextcloud, such as ownCloud, Seafile or a document management system | Integration effort is tied to that host's login, token issuance and WOPI access checks, which differ from Nextcloud | How the host issues WOPI access tokens, token lifetime, how it restricts Collabora server addresses, and which groups may edit |
| Group-only access, all signed-in users may edit | Small teams where any authenticated user should edit and the document store already restricts who can sign in | Lowest rule count, but any account that can sign in gains edit rights, so offboarding and group hygiene carry the risk | Whether the host can separate view and edit rights per user or group, and how read-only sharing is enforced |
How to build SSO and group rights for Collabora Online step by step
This sequence connects Collabora Online to the identity provider through the WOPI host, so people sign in once and receive editing or view-only rights based on their groups. Each step ends with a check you can run before users depend on the setup.
Confirm host version and supported SSO connector
Start by recording the exact version of your WOPI host, such as Nextcloud, and the version of Collabora Online you plan to run. Check the host's administration documentation to see which SSO connectors it supports for SAML and OpenID Connect, and confirm that the Collabora Online release you chose works with that host version. Ask your identity team which identity provider will be used and whether it issues group claims. The step is complete when you have a written compatibility note listing host version, Collabora version, connector and identity provider, and your administrators have agreed on it.
Configure SAML or OpenID Connect on the host
On the WOPI host, configure the chosen SSO connector to trust your identity provider. Register the host as a relying party or client, exchange metadata or client settings, and set the redirect or assertion consumer addresses to the host's public URL. Keep local administrator accounts available in case the identity provider is unreachable. The step is complete when a test user can sign in to the host through the identity provider and the host shows the correct account name and attributes. Do not move on until that sign-in works in a clean browser session.
Map identity provider groups to host groups
Decide which identity provider groups should exist on the host for document editing, such as one group for editors and one for viewers. Configure the host so that group claims or attributes from the identity provider create or update matching host groups at sign-in. Confirm the exact attribute name and format with the identity team, because group values are often long identifiers rather than friendly names. The step is complete when a test user from each identity group appears in the expected host group after signing in, and no user lands in a group they should not hold.
Set group-based editor and edit rights
Following the host's administration guide for Nextcloud Office, limit which groups can use the editor and which groups can edit documents rather than only view them. Apply the rules to the groups created in the previous step, and document which group grants which right. Avoid granting edit rights to a broad group such as all users unless that is an intended policy. The step is complete when your rule list matches the written access policy and the host's settings page displays those group restrictions.
Restrict WOPI requests to Collabora server addresses
Configure the WOPI allow list on the Collabora Online side or in the host settings so that only the Collabora server addresses can make WOPI requests back to the host. The Nextcloud administration manual recommends restricting WOPI requests to the IP addresses of the Collabora servers. Collect the outbound addresses of each Collabora server from your network team, including any load balancer or NAT path. The step is complete when a request from a host or address outside the list is refused, and a normal document session still opens.
Align Collabora server URL protocol with the host
Set the Collabora server URL in the host so that it uses the same protocol as the host installation. The Nextcloud administration manual recommends using the same protocol, preferably HTTPS, for both. Confirm that the certificates for the host and the Collabora server are valid for the names used in those URLs, and that the reverse proxy passes the required headers. The step is complete when the host opens documents through the Collabora server URL without mixed-content warnings or certificate errors in the browser.
Test sign-in and view-only restrictions
Run an end-to-end test with at least three illustrative test accounts: one in an editor group, one in a view-only group, and one outside both groups. Sign in through the identity provider, open a shared document, and confirm that the editor account can edit, the view-only account can open the file but cannot make changes, and the account outside both groups cannot open the editor at all. Record the results and repeat the test after any change to group mapping. The step is complete when the view-only test user is unable to edit and the results are saved with the change record.
What drives the effort of Collabora Online identity work
This table lists the factors that most change the scope of Collabora Online identity work, how each one raises cost, and what to do to keep it contained. Read it before requesting a quote, because the same identity requirements can produce very different effort depending on these choices.
| Driver | Why it raises effort | How to keep it down |
|---|---|---|
| Number of identity providers | Each IdP adds its own SAML or OpenID Connect configuration, claim mapping, certificate or key handling and login testing, and the WOPI host may need to trust more than one issuer. | Confirm which IdP is authoritative for document access and limit the first phase to one. Add others only with a written test plan. |
| Number of groups and nesting | Nested groups must be flattened or resolved consistently between the IdP and the WOPI host, and each group that controls edit or view rights needs test accounts and verification. | Map only the groups that govern editing and viewing rights. Ask the host admin to confirm how nested membership is evaluated before design starts. |
| Attribute-based versus group-based rules | Attribute rules need agreed claim names, value formats and handling of missing attributes, which adds design review and edge-case testing beyond simple group membership. | Start with group-based rights, which the Nextcloud administration manual supports for limiting who can use and who can edit. Add attribute rules only for a named requirement. |
| WOPI hosts sharing one Collabora server | Several hosts using one coolwsd server multiply allow-list entries, token trust settings, TLS and routing tests, and make a single misconfiguration affect every host. | Decide early whether each host gets its own server. If sharing, document the allow-list entries for each host and test each one separately. |
| Multi-environment setups | Development, test and production need separate issuers, client registrations, certificates, host URLs and allow lists, and each environment must be kept in step with the others. | Keep environment differences limited to URLs and secrets. Use the same configuration templates everywhere and confirm which environments need full SSO or only test accounts. |
| Audit and compliance evidence requirements | Assessors may ask for records of who was granted edit rights, how group changes flow to the editor, and proof of access reviews. Producing this evidence means logging, retention and documented procedures. | Agree the evidence list before build. Use existing IdP and host audit logs where they meet the requirement. DeployOpen prepares controls and evidence, but independent auditors issue any attestation. |
| Custom token or proxy work | Any change to how access tokens are issued, validated or forwarded, or any authentication proxy in front of the editor, adds code to maintain, security review and upgrade testing with each Collabora release. | Prefer the standard token flow the WOPI host already supports. Treat custom proxy logic as a separate, scoped item with its own acceptance tests and an owner for ongoing changes. |
How identity integration differs for single node, high availability and Kubernetes
On a single node, whether a Docker container or a system package, the identity question is mostly about the browser path and the host's session. The WOPI host signs the user in through its own SAML or OpenID Connect setup, then issues a WOPI access token for each file the user opens. Collabora Online passes that token back to the host when it requests file information and content, so the host decides who can view or edit. Because one server process handles every open document, sticky routing does not arise.
Check these points on a single node:
- Token lifetime: confirm the access token lifetime configured on the host and how long an editing session stays valid after the user's identity session ends.
- Browser path: the user's browser must reach the Collabora Online server URL directly, and the server must be able to call back to the host's WOPI endpoints.
- TLS at the proxy: terminate TLS at the reverse proxy in front of the server and keep the server URL on the same protocol as the host, preferably HTTPS, as the Nextcloud administration manual recommends.
- Source restriction: where the host supports it, restrict WOPI requests to the addresses of the Collabora Online server.
- Group changes: test that removing a user from an edit group takes effect on the next file open.
Before go-live, confirm that a revoked group membership removes edit rights on the next file open, not only after the browser session expires.
In a multi-server setup, several Collabora Online servers sit behind a load balancer, and the WOPI host may run on several nodes too. The main identity risk is not the sign-in itself but where a document's editing session lands. Users who edit the same document must reach the same server, because the collaborative session for that document lives on one server. The WOPI access token is still issued per file by the host, so each server must accept tokens from the same host configuration.
Plan these items for a multi-server setup:
- Sticky routing by WOPISrc: configure the load balancer to route on the WOPISrc parameter, not only on a client cookie, and test with two users opening the same file from different browsers.
- Host node consistency: every host node must trust the same identity provider configuration, certificates and key sets, and clock drift between nodes can cause token validation failures.
- Matching allow lists: keep the WOPI allow list identical on every server so that a request succeeds regardless of which server receives it.
- Failure behavior: plan for editing sessions on a failed server to end, and confirm with Collabora Online how reconnection behaves before setting user expectations.
- Capacity changes: add or remove servers in a planned window, because changing the pool alters which server owns each document.
Before go-live, open one document from two browsers through the load balancer and confirm that both users join the same editing session and that group rights apply the same way on every server.
The official Helm chart runs Collabora Online as pods, and the chart's README states that horizontal pod autoscaling is disabled because scaling breaks collaborative editing and copy and paste. Replicas are therefore set manually, and the ingress must route by the WOPISrc parameter so that all users editing one document reach the same pod. The chart supports Nginx, HAProxy and OpenShift Router ingress. Identity behavior stays the same as in a multi-server setup, but the network addresses the host sees and the place where TLS ends both change.
Check these points in a Kubernetes install:
- Ingress routing: configure the chosen ingress controller to hash on WOPISrc, and confirm the exact syntax for your controller version.
- TLS termination: decide whether TLS ends at the ingress, with plain HTTP inside the cluster, or continues into the pod, and set the allow list to the addresses the host actually sees.
- Source addresses: the host sees the ingress or load balancer address, not pod addresses, so allow lists must match that address.
- Resource profile: the README recommends production limits of 8 CPU cores and 8000 MiB of memory per pod, with requests of 4 cores and 6000 MiB, so size the replica count against those values.
- Rollouts: pod restarts and rolling updates interrupt sessions on the affected pod, so schedule them outside peak editing hours.
Before go-live, confirm that the URLs the server generates use the public name and protocol, not an internal service name, by opening a file through the public address.
In an air-gapped or restricted network, the identity provider should be reachable from the WOPI host only. The editor does not need to reach the identity provider directly in a standard WOPI flow, because the host performs sign-in and issues the access tokens. Keeping the editor away from the identity provider narrows the paths an attacker could use and simplifies the evidence auditors will ask for. The design question is which systems need outbound or inbound paths and which do not.
For restricted networks, confirm these items:
- Identity provider path: only the host should hold a route to the identity provider, and you should verify that the editor makes no sign-in calls in your chosen configuration.
- Metadata and keys: SAML metadata, OpenID Connect discovery documents and signing keys must be available inside the network if the host has no outbound access, and you should confirm how and when the host refreshes them.
- Browser reachability: users' browsers must reach both the host and the editor, so plan an internal path if the editor sits on a separate segment.
- Explicit allow lists: permit only the host's addresses on the editor side and the editor's addresses on the host side.
- Documented egress: record every network path and its purpose, since DeployOpen prepares that evidence but independent auditors issue any assessment.
Before go-live, test sign-in and an edit session with the outbound route to the identity provider removed, and confirm which connections still fail.
What to monitor, back up and document after SSO goes live
Once single sign-on is working, the risk moves from setup to drift. Identity settings change, certificates and client secrets expire, group memberships grow, and Collabora Online receives point releases. Plan these tasks as recurring operations with named owners before cutover, because the failures they prevent usually appear weeks later as a sudden wave of users who cannot open documents. Start with the signals. On the WOPI host side, watch failed sign-in attempts at the identity provider and token rejections in the host's logs, since these show whether users are failing at authentication or at the handoff to Collabora. On the Collabora side, watch coolwsd logs for WOPI access errors, particularly responses to CheckFileInfo and file retrieval calls that fail after a host configuration change. Confirm with your host's documentation which log entries and fields it writes for WOPI requests, and set alerts on error rates rather than single events so that one expired token does not page the on-call team. Credentials need a rotation calendar. For SAML, track the expiry of the signing certificate that the identity provider uses to sign assertions and the metadata the host trusts. For OpenID Connect, track the client secret and any signing keys the host fetches from the provider's discovery document. Confirm whether your identity provider can publish a new certificate or key before the old one expires, and test that the host accepts both during the overlap. Record who owns each credential and where it is stored, and rehearse a rotation in a staging environment at least once.
Group membership reviews are where the access model either stays correct or quietly widens. The groups that decide who may open the editor and who may edit rather than only view, such as the controls administrators can set in Nextcloud Office, should be reviewed on a schedule agreed with the data owners. Ask the identity team to export group membership, compare it with the last review, and remove accounts for leavers and role changes. Confirm whether removals in the identity provider take effect immediately for active editing sessions or only at the next token issue, and document the answer. Back up the configuration that makes sign-in work, not only the documents. That means the host's identity and Collabora connection settings, the Collabora server URL and WOPI allow list, the SAML metadata or OpenID Connect client registration, the group mapping rules, and any reverse proxy configuration that forwards authentication headers. Store these in version control or a backup system with restore tests. A restore should be proven on a separate instance, and the restore runbook should state which secrets must be re-issued rather than copied. For updates, follow the Collabora point release and signed package process for your deployment method, and confirm the package signing keys your RPM or DEB repositories trust. Security advisories are published by Collabora, so subscribe to them and record the date each fix was applied. Test each update against your SSO flow, because a change in the server can alter how tokens or WOPISrc parameters are handled.
The documentation package is what auditors and your own successors will read, so it should be produced as part of the handover. DeployOpen can prepare the operational runbooks, the group-to-right mapping showing which identity groups grant view or edit access, configuration records, backup and restore test results, and change logs that map identity changes to approvals. Ask for the exact list and format in the written scope so that it is agreed before work starts. Compliance evidence is prepared by DeployOpen, but audit reports and attestations come from independent auditors and certification bodies, and DeployOpen does not issue them. Agree with your auditor which records they need, how far back they will sample, and who holds the source systems that produce the evidence. The handover should name the owner of each recurring task, the escalation path to the identity team and the Collabora support channel you have, and the calendar for certificate renewal, group reviews and point release testing. Confirm with your identity provider and Collabora which support terms apply to your subscription edition before you rely on them in the runbook.
How to lock down WOPI access and identity for Collabora Online
These six controls cover the WOPI calls that load documents, the transport that carries them, the secrets that prove identity, the hosts and consoles that configure the service, the packages that fix known flaws, and the groups that decide who can change a file. Work through them before go-live, then repeat the checks after each point release or identity change.
Restrict WOPI requests by source IP
Limit the WOPI allow list in your host to the outbound addresses of your Collabora servers, so only those machines can call the WOPI endpoints that issue access tokens and file content paths. Without this limit, any client that can reach the endpoint could attempt file requests. Verify by confirming that the listed addresses match the Collabora servers, that a request from an unlisted host is refused, and that a request from a listed server succeeds. Confirm the exact setting name in your host version's documentation.
Use HTTPS for the server URL
Set the Collabora server URL in the WOPI host to HTTPS, using the same protocol as the host installation, so document traffic and WOPI callbacks are encrypted. The risk is exposure of document content and session data on the network, and browsers may block editor frames served over plain HTTP from an HTTPS host. Verify by checking the configured URL in the host admin settings, opening a document in a clean browser session, and confirming the certificate is valid for the hostname the host uses.
Store identity secrets in a vault
Keep the OpenID Connect client secret, SAML signing certificate and private keys used by the host's identity integration in a secrets manager, out of configuration files, scripts and container images. A leaked client secret or signing key lets an attacker impersonate the host or forge sign-in assertions. Verify by scanning repositories, images and configuration backups for secret values, confirming the host reads them from the vault at startup, and rotating a test secret to check that sign-in still works after a restart.
Limit host and console admin access
Allow shell access to the Collabora host only for named administrators using key-based login through a bastion host or VPN. Restrict the Collabora admin console to a management network or specific accounts with strong authentication. The risk is that console access exposes server configuration, logs and document metadata. Verify by checking which addresses can reach the console port from outside the management network, reviewing login and sudo logs, and confirming a standard user account cannot open the console. Confirm the console path and port for your version.
Apply security advisories promptly
Track Collabora security advisories for your release branch and apply fixed point releases. For example, the 25.04 release notes record that 25.04.7.5, released January 29, 2026, fixed CVE-2026-23623 and updated package signing keys for RPM and DEB users. If you run 25.04, confirm the installed build is 25.04.7.5 or later. If you run another branch, check its release notes for the same advisory. Verify the version with your package manager and confirm the signing key update completed.
Separate edit and view groups
Map edit rights and view rights to different identity groups, then configure the WOPI host to limit which groups can open the editor and which groups can edit. Least privilege holds only when groups are provisioned from the identity provider and reviewed on a schedule. Broad edit rights let users change confidential documents, and former staff may keep write access. Verify by signing in as a view-only member and confirming read-only mode, then removing a test user from the edit group and confirming the change applies in the next session.
How to test Collabora Online SSO and fail safely
The goal of testing Collabora Online single sign-on is to confirm that a failed or unclear identity check leaves the user without access or with view-only access, never with edit rights they were not granted. Collabora Online does not run its own user directory for this flow. The WOPI host, such as Nextcloud, authenticates the person through its SAML or OpenID Connect configuration, then issues a WOPI access token that Collabora Online accepts for a single file. Each test below should therefore be run against the host and the editor together, because a pass on one side can hide a failure on the other.
Start with three sign-in cases: a user in the view group, a user in the edit group, and a user in neither group. In Nextcloud Office, administrators can limit which groups may use the editor and which may edit rather than only view, according to the Nextcloud administration manual. For each account, open a document from the host, then record the rights shown in the editor toolbar and whether the file can be saved. The no-access user should be stopped before the editor loads. Use a test account in each group and repeat the sign-in after any group change, since cached sessions can keep old rights for a while. Confirm the group lookup behavior with your identity provider's documentation and your host version, because claim mapping differs between SAML and OpenID Connect setups.
Next, test removal. Disable a test user in the identity provider, or remove them from the edit group, while they have a document open in the editor. Access should end when the host session ends and any active WOPI token expires or is revoked, which you should confirm with your host and Collabora versions rather than assume. Then check that a fresh open attempt is refused. Also test a request from an address outside the WOPI allow list, which the Nextcloud manual recommends restricting to the Collabora server addresses. The request should be refused and not fall back to a looser path. Use a host outside the list to make the call and confirm the refusal appears in the Collabora log.
Mismatched configuration is the most common source of confusing failures. The Nextcloud manual recommends that the Collabora server URL use the same protocol as the Nextcloud installation, preferably HTTPS. Deliberately set a mismatched protocol or host name in a staging environment and confirm that the editor fails visibly with an error rather than opening in a degraded state. Also test expired or rotated credentials: rotate the WOPI shared secret or certificate in staging, then open a document and confirm that the token check fails. Note whether the error is shown to the user and whether it names the cause, since an opaque error will slow down support teams in production.
For each test, record the expected result before running it and check logs on both sides. On the host, review the authentication and sharing logs for the sign-in attempt, the group decision and the token issue. On the Collabora side, review the coolwsd logs for the WOPI request, the source address, the file identifier and the refusal reason. Matching timestamps across the two systems make failures far easier to trace. Keep the results in a short test record that names the versions tested, because a fix in a later point release may change the behavior. Ask your implementation partner to include these cases in the acceptance tests, and confirm with Collabora which log levels and fields your release provides.
Questions teams ask before building Collabora Online SSO
Does Collabora Online have its own user accounts?
No. Collabora Online does not run a user directory for document sessions. The WOPI host authenticates the user, decides who may open a file and with which rights, and then issues an access token for each session. Collabora receives that token and the file context. In practice, the accounts live in your identity provider or in the host's user store. Confirm this token flow for the exact host and version you run, because host settings and token handling can change between releases. Ask your host vendor to walk through the WOPI token exchange in your configuration before you plan the identity work.
Is SAML or OpenID Connect set up in Collabora Online or in the host?
The sign-in protocol is set up in the WOPI host. For Nextcloud or another host, the host runs the SAML or OpenID Connect login against your identity provider, then hands Collabora a token for each editing session. On the Collabora side, the server is configured to trust that host through its WOPI allow list and related settings. Plan the identity configuration on the host and the server configuration on Collabora as two separate pieces of work. Confirm the supported protocols, plugins and menu options for your host release, since SSO features depend on the host version.
What drives the cost and effort of a Collabora Online SSO build?
The main cost components are the people who configure the host, the identity provider, the reverse proxy and the Collabora servers, plus any software subscription. Effort rises with the number of hosts, the number of identity providers, the complexity of your group model, and the number of test cases needed to prove edit and view rights. Collabora's pricing page lists the Business plan at 3 euros per user per month for up to 99 users, with the Enterprise plan for 100 or more users quoted with volume discounts. Ask any quote to separate one-time build work from recurring subscription and support costs, and to state which host versions and identity providers it covers.
What does the client's identity team need to provide?
The identity team usually provides administrator access to the identity provider, the ability to register the host as a SAML service provider or OpenID Connect client, and the metadata or client settings the host needs. They also define how user and group claims are mapped, create test users in each group that should edit or only view, and set who owns certificate and client secret renewal. The infrastructure team provides DNS and TLS for the Collabora server URL, using the same protocol as the host, and network rules that limit WOPI requests to the Collabora server addresses. Where a load balancer sits in front of Collabora, it must route by the WOPISrc parameter so all users editing one document reach the same server.
Can an internal team build Collabora Online SSO without outside help?
Yes, an internal team can build it if it already has engineers who administer the WOPI host, the identity provider and the reverse proxy, and who can test each path end to end. The usual gaps are not the sign-in itself but the testing: checking edit and view rights across groups, confirming behavior after host and Collabora updates, and documenting the setup for the next upgrade. Collabora publishes security advisories for its server, such as the fix recorded for CVE-2026-23623 in the 25.04.7.5 point release, so the team also needs a routine for applying signed updates. Estimate internal effort by listing these skills and the hours they would take, then compare that list with a written scope.
What does a fixed-scope DeployOpen engagement cover for SSO?
A fixed-scope engagement covers the work listed in a written scope, with deliverables and timelines agreed before work starts. For SSO, that typically means reviewing the host and identity provider settings, implementing the sign-in path, mapping groups to edit and view rights, testing those rights, and documenting the configuration for your own team. It may also include hardening steps that affect the sign-in path. DeployOpen does not issue audit reports or certifications, so any compliance evidence it prepares is for your assessor to evaluate. Ongoing support, upgrades and continuous testing are available as retainers. Ask for the written scope to name each deliverable and the systems it touches.
How are edit and view rights assigned by group in Nextcloud Office?
The Nextcloud administration manual describes group controls for Nextcloud Office. Administrators can limit which groups may use the editor and which groups may edit documents, instead of allowing every signed-in user full editing. Your identity provider then needs to pass group membership to Nextcloud in a form it can read, so the group names in your directory must match the groups set in the host. Confirm the exact setting names, group behavior and any group sync requirements for your Nextcloud version, because the configuration screens and defaults change between releases.
Does the SSO design change between Collabora Online 25.04 and 26.04?
The supplied facts do not describe changes to the SSO or token design between these branches, so confirm it before you fix the design. Collabora announced 26.04 with an optional AI assistant that is off by default, and the 25.04 branch continued to receive point releases. Those release changes may not touch identity at all, but the host version determines how SSO is configured and which token behavior applies. Ask your build partner or host vendor to list the identity-related changes between your current version and the target version, and test the sign-in and rights paths on the version you plan to run.
How DeployOpen scopes, builds and hands over Collabora Online identity integration
DeployOpen approaches Collabora Online identity integration as a fixed-scope engagement. Users sign in through the WOPI host's own identity, and access tokens are issued by that host, so the work is defined by how Nextcloud or another host authenticates users, how group rules map to edit and view rights, and how the Collabora server is kept in step with those settings. Scope, deliverables and timelines are agreed in writing before work starts.
How we scope
- Confirm which WOPI host issues access tokens and which identity provider it uses for sign-in.
- Document whether SAML or OpenID Connect is configured on the host side, and who owns that configuration.
- Agree in writing which groups receive edit rights and which receive view-only access to documents.
How we build
- Configure the host's SSO connection and test sign-in with real accounts from each group.
- Set WOPI allow lists and server URL settings so only the intended host can request editing sessions.
- Test that group-based edit and view rights behave as written, including denied edit attempts for view-only users.
How we hand over
- Deliver a written record of identity settings, group mappings, token lifetimes and allow list entries.
- Walk your administrators through how to add users, move them between groups and verify access.
- Document the test cases used, so your team can repeat them after host or Collabora upgrades.
How we support
- Ongoing support is available as a retainer, covering changes to identity settings after go-live.
- Retainers can cover re-testing sign-in and group rights when the WOPI host or Collabora Online is upgraded.
- Confirm with DeployOpen during scoping which support hours, response paths and exclusions apply.

