# What is DPoP?

> DPoP (Demonstrating Proof of Possession) is an internet standard, RFC 9449, that ties an OAuth access token to a key the client holds. Each request carries a fresh proof signed with that key, so a copied token fails without it.

Explainer by Boston Identity, 2026-10-28. 7 min read. https://insights.bostonidentity.com/glossary/dpop

- What it is: protocol
- Defined by: IETF, RFC 9449 (Standards Track, 2023)
- Who it's for: Teams running OAuth APIs, browser apps and agents

## What is DPoP?

DPoP is a published standard from the Internet Engineering Task Force (IETF): RFC 9449, issued in September 2023 on the Standards Track [S1]. It extends OAuth, the framework apps use to get access tokens for APIs. Its job is to sender-constrain access and refresh tokens, which means tying each token to a key pair so that only the party holding the private key can use it [S1 §1].

The problem it answers is the ordinary bearer token, which any party in possession of it can use [S1 §2]. Tokens have leaked through bugs in other layers of the software stack and through attacks on OAuth implementations themselves. The RFC calls DPoP "a general defense in depth against the impact of unanticipated token leakage" [S1 §2]. It works at the application level, in an HTTP header, so it fits clients where mutual TLS is not available, such as a single-page app running in a browser [S1 §1]. DPoP is not a way to authenticate the client, and it must always be used with HTTPS [S1 §2, §3].

Think of it like this: Think of a hotel key card that only opens a door when you also press your thumb on the reader. A thief with the card alone gets nowhere. The comparison breaks in one place: a thumb cannot be borrowed, but any code running inside the app can use the app's key.

Not the same as: Not client authentication, which proves which app is calling. A DPoP proof shows only that the caller holds a key, and the RFC says a valid proof alone is not enough to make an access decision [S1 §4].

## How does DPoP work?

Three parties take part: the client (the app or agent that wants data), the authorization server that issues tokens, and the resource server, the API that holds the data. The client signs with a private key whose public half it chose itself [S1 §4.2].

[Figure: The client proves its key once to get a bound token from the authorization server, then proves it again, with a fresh proof tied to that token, on every call to the resource server.]

1. **The client signs a proof for its token request.** When the client asks the authorization server for an access token, it attaches a DPoP proof in a DPoP header [S1 §3]. The proof is a short JWT (JSON Web Token) signed with the client's private key, with the public key in its header [S1 §4.2]. Its payload must hold a unique identifier (jti), the HTTP method (htm), the target URI (htu) and a creation time (iat) [S1 §4.2]. This applies to every grant type, including a refresh [S1 §5].
2. **The authorization server binds the token to the key.** The authorization server checks the proof and ties the access token it issues to the public key in that proof [S1 §5]. It must signal this to the client by returning a token_type of DPoP [S1 §5]. For a JWT access token, the binding is a hash of the public key, the jkt value inside the cnf claim; a resource server can also learn it through token introspection [S1 §6.1, §6.2]. A refresh token issued to a public client, one with no credentials of its own, must be bound to the same key [S1 §5].
3. **The client sends the token with a new proof.** To call the API, the client sends the access token in the Authorization header under the DPoP scheme, plus a new proof in the DPoP header [S1 §7.1]. Each HTTP request requires a unique proof [S1 §4]. This proof must also carry ath, a hash of the access token, which ties the proof to that one token [S1 §4.2, §7].
4. **The resource server checks the proof and the binding.** The resource server must check the proof's signature, its type and its algorithm, and that htm and htu match the request it received [S1 §4.3]. It must check that the proof was created within an acceptable window and that ath matches the token presented [S1 §4.3]. It must also check that the public key in the proof is the key the token is bound to [S1 §7.1].
5. **The resource server serves or refuses.** The resource server must not grant access unless all of these checks succeed [S1 §7.1]. It can refuse with a 401 response carrying a DPoP challenge, for example one that reports an invalid key binding [S1 §7.1]. The access token itself must still be valid in every other respect [S1 §3].

## Why does DPoP matter now?

