FAPI 2.0 has been final since February 2025, and the bank schemes that adopted it left out its headline feature. UAE Open Finance profiles FAPI 2.0 with mTLS only. Australia's draft for 2028 does not contain the word DPoP. The DPoP deployments I can find are a Norwegian health network and Singapore's government login.
The pages ranking for this comparison don't tell you that. Most were written before the final text, one from the OpenID Foundation itself still says 2.0 has no certification suite, and none gives the numbers a client developer trips over: a 60-second authorisation code, a request_uri that must expire in under 600 seconds, a 201 from the PAR endpoint and an aud claim that fails if you send an array. I read the final specifications clause by clause and timed DPoP proofs locally. This is the diff.
FAPI 2.0 vs FAPI 1.0 Advanced: What Changed
FAPI 1.0 Advanced went final on 12 March 2021. The FAPI 2.0 Security Profile and its Attacker Model are dated 22 February 2025, and Message Signing followed on 25 September 2025. The old "Baseline" and "Advanced" names are gone from the 2.0 titles, although the working group's own FAQ still uses them.
| Requirement | FAPI 1.0 Advanced | FAPI 2.0 Security Profile |
|---|---|---|
| Response type | code id_token, or code with JARM | code only |
| Request integrity | Signed request object (JAR), by value or reference | No request object. PAR, then client_id and request_uri only |
| PAR | Optional | Mandatory, client-authenticated |
| PKCE | S256, only when PAR is used | S256, always |
| Token binding | mTLS | mTLS or DPoP |
| Client authentication | private_key_jwt, tls_client_auth, self_signed_tls_client_auth | private_key_jwt or mTLS |
iss response parameter (RFC 9207) | Not used | Server must send, client must check |
| Signing algorithms | PS256 or ES256, RS256 discouraged | PS256, ES256 or EdDSA (Ed25519) |
| Minimum EC key | 160 bits | 224 bits |
| Authorisation code lifetime | No number | 60 seconds maximum |
| Request lifetime | Request object exp within 60 minutes of nbf | request_uri expires_in under 600 seconds |
| Refresh token rotation | Not addressed | Server must not rotate, except in extraordinary circumstances |
private_key_jwt aud | No rule | Issuer identifier, as a single string |
| Clock skew | Not addressed | Server accepts iat/nbf up to 10 s ahead, rejects beyond 60 s |
| TLS 1.2 ciphers | Four named suites | BCP 195 recommended suites |
| Public clients | Not allowed | Not allowed |
Two rows correct common beliefs. Public clients are excluded from both profiles, so the usual "DPoP is for single-page apps" argument has no place in a FAPI discussion. And RS256 is not banned by name in 2.0; it is absent from a three-item allow-list, which has the same effect in a conformance test.
The code lifetime is the one line I'll quote, from section 5.3.2.1: the server "shall issue authorization codes with a maximum lifetime of 60 seconds". If your callback handler queues the code exchange behind a slow job, that is now a failure mode rather than a style problem.
How PAR Replaces the Signed Request Object in FAPI 2.0
In FAPI 1.0 Advanced the client signs a JWT containing the authorisation parameters and sends it through the browser. In FAPI 2.0 the client posts the parameters straight to the server, authenticated, and the browser only ever carries a reference.
POST /as/par HTTP/1.1
Host: as.bank.example
Content-Type: application/x-www-form-urlencoded
response_type=code&client_id=tpp-123
&redirect_uri=https%3A%2F%2Ftpp.example%2Fcb
&code_challenge=E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM
&code_challenge_method=S256&scope=accounts
&client_assertion_type=urn%3Aietf%3Aparams%3Aoauth%3Aclient-assertion-type%3Ajwt-bearer
&client_assertion=eyJhbGciOiJQUzI1NiIs...
HTTP/1.1 201 Created
Content-Type: application/json
{ "request_uri": "urn:ietf:params:oauth:request_uri:6esc_11ACC5bwc014ltc14eY22c", "expires_in": 60 }
The status is 201, not 200 (RFC 9126 section 2.2). A client that checks status === 200 works against no compliant server. The browser redirect then carries exactly two parameters, client_id and request_uri, and the response comes back with code, state and iss.
The request_uri is single-use, and that has a field-tested catch. The OpenID Foundation's implementer guide for the final text records that some mobile operating systems pre-load authorisation URLs and burn the reference before the banking app opens it. The final spec therefore tells servers to enforce one-time use when the user sees the consent screen, not when the page loads. If you run an authorisation server and invalidate on first GET, app-to-app redirects will fail intermittently on real phones and never in your test suite.
Why FAPI 2.0 Requires the Issuer as the private_key_jwt Audience
This is the change most likely to break a working client. RFC 9126 originally said a server must accept its issuer, its token endpoint URL or its PAR endpoint URL as the audience of a client assertion. Researchers showed that a client talking to several authorisation servers with one key could be tricked: a malicious server advertises an honest server's token endpoint as its own, the client writes that URL into aud, and the attacker holds a replayable assertion for the honest server.
The OpenID Foundation disclosed it on 25 February 2025 as CVE-2025-27370 and CVE-2025-27371. FAPI 2.0 Final already carried the fix: the server accepts only its issuer identifier, as a string, and an array fails. The IETF caught up in November 2026 with RFC 10070, which updates RFCs 7521, 7522, 7523 and 9126 to require the issuer as the sole audience value and forbids the token endpoint URL. It also introduces a client-authentication+jwt type header.
Most OAuth libraries written before 2025 set aud to the token endpoint. Under node-oidc-provider's '2.0' profile that assertion is rejected by default. Check yours before you blame the bank.
DPoP vs mTLS: Which Sender-Constraining Method to Use
Both bind an access token to a key the client holds. mTLS (RFC 8705) puts a hash of the client certificate in the token as cnf.x5t#S256. DPoP (RFC 9449) puts a JWK thumbprint in cnf.jkt and requires a fresh signed proof on every request. Here is a real proof, generated with Node's built-in crypto and no library:
{ "typ": "dpop+jwt", "alg": "ES256",
"jwk": { "kty": "EC", "crv": "P-256",
"x": "vkUlbb8Bw0do5C2v8qr83e_TOBuZfRCYw-UDu5LjKxg",
"y": "Ft2jsiWvIT0bPkMrCxBMUixM95P1xMC45kw6nnLc5YA" } }
{ "jti": "cdb8cb5c-71d9-4b75-b05f-0358ea16d0da",
"htm": "POST", "htu": "https://api.bank.example/payments",
"iat": 1795075876,
"ath": "fUHyO2r2Z3DZ53EsNrWBb0xWXoaNy59IiKCAqksmQEo",
"nonce": "eyJ7S_zG.eyJH0-Z.HX4w-7v" }
The request then carries Authorization: DPoP instead of Bearer, plus the proof in a DPoP header. People worry about the signing cost, so I measured it on one core of an M5 Pro under Node 24.15:
| Algorithm | Proof size (with ath, no nonce) | Build and sign | Verify (with JWK import) |
|---|---|---|---|
| ES256 | 534 bytes | 18 µs | 43 µs |
| EdDSA | 472 bytes | 17 µs | 35 µs |
| PS256 | 1,120 bytes | 303 µs | 18 µs |
CPU is not the cost. State is. RFC 9449 wants servers to reject a reused jti, which means a shared cache across every node behind the endpoint. Server nonces add a round trip: the first request gets a 400 with use_dpop_nonce from the authorisation server, or a 401 from the resource server, with the value in a DPoP-Nonce header, and the client retries. FAPI 2.0 makes nonce support mandatory for clients and optional for servers. The two servers issue separate nonces, and a new one can arrive on a 200, so the client needs a per-origin nonce store.
The deeper problem for payments is in section 6.2 of the Security Profile itself. A DPoP proof signs the method and the URL. It does not sign the body. An attacker who can read resource requests could replay a captured proof within its window against the same endpoint with a different amount or payee. The spec lists the mitigations: short-lived nonces, jti checks, signed requests, or use mTLS.
mTLS pays its cost in infrastructure instead. TLS has to terminate somewhere that can see the client certificate, and if that is a load balancer, the certificate must be forwarded. RFC 9440 defines a Client-Cert header for that, and the proxy must strip any copy sent by the caller, or anyone can forge an identity. Rotating the certificate invalidates every bound access token. FAPI 2.0 clients using mTLS must also support mtls_endpoint_aliases, because servers often put the mTLS endpoints on a separate host.
My rule: for payment initiation, use mTLS unless the scheme forces otherwise, because the binding covers the whole connection. DPoP earns its place where clients cannot hold certificates or where a CDN you don't control terminates TLS.
Which Open Banking Schemes Require FAPI 2.0 in 2026
I checked each scheme's own standards site on 19 November 2026.
| Scheme | Profile today | Flow | Token binding | FAPI 2.0 status |
|---|---|---|---|---|
| UK Open Banking v4.0.1 | FAPI 1.0 Advanced | Hybrid, signed request object, no JARM | mTLS | No published plan |
| Australia CDR v1.36.0 | FAPI 1.0 Advanced | Code, PAR, PKCE, JARM | mTLS | Draft v1.37.0 proposes 30 April 2028 |
| Brazil FAPI-BR v2.2.1 | FAPI 1.0 Advanced | PAR and PKCE, code id_token, encrypted ID token | mTLS | Nothing on the scheme wiki |
| New Zealand v3.0.3 | FAPI 1 lineage | Code, PAR, PKCE, JARM | mTLS | None |
| UAE Open Finance v2.1 | FAPI 2.0 Final | PAR, RAR, signed request at PAR | mTLS | Live |
| Chile (CMF, NCG 514) | FAPI 2.0 | Not yet live | n/a | In force 3 July 2027 |
| Berlin Group openFinance 2.4.1 | No FAPI | OAuth optional | QWAC mTLS, optional QSealC signature | Not referenced |
Saudi Arabia's standard is gated, but the certification listings show 26 FAPI 1 Advanced entries and, since August 2026, eight under FAPI 2.0 Message Signing. In the US, the FDX specification is members-only; the OpenID Foundation says FAPI 2.0 is FDX's approved "blue" profile, alongside a non-FAPI one, and the CFPB's Section 1033 compliance dates have been stayed since October 2025.
Australia's consultation (CD210) closes on 26 November 2026. Its draft keeps private_key_jwt, mTLS and JARM, and adds Message Signing. No DPoP.
The certification counts tell the same story. On the day I looked, 24 authorisation servers were certified against FAPI 2.0 Final. Brazil's FAPI-BR v2 listing alone had 389, and the UK's had 35. I compared the UK, Berlin Group and STET profiles in more detail in Open Banking APIs: UK OBIE vs Berlin Group vs STET.
Is FAPI 2.0 Message Signing Required?
No. It is a separate specification with three independently certifiable options: signed authorisation requests (a JAR request object sent to the PAR endpoint), signed authorisation responses (JARM) and signed introspection responses. A scheme picks what it needs. The UAE takes the first, and Australia's draft takes the first two.
HTTP message signatures for resource requests are not in it. Several vendor posts say they are, but that work sits in a separate draft, "FAPI 2.0 Http Signatures", whose working copy is dated 26 June 2026. It applies RFC 9421, the same mechanism I covered in Web Bot Auth vs Visa TAP.
Message Signing is also candid about its limits. JARM signs OAuth artefacts such as the code and state. It does not sign the amount or the creditor account. Non-repudiation of the payment itself therefore stays where it is today: in each scheme's own payload signature, such as the detached JWS in x-jws-signature that both UK Open Banking and Berlin Group use.
FAPI 1.0 to FAPI 2.0 Migration: What Breaks
The OpenID Foundation's position is that a FAPI 1.0 Advanced deployment already using PAR and JARM is likely to conform to 2.0 plus Message Signing. Everyone else has work to do.
- No ID token from the authorisation endpoint. The
s_hashandc_hashchecks disappear. Validate theissparameter instead, and take the ID token from the token endpoint. - Request objects by value stop working at the authorisation endpoint.
audas a token endpoint URL or an array fails.- Refresh tokens. Servers must stop rotating, and clients must still tolerate rotation.
- Clock drift. A client more than 60 seconds ahead is rejected. Between 10 and 60 seconds is the server's choice, so behaviour differs by bank.
- Redirects. Servers must not use 307 where credentials are involved, and should use 303.
x-fapi-interaction-idand friends have moved out of the profile into a non-final Implementation Advice draft.
fapi-2-security-profile and fapi-2-dpop-security-profile. node-oidc-provider takes features.fapi.profile: '2.0'. Certification costs USD 1,000 for OpenID Foundation members and USD 5,000 for non-members, per deployment.
Will UK Open Banking Move to FAPI 2.0?
This section is opinion. Open Banking Limited has published no plan, consultation or date. Version 4.0.1, published on 1 April 2026, left the security profile untouched, and the only mention of FAPI 2 I found on its site is a note about clock skew.
Of the mature schemes, the UK is furthest from 2.0. Australia and New Zealand already run code flow with PAR, PKCE and JARM on a FAPI 1 base, so their move is mostly paperwork. Brazil requires PAR and PKCE. The UK profile still uses the hybrid flow with a request object, puts JARM out of scope and does not mention PAR. Every UK bank and every TPP would have to change its redirect handling, and there is no security incident forcing it.
So I expect the UK to move last among those schemes, not before Australia's 2028 date, and most likely as part of whatever standard the successor to Open Banking Limited issues for commercial variable recurring payments. When it does, I'd bet on PAR with private_key_jwt and mTLS. The Directory already issues OBWAC transport certificates, and no bank scheme I could read has chosen DPoP.
What This Means for Open Banking Engineers
1. Build the client for code flow with PAR and PKCE now, behind a per-bank switch. It runs today in Australia, New Zealand, Brazil and the UAE, and it is where the UK will land.
2. Set aud in client assertions to the issuer string everywhere. RFC 10070 makes this the rule for plain OAuth as well, and servers that accepted the token endpoint will stop.
3. Treat PAR success as any 2xx with a request_uri, and start the redirect immediately. Budget for a 60-second expires_in, because some servers use it.
4. Exchange the code inline in the callback. Sixty seconds leaves no room for a queue.
5. Run NTP and alert on drift over five seconds. The guaranteed tolerance is ten.
6. If you operate an authorisation server, invalidate request_uri at consent, turn refresh rotation off and strip incoming Client-Cert headers at the edge.
7. Choose mTLS for payment APIs. If you must use DPoP, require server nonces and sign the body by another mechanism.
8. Do not wait for HTTP message signatures. That draft is not final, and your scheme's detached JWS is still the evidence in a dispute.
I'm Tom Wang, and I write about the engineering underneath payment rails. Scheme profiles override the base specification in both directions, so read the profile for each market before trusting any table, including mine.