Join our Newsletter — 33% off our NHI Course
Home› Guides› FAPI 2.0 Security Profile Implementation Guide: High-Assurance OAuth…
Guide Authorisation

FAPI 2.0 Security Profile Implementation Guide: High-Assurance OAuth for Sensitive APIs

PDF for newsletter subscribers · free to read online

← All guides
By NHI Mgmt Group, edited by Lalit Choda Updated 27 October 2026 17 min read
On this page

Plain OAuth 2.0 leaves too many choices open for APIs that move money, health records or identity data, and most real OAuth weaknesses live in those choices. The FAPI 2.0 Security Profile from the OpenID Foundation removes them: it fixes the flow, the client authentication methods, the token binding, the algorithms and several numeric limits, and it was published as a Final specification on 22 February 2025 together with the FAPI 2.0 Attacker Model. This guide turns the profile into implementation work for each role (authorisation server, client and resource server), explains the decisions you still have to make, such as mTLS or DPoP, and covers testing, certification, migration from FAPI 1.0 and monitoring. It is written for identity architects, API platform engineers and security reviewers who already know the material in the OAuth 2.1, GNAP and FAPI Guide, which compares FAPI with OAuth 2.1 and GNAP at overview level. Specification statuses on this page were checked on the OpenID Foundation site on 27 October 2026.

Key takeaways

  • FAPI 2.0 is a profile, not a new protocol. It is OAuth 2.0 plus PAR, PKCE, the iss response parameter and sender-constrained tokens, with options removed and limits set, so most work is configuration and enforcement rather than new code.
  • Every role has duties. The authorisation server enforces PAR, PKCE S256, 60-second single-use codes and token binding; the client checks iss and uses only authoritative metadata; the resource server refuses tokens in query strings and verifies the sender constraint on every call.
  • Two real decisions remain. Choose mTLS or DPoP for sender-constrained tokens, and mTLS or private_key_jwt for client authentication; the rest is largely fixed by the profile.
  • Message Signing is a separate, optional layer. FAPI 2.0 Message Signing (Final, September 2025) adds signed requests, signed responses and signed introspection when you need non-repudiation, for example for payment initiation.
  • Test against the conformance suite, not your own reading. The profile itself recommends certified implementations, and the OpenID Foundation's free conformance tests cover both authorisation servers and clients.

What FAPI 2.0 is and the document set

FAPI began as the Financial-grade API work for open banking and is now used for open data, open finance and identity schemes. The FAPI working group's specifications page says FAPI has been adopted by "many ecosystems in many countries" and lists implementer resources for Australia's Consumer Data Right, Brazil Open Finance, EU PSD2, UK Open Banking and FDX in the USA and Canada. The working group recommends that new ecosystems adopt FAPI 2.0 and that existing FAPI 1.0 ecosystems plan a transition. Adoption and timelines differ by ecosystem: Australia's Data Standards Body InfoSec community group, for example, was still assessing the gap between the Consumer Data Right profile and FAPI 2.0 in April 2025, without a recorded decision. Always read your own ecosystem's profile, which may add rules on top of the base profile, such as pre-registered redirect URIs.

DocumentStatus (OpenID Foundation, checked 27 October 2026)What it is for
FAPI 2.0 Security ProfileFinal, 22 February 2025The mandatory baseline: flows, client authentication, token binding, cryptography, TLS
FAPI 2.0 Attacker ModelFinal, 22 February 2025Security goals and attacker capabilities the profile is proven against
FAPI 2.0 Message SigningFinal, 25 September 2025Optional signed requests (JAR), responses (JARM) and introspection for non-repudiation
FAPI 2.0 HTTP SignaturesDraftSigning of resource requests and responses; do not build on draft details
FAPI CIBA ProfileImplementer's Draft 1Decoupled flows where the user approves on another device
Grant Management for OAuth 2.0Implementer's Draft 1Querying, updating and revoking long-lived grants
FAPI 1.0 Baseline and AdvancedFinalThe previous generation, still in use in several ecosystems

Using the attacker model for threat modelling

