Review · October 13, 2026
Letting the Audience Decide Who Can Exchange Its Tokens
The problem it's solving
A resource server receives an access token audienced to itself. It needs to call a downstream API. That token is no good downstream, so the resource server uses Token Exchange to swap it for one with the right audience.
The question this draft asks is narrow: how does the authorization server decide that the client asking for the exchange is allowed to?
RFC 8693 punts on this. Section 2.1 says client authentication "allows for additional authorization checks by the STS," and leaves the rest to policy. The may_act claim exists, but the original token issuer has to know the actor in advance, including what client ID that actor uses at whatever authorization server it will eventually talk to. That rarely works when a service calls several downstream APIs behind different authorization servers.
The draft's answer is to anchor the decision in the subject token's aud claim. If the token was issued to https://api.example.com, then the client that represents https://api.example.com is the one allowed to exchange it. The work is in establishing which client that is.
The intro makes one argument worth calling out. Sender-constraining the subject token doesn't solve this. DPoP or mTLS proves the token is being presented by the client it was issued to. It says nothing about whether the resource server that received it is allowed to turn it into something else.
How it fits in the working group
This is squarely in charter. It's a small extension to RFC 8693 that adds one parameter to Protected Resource Metadata (RFC 9728) and leans on Client ID Metadata Documents for globally scoped client IDs. No new grant type, no new token claim, no new endpoint.
The pattern is already common in production. Microsoft Entra's on-behalf-of flow works this way: the incoming token must be audienced to the middle-tier API making the request, and that's the core of the authorization check. Most enterprise token exchange deployments have some version of "client X may exchange tokens whose audience is Y" sitting in a config table.
The same question shows up in adopted work, and the draft cites none of it.
- Identity Chaining has a token exchange step at the home authorization server where exactly this check needs to happen.
- Transaction Tokens has the Txn-Token Service validating an inbound access token and authorizing the requesting workload. Same question, answered by local policy.
- ID-JAG leaves
actor_tokenhandling open for future profiles, which is where an intermediary like an API gateway would identify itself.
The gateway case is the clearest motivating example, even though the draft never names it. An enterprise gateway terminates the client's token, which is audienced to the gateway. It then goes back to the IdP to exchange that token for a downstream one, with the gateway as the actor. The IdP needs to know that the client presenting a token with aud = the gateway is actually the gateway. That's this draft's "audience-client relationship," and it gets more interesting when the gateway fans out to many upstreams behind different authorization servers.
There's one structural thing to be careful about. The draft's multi-AS examples have a resource server presenting its access token directly to a foreign authorization server as the subject token. Identity Chaining and ID-JAG deliberately avoid that. They exchange at the home authorization server and get a purpose-built assertion for the foreign one. A deployment following this draft literally ends up with a foreign AS accepting access tokens issued by someone else, audienced to someone else. That should at least be called out.
What the mechanism actually does
The authorization server picks exactly one audience value from the subject token. Multiple matching audiences with no unambiguous winner means reject. Then it establishes that the requesting client "is associated with" that audience, using one or more of three mechanisms:
- Local policy. A configured mapping, like
api://orders -> rs-orders-client. This is the only option for non-HTTPS audiences. - JWT validated with the resource's
jwks_uri. The AS fetches the resource's PRM, gets itsjwks_uri, and uses those keys to validate a JWT the client presents as either anactor_tokenor a client assertion. - A new
token_exchange_clientsPRM parameter. The resource publishes a list of{authorization_server, client_id}pairs saying "this is me at AS-A, this is me at AS-B." Omitauthorization_serverand theclient_idis a CIMD URL.
After that, all normal token exchange policy still applies. The draft says this many times: establishing the relationship doesn't authorize any particular downstream audience, scope, or actor chain.
The token_exchange_clients idea has a nice property. The party whose audience restriction is being relaxed is the resource itself, so letting the resource say who can act on its behalf puts the decision with the right owner. And the requesting client doesn't change anything about how it calls the token endpoint.
The precondition undercuts the discovery
Section 12.1 is the right call, and it's also the problem.
The AS MUST NOT treat PRM as establishing that an audience is valid. It must first decide, by its own policy, that the audience identifies a protected resource it's willing to process exchanges for. Only then can it fetch metadata to find the client. Section 6.1 adds that metadata discovery only happens for HTTPS audiences "acceptable to the authorization server according to local policy." Section 12.3 says it again for SSRF.
That's necessary, because otherwise an attacker who can get a token issued to an attacker-controlled audience also controls the metadata naming the exchanging client.
But think about what the AS has in hand at that point. It already has a list of resources it trusts for token exchange. Adding a client_id column to that list is trivial. The dynamic lookup saves one field in a config table the AS is already required to maintain, in exchange for an outbound HTTPS fetch, caching rules, SSRF defenses, and a new failure mode when the resource's metadata endpoint is down.
There is a real case where discovery helps: the resource team rotates client registrations, or adds new authorization servers, without coordinating with each AS admin. That case should be stated explicitly, because right now the reader has to construct it.
The jwks_uri mechanism repurposes a key
RFC 9728 defines jwks_uri as the resource server's public keys, "such as signing key(s) that the resource server uses to sign resource responses." This draft turns those keys into client authentication credentials. Any JWT signed by a key at that URL can establish that the presenter is the resource.
That's a key-purpose change made by reference, with no use or typ requirement to keep the two apart. A resource that publishes jwks_uri today for response signing would, under this draft, implicitly be publishing client authentication keys too.
The JWT itself is also unspecified. Section 8.2 says to validate "the signature, issuer, audience, expiration time, and any other claims required by local policy." What's the expected iss? The resource URL? The client ID? What aud does the AS check? If it's an actor_token, what's the actor_token_type? If it's a client assertion, RFC 7523 requires iss and sub to be the client ID, so how does the AS get from that to the resource's PRM? None of this is answered. Two implementations will make different choices.
This mechanism is really an attempt at "the resource server is its own client, identified by its resource URL." CIMD already gives you that, with a URL client ID and a jwks_uri that is unambiguously for client authentication. Mechanism 3 already supports CIMD client IDs. Mechanism 2 isn't adding anything that path doesn't already cover.
It authorizes who, not what
The metadata says which client represents a resource. It says nothing about which downstream audiences that client may request. The draft is explicit that this stays in local policy.
That's a defensible scoping decision. It's also where the actual risk lives. A resource server that can exchange its inbound token is fine. A resource server that can exchange its inbound token for an access token to the payroll API is the thing an operator worries about. If PRM is going to carry token exchange information, a list of permitted downstream resources is arguably more useful than a list of client IDs, and it fits Yaron's authority metadata work.
Significant interoperability concerns
- The client can't tell what the AS expects. There's no AS metadata indicating which mechanisms are supported, so a client doesn't know whether to send a JWT
actor_token, a client assertion, or nothing extra. - Contradictory requirements. Section 8.2 says the AS SHOULD verify the JWT client is consistent with
token_exchange_clientsand MUST reject if inconsistent. Section 9.4 says MUST verify and SHOULD reject. These describe the same check. - "Bound to" a global client ID is undefined. Section 9.4 says the AS MUST verify the client "is bound to the globally scoped client identifier." For CIMD, that presumably means the request's
client_idis that URL and authentication used its keys. Say so. may_actprecedence is unclear. Section 7 saysmay_act"takes precedence," then Section 11 says the AS MAY require both or neither. What happens whenmay_actnames a different actor than the audience-client relationship would?- Error codes. Section 10.1 attributes
invalid_requestandinvalid_grantto RFC 8693. They're from RFC 6749.unauthorized_clientis arguably the better fit for "this client may not exchange this token." - MAY everywhere. The AS MAY use any mechanism, MAY require more than one, and MAY let local policy override inconsistencies. Two compliant servers can disagree on every request.
Mechanisms that could be removed
Drop the jwks_uri mechanism. It changes the meaning of an existing RFC 9728 parameter, leaves the JWT profile unspecified, and is covered by CIMD client IDs in token_exchange_clients.
Drop local policy as a named "mechanism." It's the default behavior of every authorization server and needs no spec text beyond a sentence saying the AS can always use it.
What's left is one PRM parameter plus the audience-selection rules in Section 6. That's a two-page document, and a much easier one to evaluate. It might be better still as a section in Identity Chaining or Transaction Tokens than as a standalone RFC.
Writing quality
Clear and correctly formed. BCP 14 keywords are used properly, the PRM URL construction rules in Section 8 are precise, and the SSRF section has concrete, useful defenses.
It's also roughly twice as long as it needs to be. The three mechanisms are enumerated in the abstract, the introduction, Section 5, Section 7, and Section 10. The sentence that the relationship "does not authorize issuance of a token for any particular requested resource, scope, subject, or actor chain" appears at least four times.
Some reference cleanup is needed. RFC 8707 and RFC 7523 are normative but never cited in the body. RFC 8414 and RFC 9126 are informative and never cited at all. The acknowledgments say "the authors" on a single-author draft.
Background of the author
Yaron Zehavi, Raiffeisen Bank International. His Datatracker profile shows zero published RFCs and four active drafts: this one, authority metadata, authorization request delegation chains, and RAR metadata and remediation, which the working group has adopted. Three more have expired, including native clients federation and app2app browserless.
So not a new author. He's one of the more prolific individual contributors in the OAuth WG right now, and he's already gotten a draft through adoption.
His documents share a theme: multi-AS deployments and making intermediaries visible. The delegation chain draft handles intermediary authorization servers on the front channel. This one handles intermediary resource servers on the back channel. Those should probably be talking to each other.
The right next step is a mailing list thread on whether this belongs as a standalone spec or as a profile of the Identity Chaining token exchange step, with the jwks_uri mechanism dropped either way.