| Internet-Draft | RAR Payment Mandates | November 2026 |
| Craig | Expires 21 May 2027 | [Page] |
Software agents, including those driven by large language models, increasingly initiate payments on behalf of people. OAuth 2.0 Rich Authorization Requests (RFC 9396) can carry what such an agent may do, but there is no common way to express the limits that banks and their customers need, to tell an agent why a payment needs the customer's approval, or to keep an independent record of what was decided.¶
This document defines two authorization details types for payment mandates (a standing mandate with named payees, per-payment and per-period limits and an approval mode, and a single approved payment); an ordered set of machine-readable reasons a payment falls outside a mandate; how those reasons are carried in an approval challenge, including the OAuth Transaction Authorization Challenge; and a signed, hash-chained receipt for every decision, with personal data kept outside the chain so it can be erased.¶
This note is to be removed before publishing as an RFC.¶
Discussion of this document takes place on the Web Authorization Protocol Working Group mailing list (oauth@ietf.org).¶
An open-source implementation (Apache-2.0) is described in Appendix B.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 21 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
A customer who lets an agent pay bills wants to say, in terms they understand: whom it may pay, how much at a time, how often, how much in a month, and when it must ask first. The bank holding the account needs the same statement in a form it can enforce on every request, outside the agent and outside any language model, and needs evidence afterwards of what was asked, what the rules said and what it did.¶
Rich Authorization Requests [RFC9396] provide the container: an authorization_details object whose type determines its contents. This document defines the contents for payment mandates, so that one agent integration works with every account-servicing institution that implements it, and so that institutions describe the same limits in the same way.¶
The OAuth Transaction Authorization Challenge [I-D.rosomakho-oauth-txn-challenge] defines how a protected resource challenges a client for approval of one specific transaction, and how a short-lived token for that transaction is issued once the approval is given. This document is designed to work with it. It adds three things the challenge leaves to each deployment:¶
Use case analysis in the working group [I-D.chen-oauth-agent-authz-use-cases] identifies verifiable evidence created when an action is taken as a gap; Section 6 is a concrete proposal for payments.¶
This document covers payments from an account held by the customer at the institution that operates the authorization server and the resource. It does not define how an agent is identified or attested, how the customer is authenticated, or how payments are executed, cleared or settled. Read-only access to account information is out of scope; existing open banking types serve it.¶
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.¶
This document uses the terms "authorization server", "client", "resource server" and "access token" from [RFC6749], and "authorization details" from [RFC9396].¶
payment_mandate the customer approved, as stored by the institution.¶
Customer Agent Institution (AS, RS, receipts)
| | 1. authorization request with |
| | payment_mandate, intent |
|<-------------+------------------------------------------>|
| 2. consent screen: payees, limits, approval mode |
|--------------------------------------------------------->|
| | 3. access token (sender-constrained) |
| |<-----------------------------------------|
| | 4. payment request |
| |----------------------------------------->|
| | 5. evaluate mandate (Section 4) |
| | covered: execute, receipt |
| | not covered: hold, receipt |
| | 6. approval challenge with reason |
| |<-----------------------------------------|
| 7. approve this exact payment (out of band) |
|--------------------------------------------------------->|
| | 8. single_payment token, same payment |
| |----------------------------------------->|
| | 9. result; receipt names the approval |
| |<-----------------------------------------|
The customer approves a standing mandate once (steps 1 to 3). Each payment is evaluated against it by the institution (step 5). A payment inside the mandate proceeds. A payment outside it is held, and the agent is told the reason and offered a single payment for the customer to approve (steps 6 to 8). Every decision produces a receipt (Section 6).¶
An authorization details object of type payment_mandate grants the agent permission to initiate payments to named payees within limits. It has the following members, in addition to type:¶
pay_existing_beneficiary. Other values are reserved for future extensions; an institution MUST refuse a mandate containing an action it does not support.¶
every_payment (the customer approves each payment) or within_limits (payments inside the mandate proceed without approval).¶
REQUIRED. An object with the following members. Amounts are objects with members amount (a decimal string with at most the number of fractional digits of the currency) and currency (an ISO 4217 alphabetic code). All amounts in one mandate MUST use the same currency.¶
per_period.amount.¶
amount and currency (the most that may be paid in one period), count (an integer, the most payments in one period) and period (one of day, week, month). Periods are calendar periods in the time zone the institution publishes as payment_mandate_time_zone in its authorization server metadata [RFC8414].¶
within_limits, payments above this amount need the customer's approval.¶
An agent MAY send a payment_mandate in its authorization request with any members omitted or proposed. The values that apply are those the customer chooses during consent. The authorization server MUST return, and store, the authorization details as granted, which MAY be narrower than requested and MUST NOT be broader than what the customer chose (Section 7 of [RFC9396]).¶
An authorization details object of type single_payment permits exactly one payment. It is offered by the institution when a payment falls outside a mandate (Section 5); an agent MUST NOT construct one itself, and an institution MUST refuse an approval request for a single_payment it did not offer. Members:¶
name and account of the payee.¶
The institution computes a digest over the JCS canonical form [RFC8785] of these members. An approval, and any token issued from it, is bound to that digest and to the held payment it was offered for. A payment whose digest differs MUST be refused.¶
The intent member records the purpose the customer confirmed. The agent MAY propose it; the consent screen MUST show it and SHOULD let the customer change it. It is informative: it does not widen or narrow what the mandate permits, and an institution MUST NOT base an authorization decision on it. It is recorded on receipts (Section 6) as personal data (Section 6.3).¶
The resource server evaluates every payment request against the stored mandate after it has validated the access token, its sender constraint (for example DPoP [RFC9449]), and that the grant is active. Evaluation and, if the payment proceeds or is held, recording the held payment MUST be performed as one atomic operation per mandate, so that two concurrent payments cannot both be found within a limit that only one fits.¶
For the period containing the request, the amount used and the count of payments used each include payments the institution has completed, payments it holds while its payment system has not confirmed or declined them, and payments the customer approved under a single_payment. A held payment MUST continue to count until the payment system confirms or declines it, or the institution has cancelled it and the payment system has confirmed the cancellation. It MUST NOT be released on a timer.¶
The resource server applies the following rules in order. The first rule the payment breaks determines the reason. If it breaks none, the payment is covered by the mandate.¶
| Order | Reason | The payment... |
|---|---|---|
| 1 |
new_recipient
|
is to an account that is not a saved payee of the customer |
| 2 |
payee_not_on_mandate
|
is to a saved payee that is not in payees
|
| 3 |
over_per_payment
|
is above limits.per_payment
|
| 4 |
over_period_count
|
would exceed limits.per_period.count
|
| 5 |
over_period_limit
|
would take the amount used above limits.per_period.amount
|
| 6 |
every_payment
|
is under a mandate whose approval is every_payment
|
| 7 |
over_approval_threshold
|
is above limits.approve_above
|
Reasons 1 to 5 are limits of the mandate; reasons 6 and 7 are the customer's choice to be asked. A payment from an account not in accounts, an expired mandate, or an action not granted is not a reason: it is refused with insufficient_authorization or the applicable error, and no approval is offered.¶
The fixed order means an agent receives the same reason from every institution for the same situation, and a customer is told the most fundamental problem first.¶
A covered payment proceeds. For a payment with a reason, the institution either:¶
An institution MAY refuse rather than offer approval for reasons 1 to 5, for example where the client's tier of assurance is low. It MUST offer approval, not refuse, for reasons 6 and 7. An approval MUST NOT add a payee, raise a limit or change the mandate. An approval given for reason 5 permits the period's limit to be exceeded by that one payment only.¶
A resource server that implements [I-D.rosomakho-oauth-txn-challenge] responds with a transaction authorization challenge whose authorization_details contains the single single_payment it offers, and adds the claim:¶
The challenge's reason claim SHOULD state the same reason in words the customer can understand, built by the institution from the payment itself and never from text supplied by the agent alone. The challenge's txn identifies the held payment.¶
Otherwise, the resource server responds with HTTP status 403 and a JSON [RFC8259] body with these members:¶
approval_required.¶
single_payment offered.¶
The agent requests the customer's approval for exactly that single_payment, for example with Client-Initiated Backchannel Authentication [CIBA], and repeats the payment with the resulting token and the same idempotency key.¶
single_payment. Any text from the agent MUST be shown separately and labelled as the agent's words.¶
The institution records every decision on a payment request, whether covered, held, refused, approved, completed, declined, cancelled or of unknown outcome, as a receipt. Receipts are kept by the institution, not by the agent; the agent is never its own witness.¶
A receipt is a JSON object with these members. Members marked personal are carried as commitments (Section 6.3).¶
| Member | Presence | Meaning |
|---|---|---|
seq
|
REQUIRED | Position in the chain, from 1 |
prev
|
REQUIRED | The hash of the previous receipt in the chain, or the genesis value |
time
|
REQUIRED | RFC 3339 date-time with offset |
grant_id
|
REQUIRED | The mandate's grant identifier |
mandate_version
|
REQUIRED | The version of the mandate evaluated |
client_id
|
REQUIRED | The agent |
action
|
REQUIRED | For example payment
|
outcome
|
REQUIRED | One of allowed, held, refused, failed, cancelled, unknown
|
basis
|
REQUIRED |
mandate (covered), approval (the customer approved), or refused
|
reason
|
When applicable | The reason from Section 4.2 |
approval_id
|
When applicable | The customer's approval |
payment_id, idempotency_key, institution_payment_id
|
When applicable | Match the receipt to the agent's request and to the institution's payment record |
policy
|
RECOMMENDED | Object with version and hash of the institution's policy in force |
intent
|
When present, personal | The mandate's intent |
agent_instruction
|
When supplied, personal | What the agent states it was asked to do, labelled as supplied by the agent. Never used to decide |
payment
|
When applicable, personal | Payee name and account, amount, currency and reference |
The hash of a receipt is the string sha256: followed by the lowercase hexadecimal SHA-256 digest of the JCS [RFC8785] serialisation of the receipt. The genesis value of prev is sha256: followed by 64 zeros. The institution signs each receipt with a JWS [RFC7515] whose payload is {"seq": ..., "hash": ...}, whose typ header is payment-receipt+jwt, and whose kid identifies a key published in the institution's JWK Set. Retired keys MUST remain published while receipts signed with them are retained.¶
An institution SHOULD keep one chain per mandate and SHOULD periodically publish each chain's head so that an operator or auditor can detect a truncated chain. Changing or deleting a receipt breaks every later link.¶
Personal members are not written into the chained receipt. For each, the receipt carries, in a member personal, a commitment: sha256: followed by the hex SHA-256 digest of the JCS serialisation of {"salt": s, "value": v}, where s is at least 128 bits from a cryptographically secure random source, unique per member per receipt. The value and salt are stored separately and MAY be erased, for example to meet a data-subject request under [GDPR] or [POPIA], without breaking the chain. A party given a value and its salt can check it against the receipt.¶
An institution SHOULD return the signed receipt, or its hash, in the response to each payment request, so the agent's operator holds a copy. For a dispute, the institution MAY disclose an evidence set: the receipts for the mandate, their signatures, the disclosed personal values with their salts, the policy documents named, and the public keys needed to verify them.¶
The security of the mandate depends on evaluation taking place at the institution, outside the agent. An agent driven by a language model can be manipulated by content it reads (indirect prompt injection); the rules in Section 4 bound what such an agent can do regardless of what it is instructed to do. For the same reason, intent and agent_instruction are never inputs to an authorization decision.¶
Access tokens and approval tokens SHOULD be sender-constrained, for example with DPoP [RFC9449], and the mandate SHOULD be bound to the agent's key when the customer approves it, so that a leaked token or grant identifier cannot be used by another client.¶
Without the atomicity required in Section 4, concurrent requests could each pass a limit only one fits under. Without counting held payments (Section 4.1), an agent could exceed a limit by sending payments faster than the payment system confirms them. Releasing a held payment on a timer would allow a payment that later completes to be paid twice against the limit.¶
A reason tells the agent which rule a payment broke. An agent could probe limits by sending payments and reading reasons. Institutions SHOULD rate-limit payment requests and approval requests, and limit the number of pending approvals per mandate, to prevent approval fatigue.¶
Receipts prove that a record was made by the institution's key and not altered afterwards. They do not by themselves prove that the customer understood what they approved, or allocate liability.¶
A mandate and its receipts describe a customer's financial relationships. The institution SHOULD use payee and account identifiers that are meaningful only within the institution, and a pairwise subject identifier per agent. The agent learns the reason a payment needs approval, which may reveal how much of a limit is used; this is inherent in telling the agent why, and the customer chose to share it with that agent.¶
Personal members of receipts are committed rather than recorded (Section 6.3) so that the institution can meet erasure and minimisation obligations while keeping a verifiable record. Salts prevent confirming a guessed value from the commitment alone.¶
This document requests registration of the following value in the "OAuth Extensions Error Registry" established by [RFC6749]:¶
This document requests registration of the following value in the "OAuth Authorization Server Metadata" registry established by [RFC8414]:¶
This document requests that IANA create a registry "Payment Mandate Reasons" with the registration policy Specification Required [RFC8126]. Each entry has a reason name, a position in the evaluation order, a description, and a reference. The initial contents are the reasons in Section 4.2. A new reason MUST state where it falls in the order.¶
This document requests registration of the media type application/payment-receipt+jwt for signed receipts as defined in Section 6.2. Template details will be completed in a later revision.¶
A mandate as granted, as it appears in authorization_details:¶
{
"type": "payment_mandate",
"actions": ["pay_existing_beneficiary"],
"accounts": ["acc_4821"],
"payees": ["ben_water", "ben_city_power"],
"approval": "within_limits",
"limits": {
"per_payment": {"amount": "1000.00", "currency": "ZAR"},
"per_period": {"amount": "2000.00", "currency": "ZAR",
"count": 4, "period": "month"},
"approve_above": {"amount": "500.00", "currency": "ZAR"}
},
"valid_until": "2027-02-15T23:59:59+02:00",
"intent": "Pay my monthly utility bills"
}
¶
A payment to a saved beneficiary that is not one of the mandate's payees, without the transaction challenge:¶
The receipt for the payment once approved and completed:¶
{
"seq": 42, "prev": "sha256:9c1e...",
"time": "2026-11-17T10:42:07+02:00",
"grant_id": "g_3fa8", "mandate_version": 1, "client_id": "kaya",
"action": "payment", "outcome": "allowed", "basis": "approval",
"reason": "payee_not_on_mandate", "approval_id": "ar_51b0",
"payment_id": "pi_8Qm2Lk", "idempotency_key": "school-term4-2026",
"institution_payment_id": "bp_Jx41",
"policy": {"version": "CHG-2026-1182", "hash": "sha256:4be0..."},
"personal": {
"payment": "sha256:...",
"intent": "sha256:...",
"agent_instruction": "sha256:..."
}
}
¶
This section is to be removed before publishing as an RFC.¶
This section records the status of known implementations of the protocol defined by this specification at the time of posting of this Internet-Draft, and is based on a proposal described in [RFC7942].¶
valet_payments, valet_payment_once) and with the approval mode values approved_payer and bill_payer. Payee details are not yet committed outside the chain (Section 6.3).¶
The approval challenge this document builds on is the work of the authors of [I-D.rosomakho-oauth-txn-challenge].¶