The FAPI 2.0 Attacker Model sets three goals (authorisation, authentication and session integrity) and the attackers the profile withstands, from the web attacker (A1) and a malicious authorisation server in the ecosystem (A1a) to readers of authorisation requests (A3a) and of resource requests in places such as TLS-intercepting proxy logs (A5); the overview guide tabulates them. Use the model as your scope statement: for each FAPI rule someone proposes to relax, ask which attacker it answered. Note what it excludes: compromised browsers or operating systems, remote code execution on servers, misconfigured databases, credentials leaked by human error and implementation bugs all need your own controls.

Authorisation server requirements

The authorisation server carries most of the profile. The table lists the normative requirements in section 5.3.2 of the Security Profile with the values you will configure and test.

AreaRequirementValue or detail
DiscoveryPublish metadata per OpenID Connect Discovery and RFC 8414Advertise pushed_authorization_request_endpoint, require_pushed_authorization_requests, DPoP algorithms or mTLS aliases
ClientsConfidential clients only; reject the resource owner password credentials grantNo public clients, no grant_type=password
Client authenticationmTLS (RFC 8705) or private_key_jwtClient assertion aud must be the issuer identifier as a string, not an array
Flowresponse_type=code onlyNo implicit or hybrid responses, no ID tokens in the front channel
PAR (RFC 9126)Require it, reject authorisation requests without it, authenticate the client at the PAR endpointrequest_uri expires_in below 600 seconds; redirect_uri required in the pushed request
PKCE (RFC 7636)RequiredS256 only
Authorisation codesSingle use, reject reuseMaximum lifetime 60 seconds
Mix-up defenceReturn iss in the authorisation response (RFC 9207)Issuer identifier exactly as in metadata
RedirectsNo open redirectors; no http redirect URIs except native app loopbackDo not use HTTP 307 for requests carrying credentials; use 303
Access tokensSender-constrained only, via mTLS or DPoPWith DPoP, support authorisation code binding (dpop_jkt); server nonces optional
Refresh tokensDo not rotate except in extraordinary circumstancesTokens are already bound to a key, and rotation causes availability failures
Clock skewAccept iat and nbf up to 10 seconds in the futureReject values more than 60 seconds in the future
OpenID ConnectIf supported, accept nonce values up to 64 charactersIf the user identifier is returned in the token response, OpenID Connect must be supported
PrivilegesShould restrict token privileges to the minimumUse RAR (RFC 9396) when scope cannot express the grant

Two notes in the specification often trip up implementers: state is not FAPI's CSRF defence (PKCE is), and the request_uri lifetime must allow for handoff between devices, which can exceed 30 seconds. See the OAuth Pushed Authorization Requests and JAR Guide for PAR endpoint design and the OAuth Rich Authorization Requests (RAR) Guide for fine-grained grants.

Client requirements

Client-side failures are less visible than server ones, because the server cannot see whether a client checked a value. Section 5.3.3 of the profile requires the client to:

  • Use PAR and send only two parameters to the authorisation endpoint: client_id and request_uri. Everything else, including scope, RAR details and the PKCE challenge, travels in the authenticated back-channel POST.
  • Generate a fresh PKCE challenge for every request: with S256, bound to both the client and the user agent, so a code captured from one browser cannot be redeemed in another session.
  • Check iss on every response: this is the mix-up defence when the client talks to more than one authorisation server.
  • Trust only authoritative metadata: obtain the issuer URL from an authoritative source over a secure channel, use only endpoints from the metadata document, and confirm that the metadata issuer matches the expected issuer.
  • Support refresh token rotation anyway: servers should not rotate, but clients must handle it if a server does.
  • Handle binding mechanics: with mTLS, use mtls_endpoint_aliases when the server publishes them; with DPoP, support server-provided nonces (the DPoP-Nonce header and use_dpop_nonce error in RFC 9449).
  • Protect initiation: start a flow only with the user's consent and protect the initiating endpoint against CSRF; request the least privilege needed.

