| Internet-Draft | Transactional Access Tokens | November 2026 |
| Tulshibagwale | Expires 22 May 2027 | [Page] |
OAuth 2.0 access tokens are typically scoped to a session rather than to a transaction. They carry no transaction identifier and no context beyond scope. This document defines Transactional Access Tokens: a profile of JSON Web Token (JWT) access tokens that carries a transaction identifier and authorization server-granted transaction context, has a very short lifetime, and is audienced to a single resource server. Transaction context is requested and conveyed using OAuth 2.0 Rich Authorization Requests. Transactional Access Tokens align with the claims and semantics of OAuth Transaction Tokens, so that transaction context can flow from the authorization server to a resource server and onward into that resource server's trust domain. A primary use case is task-scoped authorization of AI agents, where the authorization server makes a fresh policy decision for each transaction.¶
This note is to be removed before publishing as an RFC.¶
Status information for this document may be found at https://datatracker.ietf.org/doc/draft-tulshi-oauth-transactional-access-tokens/.¶
Discussion of this document takes place on the Web Authorization Protocol Working Group mailing list (mailto:oauth@ietf.org), which is archived at https://mailarchive.ietf.org/arch/browse/oauth/. Subscribe at https://www.ietf.org/mailman/listinfo/oauth/.¶
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 22 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.¶
OAuth 2.0 [RFC6749] access tokens represent an authorization grant
for a session. Access token lifetimes are often short, but the
authority behind them is durable: a client holding a refresh token or
client credential can obtain new access tokens without any
per-transaction decision by the authorization server (AS). Access
tokens convey what the client may do (typically via scope), but they
do not convey why, in what transaction, or under what context.¶
OAuth Transaction Tokens [TXN-TOKENS] (Txn-Tokens) address a related
problem inside a trust domain. A Txn-Token is short-lived, carries a
transaction identifier (txn) and transaction context, and is
audienced to the trust domain rather than to any single workload.
Txn-Tokens are not intended for use across trust domain boundaries,
and a resource server outside the trust domain that issued a Txn-Token
receives none of that context.¶
Transaction context therefore needs to travel over several kinds of hop, each addressed by a different specification:¶
| Hop | Specification |
|---|---|
| Inside an application, between its workloads | Transaction Tokens [TXN-TOKENS] |
| Across enterprises | Transaction Token Chaining Profile [CHAINING-PROFILE] with Identity and Authorization Chaining [ID-CHAINING] |
| From an AS or identity provider to an application (resource server) | Transactional Access Tokens (this document) |
This document defines Transactional Access Tokens (Txn-ATs). A Txn-AT is an OAuth access token, based on the JWT access token profile [RFC9068], that also carries the transaction identifier and context semantics of a Txn-Token. Unlike a Txn-Token, a Txn-AT is audienced to a single resource server. Unlike the Chaining Profile, which starts from a Txn-Token that already exists inside a trust domain, a Txn-AT starts at the AS, for a client outside the application. The two compose: an AS participating in a chained flow can itself issue a Txn-AT to the resource server it serves (Appendix B).¶
Clients request transaction context, and the AS conveys the context it
grants, using OAuth 2.0 Rich Authorization Requests (RAR) [RFC9396].
This document defines an authorization_details type that carries the
transaction context (Section 3.4). An AS that already supports RAR
reuses its existing request handling and policy to issue Txn-ATs.¶
Txn-ATs provide the following benefits:¶
Resource servers receive AS-granted transaction context, not only scope.¶
A client, such as an AI agent authorized for a specific task, can be issued a token bounded to that task, with no more durable permission than the task requires. The AS evaluates policy for every transaction and can deny any individual transaction, placing the AS in control of each authorization decision.¶
The transaction identifier and context can be carried from the resource server into its own trust domain via Txn-Tokens (Section 6).¶
In the model defined here, consent and client authority are durable, while tokens are per-transaction.¶
The following examples illustrate the flow. An AI agent holding a token for a user obtains a Txn-AT for one resource server, then a second Txn-AT for another resource server in the same transaction. The elements shown are defined in the sections that follow. Line breaks within values are for display purposes only.¶
The authorization_details parameter, decoded:¶
[
{
"type": "transaction",
"task": "summarize_invoices",
"period": "2026-Q3",
"actions": ["read"]
}
]
¶
{
"access_token": "eyJ0eXAiOiJ0eG5hdCtqd3QiLCJhbGci...",
"issued_token_type":
"urn:ietf:params:oauth:token-type:txn_access_token",
"token_type": "DPoP",
"expires_in": 60,
"txn_handle": "th_9Qm2xVb7LkP0sR4tYw8eZa"
}
¶
Header:¶
{
"typ": "txnat+jwt",
"alg": "ES256",
"kid": "as-2026-09"
}
¶
Payload:¶
{
"iss": "https://as.example.com",
"aud": "https://api.example.net",
"sub": "pw-5c1e9f0a2b",
"client_id": "agent-7f3a",
"iat": 1790560000,
"exp": 1790560060,
"jti": "0f8b6a4e-2d1c-4b7e-9a3f-6c5d4e3b2a10",
"txn": "k3JdQ9vX2mPz7LwR5tYb8A",
"authorization_details": [
{
"type": "transaction",
"task": "summarize_invoices",
"period": "2026-Q3",
"actions": ["read"],
"requester": {
"authn": "private_key_jwt",
"req_ip": "198.51.100.7"
}
}
],
"act": {
"sub": "agent-7f3a"
},
"cnf": {
"jkt": "0ZcOCORZNYy-DWpqq30jZyJGHTN0d2HglBV3uiguA4I"
}
}
¶
The AS granted the task, period, and actions fields as requested
and enriched the object with a requester field describing how the
client authenticated and from where.¶
The request omits authorization_details, so the AS carries forward
the transaction context it established for the transaction. The
resulting Txn-AT has aud set to https://billing.example.org, a
txn value that cannot be correlated with k3JdQ9vX2mPz7LwR5tYb8A,
and a transaction authorization details object that the AS has
evaluated for, and may have tailored to, the new audience.¶
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 "access token", "authorization server", "client", "refresh token", and "resource server" defined in [RFC6749], the terms "authorization details" and "authorization details type" defined in [RFC9396], and the terms "Transaction Token", "Txn-Token", "Transaction Token Service", "trust domain", and "workload" defined in [TXN-TOKENS].¶
An access token conforming to this specification.¶
A unit of work, such as an AI agent task, for which the AS makes an authorization decision and which may span requests to one or more resource servers.¶
A value generated by the AS that uniquely identifies a transaction. The ITID is known only to the AS and is never disclosed to clients or resource servers.¶
An opaque value issued by the AS to a client, which the client uses to request additional Txn-ATs for the same transaction.¶
The content of the transaction authorization details object (Section 3.4) that the AS grants in a Txn-AT, after evaluating the request against policy.¶
+--------+ (1) Token Request +---------------+ | | (resource=RS1, grant, | | | | authorization_details) | | | |------------------------------->| | | | (2) Txn-AT (aud=RS1, txn=T1) | Authorization | | | + txn_handle | Server | | |<-------------------------------| (policy on | | Client | (3) Token Request | every request)| | | (resource=RS2, txn_handle) | | | |------------------------------->| | | | (4) Txn-AT (aud=RS2, txn=T2) | | | |<-------------------------------| | | | +---------------+ | | (5) Txn-AT (aud=RS1) +-----+ (7) Txn-Token | |---------------------->| RS1 |---> (txn=T1) ---> internal | | (6) Txn-AT (aud=RS2) +-----+ workloads | |---------------------->| RS2 | +--------+ +-----+
The client requests a Txn-AT for resource server RS1 using a
supported grant (Section 4.1). The request describes the
transaction in an authorization_details parameter
(Section 3.4).¶
The AS evaluates the request against policy and issues a Txn-AT
audienced to RS1. The Txn-AT carries the granted, and possibly
enriched, transaction context in its authorization_details
claim, and a txn value derived for RS1. The AS also returns a
transaction handle.¶
For the same transaction, the client requests a Txn-AT for RS2 and presents the transaction handle.¶
The AS evaluates policy again and issues a Txn-AT audienced to RS2,
with a different txn value that cannot be correlated with the
value for RS1.¶
and 6. The client presents each Txn-AT to its resource server.¶
A resource server MAY exchange the Txn-AT for a Txn-Token within its own trust domain (Section 6).¶
A Txn-AT is a JWT [RFC7519] that conforms to [RFC9068], except as modified by this section.¶
Txn-ATs MUST include the typ header parameter with the value
txnat+jwt. This deviates from Section 2.1 of [RFC9068], which
requires at+jwt. The distinct type is intentional: it causes
resource servers that do not implement this specification to reject
Txn-ATs, rather than accept them as ordinary access tokens and ignore
their transactional semantics. It also prevents confusion between
Txn-ATs, ordinary JWT access tokens, and Txn-Tokens
(Section 7.1). Whether this benefit outweighs the ability to
reuse existing RAR deployments unchanged is an open question
(Appendix C).¶
The following claims are used in Txn-ATs. Claims not listed here MAY be included as permitted by [RFC9068], subject to Section 8.¶
| Claim | Requirement | Description |
|---|---|---|
iss
|
REQUIRED | As defined in [RFC9068]. |
aud
|
REQUIRED | Identifier of exactly one resource server. MUST be a single string value. |
sub
|
REQUIRED | As defined in [RFC9068]. See Section 8 regarding pairwise identifiers. |
client_id
|
REQUIRED | As defined in [RFC9068]. |
iat
|
REQUIRED | As defined in [RFC9068]. |
exp
|
REQUIRED | See Section 3.6. |
jti
|
REQUIRED | Unique per token. MUST NOT be derived from the ITID. |
txn
|
REQUIRED | Transaction identifier, as defined in Section 2.2 of [RFC8417] and generated per Section 3.3. |
authorization_details
|
REQUIRED | Granted authorization details, as defined in Section 9 of [RFC9396]. MUST contain exactly one transaction authorization details object (Section 3.4) and MAY contain objects of other types. See Section 3.5. |
scope
|
OPTIONAL | Scope granted for this transaction. |
act
|
CONDITIONAL | REQUIRED when the Txn-AT is issued via token exchange with an actor token, as defined in [RFC8693]. |
cnf
|
CONDITIONAL | REQUIRED when the Txn-AT is sender-constrained. |
Txn-ATs do not use the tctx and rctx claims defined in
[TXN-TOKENS]. The transaction context that those claims carry in a
Txn-Token is carried in a Txn-AT by the transaction authorization
details object. Section 6 describes how a Transaction
Token Service maps one to the other.¶
When the AS begins a new transaction, it MUST generate an ITID with at least 128 bits of entropy.¶
The txn value in each Txn-AT MUST satisfy the following requirements:¶
It MUST be the same for all Txn-ATs issued for the same transaction and the same audience.¶
It MUST be different for different audiences in the same transaction.¶
It MUST NOT allow any party other than the AS to determine whether
two txn values with different audiences belong to the same
transaction.¶
It MUST NOT disclose the ITID.¶
Any method satisfying the requirements above is acceptable, such as a random value per audience with a mapping table stored at the AS. For one possible construction using keyed derivation, see Section 7.7.¶
This document defines an authorization details type, as specified in
Section 2 of [RFC9396], that describes a transaction. The type
field of a transaction authorization details object has the value
transaction.¶
Note: the type identifier and the set of fields defined below are provisional. See Appendix C.¶
In addition to type, a transaction authorization details object MAY
contain the following fields:¶
the common data fields locations, actions, datatypes,
identifier, and privileges, with the semantics defined in
Section 2.2 of [RFC9396]. If locations is present in a Txn-AT,
every value MUST identify the resource server named by aud;¶
requester: a JSON object containing context about the requesting
client and the circumstances of the request, as observed by the
AS, for example the client authentication method used. Clients
MUST NOT include this field in a request; the AS adds it by
enrichment (Section 3.5). The AS SHOULD use the member names
defined for the rctx claim in [TXN-TOKENS] where they apply;
and¶
any other field defined by the deployment or by a profile of this document, such as a task name, a purpose, a time period, or evidence that a human approved the transaction.¶
The fields of a transaction authorization details object other than
type are determined by the AS. The resource server MUST NOT treat
the presence of a field as evidence of anything other than that the
AS granted it.¶
An AS that supports Txn-ATs MUST list transaction in the
authorization_details_types_supported metadata parameter
(Section 10 of [RFC9396]).¶
Clients describe the transaction they intend to perform by including a
transaction authorization details object in the authorization_details
request parameter (Section 4.3). The AS evaluates the
requested object against policy, as it would any authorization details
request, and conveys the result in the authorization_details claim of
the Txn-AT.¶
The AS MAY grant less than was requested, as described in Section 7 of [RFC9396]. The AS MAY also enrich the granted object with information the client did not supply, as described in Section 7.1 of [RFC9396]. Enrichment is how the AS asserts context that only it can know or has verified, such as:¶
the authenticated subject's properties, such as authentication time, method, and assurance level;¶
the client's registration metadata and authentication method, and
any client or workload attestation, conveyed in the requester
field;¶
claims in a subject token or actor token, in token exchange flows;¶
properties of the request environment that the AS observes, such as the source network address; and¶
the results of policy evaluation, such as limits that policy placed on the transaction.¶
The AS MUST NOT include a client-supplied field in the granted object without first evaluating it against policy. Fields the AS does not understand or cannot evaluate MUST be omitted or the request rejected.¶
A transaction authorization details object in a Txn-AT therefore represents, in a single structure, both what the client was granted and what the AS asserts about the transaction. The resource server relies on it being granted by the AS (Section 7.6).¶
The AS SHOULD include in the granted object only the context that the audience resource server needs (Section 8). Where a transaction spans several resource servers, the AS MAY grant a different transaction authorization details object to each.¶
Txn-ATs are intended to be valid for about as long as a single transaction.¶
Txn-ATs MUST be issued only at the token endpoint, using one of the following grants:¶
the client credentials grant (Section 4.4 of [RFC6749]).¶
The AS MUST NOT issue Txn-ATs directly from the authorization code grant. Requiring user interaction such as consent or credential entry for every transaction is unrealistic and would disrupt the user experience. Instead, the authorization code grant MAY be used once to obtain user consent and a refresh token, which the client then uses to request Txn-ATs without further user involvement. The consent obtained in that step bounds the transactions the client can later request (Section 7.4).¶
The token exchange grant is used when the client holds a source token, for example a token representing the user as the subject and the client (such as an AI agent) as the actor.¶
To request a Txn-AT, the client includes the requested_token_type
parameter with the value
urn:ietf:params:oauth:token-type:txn_access_token.¶
With the token exchange grant, this parameter is used as defined in [RFC8693].¶
This document also permits this parameter with the refresh token and client credentials grants, where it has the same meaning.¶
If the client's registration metadata includes
transactional_access_tokens_required with the value true
(Section 10.6), the AS MUST issue only Txn-ATs to that client,
whether or not requested_token_type is present.¶
The following parameters apply to Txn-AT requests:¶
REQUIRED. Exactly one resource indicator, as defined in [RFC8707],
identifying the resource server the Txn-AT is for. If the request
contains zero or more than one resource value, the AS MUST reject
it with the invalid_target error. In token exchange requests, the
client SHOULD NOT use the audience parameter. If it does use it,
the resulting audience MUST resolve to a single resource server.¶
As defined in Section 6 of [RFC9396]. REQUIRED when the request
begins a new transaction, in which case it MUST contain exactly one
transaction authorization details object (Section 3.4) and MAY
contain objects of other types. OPTIONAL when the request includes
a txn_handle; if absent, the AS uses the transaction context
established when the transaction began, adjusted for the new
audience (Section 3.5). If present, the transaction object MUST be
consistent with the existing transaction, as determined by the AS.¶
OPTIONAL. A transaction handle previously issued to this client (Section 4.5). If present, the request is for an additional Txn-AT in the existing transaction. If absent, the AS begins a new transaction.¶
The AS MAY accept additional parameters as inputs to policy. The AS MUST NOT copy their values into the granted transaction object without evaluation (Section 3.5).¶
Malformed or unsupported authorization details are rejected as
specified in [RFC9396], with the invalid_authorization_details
error. A request that is well formed but denied by policy is rejected
with transaction_denied (Section 4.7).¶
The AS MUST evaluate policy for every Txn-AT request. The AS MAY deny a request even when the presented grant, credential, refresh token, or transaction handle is valid.¶
When the request includes a transaction handle, the AS MAY enforce transaction-level policy, for example:¶
limiting the set of resource servers the transaction may access;¶
limiting the number of Txn-ATs issued for the transaction;¶
limiting the transaction's total duration; or¶
rejecting a transaction object that is inconsistent with the transaction as it began.¶
If the AS denies a request on policy grounds, it MUST return the
transaction_denied error (Section 4.7).¶
When the AS begins a new transaction, it MUST include a transaction handle in the token response (Section 4.6). The transaction handle:¶
MUST be opaque to the client and MUST contain at least 128 bits of entropy;¶
MUST be bound to the client to which it was issued. The AS MUST reject a handle presented by a different client;¶
MUST be bound to the transaction's subject. In token exchange requests, the AS MUST reject a handle if the subject of the presented subject token differs from the transaction's subject;¶
SHOULD be bound to the same key as the Txn-ATs, when Txn-ATs are sender-constrained;¶
MUST have an expiry set by the AS; and¶
MUST NOT be included in any Txn-AT or otherwise disclosed to resource servers.¶
If the handle is unknown, expired, or fails any of the binding checks
above, the AS MUST return the invalid_txn_handle error.¶
A successful response follows Section 5.1 of [RFC6749] and, for token exchange, Section 2.2 of [RFC8693], with these additions:¶
The issued_token_type parameter, if present, MUST be
urn:ietf:params:oauth:token-type:txn_access_token.¶
The txn_handle parameter MUST be present when a new transaction
was started. It MAY be present in responses for an existing
transaction.¶
The AS SHOULD include the authorization_details response
parameter, as described in Section 7 of [RFC9396], whenever the
granted transaction object differs from the one requested.¶
In token exchange responses, the AS MUST NOT include a refresh token.¶
In refresh token grant responses, the AS MAY rotate the refresh token as described in [RFC9700].¶
A resource server that accepts Txn-ATs MUST validate them as specified in Section 4 of [RFC9068], with the following modifications:¶
The resource server MUST verify that the typ header is
txnat+jwt.¶
The resource server MUST verify that aud is a single value that
identifies itself.¶
The resource server MUST verify that txn is present.¶
The resource server MUST verify that authorization_details is
present and contains exactly one transaction authorization details
object (Section 3.4).¶
If the Txn-AT contains a cnf claim, the resource server MUST verify
proof of possession, for example as specified in [RFC9449] or
[RFC8705].¶
The resource server MUST NOT accept a Txn-Token (typ value
txntoken+jwt) as a Txn-AT.¶
A resource server SHOULD use the transaction authorization details
object in its own authorization decisions, as it would any granted
authorization details (Section 9 of [RFC9396]), and SHOULD record
txn in audit logs.¶
A resource server that requires Txn-ATs for a resource MUST reject
ordinary access tokens (typ value at+jwt) for that resource.¶
A resource server may call workloads within its own trust domain. In that case, it SHOULD obtain a Txn-Token from its Transaction Token Service (TTS), rather than forwarding the Txn-AT, as follows:¶
The resource server presents the Txn-AT as the subject_token, with a
subject_token_type of
urn:ietf:params:oauth:token-type:txn_access_token.¶
The TTS MUST validate the Txn-AT as specified in Section 5,
including verifying that aud identifies the resource server
presenting it.¶
The TTS SHOULD set the Txn-Token's txn to the txn value from the
Txn-AT. This preserves correlation within the resource server's trust
domain without enabling correlation with other resource servers.¶
The TTS SHOULD derive the Txn-Token's tctx claim from the
transaction authorization details object in the Txn-AT, and MAY
derive members of the Txn-Token's rctx claim from that object's
requester field, in each case subject to the TTS's own policy.
The TTS MAY also use the request_context and request_details
parameters of the Txn-Token request (Section 11.1 of [TXN-TOKENS]) as it normally would.¶
Workloads MUST NOT accept a Txn-AT in place of a Txn-Token.¶
When the Txn-AT is sender-constrained (Section 7.2), the resource
server verified the client's proof of possession before accepting it.
That verification does not travel with the token. The resource server
authenticates itself to the TTS (Section 11.5 of [TXN-TOKENS]), but
that authentication proves only who is presenting the Txn-AT, not that
the client proved possession of the key in cnf.¶
To let the TTS verify the client's presentation itself, the resource server includes evidence of the original presentation in the Txn-Token request. For a DPoP-bound Txn-AT, the evidence is the DPoP proof JWT the client sent. The TTS then:¶
verifies the proof's signature using the public key bound in the
Txn-AT's cnf claim;¶
verifies that the proof's ath claim matches the presented Txn-AT;
and¶
verifies that the proof's htu and htm claims name an endpoint
of the resource server identified by the Txn-AT's aud claim.¶
The TTS MUST NOT rely on the resource server's own report of having
verified the proof. For mutual-TLS-bound Txn-ATs ([RFC8705]), the
TLS handshake cannot be re-verified by a third party; the resource
server's assertion that the client certificate matched the cnf claim
MAY be recorded in the TTS's audit record, but it is a reported
assertion, not verified evidence.¶
This document does not yet define the Txn-Token request parameter that carries the presentation evidence (Appendix C).¶
The security considerations of [RFC6749], [RFC8693], [RFC9068], [RFC9396], [RFC9700], and [TXN-TOKENS] apply.¶
Txn-ATs share claims with both JWT access tokens and Txn-Tokens, which
creates a risk of token confusion. The distinct typ value and a
single-valued aud claim mitigate this risk:¶
resource servers reject Txn-Tokens, whose aud identifies a trust
domain and whose typ is txntoken+jwt;¶
workloads reject Txn-ATs, whose typ is txnat+jwt; and¶
resource servers that do not implement this specification reject
Txn-ATs because of their typ value.¶
Implementations MUST validate both typ and aud.¶
A bearer Txn-AT can be replayed within its lifetime. This document accepts that risk in exchange for keeping resource servers stateless, and bounds it with a short lifetime (Section 3.6).¶
Txn-ATs SHOULD be sender-constrained using DPoP [RFC9449] or mutual TLS
[RFC8705]. Sender-constraining is especially important for AI
agents, where tokens may be exfiltrated through prompt injection or
tool misuse. Resource servers that need single-use semantics can track
jti values, but this document does not require it.¶
The refresh tokens and client credentials used to obtain Txn-ATs remain durable. The security benefit of Txn-ATs depends on the AS evaluating policy for every request and being able to deny individual transactions. An attacker who obtains such a credential can request Txn-ATs, but remains subject to per-transaction policy. Refresh tokens used to obtain Txn-ATs SHOULD be sender-constrained or rotated as described in [RFC9700].¶
When a user consents once (Section 4.1) and a client then performs long-running or recurring activity on the user's behalf, the consent can outlive the user's awareness of what the client is doing. Txn-ATs do not remove this risk; they make each transaction visible to the AS and subject to its policy. An AS SHOULD use that visibility: for example, by bounding the transactions a given consent authorizes in scope, resource servers, rate, or elapsed time; by requiring the transaction object to name a purpose that policy can compare with the consent; and by giving users a view of the transactions performed under their consent and a way to withdraw it.¶
A stolen transaction handle alone does not allow an attacker to obtain Txn-ATs, because the handle is bound to the client, and to the subject and sender-constraining key where applicable (Section 4.5).¶
Resource servers rely on the transaction authorization details object
having been granted by the AS. A client can propose transaction
context, but the AS decides what is granted and never includes
unevaluated client input (Section 3.5). A client therefore cannot
inject context into a Txn-AT. An AS that fails to follow this rule
would turn Txn-ATs into signed but unverified assertions. Enriched
fields such as requester are especially sensitive, because resource
servers may treat them as facts observed by the AS.¶
One way to generate txn values satisfying the requirements in
Section 3.3 is keyed derivation:¶
txn = BASE64URL(HMAC-SHA-256(K_txn, ITID || UTF8(aud)))¶
where:¶
K_txn is a secret key of at least 256 bits, known only to the AS
and used only for this purpose;¶
ITID is the internal transaction identifier, which MUST be of
fixed length for a given K_txn;¶
aud is the value of the Txn-AT's aud claim;¶
|| denotes concatenation;¶
BASE64URL is base64url encoding without padding.¶
The output MAY be truncated to no fewer than 128 bits.¶
Keyed derivation lets the AS recompute the txn value for any
transaction and audience without storing a mapping. The AS can
therefore correlate a transaction across resource servers for audit,
while no other party can. An AS that rotates K_txn needs to retain
retired keys, or record which key each transaction used, for as long
as it requires this audit capability.¶
Disclosure of K_txn allows the holder, together with knowledge of
ITIDs, to correlate txn values across resource servers. It does not
allow forging Txn-ATs. Because ITIDs are never disclosed outside the AS,
correlating txn values additionally requires access to AS internal
state. The AS SHOULD protect K_txn with the same rigor as its token
signing keys.¶
Short lifetimes increase sensitivity to clock skew. Resource servers
SHOULD allow no more than a small leeway, such as 30 seconds, when
validating exp and iat.¶
Per-audience txn values (Section 3.3) prevent resource
servers from using txn to correlate a transaction across resource
servers. Only the AS can link a transaction across resource servers.
Cross-resource-server forensic analysis therefore requires the AS's
cooperation. This is an intentional trade-off.¶
Other claims can still enable correlation, even when txn values
differ:¶
sub: The AS SHOULD use pairwise subject identifiers per resource
server, similar to the pairwise identifiers defined in [OIDC].¶
client_id: This claim is the same across resource servers.
Correlation of the client's activity is therefore inherent.¶
jti: This claim MUST NOT be derived from the ITID or from txn.¶
authorization_details: The AS SHOULD include only the context the
audience resource server needs, and SHOULD avoid stable identifiers
that would enable correlation. A task name or identifier that is
the same in every Txn-AT of a transaction is itself a correlator;
the AS SHOULD vary or omit such values when granting objects to
different resource servers.¶
Timing: Tokens for the same transaction are issued close together in time. Resource servers that collude may be able to correlate transactions by timing. This residual risk is not addressed by this document.¶
The AS observes every transaction. AS operators SHOULD apply retention limits and access controls to transaction records.¶
Issuing a token for every transaction places the AS on the critical path of each transaction:¶
Token issuance latency adds directly to transaction latency.¶
AS availability becomes critical to the resource servers that require Txn-ATs.¶
Issuance volume scales with the number of transactions rather than the number of sessions.¶
Deployments should plan for:¶
IANA is requested to register the following media type [RFC6838] in the "Media Types" registry:¶
Type name: application¶
Subtype name: txnat+jwt¶
Required parameters: N/A¶
Optional parameters: N/A¶
Encoding considerations: binary. A Txn-AT is a JWT; JWT values are encoded as a series of base64url-encoded values (some of which may be the empty string) separated by period ('.') characters.¶
Security considerations: See the Security Considerations section of RFC XXXX.¶
Interoperability considerations: N/A¶
Published specification: RFC XXXX¶
Applications that use this media type: Applications that issue or consume Transactional Access Tokens.¶
Fragment identifier considerations: N/A¶
Additional information: N/A¶
Person & email address to contact for further information: IETF OAuth WG, oauth@ietf.org¶
Intended usage: COMMON¶
Restrictions on usage: none¶
Author: IETF OAuth WG¶
Change controller: IETF¶
IANA is requested to register the following value in the "OAuth URI" registry established by [RFC6749]:¶
IANA is requested to register the following parameter in the "OAuth Parameters" registry established by [RFC6749]:¶
IANA is requested to register the following values in the "OAuth Extensions Error Registry" established by [RFC6749]:¶
Name: invalid_txn_handle¶
Usage Location: token error response¶
Protocol Extension: Transactional Access Tokens¶
Change controller: IETF¶
Specification document(s): RFC XXXX¶
Name: transaction_denied¶
Usage Location: token error response¶
Protocol Extension: Transactional Access Tokens¶
Change controller: IETF¶
Specification document(s): RFC XXXX¶
IANA is requested to register the following value in the "OAuth Dynamic Client Registration Metadata" registry established by [RFC7591]:¶
[RFC9396] does not establish a registry for authorization details
types, and Section 10 of [RFC9396] places type registration out of
scope. This document therefore defines the transaction type
(Section 3.4) without an IANA action. Whether the identifier
should instead be a collision-resistant name, as recommended by
Section 2.1 of [RFC9396], for example a URN registered in the
"OAuth URI" registry, is an open issue (Appendix C).¶
OAuth Identity and Authorization Chaining Across Domains [ID-CHAINING] lets a client in trust domain A obtain, from its own AS (AS-A), an authorization grant that it then presents to the AS of trust domain B (AS-B) to obtain an access token for a resource server in domain B. The Transaction Token Chaining Profile [CHAINING-PROFILE] profiles that flow for the case where the starting credential is a Txn-Token that already exists inside domain A, so that the transaction context established in domain A can cross into domain B.¶
Txn-ATs address a different hop. A Txn-AT starts at an AS, for a client that is outside the application it is calling, and establishes the transaction context at that AS. Neither specification requires the other, and they compose:¶
In a chained flow, AS-B receives an authorization grant that carries
transaction context from domain A. AS-B can evaluate that context
against its own policy and issue a Txn-AT to the resource server in
domain B, with the granted transaction object in
authorization_details and a txn value for that resource server.
The resource server then proceeds as in Section 6.¶
Conversely, a resource server that received a Txn-AT, and whose workloads need to call a partner enterprise, can use the Txn-Token it obtained in Section 6 as the starting point for the Chaining Profile.¶
Both specifications use RAR to carry authorization context between authorization servers. Using RAR to carry the transaction context in Txn-ATs (Section 3.4) lets an AS treat a transaction object the same way whether it arrives directly from a client or inside a chained authorization grant.¶
Definition of the transaction authorization details type
(Section 3.4): the type identifier (transaction is a
placeholder; Section 2.1 of [RFC9396] recommends
collision-resistant names), the set of fields to standardize, and
whether a common vocabulary for AI agent tasks should be defined or
left to deployments.¶
Should Txn-ATs keep the distinct typ value txnat+jwt, or be
ordinary at+jwt tokens profiled by the presence of the
transaction authorization details type and the txn claim? The
distinct type fails closed at resource servers that do not
implement this specification; the plain type lets existing RAR
deployments issue and consume Txn-ATs with fewer changes.¶
How should a resource server convey the client's proof of possession to its TTS (Section 6.1)? A Txn-Token request parameter carrying the DPoP proof is one option.¶
Should the AS return the transaction handle's expiry, for example
in a txn_handle_expires_in parameter?¶
Should a resource server error code be defined, for use in the
WWW-Authenticate response header, that signals a Txn-AT is required?¶
Should the AS be able to end a transaction explicitly before its handle expires, for example through a revocation-style endpoint for handles?¶
How should this draft align with the WIMSE WG and with AI agent authorization work?¶
Name: "Transactional Access Tokens" is close to "Transaction Tokens". Should an alternative, such as "Transaction-Scoped Access Tokens", be considered?¶
The authors thank the authors of [TXN-TOKENS], whose work this document builds on, and Jeff Lombardo, Girish Konda, Wes Jackson, and Ashay Raut for their feedback on earlier versions of this document.¶
-01¶
Aligned transaction context with Rich Authorization Requests
[RFC9396]. Clients now request transaction context with an
ordinary authorization_details parameter, using a new
transaction authorization details type, and the Txn-AT carries the
granted and possibly enriched object in its authorization_details
claim. Removed the tctx and rctx claims and the Txn-Token
request context parameters from the token request. This also
resolves the question of why both request context and
authorization_details were supported.¶
Rewrote the Transaction Context section to describe the AS's evaluation and enrichment of the requested object, replacing the earlier framing of RAR as copying the request into the token.¶
Added a positioning table to the Introduction and an appendix on the relationship to Identity Chaining and the Transaction Token Chaining Profile.¶
Added a section on exchanging sender-constrained Txn-ATs for Txn-Tokens, in which the TTS verifies the client's presentation itself.¶
Added a Durable Consent security consideration.¶
Updated the Txn-Token interoperability section so that the TTS maps
the transaction authorization details object into tctx.¶
Updated the comparison table, examples, and IANA Considerations.¶
Updated the open issues: replaced the tctx vocabulary question
with the definition of the transaction authorization details type,
and added the typ and presentation-evidence questions.¶
-00¶
Initial version.¶