# What is Rich Authorization Requests?

> Rich Authorization Requests let an app ask for a precise permission, such as paying 123.50 euros to one merchant, as structured data. The user approves those exact details, and the API enforces them.

Explainer by Boston Identity, 2026-10-28. 5 min read. https://insights.bostonidentity.com/glossary/rar

- What it is: standard
- Defined by: IETF, RFC 9396 (Standards Track, 2023)
- Who it's for: Teams granting agents and apps access to APIs

## What is Rich Authorization Requests?

OAuth is the standard way an app gets an access token to call an API on a user's behalf. Its scope parameter, a short string naming what the token may do, works for coarse requests such as "read my profile". RFC 9396 says that is not enough for a request like "transfer 45 euros to Merchant A" [S1 §1].

Rich Authorization Requests (RAR) add one parameter, authorization_details. It carries a JSON (JavaScript Object Notation) array of objects, each describing one permission in detail [S1 §2]. The authorization server, which issues tokens, uses those details to ask the user for consent. The authorization server and the API then enforce what the user approved together [S1 §1]. RFC 9396 is a finished IETF standard, published in May 2023 [S1].

Think of it like this: A scope is like a signed blank cheque marked "payments"; a rich authorization request is a filled-in cheque with the amount and payee. The comparison stops at enforcement: the bank reads a cheque one way, while each API decides for itself how to read its own details.

Not the same as: Not a new token format or a new grant. RAR is a request parameter that rides on existing OAuth flows and can sit beside the old scope string in the same request [S1 §3.1].

## How does Rich Authorization Requests work?

Three parties act: the client (the app or agent asking for access), the authorization server that asks the user and issues tokens, and the resource server, the API that receives the calls.

[Figure: The client describes the exact permission it wants, the user approves all or part of it at the authorization server, and the API checks the approved details when the token arrives.]

1. **The client describes each permission.** The client builds an array of objects. Each must carry a type that names the kind of permission, and the type decides which other fields are allowed [S1 §2]. RAR offers optional common fields such as locations, actions, datatypes, identifier and privileges, and an API may add its own, such as an amount or a creditor [S1 §2.2]. Values in one object multiply: every listed action applies at every listed location, so a client wanting narrower access sends separate objects [S1 §2.2].
2. **The client sends the details with its request.** The client puts authorization_details in its authorization request, or anywhere else OAuth uses scope for the same purpose, such as device or backchannel requests [S1 §3]. For long or sensitive details, the RFC suggests implementers consider pushed authorization requests, which send the request straight to the server first [S1 §3, §11.4].
3. **The authorization server checks and asks the user.** The server must refuse an unknown type, an unknown field, or a missing required field, with the error invalid_authorization_details [S1 §5]. It then asks the user for consent to the details, and the user may grant only part of them [S1 §3]. If the request also carries scope, the consent screen must show the merged set [S1 §3.1].
4. **The client asks for a token, perhaps for less.** At the token endpoint, the client may send authorization_details again to say what this token should carry. The server checks that the underlying grant, or the client's policy, allows it, and refuses otherwise [S1 §6]. Asking for fewer permissions leaves the user's earlier approval unchanged [S1 §6.1].
5. **The authorization server returns what was granted.** The token response must include the authorization details granted and tied to the token [S1 §7]. The server may omit values. Where the type definition allows, it may also enrich them, for example by adding the accounts the user picked during consent [S1 §7, §7.1].
6. **The API enforces the approved details.** The authorization server must make the approved details available to the API [S1 §9]. It may put them in a JWT (JSON Web Token) access token, where a top-level claim filtered to that API is recommended, or return them when the API asks about the token through introspection [S1 §9, §9.1, §9.2].

## Why does Rich Authorization Requests matter now?