Resource server requirements

  • Header only: accept tokens in the Authorization header (RFC 6750 section 2.1, or the DPoP scheme in RFC 9449 section 7.1) and never in query parameters, which leak into logs and browser history.
  • Full validation: verify validity, integrity, expiry and revocation status, then whether the token's authorisation covers the request, returning RFC 6750 errors when it does not.
  • Verify the binding on every call: for mTLS, compare the certificate thumbprint in the token or introspection response with the presented client certificate; for DPoP, check the proof's htm, htu, iat, jti and ath, and reject a DPoP-bound token presented with the Bearer scheme.
  • Plan for proof replay: section 6.2 of the profile notes that an A5 attacker can obtain and replay DPoP proofs. Mitigate with short-lived server nonces, jti replay caches, Message Signing, or mTLS instead.

The DPoP Guide and the mTLS Guide cover the binding mechanics in depth.

Cryptography, keys and transport

ControlFAPI 2.0 requirementPractical note
TLS versionTLS 1.2 or later, following BCP 195Adopt new BCP 195 versions within 12 months; non-browser endpoints allow only BCP 195 cipher suites
Certificate checksServer certificate check per RFC 9525DNSSEC should be used; CAA records help against rogue certificates
Browser endpointsPrevent TLS stripping (HSTS)No CORS on the authorisation endpoint
JWT algorithmsPS256, ES256 or EdDSA with Ed25519; never noneNote that RS256 is not on the list; follow RFC 8725 JWT best practice
Key sizesRSA at least 2048 bits; elliptic curve at least 224 bitsApplies to client and server keys
Token and code entropyAt least 128 bits for non-user credentialsCovers codes, tokens and request_uri values
Key distributionjwks_uri served over TLS only; avoid x5u and jkuAvoid duplicate kid values; verifiers also match kty, use, alg

Section 6.8 adds key compromise advice: automate key rotation through jwks_uri, use single-purpose keys, weigh stateful against stateless tokens (a stolen signing key can mint valid stateless tokens) and record which credentials are linked so related ones can be revoked together. See the JSON Web Key Sets and Signing Key Rotation Guide.

Where identity fits: client credentials as non-human identities

Every FAPI client is a confidential client holding a private key, either the mTLS certificate key or the private_key_jwt signing key, plus DPoP keys where used. Manage them as non-human identities: a named owner per client, keys in an HSM or secrets manager, rotation through the JWKS endpoint and a revocation path tested before go-live. Section 6.3 of the profile also recommends separate DPoP keys or mTLS certificates per authorisation server, which limits the Cuckoo's Token attack where a malicious server injects a stolen token. See the JWT Client Authentication Guide and the Machine Identity, PKI and Certificate Lifecycle Guide.

Decisions: mTLS or DPoP, and private_key_jwt or mTLS

FactormTLS (RFC 8705)DPoP (RFC 9449)
LayerTransport: binding to the TLS client certificateApplication: a signed proof JWT on every request
InfrastructurePKI, certificate issuance and a trust list; the profile says mTLS ecosystems should provide the CA trust listKeys only; no client certificates
Gateways and proxiesHarder where TLS terminates before the serverSurvives TLS termination because the proof is in the header
Replay of captured requests (A5)Strong: a logged token is useless without the TLS keyProofs can be replayed within their window; needs nonces or jti caches
  • Choose mTLS when: your ecosystem already runs a PKI (many open banking schemes do), clients are server-side, and TLS terminates at a point you control. It can then serve as both client authentication and token binding.
  • Choose DPoP when: you have layered gateways or CDNs, no ecosystem PKI, or clients you cannot issue certificates to. Budget for nonce handling and replay caches.
  • Choose private_key_jwt for client authentication when: you use DPoP, or want client authentication independent of transport; set aud to the issuer string and keep assertion lifetimes short.
  • Small versus large: a single server with a few partner clients can support one combination only; large ecosystems must decide centrally so every server and client interoperates.

Adding FAPI 2.0 Message Signing

