Review · October 13, 2026
"Deferred Token Response: authorization_pending for Every Grant"
The problem it's solving
Every OAuth grant today assumes the authorization server can decide on the spot. The client makes a token request, and it gets back a token or an error.
That breaks down when the decision isn't the AS's to make right now. A fraud analyst needs to look at a wire transfer. A human has to review a passport scan. An identity governance workflow needs sign-off from a manager and a resource owner. An agent asks for a scope beyond what its principal pre-approved.
In all of these the AS's only option today is to return an error. The client has no way to learn whether the request will eventually be approved, or when.
Deferred Token Response (DTR) gives the AS a third answer: "not yet." The AS returns an authorization_pending error carrying a deferral_code, an expires_in, and an interval. The client polls the token endpoint with the deferral code until the request resolves, or waits for an optional callback telling it to poll now.
The key thing that makes DTR different from the device grant and CIBA: the AS decides to defer, not the client. Any grant can plug into it. Authorization code, client credentials, token exchange, ID-JAG, all of them.
How it fits in the working group
This is squarely in charter, and the working group agreed by adopting it. It's a small, focused extension to the token endpoint.
It also already has downstream consumers. draft-gazitt-oauth-authzen-issuance uses DTR to express an AuthZEN "not yet" decision as a deferral instead of a denial. draft-dellaert-oauth-approval-based-dcr copies the pattern for dynamic client registration. That's a good sign the abstraction is useful.
Normative dependencies are OAuth 2.1, RFC 7009 (revocation), RFC 7591 (DCR), RFC 8414 (metadata), RFC 8628 (device grant, for polling semantics), RFC 8693, RFC 8705, RFC 9449 (DPoP), and RFC 9700. That's a lot of references, but almost all of them are borrowed behavior rather than new relationships between roles.
DTR doesn't introduce any new parties. The AS stays the client's only counterparty, and whatever fraud vendor, IDV provider, or IGA system actually makes the decision is explicitly out of scope. That's the right line to draw.
What changed since adoption
Nothing. The -00 of the WG draft is byte-for-byte identical to draft-gerber-oauth-deferred-token-response-00 apart from the name, date, and expiry. Even the "About This Document" section still points at the gerber URL on Datatracker and GitHub.
So everything below applies equally to the individual draft that the WG adopted.
What the mechanism actually does
Four pieces.
Opt-in. The client adds completion_mode=deferred to its normal token request. The AS MUST NOT defer a client that didn't opt in, and it's free to answer synchronously even if the client did. For grants with a front-channel step (authorization endpoint, device authorization endpoint, first-party apps challenge endpoint), the client MAY also send the parameter there as an advance hint, so the AS can show different consent or route to a review queue.
The deferred response. An HTTP 400 with error=authorization_pending, plus deferral_code, expires_in (lifetime of the deferral code, not the eventual token), and interval.
Polling. The client POSTs grant_type=urn:ietf:params:oauth:grant-type:deferred with the deferral_code, authenticating the same way it did originally. Responses use the device grant's error vocabulary: authorization_pending, slow_down, expired_token, access_denied. On success, the client gets exactly the token response the originating grant would have returned.
Callback and cancellation. A client can register a deferred_client_notification_endpoint and pass a per-request client_notification_token. When the request resolves, the AS POSTs the deferral code to the endpoint with the token as a Bearer credential. The callback carries no tokens. It just says "go poll now." Cancellation reuses token revocation with a new token_type_hint.
Deferral codes are sender-constrained using DPoP's refresh token rules. Public clients MUST use DPoP. And before issuing a token at resolution time, the AS MUST re-check that consent and the client's authorization still hold. That last one is important when the gap between request and resolution is measured in days.
So how does this compare to the device grant and CIBA?
DTR is basically the polling half of the device grant and the ping mode of CIBA, lifted out of their grants and made generic.
From RFC 8628 it takes the interval semantics, the +5 second slow_down rule, and all four error codes. The difference is where the handle comes from. In the device grant the client asks for a device_code at a dedicated endpoint and gets it in a 200 response. In DTR the AS mints the deferral_code inside an error response from the token endpoint, mid-grant, because it decided to.
From CIBA it takes ping mode almost verbatim. CIBA has auth_req_id, a registered backchannel_client_notification_endpoint, and a client_notification_token sent as a Bearer token on a callback that tells the client to poll. DTR has deferral_code, a registered deferred_client_notification_endpoint, and a client_notification_token doing exactly the same job. It sensibly leaves out CIBA's push mode, which delivers tokens directly to the callback and which FAPI-CIBA already dropped.
What DTR doesn't take from CIBA is the user model. CIBA is client-initiated and requires the client to tell the AS who to contact via login_hint or id_token_hint. DTR lets the AS pick who or what approves, which is what the IGA and agent use cases need.
Section 9 covers the CIBA relationship well. It would be stronger if it also said plainly that DTR could express the device grant's polling phase, since the error codes are identical. A reader will wonder whether a future device grant or CIBA profile should just use DTR underneath.
Why this matters for agents and enterprise
Appendix A.4 and A.5 are the use cases I'd expect to drive adoption.
An agent with narrow pre-approved scopes hits a purchase above its ceiling. Today the AS denies and the agent has to invent some side channel to ask its human. With DTR the agent asks once, gets a deferral code, parks the task, and the AS pings the human through its own channels.
On the enterprise side, an ID-JAG or client credentials request for production database access can route into an access request workflow in an IGA product like Okta Identity Governance or SailPoint. The AS remains the token issuer and the client never has to integrate with the governance system directly. That's a real gap today.
Significant interoperability concerns
The core poll loop is well specified. Most of the problems are in the edges and in IANA.
The polling validation steps are out of order. Section 5.5.1 step 4 returns the token if the request resolved successfully. Step 5, checking whether a token was already issued for this deferral code, comes after it. Read literally, a second poll on a resolved request returns the token again before the redemption check ever runs. Section 5.5.2 says the right thing, but the validation list needs the redemption check moved to step 2.
Expiry only applies while pending. Step 3 checks expires_in only "if the request is still pending." So a request that resolved but was never retrieved is redeemable forever? Section 6 separately says the AS MUST NOT send a callback for an expired deferral code. These need to agree.
The hint becomes a commitment. Section 4.2 says the AS MAY ignore the authorization endpoint hint entirely. It also says that if the client sent the hint and then omits completion_mode=deferred at the token endpoint, the AS MUST reject with invalid_request. That forces every AS to store the hint alongside the authorization code, even one that never acts on it. It also doesn't say whether the code is consumed by that rejection. I'd make the consistency rule apply only when the AS actually took a deferral-aware path, or drop it.
IANA has real gaps.
- Section 12.4 asks for registration in an "OAuth Grant Type" registry. There isn't one. Extension grant URNs go in the OAuth URI registry, which Section 12.6 already does.
deferral_code(token request and response) andclient_notification_token(token request) are never registered in the OAuth Parameters registry. Onlycompletion_modeis.urn:ietf:params:oauth:token-type:deferral-codeis used as atoken_type_hintvalue but isn't registered in RFC 7009's OAuth Token Type Hints registry.completion_modelists usage locations as authorization request and token request, but the draft also uses it at the device authorization and first-party challenge endpoints.
Metadata says MUST and OPTIONAL in the same breath. Section 4.1 says an AS "MUST include" deferred_token_response_supported, then defines it as OPTIONAL.
Sender-constraint framing is inconsistent. Section 10.1 says possession alone confers the right to retrieve the token, which is why the code is sender-constrained. Section 10.8 calls it "a bearer-equivalent credential." And Section 10.1 spells out DPoP binding in detail while saying nothing about how mTLS-bound polling works, even though Section 5.4 allows it.
The example violates its own entropy rule. The deferral code MUST have at least 128 bits of entropy. The example is a UUIDv4, which has 122.
Callback authentication should be mandatory. Without client_notification_token, the draft falls back to "network-position assumptions." Since callbacks are only a hint to poll, the blast radius is small, but there's no good reason to allow an unauthenticated mode. CIBA ping requires the token. DTR should too, whenever a notification endpoint is registered.
Smaller items:
- RFC 7234 is obsoleted by RFC 9111.
- RFC 6749 is informative but Section 5.4 points at its Section 10.10 for a MUST-level entropy requirement.
- Section 7.2 makes revocation-endpoint support mandatory for DTR. RFC 7009 is optional in OAuth generally, so this should be stated as a conformance requirement up front.
Mechanisms that could be removed
deferred_token_response_supported. RFC 8414's grant_types_supported can already list urn:ietf:params:oauth:grant-type:deferred. One discovery signal is enough.
The "OAuth Completion Mode Values" registry. It's a space-separated, extensible list with exactly one value. Nobody has proposed a second one. A plain deferred=true style parameter, or completion_mode without a new registry, would do the same job. Build the registry when there's a second value to put in it.
revocation_endpoint_token_type_values_supported. This is a genuinely useful general-purpose metadata property. That's the argument for pulling it out into its own short document or into an RFC 7009 update, not burying it in DTR where other specs won't find it.
Section 8.2's parallel grant. The advice to run a second prompt=none flow to get an immediate token is reasonable, but it's implementation guidance, not protocol. I'd shrink it to a sentence. There's also a case for future work here: returning a lower-assurance access token alongside the deferral code would cover A.2 and A.3 much more cleanly than two parallel flows.
Things worth keeping: the callback being notification-only, the consent re-evaluation MUST in 10.7, and the SSRF guidance in 10.5. All three are correct calls.
Writing quality
Good. The BCP 14 language is used correctly, the error codes line up with RFC 8628 and OAuth 2.1, and the security considerations are substantive. The motivating use cases in Appendix A are concrete and make the case well.
It's repetitive. The hint-consistency rule appears in Sections 3, 4.1, 4.2, 5.1, 5.3.1, and 5.6. The "SHOULD continue polling even with a callback" guidance shows up three times. Stating each rule once and linking to it would cut several pages.
A few loose ends:
- Section 5 is titled "The Deferred Authorization Grant," but DTR isn't a grant. It's a response mode on other grants, plus a polling grant type.
- Appendix A.1 says "If the bank registered a callback endpoint." The bank is the AS. The client registers the endpoint.
- Several use cases say "authorization request with completion_mode=deferred" when they mean the token request.
- "the the" in Section 4.1, and the acknowledgments list is missing its final period.
- "About This Document" still points at the gerber draft URLs.
Background of the authors
Three authors, all first-time IETF authors by their Datatracker records.
- Frederik Krogsdal Jacobsen (Idura): zero RFCs, one active draft (this one), no expired drafts.
- Guilherme de Oliveira Niero (Itaú): zero RFCs, one active draft (this one), no expired drafts.
- Maxwell Gerber (Twilio): zero RFCs, one active draft (this one), no expired drafts.
The mix is a good one for this problem. Idura is a Nordic eID broker, Itaú is Brazil's largest private bank, and Twilio runs Verify. Those are exactly the organizations that hit document review and fraud-hold delays in production, and it shows in the use cases. The draft is also more polished than most first submissions, with a clear security section and careful reuse of existing error codes.
None of them are carrying other drafts, so this has their full attention. The issues above are mostly cleanup and IANA, which is normal for a first WG revision. The bigger design questions worth a mailing list thread are whether the authorization endpoint hint needs to be binding, and whether the device grant and CIBA polling patterns should be described as profiles of DTR going forward.