All entries
Chapter VIII
Journal · 19 Nov 2026 · 12 min read

FAPI 2.0 vs FAPI 1.0: PAR, DPoP and mTLS Compared

FAPI 2.0 vs FAPI 1.0 Advanced by clause: PAR, the 60-second code, issuer-only aud, DPoP vs mTLS cost, and which Open Banking schemes require which.

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.

RequirementFAPI 1.0 AdvancedFAPI 2.0 Security Profile
Response typecode id_token, or code with JARMcode only
Request integritySigned request object (JAR), by value or referenceNo request object. PAR, then client_id and request_uri only
PAROptionalMandatory, client-authenticated
PKCES256, only when PAR is usedS256, always
Token bindingmTLSmTLS or DPoP
Client authenticationprivate_key_jwt, tls_client_auth, self_signed_tls_client_authprivate_key_jwt or mTLS
iss response parameter (RFC 9207)Not usedServer must send, client must check
Signing algorithmsPS256 or ES256, RS256 discouragedPS256, ES256 or EdDSA (Ed25519)
Minimum EC key160 bits224 bits
Authorisation code lifetimeNo number60 seconds maximum
Request lifetimeRequest object exp within 60 minutes of nbfrequest_uri expires_in under 600 seconds
Refresh token rotationNot addressedServer must not rotate, except in extraordinary circumstances
private_key_jwt audNo ruleIssuer identifier, as a single string
Clock skewNot addressedServer accepts iat/nbf up to 10 s ahead, rejects beyond 60 s
TLS 1.2 ciphersFour named suitesBCP 195 recommended suites
Public clientsNot allowedNot 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:

AlgorithmProof size (with ath, no nonce)Build and signVerify (with JWK import)
ES256534 bytes18 µs43 µs
EdDSA472 bytes17 µs35 µs
PS2561,120 bytes303 µs18 µ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.

SchemeProfile todayFlowToken bindingFAPI 2.0 status
UK Open Banking v4.0.1FAPI 1.0 AdvancedHybrid, signed request object, no JARMmTLSNo published plan
Australia CDR v1.36.0FAPI 1.0 AdvancedCode, PAR, PKCE, JARMmTLSDraft v1.37.0 proposes 30 April 2028
Brazil FAPI-BR v2.2.1FAPI 1.0 AdvancedPAR and PKCE, code id_token, encrypted ID tokenmTLSNothing on the scheme wiki
New Zealand v3.0.3FAPI 1 lineageCode, PAR, PKCE, JARMmTLSNone
UAE Open Finance v2.1FAPI 2.0 FinalPAR, RAR, signed request at PARmTLSLive
Chile (CMF, NCG 514)FAPI 2.0Not yet liven/aIn force 3 July 2027
Berlin Group openFinance 2.4.1No FAPIOAuth optionalQWAC mTLS, optional QSealC signatureNot 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_hash and c_hash checks disappear. Validate the iss parameter instead, and take the ID token from the token endpoint.
  • Request objects by value stop working at the authorisation endpoint.
  • aud as 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-id and friends have moved out of the profile into a non-final Implementation Advice draft.
On the server side, Keycloak has supported FAPI 2.0 Final and DPoP since 26.4.0, with client profiles named 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.