> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tightknit.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Single sign-on (SSO)

> Set up enterprise Single Sign-On for your community site with OIDC, SAML 2.0, or token-based JWT, using SP-initiated or IdP-initiated flows.

Tightknit supports enterprise Single Sign-On (SSO) to integrate with your organization's identity provider and authenticate community members through OIDC, SAML, or a custom JWT flow.

## Supported protocols

Tightknit supports the following industry-standard SSO protocols:

* **OIDC (OpenID Connect)** - Modern authentication protocol built on OAuth 2.0
* **SAML 2.0** - Enterprise-grade XML-based authentication standard
* **Token-based JWT** - Custom integrations for IdP-initiated flows

## Supported authentication flows

### SP-initiated flow

Users start at your Tightknit community and are redirected to your identity provider to authenticate. After successful authentication, they are returned to Tightknit and logged in automatically.

```mermaid theme={null}
sequenceDiagram
    autonumber
    actor Member
    participant Site as Tightknit community site
    participant IdP as Your identity provider

    Member->>Site: Visit site and choose SSO login
    Site->>IdP: Redirect with authentication request<br/>(OIDC or SAML)
    IdP->>Member: Prompt to authenticate<br/>(or reuse an existing session)
    Member->>IdP: Authenticate
    IdP->>Site: Redirect back with signed assertion
    Site->>Member: Session created, member is signed in
```

### IdP-initiated flow

Users start at your identity provider portal and can access your Tightknit community directly from there. They land on Tightknit already authenticated without needing to sign in again.

```mermaid theme={null}
sequenceDiagram
    autonumber
    actor Member
    participant IdP as Your identity provider portal
    participant Site as Tightknit community site

    Member->>IdP: Sign in to the IdP portal
    Member->>IdP: Open the Tightknit tile
    IdP->>Site: Redirect with signed JWT
    Site->>Site: Validate token and match the member
    Site->>Member: Session created, member is signed in
```