Several new proposals for AI agents use RAR to state exactly what an agent may do. One OAuth draft has the API, not the agent, describe the operation as RAR details in a challenge it signs, and the agent must pass it on unchanged [BI-FIND-2026-0626](https://insights.bostonidentity.com/ref/BI-FIND-2026-0626). The TPX proposal puts a dollar budget for AI inference in a RAR object of its own type [BI-FIND-2026-0624](https://insights.bostonidentity.com/ref/BI-FIND-2026-0624). Chen and Su's draft adds a binding to the RAR request so that an agent's token ends when its task does [BI-FIND-2026-1251](https://insights.bostonidentity.com/ref/BI-FIND-2026-1251).

Ping Identity is one vendor that has moved. In April, it added partial support for RAR details at its authorize and pushed-authorization endpoints, and its September notes let access tokens carry them through the code and refresh grants [BI-FIND-2026-1182](https://insights.bostonidentity.com/ref/BI-FIND-2026-1182). Not every critique of OAuth for agents deals with RAR. One IETF draft says nothing carries a person's limits through to the action, and leaves RAR unmentioned [BI-FIND-2026-0880](https://insights.bostonidentity.com/ref/BI-FIND-2026-0880). One academic paper does weigh RAR, then dismisses it because each call would need its own grant, an argument it does not test [BI-FIND-2026-1017](https://insights.bostonidentity.com/ref/BI-FIND-2026-1017). Gaps remain: a cross-domain grant draft leaves how RAR details would cross domains to a future revision [BI-FIND-2026-0494](https://insights.bostonidentity.com/ref/BI-FIND-2026-0494).

## Where does it fit?

- Compared with OAuth Token Exchange: Token exchange (RFC 8693) trades one token for another. RAR describes what a token permits, and Sweeney's delegation draft profiles both together [BI-FIND-2026-1113](https://insights.bostonidentity.com/ref/BI-FIND-2026-1113).
- Compared with DPoP: DPoP binds a token to the client's key so a thief cannot use it; RAR says what the token may do. TPX uses both: a RAR budget object, and providers that must support DPoP [BI-FIND-2026-0624](https://insights.bostonidentity.com/ref/BI-FIND-2026-0624).
- Compared with Attenuating Authorization Token: In Niyikiza's attenuating tokens, any holder narrows a token offline with no authorization server [BI-FIND-2026-0532](https://insights.bostonidentity.com/ref/BI-FIND-2026-0532). With RAR, a client asks the authorization server for a token with fewer details, and the server checks the request against the grant [S1 §6].
- Compared with OAuth Token Introspection: Introspection is how an API asks the authorization server about a token. RAR defines how the approved details appear in that answer, as a top-level authorization_details member [S1 §9.2].

## What goes wrong?

- No general rule says whether one set of details is narrower than another. Each API defines how its fields combine, and the RFC warns that simple object comparison can misstate the access granted [S1 §6.1] [BI-FIND-2023-0045](https://insights.bostonidentity.com/ref/BI-FIND-2023-0045).
- In an ordinary authorization request, the details pass through the user agent, usually the browser, so the user can change them. When integrity matters, clients must protect them, for example with signed request objects or pushed requests [S1 §12].
- String values are compared exactly, with no normalization, so look-alike characters in a type value can cause mismatches [S1 §2.1, §12].
- The authorization server must sanitize the details against injection attacks [S1 §12].
- An attacker who holds encrypted request data can inject it into a request on their own device and read it, decrypted, on the consent screen. The RFC suggests showing only part of the data or checking that the user context is the same [S1 §13] [BI-FIND-2023-0047](https://insights.bostonidentity.com/ref/BI-FIND-2023-0047).

## What should a security leader ask?

1. For each API our agents call, who has defined the RAR types, and who decides whether a token request asks for less than the user approved?
2. Do our consent screens show the actual amounts, recipients and resources from the details, or only a generic label?
3. Which of our APIs read authorization_details from the token or introspection and enforce them, and which still check only scope?
4. Are authorization details sent through pushed or signed requests wherever their integrity matters?

## Sources

- [S1] [OAuth 2.0 Rich Authorization Requests (RFC 9396)](https://www.rfc-editor.org/rfc/rfc9396) (IETF, Standards Track, May 2023)

## Evidence

- [BI-FIND-2026-0626](https://insights.bostonidentity.com/ref/BI-FIND-2026-0626): The draft moves the description of what is being approved from the agent to the API. When a call needs approval, the protected resource answers 401 with a challenge it signs itself: a JWT carrying a transaction id and the operation as Rich Authorization Request details. The agent must relay that challenge unmodified and "MUST NOT replace it with an agent-generated description". The authorization server gets a decision from an approving party, who need not be the agent's user, and the resulting token is bound to that one transaction, may be narrowed but never broadened, and is meant to be short-lived and sender-constrained. (from "A new OAuth draft lets the API, not the agent, describe what a person is approving")
- [BI-FIND-2026-0624](https://insights.bostonidentity.com/ref/BI-FIND-2026-0624): TPX replaces the provider key an app would embed with a per-user grant built entirely from standard OAuth parts. The app pushes an authorization request (PAR, PKCE S256) carrying a Rich Authorization Requests object of type llm-inference with a budget in US dollars; the user consents at a provider they chose, and the provider may grant less. The refresh token "represents the grant" and rotates, reuse revokes it, and providers must support DPoP. The provider meters actual use, returns 402 budget_exhausted at the cap, and revokes immediately on request. "TPX grants tokens, not identity": no subject or account appears in any token. The budget is framed as "a hard damage cap", but the text does not say what happens when one request crosses the cap mid-flight or when requests run concurrently. (from "TPX replaces an app's embedded AI provider key with a capped, metered grant the user approves at their provider")
- [BI-FIND-2026-1251](https://insights.bostonidentity.com/ref/BI-FIND-2026-1251): Chen and Su's draft lets an agent's access token end when its task does, not only when it expires. The client adds a lifecycle_binding to its Rich Authorization Requests (RAR) request, naming a task id and the states that end the task. The one binding type the draft defines is a task-status webhook: the task provider reports those states to the authorization server, which MUST link the task to the token and, when the task ends, "MUST immediately revoke the associated token and propagate this revocation information." Resource servers SHOULD NOT rely solely on the token's expiry and MUST check for revocation in real time, through a revocation feed or token introspection. The authors call the scheme "entirely dependent" on that notice arriving and keep expiry as the fallback; the authorization server has to trust the task provider's webhook, and they say only that mutual TLS and request signing SHOULD protect it. We read the cost as falling on every API: a token carrying the binding can no longer be trusted on its signature and expiry alone, and if the webhook never fires, nothing ends it early. (from "A China Mobile draft would end an agent's token when its task ends, if a webhook says so")
- [BI-FIND-2026-1182](https://insights.bostonidentity.com/ref/BI-FIND-2026-1182): Ping, Auth0 and Cloudflare each tightened what a third-party or delegated token can reach in April. Ping's April 14 regular channel let token exchange requests name an audience, which can be limited to an allowlist, and gave partial support for rich authorization request (RAR) details at its authorize and pushed-authorization endpoints. Auth0 made strict mode for third-party applications GA on April 30: PKCE required, a client grant for each API, and default permissions applied to apps created by dynamic client registration. Cloudflare let users grant a third-party OAuth app chosen accounts instead of all of them. Ping's September notes let access tokens carry RAR details through the authorization code and refresh token grants. (from "Microsoft and Google made AI agent identity generally available in April; Okta's notes put its GA in May")
- [BI-FIND-2026-0880](https://insights.bostonidentity.com/ref/BI-FIND-2026-0880): Yossif separates the moment a person signs off on what an agent may do (T0) from the moment the agent acts with the person gone (T1), and argues nothing binds the two: the agent's credentials and session carry no copy of the person's limits, so a server can check "that an authorized agent asked, not that the Principal authorized this action." He argues the gap grows with volume, since a person can bound a handful of actions per interaction and an agent can run thousands. He names three mechanisms that fall short. OAuth scopes cover a class of operation with no per-action parameters, an audit log is written by the executor after the fact and cannot stop anything, and payment mandates such as AP2 only speak the vocabulary of payments. Our briefing on an independently authored OAuth use-cases draft found the same diagnosis. His case against OAuth rests on scopes alone; Rich Authorization Requests, the OAuth extension built to carry per-action detail, go unmentioned. (from "Nothing carries a person's limits on an agent through to the moment it acts, Yossif's problem statement argues")
- [BI-FIND-2026-1017](https://insights.bostonidentity.com/ref/BI-FIND-2026-1017): The authors' case against OAuth is that a scope grants an operation type, such as transfer, and cannot say "TRANSFER $100 to Bob.", so an agent given enough scope for a precise task is over-privileged by design. They dismiss Rich Authorization Requests (RFC 9396), which can carry concrete values, because each call would still need its own grant and approval. For the first point they cite their own simulated calls, which keep the operation but change the amount or recipient and, they say, would pass an operation-level scope; their results tables report no run against OAuth itself. The RAR dismissal is argued, not tested. Two other sources in our corpus describe the same gap from different angles: an authorization server that never sees the task, and approved intent that never becomes enforceable authority. (from "Checking each agent call against the user's own task stopped all 634 off-task calls the authors wrote")
- [BI-FIND-2026-0494](https://insights.bostonidentity.com/ref/BI-FIND-2026-0494): Narrowing is a no-wider rule that authorization servers check one crossing at a time. Domain A's server "MUST NOT" expand scope beyond the Txn-Token's (the grant's scope is the intersection of the token's and the request's), and domain B's server must independently keep its access token within the grant. Across three or more domains, trust stays "strictly pairwise": a server accepts a grant because it trusts the server that issued it under their bilateral agreement, not through any tie to domains further upstream, and the draft concedes that a grant's claims may be derived from context an upstream domain sent. The no-wider rule is written for scope strings; how rich authorization details (RAR) would cross is left to a future revision. (from "A cross-domain transaction-token grant now names AI agents as a use and keeps the call chain at home")
- [BI-FIND-2026-1113](https://insights.bostonidentity.com/ref/BI-FIND-2026-1113): The draft calls itself a profile of four existing specifications: OAuth token exchange (RFC 8693), DPoP, Rich Authorization Requests (RFC 9396) and CIBA. Its new implementation section, Sweeney's account of his own TypeScript Cred SDK, lists each of the four among what the SDK does not implement. It delegates through custom endpoints, proves key possession with signed payloads and HTTP Message Signatures, carries scope strings with constraints instead of authorization_details, runs consent through a URL the user opens, and has no act or prf claim. What it does build is the architecture: credentials kept in the server's vault, calls made by proxy, sub-delegation with attenuation, all six constraint types and signed receipts at each hop. Sweeney rates it "Experimental" and writes that "It is not wire-compatible with this document." It passes all twenty interop vectors from Asor's draft, which he notes "do not test any token, receipt, or request format defined in this document", and the one-second and five-second revocation bounds are "not measured by tests". (from "Sweeney's agent delegation draft builds on four standards, and his own SDK uses none of them")
- [BI-FIND-2026-0532](https://insights.bostonidentity.com/ref/BI-FIND-2026-0532): Niyikiza's tokens narrow further than the other agent-delegation drafts: down to a tool's argument values. A root token from the authorization server maps tool names to constraints on each argument (exact, range, one_of, subset and five more types), and any holder can derive a child offline with fewer tools or tighter constraints, sign it with its own key and pass it on: "No authorization server communication is required." Argument matching is closed-world, so an argument the issuer did not name is refused. The enforcement point verifies the chain in eight steps with only the trust anchor's key, ending with a proof-of-possession token bound to the exact tool and arguments of the call. If that point skips or botches the narrowing check, in the draft's words, it "provides no blast radius containment". (from "Niyikiza's agent tokens narrow to a tool's arguments offline, and all containment rests on the enforcement point")
- [BI-FIND-2023-0045](https://insights.bostonidentity.com/ref/BI-FIND-2023-0045): Requesting a token with reduced authorization_details leaves the resource owner's earlier authorization in place. The authorization server checks token requests against the underlying grant or client policy, but RFC 9396 supplies no general algorithm for comparing arbitrary detail objects: those rules belong to the API. Simple object comparison can misstate the resulting access rights. The token response must return granted details, though the server may omit values and enrich objects where the type definition allows. (from "Rich Authorization Requests need API-specific permission rules")
- [BI-FIND-2023-0047](https://insights.bostonidentity.com/ref/BI-FIND-2023-0047): Encrypted request data can still expose personal information through consent screens. RFC 9396 describes an attacker inserting that encrypted data into an authorization request on a device they control, then using the authorization server's consent display to see it decrypted. The RFC points to partial display and checks on the authenticated user context as possible countermeasures. Separately, the server must sanitize authorization_details against injection; clients must protect the details from tampering and swapping when their integrity is a concern. (from "Rich Authorization Requests need API-specific permission rules")

---

© 2026 Boston Identity LLC. All rights reserved. Published by Boston Identity LLC.
Quote up to 100 words with the credit "Boston Identity, IAM Insights" and a link to https://insights.bostonidentity.com/glossary/rar. Claim numbers may be cited freely. Training, fine-tuning and text-and-data-mining use of this page is permitted.
Terms: https://insights.bostonidentity.com/terms · How to cite: https://insights.bostonidentity.com/cite
