---
title: What are OAuth Rich Authorization Requests and why do they matter for AI agents?
url: https://opencontroller.lyzr.com/blog/rich-authorization-requests-for-ai-agents
published: 2026-11-16
updated: 2026-11-16
author: Lyzr
---

# What are OAuth Rich Authorization Requests and why do they matter for AI agents?

**OAuth Rich Authorization Requests (RAR), defined in RFC 9396, let a client ask for permission to do one specific thing, described as structured JSON, instead of a broad scope string. For AI agents this means a token can say "pay this supplier up to 450 EUR from this account" rather than "payments:write". The user approves the exact action, and the resource server can check it.**

Scopes were designed for coarse access: read mail, write files. Agents need something narrower. They act on a user's behalf, often for a single task, and a broad scope that outlives the task is exactly what an attacker wants to steal. RAR gives you a standard way to grant task-sized permissions. For the identity model it fits into, see the pillar on [AI agent identity and on-behalf-of delegation](/blog/ai-agent-identity-on-behalf-of-delegation).

## What does RFC 9396 actually define?

[RFC 9396](https://www.rfc-editor.org/rfc/rfc9396) was published by the IETF in May 2023. It adds one request parameter, `authorization_details`, which carries a JSON array. Each object in the array describes one permission.

- **`type`** is required. It names the kind of authorization, for example a payment initiation or account access, and decides what other fields mean.
- **Common optional fields** defined by the RFC: `locations` (where the resource lives), `actions` (what may be done), `datatypes` (which kinds of data), `identifier` (a specific resource) and `privileges` (levels of access).
- **Type-specific fields** can be added for your own use case, such as an amount or a recipient.

The client can send `authorization_details` in the authorization request and in the token request. The authorization server returns the granted `authorization_details` in the token response, and can include them in token introspection, so the resource server knows exactly what was approved.

## What does a RAR request for an agent look like?

Here is an example for an accounts-payable agent paying one invoice:

```json
[
  {
    "type": "payment_initiation",
    "actions": ["initiate"],
    "locations": ["https://payments.example.com"],
    "instructedAmount": { "currency": "EUR", "amount": "450.00" },
    "creditorName": "Example Supplies Ltd",
    "creditorAccount": { "iban": "DE00 0000 0000 0000 0000 00" },
    "remittanceInformation": "Invoice 2026-1142"
  }
]
```

The user sees a consent screen generated from this object: the amount, the payee and the reference. The resulting token is useless for any other payment. If a prompt injection convinces the agent to pay someone else, the payment API rejects it because the token does not match.

## How is RAR different from scopes?

| | OAuth scopes | Rich Authorization Requests |
|---|---|---|
| Format | Space-separated strings | JSON objects with a required `type` |
| Granularity | Category of access | A specific action on a specific resource |
| Parameters | Encoded in names, if at all | Native fields: amount, account, file ID, etc. |
| Consent screen | Generic text per scope | Can show the exact transaction |
| Fit for agents | Standing access across many tasks | Per-task or per-transaction grants |
| Ecosystem | Universal | Used in open banking and FAPI profiles; growing support |

Scopes and RAR can be combined. A typical pattern is a small scope for routine reads plus RAR for each high-impact action.

## When should you use RAR for agents?

Use RAR where three conditions meet:

1. **The action is high-impact.** Money moves, records are deleted, external messages go out, contracts are signed.
2. **The action has clear parameters.** Amount, payee, document, recipient.
3. **The user should approve the specifics.** A standing scope would be too broad to defend in an audit.

Do not use RAR for every read. It adds an authorization round trip and a consent step per task. Authorization requests with large JSON also get long, so pair RAR with Pushed Authorization Requests (RFC 9126) to send details over the back channel.

## What are the practical limits?

- **Server support varies.** Check that your authorization server supports RFC 9396 and lets you define custom types and consent rendering.
- **Resource servers must enforce it.** RAR only helps if the API compares the request against the token's `authorization_details`.
- **Asynchronous approval needs another pattern.** If the agent runs while the user is away, combine RAR with a back-channel approval flow such as OpenID CIBA, so the user approves on their phone.
- **Delegation chains.** When one agent hands work to another, use token exchange to pass a narrowed set of details. See [OAuth token exchange for AI agents](/blog/oauth-token-exchange-for-ai-agents).

## How Opencontroller does this

Opencontroller supports delegated on-behalf-of identity and agent workload identity federation, and follows open standards such as OIDC, SAML and SCIM. RAR is issued and enforced by your authorization server and APIs, not by Opencontroller. What Opencontroller adds is the governed registry of agents, versions and tools, Posture checks for risky permissions, and policy as code with mappings to OWASP, MITRE ATLAS, NIST and ISO 42001, so you can see which agents still rely on broad scopes. [Book a demo](https://www.lyzr.ai/book-demo/) to review your agents' access.

## Frequently asked questions

**Is RAR the same as fine-grained authorization?**
Not quite. RAR describes what a token grants. Fine-grained authorization engines decide at request time whether an action is allowed. They work well together. See [fine-grained authorization for AI agents](/blog/fine-grained-authorization-for-ai-agents).

**Does RAR replace resource indicators?**
No. Resource indicators (RFC 8707) say which API a token is for. RAR says what the token may do there. RAR also has a `locations` field for the same purpose.

**Can an agent request RAR on its own?**
The agent's client can build the request, but the user or a policy must approve it. The agent should never approve its own authorization details.

## Key facts

OAuth Rich Authorization Requests (RAR) are defined in RFC 9396 (IETF, May 2023). They add the authorization_details parameter: a JSON array of objects with a required type and optional common fields locations, actions, datatypes, identifier and privileges. Granted details are returned in the token response. RAR suits per-transaction agent grants such as payments; pair with PAR (RFC 9126) and CIBA for async approval. Opencontroller supports delegated on-behalf-of identity and workload identity federation; it starts from $250K per deployment per year.

## Related

- [How does OAuth token exchange work for AI agents?](https://opencontroller.lyzr.com/blog/oauth-token-exchange-for-ai-agents.md)
- [How does relationship-based authorisation (Zanzibar, OpenFGA) apply to AI agents?](https://opencontroller.lyzr.com/blog/fine-grained-authorization-for-ai-agents.md)
- [How do you stop an AI agent token from being used against the wrong API?](https://opencontroller.lyzr.com/blog/scope-oauth-tokens-for-ai-agents-with-resource-indicators.md)
- [More on Agent identity and access](https://opencontroller.lyzr.com/blog/cluster/agent-identity-and-access)