> [!NOTE]
>
> IdP-initiated SSO requires a custom token (JWT) provider. See [Set up a
> custom token (JWT) provider](#set-up-a-custom-token-jwt-provider).

## Supported identity providers

Tightknit works with major enterprise identity providers, including:

* Google Workspace
* Microsoft Azure AD / Entra ID
* Okta
* Auth0
* OneLogin
* And other OIDC/SAML-compliant providers

## Where to configure this

In Studio, go to **[Site > Authentication](https://studio.tightknit.ai/-/website/authentication)** and use the **Single Sign-On** section to add and manage providers.

## Set up an OIDC or SAML provider

You can configure up to five providers from Studio. A new provider starts disabled so you can review the configuration before making it available to members.

**1. Open authentication settings**

In Studio, go to **[Site > Authentication](https://studio.tightknit.ai/-/website/authentication)** and find **Single Sign-On**.

**2. Choose the connection type**

Select **Add provider**, then select OIDC or SAML. Tightknit suggests a provider ID based on your community and protocol. The provider ID must be globally unique and cannot be changed after creation.

**3. Configure your identity provider**

Copy the callback URL shown by Tightknit into your identity provider. SAML setups also receive an ACS URL and entity ID. Use **Provider help** for concise Auth0, Okta, Microsoft Entra ID, or Google Workspace instructions.

**4. Enter the provider configuration**

For OIDC, enter the issuer, client credentials, endpoints, and scopes. For SAML, paste the IdP metadata XML or enter the sign-on URL and the **IdP signing certificate**. Paste the certificate as PEM text with real line breaks; a certificate copied as a single line with literal `\n` characters is rejected. Configure your identity provider to sign the SAML assertion itself: a response whose outer message is signed but whose assertion is not is rejected.

**5. Create and test the provider**

Save the provider while it is disabled, then enable it immediately before a controlled test with an existing community member. Review **[Workspace Settings > Audit](https://studio.tightknit.ai/-/workspace/audit)** under **Authentication** after the test. If the test fails, you can correct the configuration without disabling the provider first; see [Editing a live provider](#editing-a-live-provider).

For an end-to-end provider example, see [Set up Auth0 SSO](https://docs.tightknit.ai/guides/sso-auth0.md).

## Automatically provision accounts

By default, SSO only signs in people who are already members of your community. When you turn on **Automatically provision accounts** for a provider, a first sign-in with no matching member creates one instead.

If the provider has an **Email domain**, a first sign-in from an address outside that domain is refused: it neither creates a member nor connects to an existing member's profile. The domain is optional. Leave it blank if your members sign in with addresses on many domains, for example when your community is for your customers. Setting it then stops invited members on other domains from signing in through the provider.

> [!WARNING]
>
> Automatic provisioning lets anyone your identity provider signs in join your community. If people can create their own accounts with your identity provider, for example through a public sign-up page, anyone on the internet can join. Turn it on only for an identity provider where your organization creates every account, such as your company directory.

For a custom token provider, the new member gets the email address in the token. If your application lets people sign in with an address they haven't confirmed they own, someone could join under another person's address. Turn on automatic provisioning only if your application verifies every member's email address. Tightknit doesn't connect the new member to a Slack member with the same address until they confirm it, for example by signing in to the community with a code sent to that address. The exception is when the token marks the address as verified and Tightknit support has set the provider to trust it. If the address already has a Tightknit account, the person confirms it by email first, as described in [Connecting SSO to an existing account](#connecting-sso-to-an-existing-account), and becomes a member once they do. If someone joined with an address that isn't theirs, the owner of the address can take the account back by signing in with a code sent to it. Tightknit then signs everyone else out of the account and disconnects the sign-in methods added before.

## Require a verified email

On a member's first sign-in, Tightknit matches the email address your identity provider sends to a community member, or creates one. So that nobody can register someone else's address with your identity provider and sign in as them, Tightknit can require the provider to mark the address as verified. Members who have already signed in through the provider aren't affected.

Set this in the **Configuration** step when you add or edit an OIDC or SAML provider in **[Site > Authentication](https://studio.tightknit.ai/-/website/authentication)**. You can change it at any time, even after members have signed in through the provider.

* **OIDC: Email verified claim.** Tightknit always requires a verified email from OIDC providers. By default it reads the standard `email_verified` claim. If your provider uses another claim, enter its name, such as `xms_edov` for Microsoft Entra ID.
* **SAML: Email verified attribute.** SAML has no standard attribute for this, so it's optional. Enter the name of the attribute your identity provider sets when it has verified the address. A first sign-in is then refused unless the attribute is `true`. Leave it blank to accept the address your identity provider sends without this check.

Only `true` (or the text `"true"`) counts as verified. See [the troubleshooting entry](#troubleshooting) if members see a message about an unverified email.

For OIDC providers with a UserInfo endpoint, Tightknit reads the claim there first. If it is absent, Tightknit reads it from the signed ID token only when both responses identify the same person and email address. An explicit `false` in UserInfo still refuses a first sign-in.

## Set up a custom token (JWT) provider

Use a custom token provider when your own application signs members in and should send them straight to your community, for example from a **Community** link inside your product. Your application signs a short-lived JSON Web Token (JWT) for the member and posts it to Tightknit, which verifies it and signs the member in. For standard identity providers such as Okta or Microsoft Entra ID, use OIDC or SAML instead.

**1. Choose the connection type**

In **[Site > Authentication](https://studio.tightknit.ai/-/website/authentication)**, select **Add provider**, choose **Custom token (JWT)**, and enter a display name.

**2. Send tokens to the callback URL**

Copy the **Token callback URL** from the **Connect** step. Your application posts each signed token to it as a form field named `token`. Each token must:

* be signed with RS256 or ES256
* carry `iss` and `aud` claims that exactly match the issuer and audience you enter in the next step
* carry the member's `email`, `iat`, `exp`, and a unique `jti`
* carry a `sub` that identifies the member: unique to them, never reused for anyone else, and the same for the life of their account. Tightknit recognizes returning members by it (see [How Tightknit recognizes returning members](#how-tightknit-recognizes-returning-members)).
* be posted within 60 seconds of its `iat`, so sign it when the member clicks rather than when the page loads. Each token can be used once.

**3. Enter the verification details**

Enter the issuer, audience, and signing algorithm, then add the key Tightknit verifies tokens with. We recommend a **JWKS URL**: the `jwks_uri` your issuer's OpenID configuration lists, or, if it publishes none, a URL under your issuer URL such as `https://app.acme.com/.well-known/jwks.json` for the issuer `https://app.acme.com/`. You rotate keys inside the JWKS without editing the provider. It is also the only key you can change yourself once members have signed in through the provider. A **Public key** must be the PEM-encoded public half of your signing key, at least 2048 bits for RS256. Once members have signed in through the provider, only Tightknit support can replace it. Never paste a private key.

**4. Create and test the provider**

Save the provider while it is disabled, enable it, and sign in through your application with an existing community member. Review **[Workspace Settings > Audit](https://studio.tightknit.ai/-/workspace/audit)** under **Authentication** after the test.

A custom token provider can also have a **Login URL**. With one, the community site login page shows a button that sends members to that URL; your application signs them in and posts the token back. Without one, members can only start sign-in from your application.

Tightknit opens the login URL with two query parameters:

* `redirect_uri`: the token callback URL, including the page the member started from. Post the token here rather than to the plain callback URL, so members land back where they were.
* `client`: always `tightknit`.

Members who already have a Tightknit account confirm their email the first time they sign in through a new token provider. See [Connecting SSO to an existing account](#connecting-sso-to-an-existing-account).

### How Tightknit recognizes returning members

Tightknit matches a member's first sign-in through a custom token provider to their community profile by email. Tightknit then records the token's `sub` against their account, and later sign-ins find them by it:

* A member whose email address changes in your application keeps signing in to the same account.
* Connecting Google, GitHub, or Slack under **Settings > Account** doesn't stop them signing in with your provider.
* Members see your provider under **Settings > Account > Sign-in methods**. Your community manages it, so they can't disconnect it there.

Because the `sub` decides whose account a sign-in reaches, never give one person's `sub` to another. If your tokens identify members with a different claim, or carry no stable one, contact Tightknit support: members are then matched by email on every sign-in.

## Hide a custom token provider from the community site login page

Custom token providers have a **Show on community site login page** setting in the **Configuration** step. When it is on, the community site login page shows a sign-in button that takes members to your login URL. Turn it off if members only ever start from your application. They can still sign in from there either way, as long as the provider is enabled.

The setting needs a login URL. Without one, the provider is always hidden and members can only sign in from your application. Hidden providers are labeled **Hidden from the community site login page** in the **Single Sign-On** section.

OIDC and SAML providers are always shown on the community site login page while enabled, because members start those sign-ins from their button. To stop sign-ins through one, disable it instead.

## Reviewing a provider's connection details

Each provider row you can manage in the **Single Sign-On** section has an info button that reopens the setup wizard on the **Connect** step. Use it to copy the callback URL, ACS URL, entity ID, or token callback URL again when your identity provider or application needs them, without changing anything on the provider. Providers the Tightknit team set up with more than one configuration do not have this button; contact support for their connection details.

## Editing a live provider

You can edit providers you set up yourself while they are enabled, using the same rows that offer the info button above. Because the change applies immediately, Studio asks you to confirm before saving: select **Save live changes** to apply, or cancel to keep the current configuration. A configuration that no longer matches your identity provider interrupts member sign-ins until you correct it, so review each step of the wizard before confirming.

When editing a SAML provider, the stored signing certificate is masked. Leave the **IdP signing certificate** field blank to keep the current certificate, or paste a new one to replace it. Custom token providers work the same way for a stored public key.

After members have signed in through a provider, you can no longer change its identity settings, such as the issuer, audience, client ID, or the claim a custom token provider identifies members by. Their accounts are linked to the provider by these settings, so create a new provider instead. A custom token provider's signing key is the one exception. You can switch it to a JWKS URL your issuer vouches for, as described in [Switch a custom token provider to a JWKS URL](#switch-a-custom-token-provider-to-a-jwks-url), and Tightknit support can rotate it for you. For some custom token providers that Tightknit set up for you, only Tightknit support can change the identity settings, signing key included.

## Switch a custom token provider to a JWKS URL

A custom token provider that verifies tokens with a stored public key can move to a JWKS URL without interrupting sign-ins, even after members have signed in through it. From then on you rotate keys inside your JWKS, with no change in Tightknit.

The JWKS must meet these requirements. When the provider is enabled or members have signed in through it, Tightknit fetches the JWKS and refuses to save until it does:

* It publishes every key your app signs tokens with today, marked `"use": "sig"` and `"alg": "RS256"` or `"ES256"` to match the provider. When you replace one JWKS URL with another, the new JWKS must publish every signing key the current one does, under the same `kid`. Tightknit can't tell which one your issuer signs with.
* It uses HTTPS, resolves to a public address, and answers directly with `200 OK` rather than a redirect.
* Once members have signed in through the provider, your issuer must vouch for it. If your issuer publishes an OpenID configuration at `<issuer>/.well-known/openid-configuration`, the JWKS URL must be the `jwks_uri` it lists. Otherwise the JWKS must sit under your issuer URL itself: on the same host, and under the issuer's path if it has one (`https://app.acme.com/.well-known/jwks.json` for the issuer `https://app.acme.com/`). The issuer must be an `https://` URL. Only whoever controls your issuer URL can publish there, which is what keeps a changed key trustworthy. To host the JWKS anywhere else, publish an OpenID configuration at your issuer that names it.

**1. Publish your current key in a JWKS**

Add the public key you sign tokens with today to a JSON Web Key Set that meets the requirements above. If your tokens carry a `kid` header, give the key the same `kid`, so Tightknit finds it without trying each key.

**2. Enter the JWKS URL**

Edit the provider in **[Site > Authentication](https://studio.tightknit.ai/-/website/authentication)**. In the **Configuration** step, set **Verification key** to **JWKS URL**, enter the URL, and save.

**3. Confirm sign-in still works**

Sign in through your application with an existing community member, then check that **[Workspace Settings > Audit](https://studio.tightknit.ai/-/workspace/audit)** lists `SSO provider signing key updated` under **Authentication**.

**4. Rotate inside your JWKS**

To rotate later, add the new key to your JWKS, start signing with it, and remove the old key once no unexpired tokens use it.

Tightknit reuses the keys it fetches from your JWKS for up to 5 minutes:

* **A new key** works within about 30 seconds. When a token is signed with a key Tightknit doesn't have yet, it fetches your JWKS again, at most once every 30 seconds, whether or not the token carries a `kid`.
* **A removed key** can still verify sign-ins for up to 5 minutes, or for as long as your JWKS can't be reached (at most 24 hours). If a key is compromised, also disable the provider in **[Site > Authentication](https://studio.tightknit.ai/-/website/authentication)**, which stops its sign-ins immediately. Enable it again once your JWKS answers without the key, and at least 5 minutes after you removed it.
* **If your JWKS is unreachable** or answers with a server error (`5xx`) or `429 Too Many Requests`, sign-ins keep working with the last keys Tightknit fetched for up to 24 hours. After that, they fail until your JWKS answers again.
* **If your JWKS answers anything else**, such as `404 Not Found` or a response that isn't a key set, sign-ins fail at once until it serves a key set again.

To change the issuer, audience, or signing algorithm of a provider members have signed in through, or to replace its public key with another, contact Tightknit support. Tightknit records every signing key change you make in **[Workspace Settings > Audit](https://studio.tightknit.ai/-/workspace/audit)** as `SSO provider signing key updated`. When the provider is enabled or members have signed in through it, Tightknit also posts an [SSO signing key changed](https://docs.tightknit.ai/slack/notification-settings.md#sso-signing-key-changed) alert to your Tightknit Hub channel for every change, including one Tightknit support makes. You can't turn this alert off.

## Connecting SSO to an existing account

When a member signs in with SSO using an email address that already has a Tightknit account created another way (an email sign-in code, or a Google, GitHub, or Slack login), Tightknit does not merge the two automatically. Trusting the identity provider's word alone would let a misconfigured or compromised IdP claim someone else's account.

Instead, the member is sent a confirmation email:

1. They sign in with your identity provider as usual.
2. The login page tells them to check their email, and Tightknit emails the asserted address a confirmation link naming your community and the identity provider.
3. Opening the link shows a confirmation page. Nothing changes until they select **Connect**. Simply opening the email is not enough.
4. After confirming, they return to the login page and sign in with SSO again, which now succeeds.

This happens once per member, per identity provider. Afterwards, SSO sign-in works normally.

If the provider has an **Email domain** and the address is outside it, no confirmation email is sent, unless the account already belongs to an active member of your community. The login page still asks the person to check their email, so it doesn't reveal which addresses have accounts.

The confirmation email is always required when the asserted address belongs to someone who is not yet an established member of your community. An invitation on its own is never enough for your identity provider's claim to attach to an existing Tightknit account. A Tightknit account can belong to several communities, so only the person who can open that mailbox may connect it to yours.

> [!NOTE]
>
> Confirmation links are single-use and expire after 10 minutes. While a member's link is still valid, signing in with the same identity provider again doesn't send another, so they should use the email they already have. Once the link expires, or after you edit the identity provider (which makes earlier links unusable), signing in with SSO sends a new link. A member who never confirms keeps their existing sign-in methods and loses no access.

Administrators can see this activity in **[Workspace Settings > Audit](https://studio.tightknit.ai/-/workspace/audit)** under the **Authentication** section: `SSO link confirmation sent`, `SSO link confirmed`, `SSO link expired`, and `SSO link rate-limited`.

## Email domain aliases

Some identity providers and applications send a member's address on a different domain from the one on their community profile, such as a security or legacy domain: `alex@acme-sec.com` instead of `alex@acme.com`. An email domain alias tells Tightknit to sign that member in to their profile on the primary domain.

> [!NOTE]
>
> Email domain aliases work with custom token providers only. OIDC and SAML
> providers don't offer them.

### Add an alias

**1. Edit the provider**

In Studio, go to **[Site > Authentication](https://studio.tightknit.ai/-/website/authentication)**, edit the custom token provider under **Single Sign-On**, and find **Email domain aliases** in the **Provider** step.

**2. Enter the alias**

Select **Add alias**. Enter the domain your provider sends as the **Alias domain**, then choose the **Primary domain**. The list shows the domains your members use most, with how many members use each; you can also type a domain that isn't listed. A provider can have up to five aliases.

**3. Check the preview**

Studio shows what the new alias would do before you save, in counts only:

* how many people couldn't sign in through this provider with an alias-domain address in the last 30 days, and how many of them the alias would match to an active profile on the primary domain, for example **28 people will be able to sign in**
* how many profiles already use alias-domain addresses. An exact address match always wins, so those people are never matched to a primary-domain profile.
* a note when no members use the primary domain, since the alias couldn't match anyone

A primary-domain profile that's already connected to an account with a different email address doesn't count as a match, because sign-in won't link around it. In a very large community, the counts can stop at a limit and show with a **+**, such as **20,000+ people**. A new provider has no sign-ins yet, so its preview only shows profile counts. If Studio can't load the preview, it says so and offers **Retry**; you can still save.

**4. Save the provider**

Continue through the wizard and save. If the provider is enabled, confirm the live change.

Studio refuses an alias that:

* is a public email domain such as `gmail.com`, where different people share names
* is the same as its primary domain
* is also the primary domain of another alias
* is listed twice

The provider's row in the **Single Sign-On** section lists its aliases, for example `Email domain aliases: acme-sec.com → acme.com`. Every change is recorded in **[Workspace Settings > Audit](https://studio.tightknit.ai/-/workspace/audit)** under **Authentication** as `SSO email domain aliases updated`.

### Low-match warning

When at least five people couldn't sign in with an alias-domain address and fewer than half of them have a matching profile on the primary domain, Studio warns that the domain may not be an alias of the primary domain. The addresses probably belong to different people who share names, such as a customer's domain. To save the alias anyway, select **Save this alias anyway** under the warning.

In a very large community, an alias domain can have more refused sign-ins than the preview reads. Studio can't tell the match rate for the rest, so it asks you to confirm that alias the same way.

The warning catches mistakes; it isn't what keeps members safe. Every member matched through an alias still confirms by email at their primary address before signing in.

### How members are matched

1. Tightknit first looks for a profile with the exact address the provider sent. An exact match always wins, so a member whose profile is on the alias domain keeps signing in to that profile.
2. If there isn't one, Tightknit looks for the same name on the primary domain: `alex@acme-sec.com` matches `alex@acme.com`. If neither profile exists, the sign-in fails as it would without the alias.
3. The first time a member is matched this way, Tightknit emails a confirmation link to the address on their profile, and the login page asks them to check their email. After they confirm, they sign in directly. The confirmation works like [Connecting SSO to an existing account](#connecting-sso-to-an-existing-account).

### Change or remove an alias

You can't edit a saved alias in place. To change one, remove it and add the new pair. Studio asks you to confirm before it removes a saved alias, because once you save:

* Sign-ins with an address on the removed alias domain only match profiles on that domain.
* Members who confirmed through the alias can no longer use it to sign in. If you add the alias back, they confirm by email again.

### If your plan no longer includes the add-on

Saved aliases are paused. Studio shows them with a **Paused** notice, and the provider's row ends in `(paused)`. While aliases are paused:

* New sign-ins don't use them. A member who hasn't confirmed through an alias is only matched by the exact address the provider sent.
* Members who already confirmed through an alias keep signing in.
* You can remove aliases and edit the provider's other settings, but you can't add aliases.

[Contact sales](https://docs.tightknit.ai/support/contact.md) to turn them back on.

## Troubleshooting

> [accordion] The identity provider rejects the callback URL
>
> Use the info button on the OIDC or SAML provider row to reopen the **Connect** step and copy the callback or ACS URL again. It must match exactly, including the protocol, path, provider ID, and trailing slash behavior.

> [accordion] The provider does not appear on the community site login page
>
> Confirm the provider is enabled and **Allow members to log in** is enabled under **Access**. A disabled provider remains hidden while you configure it. For a custom token provider, also confirm it has a login URL and **Show on community site login page** is on.

> [accordion] Authentication succeeds but access is denied
>
> SSO verifies identity. Unless **Automatically provision accounts** is enabled for the provider, it does not create community access: confirm the user's email address belongs to an existing, active community member. When automatic provisioning is enabled, a first sign-in with no matching profile creates the member instead. If the provider has an **Email domain**, a first sign-in from an address outside it is denied either way, so check that the user's address is on that domain. Someone outside the domain who already has a Tightknit account may instead be asked to check their email for a confirmation that never arrives; see [Connecting SSO to an existing account](#connecting-sso-to-an-existing-account).
>
> Turn on automatic provisioning only if people can't create their own accounts with your identity provider. If anyone can sign up there, anyone can join your community.

> [accordion] The login page says the identity provider hasn't verified the member's email
>
> Tightknit checks verification on a member's first sign-in through an OIDC provider, or through a SAML provider with an **Email verified attribute**. It only matches the email address to a community member, or creates one, when the provider marks the address as verified. Otherwise the sign-in is refused, and the Authentication audit log records the error code `sso_email_not_verified`. See [Require a verified email](#require-a-verified-email).
>
> To fix it, have your identity provider send `true` in that claim or attribute for members whose address it trusts. If it uses a different claim, such as `xms_edov` in Microsoft Entra ID, enter that name as the provider's **Email verified claim**. A member who signed up with a password can verify their address with the provider. If one identity provider sits in front of another, such as Auth0 federating to your organization's Entra ID, the front provider may mark those addresses as unverified. In Auth0, add an Action that marks addresses from your enterprise connections as verified.
>
> Members who have already signed in through the provider aren't affected.

> [accordion] OIDC authentication fails
>
> Confirm the issuer and every endpoint use HTTPS, the client secret is current, and the application allows the `openid`, `profile`, and `email` scopes. Review the Authentication audit log for the recorded provider error.

> [accordion] SAML authentication fails
>
> Confirm the IdP sends the member email as `email` or NameID, the assertion is signed when required, and the IdP metadata or certificate is current.

> [accordion] Studio refuses a JWKS URL for a custom token provider
>
> The error names the check that failed. Confirm the JWKS includes every key your tokens are signed with today and answers with `200 OK` without redirecting. Once members have signed in through the provider, also confirm it is the `jwks_uri` your issuer's OpenID configuration lists or, if your issuer publishes none, that it sits under your issuer URL. See [Switch a custom token provider to a JWKS URL](#switch-a-custom-token-provider-to-a-jwks-url).

> [accordion] Custom token sign-in fails
>
> Confirm the token's `iss` and `aud` exactly match the provider's issuer and audience, it is signed with the configured algorithm and key, it has not expired, and it carries a `jti` that has not been used before. Review the Authentication audit log for the recorded reason.

> [accordion] The identity provider blocks the member before they reach Tightknit
>
> The member sees an error on your identity provider's own page instead of returning to the community. Because the sign-in never comes back to Tightknit, the Authentication audit log records no failed attempt for it. When a member reports an SSO error and the audit log shows nothing, investigate in your identity provider.
>
> Some identity providers send the member back to the community instead of showing their own error page. The login page then tells the member that their company's single sign-on didn't let them in, and the Authentication audit log records the failed attempt with the error code `sso_access_denied`. The cause and the fix are the same.
>
> The most common cause is an application that only admits assigned users. In Microsoft Entra ID the error is `AADSTS50105`, and the enterprise application has **Assignment required** turned on. To fix it, open **Enterprise applications**, select the application that signs members in to Tightknit, go to **Users and groups**, and assign the member or a group they belong to. Okta and other providers have the same per-application assignment. The error page usually shows a request ID and a correlation ID, which your identity provider admin can use to find the attempt in the provider's sign-in logs.
>
> If one identity provider sits in front of another, such as Auth0 federating to your organization's Entra ID, make the assignment in the provider that showed the error.
>
> Until the assignment is fixed, the member can sign in with any other method your community enables, such as Slack. If they already have a Tightknit account, their first successful SSO sign-in sends a one-time confirmation email. See [Connecting SSO to an existing account](#connecting-sso-to-an-existing-account).

If the audit log does not identify the problem, contact [support@tightknit.ai](mailto:support@tightknit.ai) with the provider type, provider ID, error message, and a redacted screenshot. Never send a client secret or private key by email.


## Related topics

- [Authentication](https://docs.tightknit.ai/community-site/authentication.md)
- [Troubleshooting](https://docs.tightknit.ai/support/troubleshooting.md)
- [List compositions](https://docs.tightknit.ai/v1/api-reference/compositions/list-compositions.md)
- [List tag groups](https://docs.tightknit.ai/v1/api-reference/tags/list-tag-groups.md)
- [List composition comments](https://docs.tightknit.ai/v1/api-reference/compositions/list-composition-comments.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.