When one SaaS application calls another on a user's behalf, the enterprise identity provider that governs sign-in to both apps is usually blind to the connection, because the user granted it through a consent screen at the second app. The result is app-to-app access that IT cannot see, approve or revoke centrally, held as refresh tokens inside third-party applications. The Identity Assertion JWT Authorization Grant (ID-JAG), an IETF OAuth working group draft, moves that decision to the IdP: the requesting app exchanges the user's SSO assertion at the IdP for a signed grant, then redeems it at the target app's authorisation server. This guide covers the roles, the exact request and token formats, the processing rules each party must enforce, deployment choices and failure patterns. It is for IAM engineers running an enterprise IdP, SaaS teams adding support as a requesting or resource app, and architects assessing Cross App Access products.
Key takeaways
- ID-JAG is a profile of identity chaining. It applies RFC 8693 token exchange at the IdP and the RFC 7523 JWT bearer grant at the resource authorisation server, with a dedicated token type and JWT
typ. - It is still an Internet-Draft. As checked on 27 October 2026 the current version is draft-ietf-oauth-identity-assertion-authz-grant-04 (21 May 2026), a working group document not yet with the IESG. Expect changes; pin your implementation to a version.
- The IdP decides, the resource app still enforces. The IdP evaluates admin policy before issuing the grant; the resource authorisation server validates it and can grant a subset of what the IdP allowed.
- Confidential clients only. The draft limits the flow to clients that can authenticate; public clients should keep using the authorisation code flow with consent.
- No refresh tokens at the resource app. Access ends when the IdP stops issuing grants, which makes offboarding and policy changes take effect at the next token request.
What problem ID-JAG solves
Today, if a wiki needs to read a user's tickets in an issue tracker, the user clicks through an OAuth consent screen at the tracker. The tracker issues a refresh token to the wiki, often valid for months. The enterprise IdP authenticated the user to both apps but played no part in the connection. Security teams find out about these grants only through SaaS posture tools or after an incident. See the Consent Phishing and Illicit OAuth Grants Guide for how attackers exploit the same consent model.
ID-JAG changes three things:
- Policy moves to the IdP: an administrator decides which requesting apps may obtain access to which resource apps, for which users and scopes.
- No per-user consent prompt: the user already authenticated through SSO, so the connection is set up silently when policy allows it.
- No long-lived app-to-app refresh tokens: the resource app should not issue them, so revocation at the IdP is effective at the next token request.
Okta markets its implementation as Cross App Access (XAA). Okta's own documentation describes XAA as implementing ID-JAG and states that it is not intended for autonomous agents running without a user session or for machine-to-machine jobs without an end-user context. The underlying draft is vendor-neutral and has authors from Okta and Ping Identity plus an independent author.
Roles and trust relationships
| Role | What it does | Trusts |
|---|---|---|
| Client (requesting app) | Confidential app that needs an access token for another app's API on behalf of the signed-in user | Is a relying party of the IdP and a separate OAuth client of the resource authorisation server |
| IdP authorisation server | Authenticates the user for SSO, evaluates policy, issues the ID-JAG | Has SSO relationships with both apps |
| Resource authorisation server | Validates the ID-JAG, resolves the user, applies local policy, issues an access token | Trusts the IdP's signing keys and issuer |
| Resource server | Hosts the API and validates access tokens from its own authorisation server | Has no direct trust relationship with the IdP |
Note the double registration: the client has one client ID at the IdP and another at the resource authorisation server. The ID-JAG's client_id claim carries the resource-side identifier, which may differ from the IdP-side one, so the IdP must know the mapping.
The flow and its parameters
Step 1: token exchange at the IdP
The client posts to the IdP token endpoint with grant_type=urn:ietf:params:oauth:grant-type:token-exchange and:
- requested_token_type (required):
urn:ietf:params:oauth:token-type:id-jag. - audience (required): the issuer identifier of the resource authorisation server.
- resource (optional): the RFC 8707 identifier of the protected resource.
- scope and authorization_details (optional): the latter uses RFC 9396 Rich Authorization Requests. See the OAuth Rich Authorization Requests (RAR) Guide.
- subject_token (required): an OpenID Connect ID Token (
urn:ietf:params:oauth:token-type:id_token), a SAML 2.0 assertion (...:saml2) or, optionally for implementers, a refresh token (...:refresh_token). - Client authentication: standard methods, for example
client_assertionunder RFC 7523.
The IdP validates the subject token (for an ID Token, its audience must match the authenticated client), evaluates policy and may narrow scope, resource or authorisation details. The response carries issued_token_type of the ID-JAG type, the grant itself in the access_token field (the draft notes this is for historical reasons; it is not an access token), token_type of N_A and a recommended expires_in. A refresh token should not be returned.
Step 2: JWT bearer grant at the resource authorisation server
The client posts grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer with the ID-JAG as assertion, authenticating with the credentials it registered at that server. The response is a standard OAuth token response with a Bearer access token, its lifetime and the granted scope.
Inside the ID-JAG
The ID-JAG is a JWT signed by the IdP. Its header typ must be oauth-id-jag+jwt, which stops it being confused with an ID Token or access token.
| Claim | Status in draft -04 | Meaning and check |
|---|---|---|
iss | Required | IdP issuer; resource AS compares against its trusted issuer list |
sub | Required | User identifier in the IdP's namespace |
aud | Required | Resource AS issuer; exactly one value |
client_id | Required | Client ID at the resource AS; must match the authenticated client |
jti, iat, exp | Required | Unique ID and lifetime; basis for replay tracking |
scope, resource, authorization_details | Optional | What the IdP allowed; resource AS may grant a subset |
tenant, aud_tenant, aud_sub | Optional | Multi-tenant issuer, and the user's tenant and identifier at the resource app |
sub_id | Optional | Alternative identifier (RFC 9493), including a saml-nameid format for SAML-based resource apps |
auth_time, acr, amr | Optional | Authentication strength, usable for step-up decisions |
email | Optional | Recommended, with aud_sub, to help subject resolution |
act | Optional | RFC 8693 actor claim; actor semantics left for future profiles |
Processing rules for each party
The resource authorisation server must, per draft -04:
- Check the JWT
typisoauth-id-jag+jwtand the signature validates against a trusted IdP key. - Check
audis its own issuer identifier, as a single string or single-element array. - Check the
client_idclaim matches the client that authenticated on this request, rejecting withinvalid_grantotherwise. - Resolve the user. If it uses
sub_idwith the SAML NameID format, compare every identifier field it relies on, notnameidalone unless local policy allows it. - Apply local policy to scope, resource and authorisation details; the result may be narrower than the grant.
- Issue an access token without a refresh token.
The IdP must not issue access tokens for an ID-JAG it issued in its own domain, and an ID-JAG is bound to the one resource authorisation server in its aud: each further hop needs a new ID-JAG. When the IdP needs fresher authentication, it can return insufficient_user_authentication with a max_age; the client re-authenticates the user and retries. See the OAuth Step-Up Authentication Challenge Guide.
Refresh behaviour: when the access token expires, the client may resubmit the same ID-JAG while it is still valid. When the ID-JAG expires, it requests a new one from the IdP using its ID Token or, after refreshing its SSO session, a new ID Token. If the IdP accepts refresh tokens as subject tokens, the client can go straight to a new ID-JAG.
SAML apps: a requesting app that signs users in with SAML can exchange the SAML assertion at the IdP for a refresh token (with openid offline_access scopes), then use that refresh token to obtain ID-JAGs without another SSO round trip. The IdP must map the SAML Audience to the authenticated client.
Discovery and metadata
- IdP: advertises
urn:ietf:params:oauth:token-type:id-jaginidentity_chaining_requested_token_types_supported, a parameter defined by the identity chaining draft. - Resource authorisation server: lists
urn:ietf:params:oauth:grant-profile:id-jaginauthorization_grant_profiles_supportedand the jwt-bearer grant ingrant_types_supported. - Client: declares the same profile and both the token-exchange and jwt-bearer grant types, through dynamic registration or a Client ID Metadata Document. See the OAuth Client ID Metadata Documents Guide.
The draft is explicit that advertising the profile does not oblige a server to accept any particular issuer, client, subject or audience. Trust is still configured, not discovered.
How ID-JAG relates to neighbouring patterns
- Identity chaining: the general cross-domain pattern. ID-JAG is a profile of it in which the home domain is the enterprise IdP and the grant has a fixed format. See the OAuth Identity and Authorization Chaining Across Domains Guide.
- Plain token exchange: RFC 8693 inside one authorisation server, for delegation and downscoping. ID-JAG uses it only for the first hop.
- Transaction Tokens: carry context between workloads inside a trust domain after the access token arrives; they do not cross to another authorisation server. See the OAuth Transaction Tokens Guide.
- MCP Enterprise-Managed Authorization: an MCP extension that applies ID-JAG so an MCP client obtains access to MCP servers under IdP policy. See the Enterprise-Managed Authorisation for AI Agents.
Deployment decisions
| Decision | Option A | Option B | Guidance |
|---|---|---|---|
| Subject token | ID Token | Refresh token at the IdP | ID Tokens are simplest; refresh tokens avoid re-login for long sessions but put a long-lived token in the requesting app |
| User resolution at resource app | aud_sub pre-provisioned via SCIM | email matching | Prefer stable identifiers; use email only for linking legacy accounts |
| ID-JAG lifetime | About 5 minutes | Longer, to cut IdP calls | Keep it short; the resource AS issues its own access token lifetime anyway |
| Access token type | Bearer | Sender-constrained (DPoP or mTLS) | Sender-constrain where the resource holds sensitive data. See the DPoP Guide |
| Policy granularity | App to app | App to app per group and scope | Start coarse in a pilot, move to group and scope rules before broad rollout |
Small organisations will mostly consume ID-JAG through their IdP's built-in feature and SaaS vendors that support it; the work is policy, not code. Large organisations and SaaS providers must implement the resource authorisation server rules, provisioning that keeps aud_sub meaningful, and multi-tenant handling through the tenant claims. Pair this with the identity lifecycle work in the IPSIE Guide.
How to implement
- Inventory existing app-to-app grants from your SaaS platforms' connected app lists, focusing on integrations holding refresh tokens.
- Check support on all three sides: the IdP feature, the requesting app and the resource app. Note which draft version each implements.
- Define the first policy: one requesting app, one resource app, a pilot group, minimum scopes.
- Test negative paths in a sandbox tenant: wrong
aud, mismatchedclient_id, expired ID-JAG, user outside the group, scope above policy, ID-JAG replayed by a different client. Each must fail. - Pilot with the pilot group while the old consent-based grant still exists, then compare access and logs.
- Revoke the legacy consent grants for pilot users at the resource app, and block new user consent for that client where the platform allows.
- Expand by group, keeping a rollback path: re-enabling consent for the client is the fallback, so document who can approve it.
Detection and measurement
- IdP logs: every ID-JAG issuance and denial with requesting client, audience, user, scopes and policy rule.
- Resource authorisation server logs: jwt-bearer requests with
iss,jti,client_id, resolved account and granted scope. - Alerts: the same
jtiat the resource AS twice,client_idmismatches, ID-JAGs for users disabled at the IdP, and any refresh token issued on this grant.
Metrics: share of app-to-app integrations governed by IdP policy rather than user consent; count of legacy refresh tokens remaining for migrated clients; median time from IdP deprovisioning to last successful resource call; ID-JAG denial rate by reason; percentage of resulting access tokens that are sender-constrained.
Framework mapping
| Framework | Reference | Relevance |
|---|---|---|
| NIST SP 800-53 Rev 5 | AC-2 Account Management; AC-3 Access Enforcement; AC-6 Least Privilege; IA-2 Identification and Authentication (Organizational Users); SA-9 External System Services | Central approval and least-privilege access between external services |
| NIST CSF 2.0 | PR.AA-01, PR.AA-05; GV.SC-07 | Managed identities, policy-defined access, supplier risk |
| ISO/IEC 27001:2022 Annex A | 5.15 Access control; 5.18 Access rights; 5.19 Information security in supplier relationships | Access rights granted and removed under policy |
| CIS Controls v8.1 | Control 5 Account Management; Control 6 Access Control Management | Centralised SSO-based access control |
| MITRE ATT&CK | T1528 Steal Application Access Token; T1550.001 Application Access Token | Fewer long-lived app tokens to steal and reuse |
Common failure patterns
- Keeping the consent path open. If users can still consent the same client directly, the IdP policy is advisory. Disable or restrict user consent for migrated clients.
- Issuing refresh tokens anyway. A resource app that issues refresh tokens on the jwt-bearer grant recreates the long-lived token store ID-JAG is meant to remove. The Salesloft Drift breach shows the cost: stored OAuth access and refresh tokens for customer integrations were stolen and used to export Salesforce data.
- Skipping the client_id check. Without it, any client registered at the resource AS can redeem an ID-JAG issued to another client.
- Email-only account linking. Matching on email without a stable identifier enables takeover where addresses are recycled or unverified at the IdP.
- Using it for public or unattended clients. The draft targets confidential clients with a user present; mobile apps and headless jobs need other patterns. See the Machine-to-Machine OAuth (Client Credentials) Guide.
- Ignoring draft drift. Claim names and metadata have changed between versions; untested upgrades break interop silently.
Practitioner checklist
- Record which ID-JAG draft version your IdP, requesting apps and resource apps implement.
- Configure IdP policy per requesting app, resource app, group and scope.
- At the resource AS, enforce
typ, singleaud, signature,client_idmatch and expiry. - Disable refresh tokens on the jwt-bearer grant for ID-JAG clients.
- Resolve users on stable identifiers and keep provisioning in sync.
- Restrict user consent for clients moved to ID-JAG and revoke legacy grants.
- Keep ID-JAG lifetimes to minutes and track
jtireuse. - Correlate IdP issuance logs with resource AS token logs.
- Re-test after every IdP or SaaS release that touches the feature.
Standards and references
- IETF: Identity Assertion JWT Authorization Grant (draft-ietf-oauth-identity-assertion-authz-grant)
- IETF: OAuth Identity and Authorization Chaining Across Domains (draft-ietf-oauth-identity-chaining)
- IETF: RFC 8693 OAuth 2.0 Token Exchange
- IETF: RFC 7523 JWT Profile for OAuth 2.0 Client Authentication and Authorization Grants
- Model Context Protocol: Enterprise-Managed Authorization
- Okta Developer: Cross App Access
- OpenID Foundation: IPSIE Working Group
Related NHI Mgmt Group resources: Enterprise-Managed Authorisation for AI Agents · OAuth Identity and Authorization Chaining Across Domains Guide · OAuth Token Exchange and Delegation Guide · Entra ID Applications and Consent Guide