The base profile gives integrity in transit; Message Signing adds evidence. Its stated goal is that a party cannot later convincingly deny having signed a message such as a payment request, so signatures are stored with the payload and metadata. It defines three methods, each testable on its own:

  • Signed authorisation requests: a JAR request object (RFC 9101) sent to the PAR endpoint, with aud containing the issuer, nbf no more than 60 minutes in the past, exp no more than 60 minutes after nbf, and typ of oauth-authz-req+jwt.
  • Signed authorisation responses: JARM with response_mode=jwt. The specification notes these carry OAuth artefacts such as the code, so they add integrity but limited non-repudiation value.
  • Signed introspection responses: JWT introspection responses per RFC 9701, which let a resource server keep proof of what the authorisation server asserted.

Adopt it where a scheme rulebook or dispute process needs proof of who authorised what, and apply minimisation and access control to stored signed messages, which may contain personal data. It does not sign resource requests.

Migrating from FAPI 1.0 Advanced

FAPI 1.0 AdvancedFAPI 2.0 Security ProfileMigration work
JAR request objectsPARAdd the PAR endpoint and switch clients to request_uri
JARM or hybrid responsesCode-only responses, no ID token in the front channelRetire hybrid flow handling
s_hashPKCE S256Add PKCE to every client
Pre-registered redirect URIsredirect_uri sent in PAREcosystems may still require registration
mTLS-only token bindingmTLS or DPoPOptional: offer DPoP for clients without certificates
x-fapi-* headers in the profileMoved to a separate advice documentKeep using them if your ecosystem requires them

How to implement: a phased rollout

  1. Baseline and scope: list every server, client and resource server in scope, the applicable ecosystem profile and the rules you already meet.
  2. Decide the options: sender constraint, client authentication and algorithm set.
  3. Harden the server in report mode first: enable PAR and PKCE alongside existing flows, log every request that would fail FAPI rules (no PAR, plain PKCE, long-lived codes, bearer tokens), and share the list with client owners.
  4. Migrate clients in rings: internal test clients, then one partner, then the rest. Run each client through the OpenID Foundation conformance suite before production.
  5. Enforce at the resource servers: turn on sender-constraint checks per API, starting with the highest-value endpoints, and reject tokens in query strings.
  6. Switch enforcement on at the server: set require_pushed_authorization_requests, reject non-PAR requests, cut code lifetime to 60 seconds and stop issuing bearer tokens.
  7. Roll back safely: keep enforcement switches per client, not global, so one failing partner can be returned to the old policy for a fixed period while it fixes its client. Never roll back by re-enabling bearer tokens for everyone.
  8. Certify and keep testing: run conformance tests in CI against each release, and self-certify where your ecosystem requires it.

Conformance testing and certification

The OpenID Foundation runs a free, open conformance suite. Implementers run the tests themselves and submit results through self-certification, after which an implementation may use the "OpenID Certified" mark; fees are set in a separate schedule. Final conformance tests exist for the FAPI 2.0 Security Profile and Message Signing, for both authorisation servers and clients, and the tests support DPoP. Section 6.6 of the profile recommends certified implementations. Certification proves conformance at test time, not your deployment configuration or key management.

Detection and measurement

  • Log at the authorisation server: PAR requests and rejections, reused or expired codes, PKCE failures, client assertion failures (wrong aud, stale iat), DPoP proof failures and use_dpop_nonce challenges.
  • Log at the resource server: binding failures (wrong certificate thumbprint, missing or invalid proof, Bearer scheme on a DPoP token), replayed jti values and tokens offered in query strings.
  • Alert on: a reused authorisation code (a sign of interception), repeated binding failures for one client, and tokens presented from a different client certificate than the one they were issued to (possible token theft, ATT&CK T1528 Steal Application Access Token and T1550.001 Application Access Token).
MetricTargetWhy it matters
Share of authorisation requests arriving through PAR100% after enforcementFront-channel parameters are the A3a attack surface
Share of access tokens issued sender-constrained100%Bearer tokens defeat the profile's main protection
Clients passing the conformance suite on the current releaseAll in-scope clientsCatches regressions in client checks the server cannot see
Resource server binding-check failures per dayLow and stable; investigate spikesSpikes mean misconfigured clients or token replay
Signing keys rotated within policy100%Section 6.8 recommends automated rotation

Framework mapping

