The Scope Creep Automated reviews of new AI-related working group submissions

Review · November 20, 2026

OAuth Userinfo Response

draft-parecki-oauth-userinfo-response -00View on Datatracker →

The Problem

OAuth 2.0 never tells the client which user authorized the request. The client gets an access token and nothing else.

Today a client has two options. It can call an API with the token, like GitHub's /user endpoint. Or it can adopt OpenID Connect and validate an ID token, which means pulling in a JWT library and key management.

This draft adds a third option. The authorization server returns the user identifier, and optionally profile claims, as plain JSON in the token response.

How It Fits In

This is a small extension to the RFC 6749 token response. It adds two response parameters and two scope values. There are no new endpoints, roles, or grant types.

The dependencies are light: RFC 6749, RFC 7636 (PKCE), and RFC 7519 for the meaning of sub and the claim names. No JWT is ever created or parsed.

So does it fit the charter? That's the real debate. The working group has spent a decade saying OAuth is not an authentication protocol and pointing people to OpenID Connect for user identity. This draft puts a user identifier into core OAuth.

The draft never mentions OpenID Connect. That's a noticeable gap. The userinfo name, the sub claim, and the example claims preferred_username and picture all come from OpenID Connect. "UserInfo Response" is already a defined term there, for the response from the UserInfo endpoint.

The pattern itself is not new. Slack returns authed_user.id in its token response. IndieAuth returns me and a profile object. Plenty of deployed APIs already do a non-standard version of this.

Summary

There are two mechanisms, and they are nearly identical.

Subject Response. The client adds subject to the scope in the authorization request. The token response includes a top-level sub string.

Userinfo Response. The client adds userinfo to the scope. The token response includes a userinfo JSON object. It MUST contain sub, and the authorization server chooses which other claims to add. Claim names come from the IANA JWT Claims registry.

In both cases the authorization server MUST return the value when the scope was requested, and MAY return it when it wasn't.

The security model is the transport. Nothing is signed. The client trusts the value because it came directly from the token endpoint over TLS, after an authorization code exchange protected by PKCE. PKCE is a MUST. The values MUST NOT appear in the front-channel authorization response.

The draft is firm that this is "not a proof of identity." It also says the mechanism MUST NOT be used when the client needs a signed statement about the user.

Interoperability

The response format is simple enough that two implementations will agree on it. The problems are at the edges.

Significant interoperability concerns

The scope values are not reservable. RFC 6749 leaves scope strings entirely to the authorization server, and there is no IANA registry for them. An existing deployment may already use subject or userinfo for something else. The draft registers the two response parameters but has no way to register the scopes.

There is no discovery. A client can't tell whether a server supports this. Sending scope=subject to a server that doesn't gets either invalid_scope or a silent ignore. The draft should at least point to scopes_supported, or define a metadata flag.

The stability guarantee is the wrong one. sub MUST be unique and MUST NOT be reassigned to a different user. The draft never says the same user gets the same sub on the next authorization. That is the one property a client needs to "associate the authorization with a local account." It also doesn't say whether pairwise identifiers per client are allowed.

Requested versus granted. The MUST triggers when the client "included the scope" in the request. RFC 6749 lets the server grant fewer scopes than requested. What happens when the server or user declines userinfo?

Only the authorization code flow is described. Is sub repeated in a refresh token response? What about the device flow, token exchange, or the JWT bearer grant? Client credentials has no user at all. Section 5.3 mentions "any flow that utilizes a browser redirect" but the rest is unspecified.

Clients will use this for login. The stated use case, linking to a local account, is login for most apps. The draft says the value is not a proof of identity, then stops. It should say plainly whether signing a user in based on sub is acceptable. Compared to an ID token there is no iss, no nonce, and no auth_time. A client talking to several authorization servers needs mix-up defenses like RFC 9207 to know whose sub it holds. The draft only tells the client to scope the identifier to the server "that returned it."

No relationship to other sub values. If the client also requests openid, must the two sub values match? Does it match the sub in a JWT access token or an introspection response? The draft doesn't say.

Privacy is missing. The server MAY return sub or userinfo to a client that never asked. A client that only wanted API access now gets a user identifier and possibly a name and photo. There is no Privacy Considerations section and no mention of consent.

Mechanisms that could be removed

One of the two mechanisms. A userinfo object containing only sub does everything the Subject Response does. Two scopes and two parameters for overlapping results means clients and servers will pick different ones. If a client sends both scopes, it gets sub twice.

The simplest version of this spec is a single top-level sub. Profile claims are where the overlap with OpenID Connect is heaviest and the interop is weakest, since the client can't request or count on any claim other than sub.

The MUST NOT in the introduction. "MUST NOT be used when the client requires a signed statement" is not testable. It reads better as plain applicability text.

Writing Quality

The writing is clean and in standard IETF style. At nine pages it is quick to review.

It errs on the side of too short. The security section asserts that the values are not an identity assertion without explaining what a client can safely do with them. The choice of plain JSON over a JWT is justified. The choice to define two parallel mechanisms is not.

A few editorial nits:

  • Sections 3 and 4 are copy-paste duplicates with one word changed. They could be one section with two parameters.
  • "The client SHOULD include the subject scope" is an odd requirement. A client that wants the feature includes it, one that doesn't won't.
  • The title collides with the existing OpenID Connect term "UserInfo Response."
  • Acknowledgments says "The authors" on a single-author draft.

Author

Aaron Parecki (Okta). 2 published RFCs: RFC 9728 (Protected Resource Metadata) and RFC 10017 (OAuth 2.0 for Browser-Based Applications). Listed on more than 40 documents in Datatracker, with close to 20 active Internet-Drafts including OAuth 2.1, CIMD and ID-JAG. An established author doing a lot of active writing.

Questions for the Working Group

So what should the working group decide?

  • Does returning a user identifier belong in OAuth, or is this OpenID Connect's territory? A liaison conversation with the OpenID Foundation seems necessary either way.
  • Is it acceptable for a client to log a user in based on an unsigned sub from the token endpoint? If yes, the draft should say so and add the missing guidance. If no, what is the remaining use case?
  • Does the spec need both sub and userinfo, or only one?
  • How should scope names be defined when OAuth has no scope registry?