The rule books now lean toward key-bound tokens. RFC 9700, OAuth's security best current practice, says authorization and resource servers should sender-constrain access tokens, naming mutual TLS and DPoP as mechanisms [BI-FIND-2025-0352](https://insights.bostonidentity.com/ref/BI-FIND-2025-0352). Revision -15 of the OAuth 2.1 draft is firmer about refresh tokens for public clients: the authorization server must catch their replay, either by binding them to the client instance or by rotating them, with DPoP and mutual TLS given as the binding examples [BI-FIND-2026-1109](https://insights.bostonidentity.com/ref/BI-FIND-2026-1109). NIST's final token guidance, published with CISA on 15 September 2026, recommends binding tokens to the client's key only for workloads, and all of that guidance is voluntary [BI-FIND-2026-0700](https://insights.bostonidentity.com/ref/BI-FIND-2026-0700).

Agent tooling is starting to carry it. Version 2.1.0 of the official MCP TypeScript client, released 23 September, can bind access tokens with DPoP, but only when the client opts in, and the MCP proposal behind it was still an open pull request on 9 October [BI-FIND-2026-0684](https://insights.bostonidentity.com/ref/BI-FIND-2026-0684). Hartman's credential-broker draft recommends, as its default, that an agent hold a short-lived token bound to its own key with DPoP [BI-FIND-2026-0534](https://insights.bostonidentity.com/ref/BI-FIND-2026-0534). In an adoption call that closed on 5 October, two of DPoP's co-authors objected to a second key-binding draft in the OAuth working group, saying a second sanctioned mechanism would hurt interoperability [BI-FIND-2026-0862](https://insights.bostonidentity.com/ref/BI-FIND-2026-0862).

Support is not the same as enforcement. Auth0's Go JWT middleware v3 ships in a default mode that still accepts plain bearer tokens beside DPoP ones [BI-FIND-2026-1089](https://insights.bostonidentity.com/ref/BI-FIND-2026-1089). In the v3.0.0 code we checked, a proof is accepted for 300 seconds by default and the library keeps no record of proof ids it has already seen [BI-FIND-2026-1088](https://insights.bostonidentity.com/ref/BI-FIND-2026-1088).

## Where does it fit?

- Compared with Bearer token: A bearer token can be used by any party that holds it [S1 §2]. A DPoP-bound token also needs a proof signed with the client's private key on each request [S1 §7.1].
- Compared with mTLS: Certificate-bound tokens over mutual TLS (RFC 8705) bind at the transport layer, which the RFC says can give strong message integrity, authenticity and replay protection [S1 §11]. DPoP binds at the application layer, which suits browser apps where TLS client authentication gives a poor user experience [S1 §1].
- Compared with Sender-constraining: Sender-constraining is the goal of tying a token to the client it was issued to. DPoP is one way to reach it at the application level [S1 §1], and RFC 9700 names mutual TLS as another [BI-FIND-2025-0352](https://insights.bostonidentity.com/ref/BI-FIND-2025-0352).
- Compared with WIMSE Workload Proof Token: Revision -07 of the WIMSE draft describes the Workload Proof Token as inspired by DPoP, binding the target, the workload identity token and any included authorization-context tokens [BI-FIND-2025-0493](https://insights.bostonidentity.com/ref/BI-FIND-2025-0493). That revision leaves open whether to use it or an HTTP Message Signatures profile, while DPoP is a published RFC for OAuth tokens [BI-FIND-2025-0493](https://insights.bostonidentity.com/ref/BI-FIND-2025-0493) [S1].

## What goes wrong?

- Hostile code inside the client defeats it. If an attacker can run code in the client's context, for example through cross-site scripting (XSS), the RFC says DPoP's security is no longer guaranteed [S1 §11.4]. A key that cannot be exported stops the attacker from carrying it away, but the attacker can still create new proofs while the client is online [S1 §11.4]. Such code can also start a silent authorization grant in an iframe and tie the resulting tokens to the attacker's own key [S1 §11.4].
- A captured proof can be replayed at the same endpoint and method, so servers must accept proofs only for a limited time after creation [S1 §11.1]. Servers can also store each proof's jti to reject reuse, but the RFC says that may not be feasible when several servers sit behind one endpoint with no shared state [S1 §11.1].
- Someone in control of the client, including its legitimate user, can sign proofs with future timestamps and copy them to another machine [S1 §11.2]. Unpredictable nonces from the server can prevent this, and deployments without them should not issue long-lived DPoP access tokens [S1 §11.2].
- A proof covers only the HTTP method and URI, not the body or general headers, and relies on TLS for message integrity [S1 §11.7].
- A resource server that supports both schemes must reject a DPoP-bound token sent as a bearer token, but a server unaware of DPoP would most presumably accept it [S1 §7.2]. An authorization server may also return a plain bearer token, and the client must discard it if that protection is important to the application [S1 §5].

## What should a security leader ask?

1. Which of our APIs still accept a DPoP-bound token sent as a plain bearer token, and when do we switch them to reject it?
2. How long does each of our resource servers accept a DPoP proof after it was created, and does it reject a proof id it has already seen?
3. Where do our browser apps, mobile apps and agents keep their DPoP private keys, and can code running in the app export them?
4. Do our authorization servers send nonces, and if not, how long do our DPoP access tokens live?
5. Which agent frameworks and SDKs (software development kits) we use have DPoP turned on, not just available?

## Sources

- [S1] [OAuth 2.0 Demonstrating Proof of Possession (DPoP)](https://www.rfc-editor.org/rfc/rfc9449) (IETF, RFC 9449, Standards Track, September 2023)

## Evidence

- [BI-FIND-2025-0352](https://insights.bostonidentity.com/ref/BI-FIND-2025-0352): For access tokens the RFC stops at SHOULD. Authorization and resource servers should sender-constrain them, tying each token to a key the client holds with a mechanism such as mutual TLS (RFC 8705) or DPoP (RFC 9449), and should restrict each token to one resource server or a small set. The threat is an attacker who gets hold of a token, for example by running a counterfeit resource server or compromising a real one. The authors concede that "architecture and performance reasons" may rule these measures out in some deployments, and that a bound token is undermined once the attacker also has the key. They also decline to rely on clients to spot a counterfeit resource server, because many clients fail to implement checks such as state: relying on them "is likely to fail as well". (from "RFC 9700 bans OAuth's password grant and loose redirect matching; binding access tokens stays a SHOULD")
- [BI-FIND-2026-1109](https://insights.bostonidentity.com/ref/BI-FIND-2026-1109): Revision -15 of OAuth 2.1 turns the advice in OAuth 2.0's security best current practice (RFC 9700) into the base protocol. The authorization code grant now carries PKCE: clients are REQUIRED to send a code challenge and authorization servers MUST enforce it, unless the client is confidential and the server has reasonable assurance that it implements the OpenID Connect nonce properly. Redirect URIs are registered in full and must match exactly, except for the port on loopback redirects. The implicit and password grants are left out, clients MUST NOT send access tokens in a URI query parameter, and for public clients the authorization server MUST catch refresh-token replay, either by binding the token to the client instance (DPoP and mutual TLS are the examples given) or by rotating it on every refresh. (from "OAuth 2.1's March draft builds in the security best practice, but 2.1-only clients can fail with older servers")
- [BI-FIND-2026-0700](https://insights.bostonidentity.com/ref/BI-FIND-2026-0700): NIST's final guidance on protecting identity tokens, published with CISA on 15 September 2026, turns token hygiene into numbers. Access and identity tokens should be valid for no more than an hour; signing keys for high-impact systems should be active no more than 90 days and others less than a year; and from moderate impact up, signing keys must sit in hardware-backed or otherwise isolated storage, which a cloud key service satisfies. Keys that sign federal tokens must not sign anything else, workload identities must use tightly scoped short-lived tokens, and tokens must never be written to logs. Binding tokens to the client's key is recommended only for workloads, and the report concedes that stateless tokens cannot always be revoked before they expire. All of it is voluntary. (from "NIST and CISA advise one-hour tokens, 90-day keys and hardware key storage; AI agents get one paragraph")
- [BI-FIND-2026-0684](https://insights.bostonidentity.com/ref/BI-FIND-2026-0684): Version 2.1.0 of the official MCP TypeScript client, released 23 September, can bind an access token to a key the client holds (DPoP, RFC 9449), so a token copied out of a log or a proxy is useless without that key. It signs a proof into every token and resource request, handles server nonces, and re-authorizes when a refresh token is bound to a key it no longer has. It is opt-in: nothing happens unless the client implements the new hook, and a token the server issued as a plain bearer token is still sent as one. The MCP proposal it implements, SEP-1932, was still an open pull request on 9 October, so the spec does not yet ask anyone to use it. (from "The official MCP TypeScript SDK now binds tokens to keys, ahead of the spec it implements")
- [BI-FIND-2026-0534](https://insights.bostonidentity.com/ref/BI-FIND-2026-0534): Hartman's broker splits the decision from the secret. A policy decision point that "MUST never touch credential material" approves, denies or escalates a signed task request naming the target, action, scope and lifetime; a separate delivery point pulls the real credential from a hardware-backed vault, mints something narrower and wipes its memory. Three delivery models follow. In the first, a proxy injects the credential and the agent never sees it. In the second, recommended as the default, the agent holds a short-lived derived token bound to its own key with DPoP. In the third, marked NOT RECOMMENDED, the agent receives the real long-lived credential and it is revoked after the task. So the abstract's promise that agents "never hold real long-lived credentials" holds only if the third model is never used, and two sections disagree on which model is the fallback for services that cannot issue short-lived tokens. (from "A SANS instructor's broker vaults agents' real keys, but its third delivery model breaks the abstract's promise")
- [BI-FIND-2026-0862](https://insights.bostonidentity.com/ref/BI-FIND-2026-0862): Richer's draft adds a second way to bind an OAuth access token to a client's key, and the working group split over it without the draft stating why. The text says only that it "complements and builds on experience with" DPoP and mutual TLS; the guidance on when to use which is an editor's note, the security and privacy sections are marked to-do, there are no test vectors, and no implementation is named. Nine people supported adoption in the call that closed on 5 October, five of them the draft's own authors. Four objected: Dick Hardt said the group had already solved key binding with DPoP, and Michael Jones and Brian Campbell, two of DPoP's co-authors, said a second sanctioned mechanism would hurt interoperability. No decision had been posted a week later. (from "The OAuth group split over a second way to bind tokens to keys, and the draft never says what DPoP gets wrong")
- [BI-FIND-2026-1089](https://insights.bostonidentity.com/ref/BI-FIND-2026-1089): v3 ships with DPoP in its permissive mode. DPoPAllowed, the default, accepts plain bearer tokens alongside DPoP ones, while DPoPRequired, which rejects bearer tokens outright, is what Dawar calls "the ultimate end goal for maximum API security." In his section on what v2 lacked, he describes the risk DPoP answers: "if someone steals the token, they effectively become you." An API that moves to v3 and leaves that setting alone still accepts a plain bearer token from whoever holds it, until its owners switch modes. (from "Auth0's Go JWT middleware v3 adds DPoP but accepts a reused proof for five minutes, and bearer tokens by default")
- [BI-FIND-2026-1088](https://insights.bostonidentity.com/ref/BI-FIND-2026-1088): Dawar writes that go-jwt-middleware v3 checks a DPoP proof's signature, its HTTP method and URL, the access-token hash and the key thumbprint, and that it "checks the proof's age to prevent replay attacks." In the v3.0.0 code we checked, that age check is the whole replay defence: by default a proof is accepted for 300 seconds after it was made, and the library keeps no record of proof ids (jti) it has already seen, although the repository's migration guide lists "Replay protection via jti and iat claims". RFC 9449 requires the time limit and leaves a single-use check to the server's choice. We read this to mean that anyone who copies a token and its proof from a log or a proxy can send the same request to the same method and URL within those five minutes, and it passes every check the post lists. (from "Auth0's Go JWT middleware v3 adds DPoP but accepts a reused proof for five minutes, and bearer tokens by default")
- [BI-FIND-2025-0493](https://insights.bostonidentity.com/ref/BI-FIND-2025-0493): Revision -07 leaves the application mechanism open between a Workload Proof Token (WPT), inspired by OAuth Demonstrating Proof of Possession (DPoP), and an HTTP Message Signatures profile. The WPT binds the target, the Workload Identity Token and any included authorization-context tokens. The signatures profile requires the HTTP method and request target to be signed, plus specified headers when present, and requires a Content-Digest for a message body. Responses may be signed; this is optional. The draft warns that the DPoP-inspired alternative does not protect major portions of requests and responses against an actively malicious middlebox. Both application options still require a secure channel. (from "WIMSE leaves its application proof choice open, with different integrity coverage")

---

© 2026 Boston Identity LLC. All rights reserved. Published by Boston Identity LLC.
Quote up to 100 words with the credit "Boston Identity, IAM Insights" and a link to https://insights.bostonidentity.com/glossary/dpop. Claim numbers may be cited freely. Training, fine-tuning and text-and-data-mining use of this page is permitted.
Terms: https://insights.bostonidentity.com/terms · How to cite: https://insights.bostonidentity.com/cite
