| oidc-ca | November 2026 | |
| Sakimura & Jay | Standards Track | [Page] |
An OpenID Provider (OP) can disclose claims about an End-User, such as a name or date of birth, to a Relying Party (RP) with the End-User's consent. This document profiles the Aggregated Claims model defined in Section 5.6.2 of OpenID Connect Core 1.0 OpenID.Core. In this model, the OP returns claims asserted by one or more Claims Providers (CPs).¶
This document specifies the following interactions.¶
This document is not an OIDF International Standard. It is distributed for review and comment. It is subject to change without notice and may not be referred to as an International Standard.¶
Recipients of this draft are invited to submit, with their comments, notification of any relevant patent rights of which they are aware and to provide supporting documentation.¶
The OpenID Foundation (OIDF) promotes, protects and nurtures the OpenID community and technologies. As a non-profit international standardizing body, it comprises over 160 participating entities (workgroup participants). The work of preparing implementer drafts and final international standards is carried out through OIDF workgroups in accordance with the OpenID Process. Participants interested in a subject for which a workgroup has been established have the right to be represented in that workgroup. International organizations, governmental and non-governmental, in liaison with OIDF, also take part in the work. OIDF collaborates closely with other standardizing bodies in the related fields.¶
OpenID Connect is a selective claims disclosure mechanism. When a set of claims included in its response is about an entity authentication event, it works as an entity authentication federation mechanism, but it can deliver other claims selected by the subject as well.¶
An OpenID Connect response can include claims from several sources. These sources can be authoritative or corroborative. The roles in the Aggregated Claims model are described in Section 5.¶
An OP can return claims from CPs to an RP by value or by reference. With Aggregated Claims, the OP obtains the claims from the CPs and returns them by value. With Distributed Claims, the OP returns references and access information so that the RP can obtain the claim values.¶
OpenID Connect Core defines the representation of Aggregated Claims returned by an OpenID Provider to a Relying Party, but does not prescribe the OP-to-CP protocol for obtaining the JWT used in that representation. In particular, it does not require the JWT to be a UserInfo response. This specification provides implementation guidance for that interaction and defines an OAuth-protected Claims Endpoint, together with discovery, authorization, account binding, storage, disclosure, and verification requirements. Its scope is Aggregated Claims; the endpoint used by an RP to retrieve Distributed Claims in Section 5.6.2 of OpenID.Core is distinct from the OP-to-CP collection interface defined here.¶
The Claims Endpoint separates OP-facing account-binding information from the CP-signed Claim
Set disclosed to the RP. This permits a Claim Set without a sub claim: the OP verifies the CP
account association when collecting it and preserves that association when storing and
disclosing it. As described in Section 6, the RP relies on the OP for Subject
binding. Omitting sub does not prevent correlation through reuse of the same JWT or
through identifying attributes. The Subject can authorize reuse of
stored Claim Sets or request new issuance. Privacy Considerations describes the
tradeoffs for privacy and availability.¶
During Setup, the Subject authorizes the OP to collect claims from a specific CP. The Subject can authorize collection before choosing an RP.¶
The Subject separately authorizes the OP to disclose claims to each RP. Section 10.4 describes how the OP obtains and reuses RP-specific authorization. When prior CP authorizations still cover collection, the OP can avoid new CP consent screens during an RP request.¶
The OP obtains an access token and, if needed and granted, a refresh token. The CP's Claims Endpoint returns signed Claim Sets separately from OP-facing account-binding information. Profiles and trust frameworks may require the use of refresh tokens.¶
The specification has four phases.¶
This document is intended for developers and systems architects who build systems that use attributes and claims.¶
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 (RFC2119 and RFC8174) when, and only when, they appear in all capitals, as shown here.¶
List item numbers are local to each section. Cite an item by its section number and item number, separated by a hyphen. For example, 9.6-4 refers to item 4 in Section 9.6.¶
The following referenced documents are indispensable for the application of this document. For dated references, only the edition cited applied. For undated references, the latest edition of the referenced document (including any amendments) applies.¶
RFC2119 - Key words for use in RFCs to Indicate Requirement Levels¶
RFC6749 - The OAuth 2.0 Authorization Framework¶
RFC6750 - The OAuth 2.0 Authorization Framework: Bearer Token Usage¶
RFC6838 - Media Type Specifications and Registration Procedures¶
RFC7009 - OAuth 2.0 Token Revocation¶
RFC7515 - JSON Web Signature (JWS)¶
RFC7518 - JSON Web Algorithms (JWA)¶
RFC7519 - JSON Web Token (JWT)¶
RFC7636 - Proof Key for Code Exchange by OAuth Public Clients¶
RFC8174 - Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words¶
RFC8414 - OAuth 2.0 Authorization Server Metadata¶
RFC8705 - OAuth 2.0 Mutual-TLS Client Authentication and Certificate-Bound Access Tokens¶
RFC8725 - JSON Web Token Best Current Practices¶
RFC9207 - OAuth 2.0 Authorization Server Issuer Identification¶
RFC9449 - OAuth 2.0 Demonstrating Proof of Possession (DPoP)¶
RFC9700 - Best Current Practice for OAuth 2.0 Security¶
RFC10070 - Updates to OAuth 2.0 JSON Web Token (JWT) Client Authentication and Assertion-Based Authorization Grants¶
OpenID.Core - OpenID Connect Core 1.0 incorporating errata set 2¶
OpenID.Discovery - OpenID Connect Discovery 1.0¶
OpenID.Registration - OpenID Connect Dynamic Client Registration 1.0 incorporating errata set 2¶
OpenID.Federation - OpenID Federation 1.0¶
OpenID4IDA - OpenID Connect for Identity Assurance 1.0 incorporating errata set 1¶
For the purpose of this document, the terms defined in RFC6749, RFC6750, RFC7636, OpenID.Core, and the following apply.¶
Aggregated Claims – claims asserted by a CP and returned by an OP using the representation defined in Section 5.6.2 of OpenID.Core¶
Claim Set – a CP-signed JWT containing claims issued through the CP's Claims Endpoint¶
RP – Relying Party¶
OP – OpenID Provider¶
CP – Claims Provider¶
HTTP - Hypertext Transfer Protocol¶
TLS - Transport Layer Security¶
JWT – JSON Web Token¶
JWS – JSON Web Signature¶
JWA – JSON Web Algorithms¶
The following example shows one CP and one RP. The OP discovers the CP and establishes client registration before this exchange. See Section 7 and Section 8.¶
Messages 1–7 illustrate Section 9.¶
Messages 8–10 illustrate Section 10.2 and Section 10.4.¶
Message 11 illustrates reuse of a stored Claim Set under Section 10.5. Messages 12–14 illustrate Section 10.5.5 and Section 10.5.6.¶
Message 15 illustrates Section 10.6. Message 16 illustrates Section 10.7.¶
The Subject authorizes a CP to give the OP access to claims. The Subject directs the OP to collect those claims and can authorize storage for later use.¶
The OP can combine claims from several sources for disclosure under the Subject's direction. The Subject can authorize collection before choosing which RPs will receive the claims. The Subject can let an RP request claims from the OP to obtain a service. Section 10.4 describes how the Subject authorizes disclosure to an RP.¶
An RP typically provides a service to the Subject. It requests claims about the Subject from the OP to provide that service. The RP can rely on contract performance, consent, or another lawful basis to process the claims.¶
The Claims Provider (CP) is an OpenID Provider that accepts the aggregating OP as a client. The CP obtains the Subject's authorization for collection during Setup. It issues signed Claim Sets through its Claims Endpoint. The CP also supplies the account reference that the OP uses to associate each set with the Subject.¶
The aggregating OpenID Provider (OP) acts as an OpenID Connect client of the CP. It serves RPs as their OpenID Provider. At the Subject's direction, it collects Claim Sets and can store them for later use. It associates each Claim Set with the Subject's OP account. It returns the CP's signed Claim Sets as Aggregated Claims to RPs that the Subject authorizes.¶
The RP relies on the OP to link each CP-signed Claim Set to the authenticated Subject.
The RP validates the enclosing ID Token or UserInfo response under OpenID.Core.
The RP verifies the CP-signed Claim Set separately under Section 10.7.
The OP asserts that each included Claim Set concerns the Subject in the enclosing response's sub claim.¶
iss and sub from the validated Setup ID Token.¶
The OP checks the binding at collection as specified in Section 10.5.6. The binding also applies to stored Claim Sets.¶
The OP and CP establish trust for client registration through OpenID.Federation. The CP grant authorizes collection. The Subject authorizes disclosure to each RP under Section 10.4.¶
A deployment can use Federation Trust Marks to indicate conformance with its trust framework. The CP-signed JWT contains no CP Subject Identifier. The RP relies on the enclosing response and the OP's protected binding to establish which Subject the claims concern.¶
An exported Claim Set retains its OP audience. Profiles can define additional Subject binding or presentation-time authentication requirements.¶
The OP obtains the CP's endpoints before it sends the Setup authorization request. OpenID.Discovery and OpenID.Federation govern issuer validation for their metadata mechanisms.¶
The metadata mechanism governs cache validity. OpenID.Federation also governs Trust Chain validity.¶
The following parameters apply to the CP's openid_provider metadata.¶
claims_endpoint.¶
claims_endpoint.¶
claims_signing_alg_values_supported.¶
RS256 in that array.¶
authorization_response_iss_parameter_supported to true.¶
code in response_types_supported.¶
S256 in code_challenge_methods_supported.¶
RFC9207 defines the authorization response issuer capability. Section 9 specifies Authorization Code Flow and PKCE for Setup. The CP advertises Claim Set signing algorithms separately from UserInfo algorithms.¶
The Claims Endpoint is an OAuth 2.0 protected resource where the OP obtains CP-signed Claim Sets. The Claims Endpoint differs from the UserInfo and Distributed Claims endpoints in OpenID.Core. See Section 10.5.5 and Section 10.5.6 for the wire protocol.¶
This profile applies to Claim Sets from the Claims Endpoint.
It uses the JWT typ in Section 10.5.6.1.
The profile defines no new metadata or Authentication Request parameter for negotiating the type.
Section 10.7 specifies the validation rules.
RFC7518 defines the signing algorithm RS256.¶
RS256 signing for Claim Sets.¶
RS256 signature verification for Claim Sets.¶
RS256 signature verification for Claim Sets.¶
RS256 in Claims Endpoint requests.¶
The following rules apply if Claim Set validation fails.¶
Stored JWTs with sub require a separate profile and deployment arrangement.¶
The following parameters apply to the aggregating OP's openid_provider metadata.¶
aggregated in claim_types_supported.¶
claims_parameter_supported to true.¶
S256 in code_challenge_methods_supported.¶
Section 10.3 governs PKCE for RPs.
A CP that only issues Claim Sets to OPs has no obligation to advertise aggregated.¶
The OP acts as an OpenID Connect client of the CP. Automatic Registration includes Trust Chain validation and metadata resolution.¶
openid_provider metadata in its Entity Configuration.¶
openid_relying_party metadata in the same Entity Configuration.¶
client_id at the CP.¶
For example, an OP with the Issuer Identifier https://op.example uses https://op.example as its
client_id at the CP and publishes its Entity Configuration at
https://op.example/.well-known/openid-federation.¶
policy_uri in its openid_relying_party metadata.¶
OpenID.Registration defines policy_uri. The CP uses it in Section 9.2.
Section 10.5.5 governs Claim Set signing algorithm selection.
UserInfo signing and encryption metadata apply to UserInfo responses.¶
private_key_jwt client authentication.¶
private_key_jwt client authentication.¶
The OP declares one token_endpoint_auth_method in its openid_relying_party metadata.
The declaration applies to every CP that uses that Entity Configuration.
OpenID.Core defines private_key_jwt.
OpenID.Federation governs client authentication during Automatic Registration, including PAR.¶
private_key_jwt in the base profile.¶
self_signed_tls_client_auth for all participating OPs and CPs.¶
self_signed_tls_client_auth when its profile or trust framework requires it.¶
none or shared-secret client authentication.¶
mTLS support is optional in the base profile.¶
The CP advertises these methods in token_endpoint_auth_methods_supported in its openid_provider metadata.
The following requirements also apply to any OpenID.Discovery configuration document the CP publishes.¶
private_key_jwt.¶
self_signed_tls_client_auth if it supports that method.¶
The following requirements apply to private_key_jwt at each CP endpoint that uses it.
Examples include the Token, PAR, and revocation endpoints.
Sections 4 and 5 of RFC10070 specify the audience restriction for JWT client
authentication at the Token and PAR endpoints.¶
aud to the validated CP Issuer Identifier as a string or single-element array.¶
aud fails these requirements.¶
openid_relying_party keys.¶
client_id, jti) pair through exp, including any permitted clock skew.¶
An assertion lifetime of a few minutes is one option.¶
RFC8705 governs certificate and client binding when the OP uses self_signed_tls_client_auth.¶
policy_uri from its client metadata.¶
Section 10.5.4 describes those controls.¶
These restrictions apply regardless of the token format. The CP checks resource and access permissions as specified in Section 10.5.5.¶
The OP and CP can use certificate binding RFC8705 or DPoP RFC9449. The Claims Endpoint applies the relevant proof requirements in Section 10.5.5. mTLS client authentication alone does not imply certificate-bound access tokens.¶
RFC6749 governs refresh token authentication and replacement. The CP can rotate refresh tokens to detect replay. Token expiration, rotation, and revocation govern further collection. Section 10.5.4 describes their effect on stored Claim Sets.¶
The following provisions apply to the code exchange.¶
redirect_uri bound to the validated transaction.¶
The OP validates the CP's ID Token under OpenID.Core before establishing the binding in Section 6.¶
The following provisions apply to an existing OP account binding for the same CP issuer.¶
sub with the stored value.¶
sub as account relinking.¶
The CP identity here is the validated (iss, sub) pair.
The OP checks the applicable account namespace. For tenant-scoped accounts, that namespace is the tenant.¶
If the OP finds such a binding, the following provisions apply.¶
When the OP chooses verification, the following restriction applies.¶
Deployments can permit a CP account to link to multiple OP accounts.¶
The Delivery Phase typically includes the following steps.¶
userinfo, id_token, or both in claims.¶
claims parameter.¶
policy_uri in its client metadata.¶
The OP selects CPs associated with the Subject's account.
OpenID.Core defines claims and scope. Selecting a specific CP requires an extension.
OpenID.Registration defines policy_uri. The OP uses it in Section 10.4.
Section 10.7 specifies how the RP evaluates the CP and the age of its Claim Set.¶
This profile adds the following PKCE requirements.¶
S256 whenever it uses PKCE.¶
S256 challenge.¶
code_challenge unless code_challenge_method is explicitly S256.¶
OpenID.Core governs authentication and prompt. The OP validates the request before seeking consent.¶
The dialogue uses the client metadata that the OP registered or resolved for the RP's client_id.¶
client_id in the dialogue.¶
client_name if that metadata includes it.¶
policy_uri from that metadata.¶
A verified organization_name or a Trust Mark that attests to the RP's identity can supply display information.
Signed metadata or a valid Trust Mark alone does not verify every displayed name.
OpenID.Registration governs language tags and the use of untagged values.
The OP omits account_ref from Aggregated Claims as specified in Section 10.5.6.¶
client_id.¶
prompt=consent.¶
prompt=none, the OP MUST return consent_required if it lacks valid consent for the disclosure.¶
Section 10.5.4 governs withdrawal. OpenID.Core governs other authentication or interaction errors.¶
The relevant policies include the OP's collection and storage policies. Access token renewal alone leaves the stored Claim Set unchanged.¶
The downscoping recommendation applies when the OP has a refresh token and a suitable narrower scope. OpenID.Core and RFC6749 govern refresh and downscoping.¶
OpenID.Federation governs Trust Chain reevaluation. The following requirement applies when the OP needs a new Claim Set but cannot obtain it through a valid access or refresh token.¶
Protected material includes stored CP access tokens, refresh tokens, and signed Claim Sets. It also includes private keys for client authentication and proof of possession.¶
Deployments choose the storage architecture, including whether the Subject controls the encryption keys.¶
For a deletion request, the following requirements apply.¶
A later authorized collection can obtain those claims again. Section 10.5.4 explains how the Subject can stop further collection and disclosure.¶
An RP request or remembered consent does not constitute that instruction. Backups remain subject to Section 10.5.2.¶
A disclosure history identifies the RP recipients, the disclosed Claim Sets, their CP sources, and the disclosure times.¶
For example, the OP can identify disclosed Claim Sets without retaining their complete signed JWTs. Applicable legal retention obligations qualify the history deletion and restoration requirements.¶
The OP MUST restrict access to those records to authorized purposes for meeting those obligations.¶
The OP MAY let the authenticated Subject export stored CP-signed Claim Sets unchanged.¶
The OP SHOULD explain the correlation and onward-transfer risks of exporting Claim Sets.¶
Exported Claim Sets remain transferable signed personal data. See Section 12.2. Their audience, account-binding, and verification requirements continue to apply. This profile sets no retention deadline for stored Claim Sets. The Subject can retain expired Claim Sets as records without treating them as valid. Section 10.7 governs acceptance and disclosure of Claim Sets.¶
The Claims Endpoint follows the protected resource rules in RFC6749. RFC6750 governs bearer token presentation and errors. RFC9449 governs DPoP presentation and errors. RFC8705 governs certificate binding.¶
claims_endpoint.¶
application/json as the request media type.¶
claims object.¶
The CP compares decoded member names using exact, case-sensitive equality.
An extension can define new request members and how the OP learns that the CP supports them.
The requested claim names inside claims follow the attribute omission rules below.¶
The base request carries nonce, claims, and signing_alg.¶
nonce string.¶
nonce string.¶
The OP establishes the following bindings before sending the request.¶
signing_alg to the pending operation.¶
The following requirements apply to the request's claim and algorithm selection.¶
claims.¶
claims to identify requested top-level claims.¶
null in the base profile.¶
iss, sub, aud, iat, exp, nbf, or jti as attributes.¶
signing_alg.¶
signing_alg from the CP's validated claims_signing_alg_values_supported.¶
signing_alg that its policy permits.¶
signing_alg.¶
Claim-specific query syntax requires an extension. The claims member does not expand
the grant's permissions.¶
For example (the access token and nonce are illustrative):¶
POST /claims HTTP/1.1
Host: cp.example
Authorization: Bearer ACCESS_TOKEN
Content-Type: application/json
{
"nonce": "request-specific-random-value",
"claims": {"birthdate": null},
"signing_alg": "RS256"
}
¶
The base request selects top-level claims, not nested fields within a compound claim.
For example, "claims": {"verified_claims": null} requests that top-level claim; it does
not convey a selection of particular attributes, evidence, or timestamps within it. A CP
or trust framework can define narrow scopes or output sets for specific uses, but this
specification does not define a general nested query syntax for the Claims Endpoint.
The OP cannot remove nested fields from an already signed Claim Set while preserving the
CP signature. All disclosed contents remain subject to Section 10.4 and
Section 10.6; the OP obtains a suitable Claim Set or omits it when those requirements
cannot be met.¶
For example, omission can reflect attribute absence, missing verification, or a Subject's choice to withhold the attribute. Section 10.5.6 defines the empty result.¶
Token and scope errors follow the applicable rules in RFC6750 and RFC9449.¶
The following requirements apply to malformed or unsupported requests, including invalid
request structure and unsupported signing_alg values.
An unrecognized top-level member or a duplicate name in either object makes the request malformed.¶
application/json as the error response media type.¶
error to invalid_request in that object.¶
error_description string in that object.¶
The following privacy requirement applies to all error responses.¶
The OP repeats collection for each CP as necessary.¶
The following requirements apply to a successful response.¶
application/json as the response media type.¶
Cache-Control: no-store.¶
nonce unchanged.¶
The base response also carries account_ref and claim_set when it supplies attributes.¶
claim_set when it supplies requested attributes.¶
claim_set as a non-empty string containing the JWT defined in Section 10.5.6.1.¶
account_ref string when it includes claim_set.¶
account_ref from the account that the access token authorizes.¶
account_ref to the Setup ID Token's sub for that account and OP.¶
account_ref identifies.¶
claim_set when it supplies no requested attributes.¶
account_ref when it omits claim_set.¶
null, an empty string, or a protocol-only JWT.¶
The following successful response carries the Claim Set decoded below. The account reference and nonce are illustrative, and the compact JWS is abbreviated.¶
{
"account_ref": "cp-sub-7f39",
"nonce": "request-specific-random-value",
"claim_set": "<CP-signed-JWT>"
}
¶
If no requested attributes are supplied, the CP returns HTTP 200 with the same content type and cache directive. In the base response, the only member is the operation nonce:¶
{
"nonce": "request-specific-random-value"
}
¶
This empty result reports only that this collection supplied no attributes.¶
The decoded protected header and payload of that claim_set are:¶
{"typ":"claims-aggregation+jwt","alg":"RS256"}
¶
{
"iss": "https://cp.example",
"aud": "https://op.example",
"iat": 1893455940,
"exp": 1893456240,
"birthdate": "1990-01-01"
}
¶
The example uses the common mandatory-to-implement algorithm RS256.
The valid test vector in ClaimsAggregation.TestVectors provides the complete signed
CP JWT and the signed OP presentation shown in Section 10.6, along with the
test keys and instructions for verifying both at 2030-01-01T00:00:00Z.
The response's cache directive prevents HTTP caching; it does not prohibit
Subject-authorized storage under Section 10.5.¶
The OP applies the following checks to a purported successful response.¶
error as a successful or empty result.¶
error.¶
Ignoring a member leaves the other validation requirements in effect. An extension establishes OP support before the CP relies on the OP to process an extension member. The CP does not need a global database of used nonces.¶
The following requirements apply when the response lacks claim_set.¶
account_ref.¶
account_ref or claim_set as an empty result.¶
Claim Set validation and storage checks apply only when the response contains a Claim Set.¶
The OP applies the following checks when the response contains claim_set.¶
account_ref exactly to the validated Setup sub for the operation's OP account and CP issuer.¶
sub from the response or access token.¶
sub with a value from the response or access token.¶
The OP validates claim_set as required by Section 10.7.1.¶
iss to the operation's CP issuer.¶
Section 10.7.3 specifies the check against the selected signing_alg.
Section 9.7 specifies account relinking.¶
Omitting a claim from _claim_names cannot hide it from an RP receiving the JWT.
For these checks, attributes exclude iss, aud, iat, exp, nbf, and jti.
Section 10.7 governs those protocol claims.¶
The OP preserves the validated association in a protected acquisition record.¶
A hash stored alongside unprotected data does not by itself provide that protection. A deployment crossing an untrusted processing or storage boundary needs integrity protection across that boundary. For example, an authenticated storage service can enforce this association, or a MAC or signature can protect a record covering both the JWT and binding fields when the storage itself is not trusted. An additional CP-signed receipt can be defined by a profile where independent evidence of acquisition is needed. The deployment cases and limits of that additional evidence are discussed in Section 11.6.¶
The OP applies the following checks before redisclosing a stored Claim Set.¶
Section 10.7.1 requires validation of the stored Claim Set before disclosure. A successful acquisition does not waive later key, trust, expiration, or freshness checks. Reusing a stored Claim Set does not require a new CP operation nonce or CP contact.¶
account_ref from the Aggregated Claims response.¶
typ to claims-aggregation+jwt.¶
RFC7515 permits omission of the media type's application/ prefix in typ.
This type identifies the inner Claim Set within the acquisition envelope or the OP's response.¶
iss, aud, iat, and exp in the payload.¶
iss to its validated Issuer Identifier.¶
aud to the OP's Entity Identifier as a string or single-element array.¶
iat and exp as NumericDate values defined in RFC7519.¶
exp to a time later than iat.¶
The OP uses its Entity Identifier as described in Section 8. These timestamps describe JWT issuance and expiration. Attribute verification can occur at a different time.¶
sub from the Claim Set.¶
account_ref from the Claim Set.¶
The Subject can authorize disclosure of identifying attributes. Section 12.2 describes their correlation risks.¶
signing_alg it accepts in the Claims Endpoint request.¶
The OP can reference those claims in _claim_names as specified in OpenID.Core.
The format uses no holder proof or per-presentation identifier.
It does not require a jti claim.¶
The name Claims Endpoint and the metadata names claims_endpoint and
claims_signing_alg_values_supported restore terminology from an earlier draft.
This profile separates the OP-facing account reference from the signed JWT that the RP receives.¶
See Section 13 for the CP metadata and Claim Set media type registration requests.¶
[[ Editor's note: The registration templates are defined below; formal registration has not yet been completed. Before submission, references must identify a stable, publicly available specification version. Previous use of a name in a draft is not a registration. ]]¶
Some JSON parsers silently keep a single value for a repeated member name. Implementers
can use a parser with duplicate-name detection or check decoded names as the parser emits
them, before converting the object to a map. Checking the resulting map cannot detect
duplicates that the parser already discarded. For the response, these envelope checks
apply to the top-level JSON object. The claim_set string is validated separately under
Section 10.7.¶
The following fragments illustrate member handling. Each fragment is added to an otherwise valid message unless indicated.¶
| Message | JSON fragment or body | Expected handling |
|---|---|---|
| Request with an unrecognized top-level member |
"example_option": true
|
Reject with invalid_request. |
| Request with an unavailable attribute name |
"claims": {"example_attribute": null} (replacing the original selection) |
Process normally and omit the unavailable attribute. |
| Request with an unsupported query value |
"claims": {"birthdate": {"essential": true}} (replacing the original selection) |
Reject with invalid_request. |
| HTTP 200 response with an extra member |
"example_hint": "informational"
|
Ignore the extra member and apply all applicable response checks. |
| HTTP 200 response with a duplicate member |
{"nonce":"first","nonce":"second"} (entire body) |
Reject the response. |
| HTTP 200 response with an error member |
{"nonce":"request-specific-random-value","error":"invalid_request"} (entire body) |
Reject the response as a successful result, including as an empty result. |
OpenID.Core governs claim destinations, omission rules, and the Aggregated Claims representation.¶
_claim_names entries for claims it cannot supply in an authorized, valid Claim Set.¶
_claim_sources entry that no remaining _claim_names entry references.¶
_claim_names would be empty, the OP MUST omit both _claim_names and _claim_sources.¶
The RP receives all claims in the embedded JWT, including claims without a mapping in _claim_names.
Section 10.5.4 specifies when the OP can use previously collected Claim Sets.
The essential flag alone does not make an omission an authentication error under OpenID.Core.¶
For example, the RP requests birthdate and address in the ID Token:¶
{
"id_token": {
"birthdate": null,
"address": {"essential": true}
}
}
¶
The CP supplies only birthdate. The OP returns the following presentation.
Only birthdate has a _claim_names mapping, and the response contains only
the source referenced by that mapping. If the RP requires address for its
operation, it does not complete that operation.¶
The decoded OP presentation below embeds the same CP-signed JWT received in
claim_set in Section 10.5.6, without changing its compact JWS
serialization. The inner JWS is abbreviated here. When the OP returns the
Aggregated Claims in an ID Token, the normal ID Token requirements still apply.¶
{
"iss": "https://op.example",
"sub": "op-vector-subject",
"aud": "rp-client",
"iat": 1893455999,
"exp": 1893456060,
"_claim_names": {"birthdate": "cp1"},
"_claim_sources": {"cp1": {"JWT": "<CP-signed-JWT>"}}
}
¶
The enclosing sub identifies the Subject at the OP. The CP's account_ref and acquisition
nonce are not included in the embedded JWT or passed on as acquisition evidence to the RP.¶
This limits the front-channel exposure described in Section 11.3.¶
The following sources supply CP metadata and its verification keys.¶
jwks_uri.¶
openid_provider metadata.¶
iss exactly to the CP issuer in validated metadata or trusted configuration.¶
iss for key resolution only as its issuer acceptance and network policies permit.¶
In that case, the OP MUST obtain a replacement Claim Set from the CP or omit the affected set.¶
The CP MUST apply the key-to-algorithm binding rules in RFC8725 when signing Claim Sets.¶
The CP MUST publish each Claim Set signing key's algorithm in every advertised JWK's alg.¶
The CP SHOULD keep retired public keys available through its advertised key sources until their signed Claim Sets expire.¶
The CP SHOULD include its clock-skew allowance in that key retention period.¶
The CP MAY withdraw compromised keys earlier under its deployment's key revocation policy.¶
RFC7515 governs signature verification.¶
alg in both local policy and the CP's validated claims_signing_alg_values_supported.¶
alg to the signing_alg bound to the collection operation.¶
kid only within the CP's trusted key set.¶
alg or trusted issuer-specific configuration.¶
alg, the verifier MUST match it to the JWT's alg.¶
The verifier checks claims after validating the signature. RFC7519 governs time claim types, expiration, and not-before processing.¶
claims-aggregation+jwt in the protected header's typ.¶
sub.¶
iss, aud, iat, and exp.¶
iss.¶
aud value as a string or single-element array.¶
aud exactly to its client_id at the CP.¶
aud exactly to the OP issuer it validated through OpenID Connect.¶
exp to be later than iat.¶
iat in the future.¶
iat, exp, and nbf.¶
The following requirements apply when the RP receives Aggregated Claims through UserInfo.¶
The RP relies on the OP for Subject binding as described in Section 6. The RP follows the same clause when deciding whether to trust the CP.¶
The verification rules in Section 10.7.1 apply to every Claim Set the RP uses. Section 10.6 specifies when the RP can complete the requested operation.¶
The RP's acceptance checks include Claim Set validation and its freshness policy.¶
iat.¶
The Subject can retry the OpenID Connect interaction after an update. Retrying authentication alone does not require the OP to recollect claims.¶
IDA.Schema defines the verified_claims structure.
Using it does not by itself implement the OpenID4IDA query protocol or external assertion format.¶
Implementations that support OpenID4IDA can use its existing request and validation mechanisms.
For example, max_age constrains verification.time or another requested date or timestamp.¶
iat when it uses OpenID4IDA freshness constraints.¶
A new JWT does not show when the CP last verified the claims.
Meeting a verification-age requirement can require renewed verification at the CP.
Mapping constraints into a Claims Endpoint request requires a separate extension or profile.
The base claims object accepts only null values.
The OP can support OpenID4IDA without forwarding constraints or using them to select stored Claim Sets under this specification.
OpenID4IDA still governs its implementers' query, filtering, and omission behavior.¶
The OpenID4IDA external assertion format uses typ=provided-claims+jwt and requires sub.
That format prohibits aud and exp.¶
Interoperability with that external assertion format requires a separate profile.¶
The security considerations of OpenID.Core, OpenID.Federation, and RFC8725 apply.¶
Before verifying the signature, the verifier constrains algorithms and keys under Section 10.7.3 and Section 10.7.2. This prevents a JWT header from selecting an unauthorized algorithm or causing use of a CP public key as a MAC secret.¶
Short lifetimes require more frequent collection, while long lifetimes extend the period
during which previously issued attributes can be presented. Expiration limits the lifetime
of the signed artifact. It does not guarantee that the underlying attributes remain current
or that the CP's grant remains authorized. Key withdrawal can make a stored Claim Set
unusable before its exp, as described in Section 10.7.2.¶
The type and claim rules in Section 10.5.6.1 distinguish Claim Sets from
ID Tokens and UserInfo JWTs. RFC8725 describes cross-JWT confusion. A separate URL
or the presence or absence of nonce or auth_time does not by itself distinguish these JWTs.¶
The issuer-based countermeasure in OAuth.Security.Update protects connections to multiple CPs. Section 7.1 binds metadata to the selected issuer. Section 9.6 checks that issuer before code exchange. That check also addresses the mix-up risk in RFC9700. Section 9.7 preserves the selected client and any connection or tenant context.¶
PKCE binds the code to the OP's token request under Section 9.4.
An attacker can still initiate Setup for the attacker's OP account and induce a victim to
authorize access to the victim's CP account. PKCE alone does not detect this cross-user session fixation attack, described in
Section 2.3 of OAuth.Security.Update, with countermeasures in Section 2.3.2. Before
exchanging the code, the OP verifies the completion session's binding under
Section 9.5. A valid state received through a URL is insufficient
without this session validation. Comparing a previously stored CP subject identifier detects account
changes. Checking for the same CP (iss, sub) on another OP account can also detect an
attempted new binding when that CP identity is already known to the OP. Neither check
establishes a relationship for a CP identity that has never been linked at the OP. The trust
assumptions in Section 6 continue to apply.¶
The checks in Section 10.3 apply to signed and unsigned requests.¶
The OP brokers requests between RPs and CPs using the broker-side consent approach in OAuth.Security.Update. The CP grant authorizes collection, and the Subject's authorization at the OP governs RP disclosure. Section 10.4 covers both RP-triggered collection and reuse. The Subject can withdraw authorization under Section 10.5.4 even if the CP grant remains valid. Pre-collection can keep the recipient RP and its activity timing from the CP.¶
An ID Token returned from the Authorization Endpoint can expose embedded CP-signed Claim Sets to browser scripts and front-channel response handling. Depending on the response mode and implementation, those artifacts can persist in URLs, including fragments, browser history, or application and diagnostic logs. Unlike an authorization code, the signed personal data can be copied and presented to other parties, subject to their acceptance checks. The back-channel delivery recommendation in Section 10.6 reduces this exposure; it does not prevent an RP that receives a Claim Set from copying it. This is an additional reason to minimize front-channel exposure alongside the leakage risks discussed in Sections 4.2 and 4.3 of RFC9700.¶
The Claim Set audience identifies the OP that obtained it. The RP checks that audience under Section 10.7.4 and applies its CP trust policy.¶
A compromised or malicious OP can include a Claim Set for one Subject in a response for another Subject. The substituted Claim Set can have a valid CP signature and the expected OP audience. The RP's signature and audience checks therefore cannot detect this substitution. The trust model in Section 6 relies on the OP to preserve the account binding through collection, storage, and disclosure. A Federation Trust Mark can attest to an OP's compliance with operational requirements. It does not prove the account binding for a particular response.¶
The collection nonce correlates an authenticated CP response with a pending OP operation; it is not an access credential or an issuance-idempotency key. The CP may process a retried request more than once, but the OP accepts at most one response for its pending operation. A holder of a stolen bearer token can request additional Claim Sets with new nonces, so a CP nonce database would not prevent that use. TLS server authentication and the token protections in Section 9.3 address that threat.¶
Deployments can impose issuance rate limits without making every CP maintain a shared nonce-replay database.¶
The OP binds the selected signing algorithm to the operation before sending the request and checks the returned JWT against it. A request or response that traverses an untrusted internal processing boundary needs integrity protection across that boundary as described in Section 10.5.6; token sender-constraining alone does not authenticate arbitrary JSON request or response bodies across such a boundary.¶
The trusted collection boundary includes the components the deployment relies on to preserve two inputs:¶
Those components preserve both inputs until a trusted component validates the response and protects the resulting binding record. The deployment identifies which components it trusts and which compromises it aims to withstand. Common ownership, an OP-managed label, and the number of TLS connections are insufficient on their own. Access controls, account and tenant separation, and authenticated handoffs help enforce the boundary.¶
The base protections suffice when a trusted OP collector receives the response over
authenticated TLS, checks it under Section 10.5.6, and protects the
complete association between the account and the JWT. The account check compares
account_ref with the CP's sub from the validated Setup ID Token. The CP-signed JWT
contains no CP Subject Identifier that could independently confirm the association.¶
A TLS-terminating gateway can be part of the trusted collector if the deployment trusts it to preserve the response and operation context. A deployment that aims to withstand compromise of that gateway places it outside the trusted collection boundary.¶
A trusted collector can validate the response and protect the complete binding record before handing it to a queue, cache, or object store outside the boundary. The trusted consumer then verifies that record. An extra CP signature is unnecessary for that handoff alone.¶
An OP MAC, signature, or suitably bound authenticated encryption can protect the exact JWT together with its OP account, CP identifiers, and acquisition context. Section 10.5.6 requires protection of the association as well as the JWT. On backup restoration, the OP applies the current deletion and withdrawal decisions under Section 10.5.3. An authentic older record can predate those decisions.¶
An additional CP signature can help when a TLS terminator outside the trusted collection boundary can alter the response before an honest OP component validates it.¶
For example, a gateway could pair a valid Claim Set for CP account B with an acquisition
envelope for account A. B's JWT can have the expected OP audience, requested attributes,
and selected signing algorithm. The envelope can carry A's account_ref and pending
operation nonce. The checks of the account reference and the JWT's issuer, audience,
signature, and lifetime can all pass because the JWT has no CP Subject Identifier.
If the gateway kept B's account_ref, the account comparison would fail.
A MAC that the OP adds after substitution protects the pairing it received.
It cannot establish that the CP supplied that pairing.¶
The trusted validator needs to verify that the CP supplied the association between the account and the exact Claim Set. A CP-signed envelope or receipt can provide that evidence. An authenticated connection from the CP to the trusted validator can also protect it if the connection keeps the plaintext from the intermediary. The need for extra evidence depends on which components the deployment trusts.¶
An independently authorized auditor can also need evidence that the CP associated an account with a particular JWT. The relevant evidence depends on the audit question and policy:¶
This audit use requires a separately authorized purpose for access to stable CP account references and acquisition records. That access also requires minimization and retention controls. Normal RP disclosure follows Section 6.¶
A separate receipt profile would need to bind the following values to the exact signed Claim Set or to a collision-resistant commitment to it:¶
The OP uses one identifier here. Its Entity Identifier, Issuer Identifier, and CP-facing
client_id are equal. A commitment would specify its algorithm and byte representation.
Using the exact compact JWS avoids reserializing decoded claims. The proof protects the
pairing only if it covers both the account reference and the JWT or its commitment.¶
A receipt profile would also need to specify trusted key and algorithm selection, pending-operation checks, and what to do if a required proof is missing or stripped. It would define how to handle empty results. This specification defines no receipt format, parameter, or mandatory additional CP signature.¶
A verified receipt authenticates a CP statement under the accepted signing key and policy. It cannot prove that the CP sent an HTTP response or that the OP received or validated it. It cannot establish the truth of the CP's account association or the Subject's consent to later RP disclosure. An issuance timestamp does not prove delivery or a new identity check.¶
The OP still needs its protected account binding. A receipt cannot restore a lost association with an authenticated OP account. A malicious OP can still violate Section 6. A receipt also cannot prevent misuse of stolen tokens, suppression of responses, or rollback of authorization state.¶
A signature provides integrity and evidence of origin. Anyone with the OP's public key can encrypt to it, so encryption to the OP alone cannot establish CP origin. A deployment that needs both confidentiality and CP-origin integrity across a boundary needs a design that protects the contents and authenticates the CP.¶
The Subject's authorization governs disclosure, including when the OP stores encrypted data or holds a receipt. The Aggregated Claims response excludes acquisition receipts. Storage, audit access, and backup handling of receipts remain sensitive-data processing.¶
If a receipt profile sets an initial acceptance deadline, a late receipt cannot establish a new acquisition binding. When the OP validates acquisition in time and preserves the binding in a protected record, expiry of that deadline alone does not require CP contact or suspension of an otherwise acceptable stored Claim Set.¶
A receipt within its acceptance window does not extend the inner JWT's exp.
Current key, signature, audience, trust, freshness, and Subject authorization checks still apply.
These rules concern acquisition and storage. They add no presentation-time CP status
check and leave the grant-revocation rules in
Section 10.5.4 in effect.¶
Pre-collection permits an OP to hold a grant that covers future Subject-authorized uses beyond a single RP request. The least-privilege requirements in Section 9 and Section 10.5 limit requested access. Downscoping an access token does not by itself reduce the authority of the original refresh token. The protections in Section 9.3 and Section 10.5.2 address the resulting concentration of credentials and personal data at the OP.¶
The assertion audience restriction in Section 8.3 implements the preferred
audience-injection countermeasure in Section 2.1.2.1 of OAuth.Security.Update. The OP's
Entity Identifier is its client_id at every CP, so uniqueness of client identifiers
across CPs is not an available countermeasure. Using different authentication keys for
different CPs can provide additional isolation only when each CP's accepted key set is
also restricted accordingly. Publishing several keys in a common RP key set does not by
itself establish that isolation.¶
The OP Entity manages the client authentication keys in this profile. An app on a device acts as the Entity's user interface or agent. The CP resolves one client identity and one RP metadata object for the OP's Entity Identifier. This profile does not define separate enrollment or authentication bindings for each device instance.¶
Sharing one authentication private key across devices increases the risk of key extraction. Listing all device keys in the common RP JWK Set can make that set grow without bound. It can reveal how many devices the OP uses and how often devices are added or removed. The CP still resolves the same client identity for those keys.¶
A confidential client can run on a device. Device-generated keys and registration for each instance can support secure client authentication. Combining these with the common Entity Identifier, OP issuer, and RP metadata requires a separate profile.¶
Such a profile could use Explicit Registration or Dynamic Client Registration for each
instance. It could also let the OP Entity attest to each instance's key while it keeps the
Entity Identifier as client_id. The profile would need to define the binding between
each instance, its credentials, client_id, and the OP issuer. It would also need rules
for selecting the authentication method. Giving an instance a different client_id while
keeping a common OP issuer would change the identity relationship in this base profile.
These instance profiles are outside the scope of this specification.¶
Client authentication and sender-constrained CP access tokens protect collection, not the subsequent presentation of a signed Claim Set. A Claim Set's audience identifies the OP, not an individual RP or presentation. An RP or another holder can copy that JWT and send it elsewhere. To accept the Claim Set, the recipient validates the enclosing response and the Claim Set under Section 10.7. The recipient also relies on the account binding described in Section 6. Possession of the embedded JWT alone does not authenticate the Subject. A short Claim Set lifetime limits the exposure period. A holder can still copy or reuse the Claim Set before expiration.¶
Under the trust model in Section 6, the RP relies on the OP's account binding and disclosure controls. These protections neither require per-presentation CP contact nor cause CP grant revocation to invalidate stored Claim Sets. Storage remains under the Subject's control within the limits described in Section 11.8.¶
The CP's signed iat establishes the JWT's age for freshness checks.¶
iat for the CP-signed iat.¶
A CP can issue a new JWT containing attributes verified earlier. Applications needing freshness of identity verification or evidence can use the corresponding signed data and validation rules in OpenID4IDA, as described in Section 10.7.5.¶
The Subject controls a signed Claim Set held by the OP. CP grant or token revocation, including unilateral revocation, affects future collection. The Subject can continue to present previously issued Claim Sets until expiration, subject to this profile's validation and acceptance rules. Section 10.5.4 describes the Subject's control over further disclosure at the OP.¶
A CP can choose a short lifetime when the underlying attributes can change quickly. An application that needs prompt status updates, such as for a revoked driver's license, can use a separate authenticated status mechanism and an acceptance policy for the issued Claim Set. Offline verification checks the signed Claim Set. It cannot establish that the attributes still reflect the current state. A current status check supplements that verification and concerns the issued Claim Set rather than the collection grant.¶
The OP processes the contents of Claim Sets from CPs and knows which RPs receive them. This combination can reveal attributes and relationships across services. In a deployment where a third party operates the OP and can access that processing or its records, the Subject places substantial trust in that operator. Encryption at rest protects stored data against some compromises; it does not by itself hide data from the OP while processing it. A distributed-claims deployment does not necessarily hide information from the OP either; visibility depends on which components actually obtain and process the data.¶
At Setup, the Subject authorizes the CP to release claims to the OP for future use under the Subject's direction. The CP relies on the OP to enforce the later RP-specific authorization in Section 10.4. A CP signature authenticates the issued data; it does not prove that the OP obtained authorization for a particular disclosure. Federation trust and policy information can inform a trust decision, but do not by themselves prove that the OP honored the Subject's instructions in an individual transaction.¶
The least-privilege and disclosure requirements in Section 9, Section 10.5,
and Section 10.6 limit what the OP obtains and discloses. In particular, the RP
receives all claims in an embedded signed JWT, including claims not listed in
_claim_names. The OP cannot remove individual claims from that JWT while preserving the
CP's signature. A deployment seeking stronger limits on OP visibility or finer-grained
disclosure needs an appropriate architecture or extension, rather than relying on storage
encryption alone.¶
The OP uses the CP's stable Subject Identifier for account binding. The RP-facing
Claim Set omits that identifier. Pairwise identifiers at the CP would otherwise
be scoped to the OP's Sector Identifier rather than to each downstream RP, as specified
in Section 8.1 of OpenID.Core. Omitting the CP sub removes that direct downstream identifier;
it does not guarantee unlinkability. Authorized identifying attributes can still correlate
Subjects, and a CP can recognize information it issued when an RP shares it.
The OP's pairwise identifiers in enclosing responses do not hide the inner JWT's contents.¶
When the OP reuses a Claim Set, it sends the same CP-signed JWT. An RP can compare the JWTs it receives in different presentations. RPs that share the JWTs they receive can also compare them across services. A matching JWT, including its signature, lets these recipients correlate the presentations. Different enclosing OP responses leave a reused inner JWT intact. Correlation by JWT comparison can therefore occur even when other identifiers are ephemeral or pairwise.¶
Recipients can also correlate newly issued JWTs through stable identifiers, identifying combinations of claims, or distinctive timestamps.¶
An RP can also pass a CP-signed JWT to a third party that can independently verify the CP's signature and the signed contents. This makes disclosure of signed personal data more consequential than disclosure of an unauthenticated assertion. The signature is evidence of what the CP issued, not proof that the Subject presented it to a particular RP or that the attributes remain current. The base format does not cryptographically prevent onward transfer. The Subject's controls at the OP cannot recover copies already held by RPs.¶
Selective disclosure can reduce the attributes revealed to a recipient, but does not by itself ensure unlinkability. For example, Section 10.1 of SD-JWT explains that recipients can correlate reuse of an issuer-signed credential and that colluding issuers and verifiers can recognize the same credential. SD-JWT is an example for future profiles, not a format introduced by this specification. Such profiles would need compatible subject-binding, audience, consent, and verification rules.¶
Pre-collection and reuse of stored Claim Sets can reduce the CP's visibility into when the Subject uses an RP. If an RP asks the Subject for fresher claims, the Subject can request an update. The OP can then request a new Claim Set from the CP.¶
The CP can observe when Claims Endpoint requests arrive and how often they arrive. If those requests follow RP activity, the CP can use that pattern to infer when the Subject uses an RP.¶
The following recommendations apply when the OP seeks the Subject's collection or disclosure authorization.¶
The Subject can then choose whether to authorize reuse or request an update, subject to the RP's acceptance policy. Section 10.5.1 describes privacy policies and rate limits for user-directed updates.¶
Reuse avoids a Claims Endpoint call for each presentation. The CP can still observe activity through information shared by RPs or retrieval of metadata, verification keys, or status. Valid metadata and key caches tied to the issuer can reduce some such contact, subject to the requirements in Section 10.7.2.¶
An alternative design can pre-issue a batch of distinct credentials for one-time use, combining advance collection with avoidance of a common reused artifact. This introduces inventory and replenishment requirements. Section 10.1 of SD-JWT describes batch issuance for presentation and verifier-verifier unlinkability, including the need to avoid other common identifiers and timing values. It does not solve issuer-verifier collusion.¶
With this profile, the Subject can instead request a newly issued Claim Set for a use,
without a CP sub in the presented JWT. This avoids maintaining a stock of unused
credentials, but requires CP availability and continued willingness to issue, and exposes
issuance timing to the CP. It does not require revealing the RP's identity to the CP.
The correlation risks for newly issued Claim Sets are described in
Section 12.2.¶
The stable account-binding identifier remains in the OP-facing acquisition envelope. The
OP validates it against the Setup ID Token, then discloses only the inner JWT. The new
endpoint avoids changing UserInfo's requirement that its sub match the ID Token sub.
Using a refreshed ID Token itself would not provide that separation: Section 12.2 of OpenID.Core
requires its issuer, subject, and audience to remain those of the original ID Token.¶
This specification introduces no batch issuance protocol and does not require a newly issued JWT per presentation. Reuse of stored Claim Sets and user-directed updates remain Subject choices, subject to RP acceptance policy. These issuance and reuse tradeoffs are not unique to either an OP-mediated or issuer-holder-verifier architecture.¶
The controls in Section 10.5.3 let the Subject distinguish stored data from collection and disclosure permissions. They complement the CP's grant-management interface: revoking a CP grant does not retract issued Claim Sets, while withdrawal at the OP controls further OP disclosure. Neither operation retracts data already received by an RP. A Subject may retain a Claim Set as a personal record even after it expires; expiration restricts valid use rather than imposing deletion. The safeguards in Section 10.5.2 address the resulting storage risks without imposing a protocol retention deadline or a particular archival encryption design.¶
Disclosure history can help the Subject identify RPs that already received their data, including when seeking deletion from those RPs. That history is itself sensitive personal data and remains subject to protection, minimization, and Subject deletion controls in Section 10.5.3. Export can give the Subject an independent copy of an issued artifact, but does not remove the transferability or correlation risks described in Section 12.2.¶
This specification requests registration of two OAuth Authorization Server Metadata parameters and one media type. The templates below do not indicate that registration has already been completed.¶
The following registration is requested in the Media Types registry IANA.MediaTypes, using the template in Section 5.6 of RFC6838.¶
application¶
claims-aggregation+jwt¶
+jwt fragment identifier rules apply.¶
Additional information:¶
The account_ref, nonce, claims, signing_alg, and claim_set members are defined
within this API's JSON request and response objects. They are not new top-level JWT claims
or new Authorization or Token Endpoint parameters, and this specification requests no
registrations for them in those registries. Existing names in other registries do not
supply their API semantics. No new JOSE header parameter, signing algorithm, or structured
syntax suffix is defined. The existing typ header, RS256 algorithm, +jwt suffix, JWT
claims, and OAuth token/error mechanisms are reused. No new client capability metadata or
OAuth error value is registered by this specification.¶
IDA.Schema - OpenID Identity Assurance Schema Definition 1.0 incorporating errata set 1¶
IANA.OAuth.Parameters - IANA OAuth Parameters¶
IANA.MediaTypes - IANA Media Types¶
SD-JWT - RFC 9901 - Selective Disclosure for JSON Web Tokens¶
OAuth.Security.Update - Updates to OAuth 2.0 Security Best Current Practice, draft-ietf-oauth-security-topics-update-03, Work in Progress¶
ClaimsAggregation.TestVectors - Claims Endpoint prototype and reproducible RS256 test vectors¶
Copyright (c) 2026 The OpenID Foundation.¶
The OpenID Foundation (OIDF) grants to any Contributor, developer, implementer, or other interested party a non-exclusive, royalty free, worldwide copyright license to reproduce, prepare derivative works from, distribute, perform and display, this Implementers Draft, Final Specification, or Final Specification Incorporating Errata Corrections solely for the purposes of (i) developing specifications, and (ii) implementing Implementers Drafts, Final Specifications, and Final Specification Incorporating Errata Corrections based on such documents, provided that attribution be made to the OIDF as the source of the material, but that such attribution does not indicate an endorsement by the OIDF.¶
The technology described in this specification was made available from contributions from various sources, including members of the OpenID Foundation and others. Although the OpenID Foundation has taken steps to help ensure that the technology is available for distribution, it takes no position regarding the validity or scope of any intellectual property or other rights that might be claimed to pertain to the implementation or use of the technology described in this specification or the extent to which any license under such rights might or might not be available; neither does it represent that it has made any independent effort to identify any such rights. The OpenID Foundation and the contributors to this specification make no (and hereby expressly disclaim any) warranties (express, implied, or otherwise), including implied warranties of merchantability, non-infringement, fitness for a particular purpose, or title, related to this specification, and the entire risk as to implementing this specification is assumed by the implementer. The OpenID Intellectual Property Rights policy (found at openid.net) requires contributors to offer a patent promise not to assert certain patent claims against other contributors and against implementers. OpenID invites any interested party to bring to its attention any copyrights, patents, patent applications, or other proprietary rights that may cover technology that may be required to practice this specification.¶
The editors thank Michael B. Jones for his feedback and contributions.¶
[[ To be removed from the final specification ]]¶
-04¶
private_key_jwt in the base profile. Bound client assertion
audiences to the CP issuer.¶
-03¶
Simplified claims aggregation¶
-02¶
defined new names for actors¶
Claims endpoint response formats allows multiple schema types (W3C VC, JWT)¶
Added new requirements for claims endpoint¶
-01¶