Managing OpenIddict applications often starts simply. A small number of trusted developers register clients, the configuration is easy to review, and everyone understands the security conventions being followed.
As the deployment grows, that consistency becomes harder to maintain.
More applications are introduced. Different administrators make changes. Older integrations remain in use, while newer clients adopt stronger OAuth and OpenID Connect security practices. Over time, small configuration differences can become security weaknesses, operational problems, or awkward questions during an audit.
AdminUI for OpenIddict now helps you address this by validating client configurations against an agreed set of security rules.
Instead of relying solely on documentation, periodic reviews, or an administrator remembering every requirement, you can make those requirements part of the application-management process itself.
The challenge of keeping OpenIddict clients secure
An OAuth client rarely becomes insecure because of one obvious decision. Problems are more likely to emerge through a series of configuration choices that appear reasonable in isolation.
For example:
- A public client is registered without PKCE.
- An old client continues to use a grant type that is no longer recommended.
- A redirect URI is entered incorrectly or is missing altogether.
- A client is given capabilities it does not need.
- Two administrators configure similar applications differently.
- A temporary exception becomes a permanent part of the configuration.
These inconsistencies become harder to identify when an OpenIddict deployment includes tens or hundreds of applications.
A written security standard can explain how clients should be configured, but it cannot prevent someone from making a mistake. Manual reviews can find problems, but they usually take place after a client has already been created or changed.
A more effective approach is to validate the configuration where it is managed.
Bring security policy into AdminUI
Compliance Validation in AdminUI checks OpenIddict client applications against a selected ruleset.
When an administrator creates or edits a client, AdminUI evaluates the configuration and identifies any rules it doesn't satisfy. This gives the administrator immediate, contextual feedback while they work on the application.
Validation results can have one of two levels:
- Compliance failures identify requirements that must be satisfied. A client with one of these failures cannot be saved until the problem has been corrected.
- Recommendations highlight configurations to review but do not prevent the administrator from saving the client.
This distinction lets you enforce critical security controls without turning every preferred practice into a blocking requirement.
For example, your organization might prevent saving an authorization code client without PKCE, while treating another configuration choice as a recommendation during a migration period.
The result is a more practical governance approach. Administrators receive clear guidance, while security teams retain control over which requirements are mandatory.
Start with recognized OAuth security profiles
AdminUI includes two built-in compliance rulesets for OpenIddict:
- OAuth 2.1 draft
- Financial-grade API 2.0
The OAuth 2.1 draft ruleset is the default and provides a sensible starting point for most OpenIddict deployments. The FAPI 2.0 ruleset is available for environments that require a more strongly constrained security profile.
The built-in checks cover common client-configuration concerns, including:
- preventing the use of grant types that are no longer recommended;
- requiring PKCE for authorization code clients;
- checking that authorization code clients have a redirect URI;
- and validating other settings associated with the selected security profile.
Each rule can also provide a link to the relevant part of its specification. Administrators can therefore see not only that a configuration has failed, but why the requirement exists.
AdminUI allows an authorized user to select the server-wide default ruleset under Settings > Compliance. You can also select a different ruleset for an individual client when its requirements differ from the server default.
Prevent configuration drift
One of the most valuable aspects of compliance validation is its continuous application.
Security reviews often provide a snapshot of the system at a particular moment. A client may pass a review today and then be changed several weeks later. Without another review, that change may go unnoticed.
AdminUI moves the validation closer to the change itself.
Whenever an administrator updates a client, AdminUI can check its configuration against the applicable ruleset. This helps prevent applications from gradually drifting away from your security baseline.
It also produces a more consistent administrative experience. Instead of every administrator interpreting a written standard independently, AdminUI applies the same rules to everyone.
That is particularly useful when:
- application administration is shared across several teams;
- developers can request or manage their own clients;
- an organization operates multiple environments;
- legacy clients are being migrated to modern OAuth patterns;
- or client configuration forms part of a regulated or audited service.
Understand the state of your OpenIddict clients
Validating an individual client is useful, but security teams also need visibility across the entire deployment.
From the client list, an authorized AdminUI user can run Validate All to evaluate eligible clients and produce a compliance report.
The report organizes clients into four groups:
- Non-Compliant: the client has at least one compliance-level failure.
- Recommendation Only: the required checks pass, but one or more recommendations need attention.
- Compliant: the client satisfies the selected ruleset.
- Not Evaluated: compliance validation is disabled for the client.
Hidden and reserved clients are excluded from these groups.
This gives administrators a practical starting point for improving an existing OpenIddict installation. Rather than reviewing every application manually, teams can first focus on clients with blocking failures, then on those with recommendations.
The report can also support internal assurance and audit activity by providing a clearer view of how the client estate aligns with the organization’s chosen standards.
It should not replace a complete security assessment, but it can provide useful evidence that client configuration is being governed consistently.
Adapt validation to your organization
Recognized specifications provide an important baseline, but most organizations also have their own requirements.
You might want to enforce:
- a naming convention for client identifiers;
- approved redirect URI domains;
- restrictions on localhost redirect URIs outside development;
- organization-specific client types;
- permitted combinations of grants and response types;
- mandatory metadata for application ownership;
- or different rules for production and non-production clients.
AdminUI allows you to customize the supplied OAuth 2.1 and FAPI 2.0 rule providers or register an entirely separate ruleset.
A custom ruleset implements IComplianceRuleSetProvider<OpenIddictClient>. For conventional synchronous checks, it can derive from DefaultComplianceRuleSetProvider<OpenIddictClient> and provide the rules that make up your organization’s policy.
The provider is registered alongside AdminUI:
services.AddAdminUI();
services.AddComplianceRuleSet<MyOrganisationPolicyRuleSetProvider>();
Custom providers are registered at application startup and become available for selection and compliance evaluation within AdminUI. Adding a provider does not automatically make it the default, so the required ruleset must still be selected in the AdminUI settings or for the relevant client. [docs.openi...onents.com]
This extensibility allows the validation process to evolve with your security requirements rather than forcing every organization to adopt an identical policy.
Make secure configuration the easiest option
OAuth security guidance continues to evolve, and OpenIddict gives developers considerable flexibility in how they register applications. That flexibility is valuable, but it also makes consistent administration important.
Compliance Validation turns security expectations into checks that administrators can see and act upon while managing clients.
It helps you:
- catch configuration errors earlier;
- prevent critical requirements from being bypassed;
- guide administrators towards stronger settings;
- identify existing clients that require attention;
- reduce differences between teams and environments;
- and demonstrate that agreed configuration standards are being applied.
Most importantly, it reduces the dependence on memory and manual review.
Administrators should not need to consult a security checklist every time they update an OpenIddict application. The appropriate guidance should appear in the workflow when it is needed.
Getting started
Begin by opening Settings > Compliance in AdminUI and reviewing the default ruleset for your OpenIddict server.
For most deployments, the OAuth 2.1 draft ruleset provides a strong initial baseline. Once it is selected:
- Run Validate All from the client list.
- Review clients marked as non-compliant.
- Correct blocking security issues first.
- Examine recommendation-level findings.
- Decide whether any recommendations should become mandatory for your organization.
- Introduce custom rules for requirements specific to your applications and environments.
Compliance Validation is included with AdminUI for OpenIddict and is not a separately charged add-on.
By starting with the built-in rules and adapting them as your requirements mature, you can make secure, consistent OpenIddict client configuration part of normal administration rather than a separate exercise performed after the event.
For implementation details, see the Compliance Validation overview and Custom Rule Sets documentation.