FAPI 2.0 controlNIST SP 800-53 Rev 5NIST CSF 2.0ISO/IEC 27001:2022 Annex A
Client authentication with mTLS or private_key_jwtIA-9 Service Identification and Authentication, IA-5 Authenticator ManagementPR.AA-03A.8.5 Secure authentication
Sender-constrained tokens, single-use codes, PKCESC-23 Session AuthenticityPR.AA-03A.8.5 Secure authentication
TLS 1.2+, BCP 195, HSTSSC-8 Transmission Confidentiality and IntegrityPR.DS-02A.8.24 Use of cryptography
Algorithm and key size rulesSC-13 Cryptographic ProtectionPR.DS-02A.8.24 Use of cryptography
Least-privilege tokens, RARAC-6 Least PrivilegePR.AA-05A.5.15 Access control

Against MITRE ATT&CK, sender-constrained tokens reduce the value of T1528 Steal Application Access Token and T1550.001 Application Access Token, and TLS with certificate checks addresses T1557 Adversary-in-the-Middle.

Common failure patterns

  • PAR offered but not required: the server advertises PAR yet still accepts front-channel requests, so the A3a protection only exists for well-behaved clients. Set require_pushed_authorization_requests and reject the rest.
  • Binding issued but never checked: the server issues DPoP or mTLS-bound tokens but a resource server or gateway still accepts them as bearer tokens. Test each API with a stolen-token scenario before calling it FAPI.
  • Trusting a forwarded certificate header: a gateway passes the client certificate in an HTTP header that external callers can also set, so the mTLS binding can be forged. Strip the header at the edge.
  • Rotating refresh tokens by default: a common OAuth habit that FAPI 2.0 tells servers to avoid, because network failures then lock clients out of long-lived grants. If you must rotate, allow a time-limited retry.
  • Using RS256 because the library defaults to it: the profile allows only PS256, ES256 and EdDSA. Pin algorithms on both sides and reject anything else, including none.
  • Enforcing request_uri one-time use at page load: link scanners and retries consume the URI and the user's real attempt fails. Enforce at completion of the authorisation.

Practitioner checklist

  • Confirm which ecosystem profile applies and record where it adds to or differs from the base FAPI 2.0 Security Profile.
  • Decide mTLS or DPoP for token binding and mTLS or private_key_jwt for client authentication, and document the reasons.
  • Require PAR, PKCE S256, response_type=code, 60-second single-use codes and request_uri lifetimes below 600 seconds.
  • Return iss on every authorisation response and make every client check it.
  • Issue only sender-constrained access tokens and verify the binding at every resource server and gateway.
  • Pin JWT algorithms to PS256, ES256 or EdDSA, with RSA keys of at least 2048 bits, and serve jwks_uri over TLS only.
  • Store client and DPoP private keys in an HSM or secrets manager, with a named owner and a tested rotation and revocation path.
  • Run the OpenID Foundation conformance suite for servers and clients in CI, and self-certify where required.
  • Decide whether you need Message Signing for non-repudiation and plan retention of signed messages.
  • Monitor PAR coverage, binding failures, code reuse and key rotation, and alert on code reuse and token presentation from the wrong key.

Standards and references

Related NHI Mgmt Group resources: OAuth 2.1, GNAP and FAPI Guide · OAuth 2.0 Security Best Current Practice Guide · DPoP Guide · PSD2/PSD3 Strong Customer Authentication Guide · OIDC CIBA Guide

PDF for subscribers

Take this guide with you

Every section, table and checklist in one PDF, with links to the sources and related guides. Subscribe to our weekly NHI & AI Identity Journal and we’ll email you a download link.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Researched and written by the NHI Mgmt Group editorial team using AI tools, under the editorial direction of Lalit Choda. Facts are drawn from the sources listed on this page and checked by our automated quality process. Last updated 27 October 2026. Spotted an error? Use our contact page.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM and Agentic AI security. nhimg.org

PDF Downloads for Newsletter Subscribers

Get the guide

Enter your details and we’ll email you a download link.

The full guide is free to read online. The PDF is a thank you for subscribing.

Fill in all fields marked * and tick the PDF box to continue.