Auth0 security for your tenant, applications and APIs
An Auth0 tenant holds the settings that decide who can sign in, through which connections, to which application, and what each token carries.
This guide explains the tenant and application settings that matter, what Auth0's documentation says about each, and what Auth0's testing policy allows. It comes with a tenant evidence workbook and a two-application authorisation matrix you run on a development tenant you own.
In this guide
Auth0 tenant evidence workbook and authorisation matrix
Work from a spreadsheet copy of the table, one per tenant. Rows W1 to W16 are the tenant evidence workbook: read each item where the second column points, record it, compare it with what Auth0's documentation says, and keep the evidence listed.
How to use itHide the instructions
W1 to W15 read settings, lists, code and logs, and W16 also runs Auth0's readiness check. Record that a secret, key or token exists and where it is stored or used, never its value. Rows M1 to M7 are the two-application authorisation matrix: run them only in a development tenant you own, with test users whose email addresses and phone numbers you control, test records, and at most one request to your API per row, with no load. Each token comes from an ordinary sign-in to your own application, and each altered request goes to your own API. Settings and defaults are as Auth0's documentation gave them on 14 November 2026.
23 rows
Row
Where to look, or what to send
W1. Tenants and environment tags
- Where to look, or what to send
- The tenant chooser at the top left of the Dashboard, then Dashboard > Settings > General for each tenant's Environment Tag.
- What to record
- Each tenant you hold, its tag (Development, Staging or Production), what it is used for, and which applications point at it.
- Compare with
- Auth0 advises a separate tenant for each environment and says a tenant used for both development and production should be tagged Production. Its readiness best practices say to decommission tenants no longer in use.
- Evidence to keep
- Tenant names, tags and the date read.
W2. Tenant members and Dashboard MFA
- Where to look, or what to send
- Dashboard > Settings > Tenant Members.
- What to record
- Each member, their role, whether the MFA indicator shows MFA enabled, whether the account is a company account, and whether the person still needs access.
- Compare with
- Auth0 recommends a periodic review: a legitimate need for each member, company accounts, no former employees and more than one Dashboard admin. "MFA for Tenant Administrators is enabled" is one of its non-critical readiness checks. Auth0's Dashboard roles page says role availability varies by plan.
- Evidence to keep
- A dated member list with roles and MFA status, with the names of people outside your business removed before sharing.
W3. Application type and grant types
- Where to look, or what to send
- The Applications page of the Dashboard, each application's settings, then Advanced Settings and Grant Types. Leave "Reveal Client Secret" unticked.
- What to record
- Application Type, first-party or third-party, each enabled grant type, and the flows the application's code actually uses.
- Compare with
- By default, public applications are created with implicit, authorization_code and refresh_token; confidential applications also get client_credentials. Adding the Password or MFA grant in the Dashboard enables all the Password and MFA grants together. Only customers from before 8 June 2017 can enable a legacy grant.
- Evidence to keep
- A grant list per application beside the flows in use, with any unused grant marked for its owner to decide.
W4. Client credentials
- Where to look, or what to send
- Each application's Credentials tab. An application with no Credentials tab is public.
- What to record
- The authentication method (None, Client Secret Post, Client Secret Basic or Private Key JWT), the server or service that uses the credential, and the name of the secret store entry that holds it.
- Compare with
- Client Secret is the default method. Auth0 lists its risks and recommends Private Key JWT, on the plan its credentials page names. Auth0 says the Client Secret cannot be rotated while the implementation is updated with the new secret.
- Evidence to keep
- Method and storage location per application, never the value. If the tab shows a secret or key, leave it hidden and copy nothing, and leave the "Reveal Client Secret" box on the settings unticked.
W5. Callback, logout and origin URLs
- Where to look, or what to send
- Each application's settings: "Allowed Callback URLs", "Allowed Logout URLs", "Allowed Web Origins" and "Allowed Origins (CORS)", with "Reveal Client Secret" left unticked. The tenant list: Allowed Logout URLs on the Advanced tab of Tenant Settings. Copy nothing from the global client information on that tab, which Auth0 says is used to generate tokens for legacy Auth0 APIs.
- What to record
- Every URL in each list, flagging wildcards, localhost, plain http and organization_name placeholders.
- Compare with
- Auth0 says not to use wildcard placeholders or localhost in callbacks or allowed origins, prefers the organization_name placeholder where relevant, and warns against wildcard and organisation placeholders in the same field. For the /v2/logout endpoint, logout requests without client_id use the tenant list. Logout URLs are case-sensitive apart from scheme and host.
- Evidence to keep
- The lists as text, with the date read.
W6. Connections per application
- Where to look, or what to send
- Each application's Connections tab, and "Enable Application Connections" on the Advanced tab of Tenant Settings. Copy nothing from the global client information on that tab.
- What to record
- The connections enabled for each application, whether that matches who should sign in to it, and the state of the tenant setting.
- Compare with
- Auth0 recommends turning "Enable Application Connections" off, because while it is on, all configured connections are enabled for any new application. Its critical readiness checks say social connections should not use the default Auth0 developer keys.
- Evidence to keep
- A grid of connections by application, with the date read.
W7. Actions inventory
- Where to look, or what to send
- Auth0 Dashboard > Actions > Library for each Action and its code, and Auth0 Dashboard > Actions > Flows for what is attached to each flow.
- What to record
- Each Action, its trigger, the flow it is attached to, the deployed version and any newer draft, its secrets by name, and each dependency with its resolved version.
- Compare with
- Only the deployed version runs. Auth0's guidance: secrets in the Secrets Manager or your own secrets manager, never in plain text in code; no personal information in code; nothing sensitive logged; dependencies audited before use and monitored for vulnerabilities. Each Action should run a recommended version of NodeJS.
- Evidence to keep
- The Action list with triggers, versions, secret names and dependency versions. Do not use the Test panel or Deploy: in Auth0's walkthrough the Test panel's Run button runs the code, and Deploy records a new Action Version.
W8. What Actions do to sign-in and tokens
- Where to look, or what to send
- The deployed code of each post-login and credentials-exchange Action.
- What to record
- Every call that redirects, denies access, triggers MFA, sets a custom claim or changes scopes, with the line it sits on. Note each use of api.accessToken.addScope().
- Compare with
- Verification and MFA steps must not be bypassable. The Login Flow also runs on single sign-on, silent authentication, refresh token exchange and Resource Owner password grants. For first-party applications, addScope() works outside RBAC, application access policy and consent, and Actions that modify access token scopes override the scopes RBAC sets.
- Evidence to keep
- Action name, version, line and what it does, plus which login routes each redirect handles.
W9. MFA policy and factors
- Where to look, or what to send
- Dashboard > Security > Multi-factor Auth.
- What to record
- Each enabled factor, the policy ("Never", "Use Adaptive MFA" or "Always"), whether risk assessment is on, and any Action that changes when MFA is asked for.
- Compare with
- At least one independent factor must be enabled to require MFA. With Never or Always, the risk assessment setting is disabled by default. A Phone Message factor should use a Twilio or custom delivery provider, per the critical readiness checks.
- Evidence to keep
- A dated screenshot of factors and policy, and the W8 Action names that touch MFA.
W10. APIs, RBAC and offline access
- Where to look, or what to send
- Dashboard > Applications > APIs, each API's Settings tab and its Machine-to-Machine Applications tab. This row reads only those two tabs.
- What to record
- Identifier, "Enable RBAC", "Add Permissions in the Access Token", "Allow Skipping User Consent", "Allow Offline Access", Maximum Access Token Lifetime, signing algorithm, and each machine-to-machine application authorised, including the test application Auth0 creates automatically to allow tests with the API.
- Compare with
- With RBAC off, an application can request any permission defined for the API. Maximum Access Token Lifetime defaults to 86400 seconds. Auth0 recommends RS256, and an API's signing algorithm cannot be changed after it is created.
- Evidence to keep
- One line per API with each switch and the authorised applications. For an API that uses HS256, record that it has a signing secret, never its value.
W11. Token claims
- Where to look, or what to send
- Each setCustomClaim call found in W8, and the claims your API's token validation code reads.
- What to record
- Each custom claim name, its namespace, the Action that sets it, the token it goes in (ID or access), and what your API or application decides from it.
- Compare with
- Auth0 recommends namespaced claims; on a collision the claim is not added and the transaction does not fail. Auth0 lists aud, org_id, permissions and roles among its restricted claims, and claims Auth0 uses internally cannot be customised. Auth0's token best practices say not to add sensitive data to the token payload, and ID tokens are not for API access.
- Evidence to keep
- A claim table with names and the kind of value only, never personal data from a real user.
W12. Refresh tokens
- Where to look, or what to send
- Each application's settings, under Refresh Token Rotation and Refresh Token Expiration, with "Reveal Client Secret" left unticked, and "Refresh Token Revocation Deletes Grant" on the Advanced tab of Tenant Settings, copying nothing from the global client information there.
- What to record
- Whether the application has the refresh_token grant, whether "Allow Refresh Token Rotation" is on, the Rotation Overlap Period, the idle and maximum lifetimes or that they are disabled, and the tenant setting.
- Compare with
- Rotation needs an OIDC-conformant application with the Refresh Token grant type, and an expiration lifetime. A disabled maximum lifetime is indefinite. Breach detection does not apply inside the overlap period. Auth0 limits active refresh tokens to 200 per user per application.
- Evidence to keep
- Settings per application, plus any ferrt events found in the tenant logs in W15.
W13. Organizations and application access
- Where to look, or what to send
- Each application's "Login Experience" view; Auth0 Dashboard > Organizations, then each organisation's Applications tab; "Allow Organization Names in Authentication API" on the Advanced tab of Tenant Settings, copying nothing from the global client information there.
- What to record
- "Type of Users" and "Login Flow" for each application; for each organisation, whether "Per-Application Access" is on and which applications it grants; whether organisation names are allowed; which roles are Organization roles.
- Compare with
- Without per-application access, members can access any application with Organizations enabled and an active connection. Your API should validate org_id against known values and must segment data by it. By default, tokens carry only org_id; with organisation names allowed, they carry org_name as well. Auth0 marks per-application access and Organization roles as Early Access features.
- Evidence to keep
- One line per application and per organisation, with the date read.
W14. Sessions and signing keys
- Where to look, or what to send
- Tenant Settings: "Inactivity timeout" and "Require log in after" on the Advanced tab, copying nothing from the global client information there, and the Signing Keys tab. Each application's Advanced Settings, under OAuth, for its signing algorithm, with "Reveal Client Secret" left unticked.
- What to record
- Both timeouts, whether a previously used signing key is still listed, and the signing algorithm of each application and API.
- Compare with
- Auth0 gives 7 days as the default SSO session timeout and recommends setting it. A previously used key still listed has been rotated but not revoked, and tokens it signed stay valid until it is revoked. Auth0 recommends RS256 over HS256.
- Evidence to keep
- Values and the date read. Do not press "Rotate Signing Key" or "Rotate & Revoke Signing Key": both change the keys.
W15. Attack protection and tenant logs
- Where to look, or what to send
- The attack protection options in the Dashboard; Auth0 Dashboard > Monitoring > Logs; the tenant's log streams.
- What to record
- Each attack protection option and whether it only monitors or also responds, your plan's log retention, each log stream with its destination, filters, masking or hashing and health, and any ferrt or attack protection events in the review period.
- Compare with
- Options enabled without response settings run in Monitoring mode and only record events. Retention runs from 1 day on Starter to 30 days on the last plan in Auth0's table. Once a stream is on, the customer is the controller of the exported data.
- Evidence to keep
- Stream names, destinations and settings, and event types with dates. If a stream's settings show a token or key for its destination, record only that one is set. Field names only from sample entries, never names, emails or IP addresses. Auth0's Dashboard roles page says logs can contain sensitive data such as secrets: where an entry shows one, record only that it is there.
W16. Readiness check
- Where to look, or what to send
- The tenant dropdown in the Dashboard, then "Run Readiness Check". Auth0's page says the screen refreshes to show the results when the check is complete.
- What to record
- Each failed check, its category (critical fix, non-critical fix or best practice) and the workbook row it relates to.
- Compare with
- Auth0 lists best practices that cannot be automated, including reviewing tenants and administrators, SSO timeout values and attack protection.
- Evidence to keep
- A dated copy of the results. Leave the Configure links alone: they lead to the area where a fix is made.
M1. Matrix baseline
- Where to look, or what to send
- In your development tenant, with test users and test records only, and no load: U1 signs in to App A, then sends one request to a read endpoint on API A for the test record owned by O1. Any message the sign-in sends goes to an address or number you control.
- What to record
- Status code, time, and the access token's aud, scope, permissions and org_id values.
- Compare with
- Should succeed. If it fails, fix the set-up before reading the other matrix rows.
- Evidence to keep
- The request line, status and claim values, never the token.
M2. Token for the wrong API
- Where to look, or what to send
- In your development tenant, with test users and test records only, and no load: send U1's App A access token, once, to the matching read endpoint on API B.
- What to record
- Status code and response body.
- Compare with
- Auth0 says an access token should be validated only by the API it was meant for, that at least one aud value must match the API's Identifier, and that a token failing a check must be rejected with 401 Unauthorized.
- Evidence to keep
- The request line, status and the aud value.
M3. ID token sent as an access token
- Where to look, or what to send
- In your development tenant, with test users and test records only, and no load: send U1's ID token from App A, once, to the read endpoint on API A.
- What to record
- Status code and response body.
- Compare with
- Auth0 says ID tokens should never be used to obtain direct access to APIs or to make authorisation decisions. This page expects a refusal.
- Evidence to keep
- The request line and status, never the token.
M4. Missing permission
- Where to look, or what to send
- In your development tenant, with test users and test records only, and no load: U1, who holds only the read permission, sends one request to a write endpoint on API A against the O1 test record.
- What to record
- Status code, and whether the token's scope or permissions claim included the write permission.
- Compare with
- Auth0 says the API should reject a request whose scope lacks the permission the endpoint needs. If the write permission appears in the token, check W10, since with RBAC off an application can request any permission defined for the API, and W8 for addScope().
- Evidence to keep
- Status, the scope and permissions values, and the test record's state afterwards.
M5. Another organisation's record
- Where to look, or what to send
- In your development tenant, with test users and test records only, and no load: U1, a member of O1, sends one read request to API A for the test record owned by O2, changing only the record id.
- What to record
- Status code and whether any O2 data came back.
- Compare with
- Auth0 says your API servers must segment access to data and resources based on org_id. This page expects a refusal that returns no O2 data.
- Evidence to keep
- The request line, status and the org_id value.
M6. The application a user should not use
- Where to look, or what to send
- In your development tenant, with test users and test records only, and no load: U3 signs in to App B once. Any message the sign-in sends goes to an address or number you control.
- What to record
- Whether sign-in completes, whether App B receives a token for API B, and what U3 sees.
- Compare with
- Your design decides the expected answer. With Organizations, members can access any application with Organizations enabled and an active connection unless per-application access is on for their organisation. Otherwise a limit can come from the connections enabled for App B, from App B or API B itself, or from an Action that denies access.
- Evidence to keep
- The outcome, the setting or Action that produced it, and the date.
M7. Token after sign-out
- Where to look, or what to send
- In your development tenant, with test users and test records only, and no load: U1 signs out of App A, then sends the access token App A held before sign-out, once, to the read endpoint on API A.
- What to record
- Status code and the token's exp value.
- Compare with
- Auth0's token best practices say a signed token stays valid unless the signing key changes or an expiry is set, and ask for a strategy for expiring or revoking tokens. Record whether API A accepts the token until exp, and whether that matches your design.
- Evidence to keep
- Status, exp value and the sign-out time, never the token.
Where Auth0 sits in your application
This guide treats Auth0 security as a question of the configuration your own administrators control and the checks your own code makes.
Auth0 sits between your application and the places your users come from. Its documentation describes a connection as the relationship between Auth0 and a source of users, such as an external identity provider, a database or a passwordless method. Each application registered in an Auth0 tenant has its own Client ID and settings, and each API registered in the tenant has an Identifier.
When someone signs in, Auth0 issues an access token or an ID token, and access tokens are what an application uses to make authenticated calls to a secured API.
Your own code makes the final decision on what a token holder may do. Auth0's API settings page says the Identifier does not have to be a publicly available URL and that Auth0 will not call your API at all.
Its page on validating access tokens says an access token should be validated only by the API it was meant for, and that a token which fails any check must be rejected with 401 Unauthorized.
That split shapes this guide. The tenant decides who can sign in, through which connections, to which application, and what each token carries. Your API decides what a token lets someone read or change. A review of the tenant sees the first half, and the two-application matrix on this page tests the second half on a development tenant you own.
How a framework such as Next.js wires sign-in into its routes is covered in the Next.js guide, and OAuth flows, JWT verification and sessions each have a guide of their own. This page stays with Auth0's settings.
What Auth0 runs and what your tenant settings decide
Asked as one question, Auth0 security splits into what Auth0 says it does and what its documentation asks of the tenant administrator and your own code.
These statements come straight from Auth0's pages:
- Passwords: for database connections that use the Auth0 user store, Auth0 says passwords are never stored or logged in plain text and are hashed with bcrypt, and that it limits repeat login attempts per user and IP address.
- Signing keys: with RS256, Auth0 signs tokens with a private key that Auth0 secures and that is unique per tenant. Your application validates the signature with the public key.
- Tenant logs: Auth0 says its logs exclude core authentication secrets such as OTP codes, OTP seeds, biometric data and private keys, and that it at no point logs access tokens from Auth0 or any identity provider.
- Tenant members: Auth0's dashboard access guidance says that as a tenant administrator you are responsible for all activities that occur under your Auth0 account and tenants, including managing tenant members.
- Your API: Auth0's token pages ask your API to validate each access token, including its audience and scope. Where tokens carry an org_id claim, they say your API servers must segment access to data and resources based on it.
- Exported logs: Auth0's log streams page says that by enabling log streams, the customer becomes the controller of that information and is responsible for the data exported.
The settings your administrators choose
Grant types, redirect URLs, connections, Actions, MFA policy, RBAC, token lifetimes and log streams are all set by the people who run the tenant. Auth0's tenant settings page lists recommended settings, including setting up tenant members with MFA, switching off "Enable Application Connections" and enabling Attack Protection, and its production readiness checks flag others.
This page treats both lists as a starting point. Each setting still has to be read against what your own applications need, which is what the workbook does.
Applications, grant types and client credentials
Auth0 sorts applications into confidential and public.
Regular web apps and machine-to-machine apps are confidential unless they are configured with no authentication method, and single-page apps and native apps are public. Auth0 gives a quick way to tell them apart in the Dashboard: an application with no Credentials tab is public, and one with a Credentials tab is confidential.
Grant types are where defaults matter. Auth0's grant types page says that by default, public applications are created with implicit, authorization_code and refresh_token enabled, and confidential applications with the same grants plus client_credentials. Trusted first-party applications have the same grant types enabled as confidential applications, plus the password, password-realm and MFA grants, and when the Password or MFA grant type is added in the Dashboard, all the Password and MFA grant types are enabled together.
Legacy grant types remain available only to customers from before 8 June 2017, and Auth0 highly recommends moving to a more secure alternative.
The workbook records each application's grant list beside the flows its code actually uses, so that a grant left on and never used shows up for its owner to decide.
For confidential applications, the credential matters too. Client Secret is Auth0's default authentication method. Auth0 says the Client ID is considered public information, while anyone who can access the Client Secret can issue tokens and access resources they should not be able to access.
Its credentials page names security risks of a client secret, especially where security demands are higher: the secret is shared with Auth0, and it is sent over the network and could be intercepted in a man-in-the-middle attack.
To improve security posture, that page recommends Private Key JWT, on the plan it names. It also says it is not possible to rotate the Client Secret while the implementation is updated with the new secret.
Rotation is planned work, so it sits outside this workbook. The workbook records which method each application uses and where its credential is stored, never the value. On an application's settings, Auth0 hides the Client Secret by default and shows it when the "Reveal Client Secret" box is ticked. Leave that box unticked throughout the review.
Callback, logout and origin URLs
The callback and logout lists on each application decide where Auth0 may send a user after sign-in and after sign-out, and the origin lists name where certain requests to Auth0 may come from.
Auth0's application settings page asks for production lists that do not point to localhost, and says not to use wildcard placeholders or localhost URLs in callbacks or allowed origins, because redirect URLs with wildcard placeholders can make the application vulnerable to attacks. Where relevant, it prefers URLs with the organization_name placeholder, which its placeholder page says should only be used on domains you fully control.
Mixing wildcard and organization_name placeholders in one field can cause a quieter problem. Auth0's placeholder page gives the example of an application whose callback URLs are https://*.exampleco.com and the same address with the organization_name placeholder in place of the star: a redirect to https://company-a.exampleco.com would be considered valid even if no organisation called company-a is registered, because of the wildcard.
Among the critical fixes in Auth0's production readiness checks are that Allowed Callback URLs, Allowed Origins (CORS) and Allowed Web Origins should not include localhost.
Logout has an application list and a tenant list. Auth0's page on redirecting users after logout, which covers the /v2/logout endpoint it calls the legacy logout endpoint, says Auth0 only redirects to allow list URLs after logout.
For that endpoint, a logout request that includes client_id is checked against the application's "Allowed Logout URLs", and one without client_id against the tenant list on the Advanced tab of Tenant Settings. Auth0 notes that these URLs are case-sensitive, apart from the scheme and host.
Because the tenant list applies to logout requests without client_id, this page puts it in the review beside each application's own list.
Connections: which sign-in methods reach which application
Each application has its own list of enabled connections, on its Connections tab.
Auth0's tenant settings page recommends switching off the tenant setting "Enable Application Connections". While it is on, all configured connections are enabled automatically for any new application, and users may be able to log in to the application through connections that were not meant to be available. For a review, that makes the connection list of each application the record that matters, read one application at a time.
Auth0's critical readiness checks add that social connections should not use the default Auth0 developer keys. Auth0's attack protection options, which the workbook records, include Bot Detection, Suspicious IP Throttling, Brute Force Protection and Breached Password Detection. Auth0 says that enabling them without configuring response settings activates Monitoring mode, which only records related events in the tenant log. How to spot and slow credential stuffing against any login is covered in the credential stuffing guide.
Auth0 Actions security: code that runs inside sign-in
Auth0 describes triggers as points in the Auth0 process where Actions can be added, with several Actions running in sequence in one trigger.
The post-login trigger runs after a user is authenticated but before a token is issued, and the credentials-exchange trigger runs before an access token is returned. Actions at those points can add custom claims and change scopes, and Auth0's coding guidelines give api.access.deny() as an example of the api method to use when a process has to stop.
That makes Actions the part of a tenant closest to application code, and the part a settings review can judge only by reading the code.
Auth0's coding guidelines give the rules to read the code against. Actions that provide verification or trigger MFA must not be bypassable, unintentionally or maliciously. Secrets go in the Secrets Manager, or a secrets manager of your own integrated into the Action, rather than in plain text in the code, Action code must not contain personal information, and secrets, sensitive data and personal information are never logged.
The guidelines also say the Login Flow runs after any successful login, including single sign-on, silent authentication, refresh token exchange and Resource Owner password grants, and that an Action which redirects has to either deny access when interaction is required or deliberately allow the bypass, which puts the burden on the application requesting login.
This page reads that as a check for every redirecting Action: what it does when a login arrives by one of those other routes.
Scopes are the second thing to look for. Auth0's page on handling scopes says the api.transaction methods change target scopes that Auth0 then evaluates against applicable authorisation policies, silently dropping unauthorised additions. The api.accessToken.addScope() method in a Post Login Action is different. For first-party applications it works after authorisation, outside RBAC, application access policy and consent, and adds the scope without showing it on the consent screen.
Auth0's page on enabling RBAC adds that Actions which modify access token scopes override the scopes RBAC sets. A search of every Action for addScope is therefore a row of the workbook.
Dependencies and versions complete the picture. Auth0 recommends auditing npm packages before using them in Actions and monitoring them for vulnerabilities, and its walkthrough shows that saving an Action resolves each dependency to a specific version number.
Auth0 executes only the deployed version of an Action. The review therefore reads the deployed code and notes any draft that differs. Auth0 also says a Secret's value will never be revealed once it is created, and the workbook lists secrets by name.
Leave the code editor's Test panel alone during the review: in Auth0's walkthrough, its Run button runs the Action, which in that example sends a message to a Slack channel.
MFA for users and for the people who run the tenant
MFA for your users is set at Dashboard > Security > Multi-factor Auth.
A tenant needs at least one independent factor enabled before it can require MFA. The independent factors are WebAuthn with FIDO Security Keys, One-time Password, Push Notification using Auth0 Guardian, Phone Message and Cisco Duo Security. The dependent factors, which need an independent factor first, are WebAuthn with FIDO Biometrics, Email and Recovery Code.
The policy is one of "Never", "Use Adaptive MFA", which requires MFA based on Auth0's risk determination, or "Always". With Never or Always, the Adaptive MFA risk assessment setting is disabled by default.
Post-login Actions can also require MFA in specific circumstances, which brings the Actions rules above into play. Where MFA uses the Phone Message factor, Auth0's critical readiness checks ask for a Twilio or custom delivery provider to avoid the default provider's rate limits.
The people who administer the tenant need the same care. Auth0's role list gives the "Admin" role read and write access to all resources in the Dashboard, including extensions. Auth0 recommends reviewing tenant members periodically to confirm that each has a legitimate need, that members use a company account, that former employees no longer have access and that there is more than one Dashboard admin.
Any Dashboard user can enrol in MFA from their profile, and the MFA indicator in the Tenant Members list shows who has.
"MFA for Tenant Administrators is enabled" is one of Auth0's non-critical readiness checks. The design of MFA itself, such as recovery paths and push fatigue, is covered in the MFA security guide.
Roles, permissions and the token claims your API trusts
Each API registered in the tenant has its own RBAC switch, under RBAC Settings in the API's settings.
Auth0's page on enabling RBAC states the difference it makes. With RBAC on, the scope claim holds the intersection of the permissions requested and the permissions assigned to the user. With RBAC off, an application can request any permission defined for the API, and the scope claim includes all requested permissions.
"Add Permissions in the Access Token" adds a permissions claim listing every permission assigned to the user.
RBAC in Auth0 is additive, so a user with two roles holds the union of both, and Auth0 calls it best practice to give users the fewest permissions that let them do their work.
Your API still has to read those claims. Auth0's validation page asks it to check that at least one audience value matches the API's Identifier and that the scope claim includes the permission the endpoint needs, and to reject the request otherwise. Its ID token page says ID tokens should never be used to obtain direct access to APIs or to make authorisation decisions.
Custom claims are added by Actions with setCustomClaim. Auth0 recommends namespacing them with a URL you control, and says that on a name collision the transaction does not fail but the custom claim is not added to the token. It lists restricted claims, among them aud, iss, sub, org_id, permissions and roles, and says standard OpenID claims and claims Auth0 uses internally cannot be customised.
Its token best practices add that tokens are easily decoded, so sensitive data does not belong in the payload.
The workbook lists every custom claim, the Action that sets it and what your API decides from it. How a verifier should handle algorithms, keys and expiry is covered in the JWT security guide.
Refresh token rotation, expiry and offline access
A refresh token gets a new access token without user interaction, and Auth0 says applications must store refresh tokens securely because they essentially allow a user to remain authenticated forever.
An API's "Allow Offline Access" setting lets applications ask for refresh tokens for that API. With it off, Auth0 will not return a refresh token for the API even when the offline_access scope is requested.
Rotation is set per application. With "Allow Refresh Token Rotation" on, each exchange returns a new refresh token and invalidates the one that was used. If an already invalidated token is sent again, Auth0 invalidates the whole token family and denies further requests until the user authenticates again, and it records the reuse in the tenant logs, for example as a ferrt event for a failed exchange.
The Rotation Overlap Period is a leeway in which the previous token can be used again, and Auth0 says breach detection does not apply during it. Rotation is only supported for OIDC-conformant applications with the Refresh Token grant type enabled.
Expiry is the other half. Each application can set an idle lifetime and a maximum lifetime. If the maximum lifetime setting is disabled, the maximum lifetime is indefinite, and when rotation is enabled, an expiration lifetime must be set. With rotation on, the default expiration is 30 days, configurable up to 1 year, and rotating does not extend it.
Auth0 limits active refresh tokens to 200 per user per application and revokes the oldest when a new one is created past that limit. On the tenant's Advanced tab, "Refresh Token Revocation Deletes Grant" decides whether revoking a refresh token through the revoke endpoint also deletes the grant.
Auth0 says it is enabled by default for existing tenants and disabled by default for tenants created as of 13 January 2021. How sign-out and timeouts should end a session inside your own application is covered in the session management guide.
Organizations: keeping one customer's members out of another's data
Auth0 says its Organizations feature best supports business-to-business implementations, and that availability depends on the login implementation and your plan or agreement.
Each application chooses who may use it on its "Login Experience" view. "Type of Users" is "Individuals", "Business Users" or "Both", stored as the organization_usage values deny, require and allow, and deny is the default.
Two behaviours deserve a line each in the workbook. The first is application access: by default, members of an organisation can access any application with Organizations enabled and an active connection, which Auth0 calls the implicit access model.
Per-application access switches one organisation to an explicit model in which first-party applications without an explicit grant are blocked, and enabling it for one organisation does not affect the others. Auth0's page for that setting marks it as an Early Access feature, available on the B2C Professional and B2B Professional plans and one further plan it names.
The second is roles: with Organizations enabled, Auth0 uses tenant roles and Organization roles. Auth0 marks Organization roles as an Early Access feature that you join through Auth0 Support, and says that when a user authenticates through an organisation and holds Organization roles, the permissions claim reflects only the roles held within that organisation for the session.
Auth0's tokens page asks for more than the SDK check. Auth0 SDKs validate the org_id claim when the organisation is passed, but you should perform additional validation when tokens are received: an API that receives an org_id should check it against values it knows and deem the token invalid otherwise.
The same page says your API servers must also segment access to data and resources based on org_id. That segmenting happens in your API, which is why the matrix sends a request for another organisation's record to it.
Tenant logs, retention and log streams
Tenant logs hold the evidence a review looks for: Auth0 records Action executions, refresh token reuse events and attack protection events there.
How long entries stay depends on the plan. Auth0's retention table gives 1 day on Starter, 5 days on the B2C and B2B Essentials plans, 10 days on the B2C and B2B Professional plans and 30 days on the last plan it lists. The same page says log streaming can export log data and that Auth0 Support can help integrate external logging services to keep logs beyond the retention time, and one of Auth0's non-critical readiness checks recommends a log streaming service to retain logs over 30 days.
Log streams send tenant logs to a log analysis service. Auth0 says that by enabling them, the customer becomes the controller of that information and is responsible for the data exported, including what is streamed and how it is used. Many log entries can hold personal information such as names, phone numbers, email addresses and IP addresses.
A stream can filter log categories, and mask or hash fields such as names, email addresses and phone numbers. Auth0 also advises against using log streams in an application's critical path or for real-time decisions, and notes that by default, logs may not display in the exact order in which they occurred.
The workbook records each stream's destination, filters and masking, and this page adds one more line of its own: who can read the destination.
Auth0 vulnerabilities: where advisories are published
A search for an Auth0 vulnerability can turn up two different things: a weakness in how a tenant is set up, which the workbook deals with, or a flaw in Auth0 software you install, such as an SDK inside your application.
Okta publishes a security advisories list. On 14 November 2026, that list included advisories for Auth0 SDKs and components, among them the Auth0 Next.js SDK, the Auth0 PHP SDK, auth0.js and the Auth0 AD/LDAP Connector. Look on the same list for entries after that date; it also offers an RSS feed.
For the second kind, the version installed in your application is the evidence. Check Okta's list for each Auth0 package your application installs, read any advisory that names one, compare it with the version in your lockfile, and look again before each release.
Reporting a suspected flaw in Auth0 itself goes the other way: Auth0's penetration testing policy points to Okta's Vulnerability Reporting Policy for reporting identified vulnerabilities, and asks that suspected findings from an approved test be disclosed to the Auth0 Security team.
How to fill in the tenant evidence workbook
Make one copy of the workbook per tenant, starting with production.
Where a row covers several applications, APIs, Actions or organisations, give each its own line. Write "not used" or "not on this plan" rather than leaving a cell blank, because a blank reads as unchecked.
- Rows W1 to W15 read settings, lists, code and logs, in the Dashboard or in your own code. Row W16 also runs Auth0's readiness check and records its results.
- Record names, types, lists, switches, dates and people. Never copy a Client Secret, signing key, Action secret, token or password into the workbook: write that it exists, where it is stored or used, and who can manage it.
- Leave every reveal, rotate, test, deploy and configure control alone. Auth0's pages describe a "Reveal Client Secret" box, "Rotate Signing Key" and "Rotate & Revoke Signing Key" controls, an Action's Test and Deploy controls, and Configure links in the readiness check. Each one shows a secret, changes a key or a version, runs code, or leads to the place where a fix is made.
- Where your plan offers limited Dashboard roles, Auth0 describes a "Viewer - Config Settings" role with read-only access to configuration settings, except sensitive information such as secrets, billing, users and logs. Its table for that role lists read-only access to areas including Applications, APIs, Actions, Security and the General and Advanced settings tabs, and marks some of them, among them Applications, APIs and Multi-factor Auth, as excluding access to secrets. This page suggests that role for the configuration rows, in particular those that open an application's settings. The table gives the Advanced tab of Tenant Settings no such mark, so there too copy nothing from the global client information. Areas the table does not list, such as Tenant Members, Signing Keys and the logs, need a role that can read them.
- The Advanced tab of Tenant Settings also holds global client information: the Global Client ID and Global Client Secret, which Auth0 says are used to generate tokens for legacy Auth0 APIs. When a row sends you to that tab, read only the setting the row names, and copy or screenshot nothing from the global client information.
- Put the date on each screenshot, keep secrets and the global client information out of it, and strip out the names of people outside your business before anyone else sees the workbook.
- Run the review again after a plan change, a new application or API, a new or redeployed Action, a new tenant member or a change of connection.
The two-application authorisation matrix
The workbook shows how the tenant is set.
The matrix shows whether your APIs act on what the tokens say. It needs two applications that call two different APIs, registered in a development tenant you own. Auth0 advises creating a separate tenant for each environment, development, staging and production, to keep them isolated, and different administrators can be set for each.
- App A calls API A, and App B calls API B. Each API has its own Identifier, RBAC switched on, and at least one read and one write permission.
- Test users only, with email addresses and phone numbers you control, because a sign-in can send a verification or MFA message: U1 is a member of organisation O1 with only the read permission on API A, U2 is a member of organisation O2, and U3 is meant to use App A but not App B.
- Test records only: one record owned by O1 and one owned by O2 in API A's development data.
- At most one request to your API per row, sent once from a tool you run, never in a loop and never under load.
- Hold tokens only inside the tool that sends the request. The matrix records the status code, the time and the claim values the row names, never the token itself. Do not paste tokens into online decoders.
Why the matrix stays on your own systems
Each token in the matrix comes from an ordinary sign-in to your own application, and each altered request goes to your own API, never to Auth0's endpoints. Where you want to go further, such as changing parameters on a sign-in or token request to your tenant, read the testing policy section below first.
Rows M2 to M5 compare your API's answer with what Auth0's pages say an API should do. Rows M6 and M7 record what your own design intends, because the right answer depends on how you set up organisations, Actions and token lifetimes.
What a review of your own tenant cannot show
The workbook records configuration.
It shows which grants, URLs, connections, Actions and policies are set, and the matrix shows how your APIs answer six requests and how App B handles one sign-in, in a development tenant. Neither shows how every endpoint of a production API treats every role, whether your application code checks ownership of each record it returns, or what happens in a flow the matrix does not cover. Answering them takes a test of the application itself.
A tenant review cannot see inside Auth0 either. Okta, which describes itself as offering solutions through Okta and Auth0, publishes information and documents on its security and compliance through its Security Trust Center, with some documents behind an access request. Evidence about the platform itself comes from Okta's own pages, such as that centre, because a review of your settings cannot supply it.
It is also a snapshot. Your plan's retention period caps how far back the logs go, an administrator can change a setting once you have read it, and an Action can be redeployed at any time.
Auth0's testing policy, read before any active test
Auth0's Penetration Testing Policy says a customer with a paid Auth0 subscription may conduct a security test of their application involving Auth0 infrastructure, such as their tenant's auth0.com address, with prior approval.
Notice goes through the Support Center at least 7 days before the planned start. The request for approval gives the dates, times and timezone, the scope and purpose, the source IP addresses, the planned tooling, the requests per second, which must conform to Auth0's Rate Limit Policy, the tenants involved and two contacts available for the whole test.
Auth0 says that if it cannot reach those contacts, it reserves the right to take measures to protect the service, which may include shutting down or blocking the tenant or the source of the intrusion traffic. Tests are not allowed during change freeze periods.
The policy's requirements are that the test is restricted to your own tenant, stays within the Rate Limit Policy and discloses suspected findings to the Auth0 Security team. Its restrictions rule out denial-of-service testing and unauthorised volumetric attacks against any tenant or space, penetration testing that targets the management dashboard, and testing of tenants Auth0 has not approved.
The Management and Authentication APIs are allowed. Private Cloud customers also request permission through the Auth0 Support Center. Load testing falls under a separate Load Testing Policy, which limits it to customers on the subscription that policy names and allows it only with Auth0's prior written approval. For Private Cloud customers, that policy points to a separate Private Cloud Load Testing Policy.
The same policy says that if a test is isolated to your own infrastructure, with no testing of Auth0 services, you do not need to notify Auth0. Okta's Vulnerability Reporting Policy, which Auth0's policy links for reporting, asks for vulnerability testing against Trial or Developer Edition instances whenever one is available, and always with test or demo accounts.
The matrix on this page is designed around those conditions: test users, a development tenant you own and single requests to your own APIs. The permission for tests involving Auth0 infrastructure is written for paid subscriptions. If your tenant is on a free plan, if a planned test would reach Auth0's endpoints in any way beyond ordinary sign-in, or if you are unsure whether a test is isolated to your own infrastructure, ask Auth0 through the Support Center before it starts, and keep the answer with the workbook.
Where Clever Ops fits around an Auth0 tenant
This guide is information for reviewing your own tenant, not a description of a Clever Ops service for Auth0, and Clever Ops does not test Auth0's platform.
Under the Clever Ops methodology, a service another business runs stays out of scope unless its owner agrees, and Auth0's policy sets its own conditions on who may test its infrastructure and how.
Your own application and API are a different matter. The Clever Ops web application and API penetration test signs in to a custom application and tests it together with the API behind it. Its scope takes in authentication and sessions, what each role is able to see and change, whether one customer can get at another customer's records, and requests sent straight to the API as well as through the screens.
For an application that signs users in through Auth0, active testing belongs inside that scoped assessment, and if the application serves several customer organisations from one database, the test needs accounts in two of them.
The methodology also checks the testing policy of each target's hosting provider before the first request, since some hosts want notice or written approval in advance.
A secure code review goes through the source instead, for example the authorisation layer and every route that returns customer data, with read-only access to your repository. For an application Clever Ops built or hosts, the work is a security review and not an independent test, and its report states who built the application and who hosts it.
Clever Ops offers neither round-the-clock monitoring nor emergency incident response. If you suspect someone is misusing a tenant or a credential right now, go to Auth0 and an incident response specialist before anything else.
Frequently asked questions
Auth0's documentation answers in parts rather than with a verdict. It says passwords in its own user store are hashed with bcrypt, that its RS256 signing key is unique per tenant and secured by Auth0, and that tenant logs exclude core authentication secrets such as OTP codes and private keys. It also says the tenant administrator is responsible for all activities under the account, including tenant members, and that your API should validate each access token and must segment data by org_id where tokens carry one. Grant types, redirect URLs, connections, Actions and RBAC are set by your administrators, and those are what the workbook on this page records.
Auth0's tenant settings page lists recommended settings: an environment tag, a support email and URL, a custom error page, a custom domain on a paid plan, the SSO session timeout (7 days by default), tenant members with MFA, switching off "Enable Application Connections" and enabling Attack Protection. Its production readiness check, run from the tenant dropdown with "Run Readiness Check", sorts further checks into critical fixes, non-critical fixes and best practices. Rows W1, W2, W6, W14, W15 and W16 of the workbook record the environment tag, tenant members, application connections, session timeouts, attack protection and readiness results.
Partly. With RBAC enabled on an API, Auth0 limits the scope claim to the requested permissions the user has been assigned. With RBAC off, an application can request any permission defined for the API and the scope claim includes all of them, and Actions that modify access token scopes override the scopes RBAC sets. The check on each request is made by your API: Auth0's validation page says the API should verify the audience and the scope claim and reject a request that fails. Rows M2 and M4 of the matrix test the audience and scope checks on a development tenant.
Auth0's Actions walkthrough says that once a Secret has been created, its value will never be revealed, and that Auth0 encrypts all Secrets. That covers values stored as Secrets. Auth0's coding guidelines say not to write secrets in plain text in Actions code. The review on this page reads the deployed code for keys written into it. The workbook records Secret names only, and Auth0's "Viewer - Config Settings" role, where your plan offers it, gives read-only access to configuration without sensitive information such as secrets.
Auth0's Penetration Testing Policy says a customer with a paid subscription may test their application involving Auth0 infrastructure with prior approval, requested through the Support Center at least 7 days ahead, and that a test isolated to your own infrastructure with no testing of Auth0 services needs no notice. The test must stay in your tenant and within the Rate Limit Policy, and the policy rules out denial-of-service and unauthorised volumetric testing, testing that targets the management dashboard, and tenants Auth0 has not approved. Read the policy on the day, and ask Auth0 where your plan or your test plan leaves doubt.
It depends on the plan. Auth0's retention table gives 1 day on Starter, 5 days on the Essentials plans, 10 days on the Professional plans and 30 days on the last plan it lists. The same page says log streaming can export log data and that Auth0 Support can help integrate external logging services to keep logs longer, and Auth0's non-critical readiness checks recommend a log streaming service to retain logs over 30 days. Once a stream is on, Auth0 says the customer is the controller of the exported data and responsible for it.
Scope the right test for your application
Tell us what you have built, who uses it and when it needs to launch. You will get a plain-English recommendation: a website audit, a web application test or a referral to a specialist.