Review · November 10, 2026
"OAuth Client Metadata Lookup: Ask the AS What It Thinks of Your Client"
The problem it's solving
A Client ID Metadata Document (CIMD) is the client's description of itself. It says nothing about what a given authorization server will accept.
Today the client finds out by failing. Worse, the client often never finds out at all. When the client ID or redirect URI is the problem, the AS is required not to redirect back. The user is left on an AS error page, and the client doesn't even know this happened.
This is a real problem for MCP. A desktop agent publishes one metadata document and presents it to whatever authorization servers its users happen to add. The developer can't test against all of them in advance.
The draft adds one unauthenticated endpoint. The client sends its client_id, and the AS returns the client configuration it will actually use, including any defaults it applied.
How it fits in the working group
This fits the charter. It's one new endpoint and one new AS metadata parameter, client_metadata_lookup_endpoint.
The closest existing mechanism is the Client Read Request in RFC 7592. That one needs a registration access token, can return secrets, and only exists for clients created through Dynamic Client Registration. A DCR client also gets its effective configuration back in the registration response. CIMD clients have no equivalent, and this draft fills that gap.
Normative dependencies are CIMD, RFC 6749, RFC 7591, RFC 8414, and RFC 9700, plus the usual HTTP and JSON references. It reuses existing metadata names and existing error codes.
No new roles. It does add a new direct interaction between the client and the AS before the authorization request, which is new for public clients that don't use PAR.
What the mechanism actually does
Discovery. The AS advertises client_metadata_lookup_endpoint in its metadata.
Request. The client sends GET /lookup?client_id=... with no authentication. For a CIMD client, the AS fetches and validates the document using the same rules it uses at the authorization endpoint.
Response. A JSON object with client_id and a "public subset" of the effective client metadata, using RFC 7591 field names. Defaults are filled in. Secrets and registration tokens must never appear.
The example makes the point well. A CIMD client omits token_endpoint_auth_method. RFC 7591 says the default is client_secret_basic, which a CIMD client can't use, so the AS applies none. A client that guessed from the RFC 7591 defaults would get this wrong.
Errors. Three codes: invalid_request, invalid_client, and invalid_client_metadata. Unknown, disallowed, and non-disclosable clients must get indistinguishable invalid_client responses. For CIMD clients the AS should explain which field or check failed, since the document is public anyway.
Caching. Success responses can be cached. Errors must not be.
So what about the "progressive rollout" use case?
The second use case is the AS changing a client's configuration and reporting it through this endpoint. The example is an AS setting dpop_bound_access_tokens to true for one cohort of clients at a time while rolling out DPoP.
This is the weaker half of the draft. The client only learns about the change by repeating the lookup, so in practice it has to do a lookup before every authorization flow. It also means the AS is overriding a field that RFC 9449 phrases as a client declaration. The draft spends a full paragraph defending that.
There's also overlap now. draft-emelia-oauth-as-metadata-dpop-required defines an AS-wide flag for requiring DPoP. This draft says "no AS metadata parameter signals this requirement," which will need updating if that one moves forward. The two cover different cases, AS-wide versus per-client, and the working group should decide whether the per-client case is common enough to standardize.
Significant interoperability concerns
Security and Privacy Considerations are both "TODO!". For this draft those sections are most of the work. The endpoint is unauthenticated, CORS-enabled, and makes the AS fetch an attacker-chosen URL on demand.
- CIMD already has SSRF and fetch-amplification risks, but there the fetch is triggered by an authorization request in a browser. Here it's a scriptable GET. The draft needs rate limiting guidance and an explicit pointer to CIMD's SSRF rules.
- The endpoint is a policy oracle. Anyone can learn which clients an AS accepts and how it configures them. That matters for enterprise deployments with allowlists.
- For non-CIMD clients, it discloses
redirect_uris,jwks_uri, and similar fields for any known client ID. The "indistinguishableinvalid_client" rule helps, but timing differences between a cached lookup and a live CIMD fetch will leak which case applied.
"Public subset" is undefined. The AS decides which fields are safe to disclose, and omitted fields mean nothing. A client checking for dpop_bound_access_tokens can't tell "false" from "this AS doesn't report that field." Two conforming servers can return completely different field sets. The draft should define a minimum set that every AS returns, at least redirect_uris, grant_types, response_types, and token_endpoint_auth_method.
Reject or adjust? If a CIMD document has one redirect URI the AS won't accept, does the AS return invalid_client_metadata, or a success with that URI dropped? "Effective configuration" after "enforcing client configuration policy" allows both readings. Clients need to know which, since one means "you can't start a flow" and the other means "you can, with these values."
Lookup success doesn't predict authorization success. The response can't depend on a user session. Many AS policies do depend on the user or tenant, like an enterprise admin blocking a client for their organization. The draft is honest that success is not a promise. It should say more plainly that the lookup catches document-level rejections only.
An untestable MUST. Section 3.3 says deployments using both this and Watson's client-specific AS metadata proposal "MUST keep the two views consistent." That's a normative requirement tied to a document that only exists on GitHub. It should be lowercase guidance.
Smaller items:
- The CIMD reference is to -02. The current version is -03, which added its own error handling for fetch failures. The error mapping here should line up with it.
invalid_clientis redefined to mean something other than failed authentication. A new error code would be cleaner than overloading an RFC 6749 one.- Section 5 says the AS "MUST include" the metadata member and then calls it OPTIONAL. The same wording problem appears in the author's Deferred Token Response draft.
- CORS is only a SHOULD. Browser-based clients can't use the endpoint without it.
Mechanisms that could be removed
Section 3.2, progressive rollout. The first use case justifies the endpoint by itself. Rollout through AS-mutated client metadata is a second, more contentious idea riding along. Cutting it to a sentence would make this an easier adoption call.
Non-CIMD clients. Extending the lookup to statically registered clients is where most of the disclosure and enumeration risk comes from. Those clients were registered by a developer who already knows the configuration. Scoping the first version to CIMD clients would remove the "non-disclosable client" branch of the error handling entirely.
Section 3.3. The comparison to an unpublished individual proposal can go in an appendix or be dropped.
Worth keeping: the rule that clients must not infer values for omitted fields, the no-store requirement on errors, and the detailed error descriptions for CIMD clients. Those are what make the endpoint useful for debugging.
Writing quality
Good. It's about eight pages of body text, uses BCP 14 language correctly, and the examples are well chosen. Each requirement comes with a short justification.
It's also clearly unfinished. Security Considerations, Privacy Considerations, and Acknowledgments are all placeholders. That's acceptable for a -00, but the missing sections cover the hardest questions about this design.
The length is right for the core mechanism. Section 3.2 is the only part that reads as an argument with an anticipated objection instead of a specification.
Background of the author
Maxwell Gerber (Twilio). No published RFCs as of my last check of his Datatracker profile in October. He co-authored Deferred Token Response, which the working group adopted this year and which is now at -01. This is his second draft, and his first as sole author.
So he's a new IETF author, but one who has already taken a draft through adoption and knows how the working group operates. He's also credited in the acknowledgments of the DPoP-required metadata draft for identifying the gap it fills.
The Datatracker profile could not be fetched for this review. The counts above come from the local document archive and the October review, so they are not confirmed as of today.
Questions for the working group
So what should the working group decide?
- Does this belong as its own document, or as a section of CIMD while that draft is still open?
- Should the first version cover CIMD clients only?
- What is the minimum set of fields every AS must return?
- Is an unauthenticated endpoint that triggers outbound fetches acceptable, and what rate limiting does it need?
- Is per-client rollout of requirements like DPoP something to standardize here, or is the AS-wide flag enough?