A classic OAuth authorisation request travels through the user's browser as plain query parameters, so anything in it can be read, logged or altered before the authorisation server sees it. Pushed Authorization Requests (PAR, RFC 9126) and JWT-Secured Authorization Requests (JAR, RFC 9101) fix this in two complementary ways: PAR moves the request to an authenticated back channel, and JAR wraps it in a signed and optionally encrypted JWT. FAPI 2.0 makes PAR mandatory, FAPI 2.0 Message Signing makes signed request objects mandatory on top, and OWASP ASVS 5.0 now asks for PAR at its highest level. This guide explains how each mechanism works, how they combine, how to configure authorisation servers and clients, and how to test and monitor them. It is for identity engineers, API security teams and architects of open banking, healthcare or high-value API platforms. For the wider OAuth 2.1 and FAPI landscape see the OAuth 2.1, GNAP and FAPI Guide.
Key takeaways
- PAR authenticates the client before the user is involved. The client POSTs the full request to the PAR endpoint using its normal client authentication and receives a short-lived, single-use
request_urifor the browser redirect. - JAR makes the request tamper-evident. A signed Request Object proves the request came from the client and was not altered; the server must use only the parameters inside it.
- They combine well. A signed Request Object can be pushed through PAR, which is exactly what FAPI 2.0 Message Signing requires.
- Enforcement is opt-in.
require_pushed_authorization_requestsandrequire_signed_request_objectboth default to false, so without them an attacker can fall back to an unprotected front-channel request. - PAR is not a replacement for PKCE. FAPI 2.0 still requires PKCE with S256, and RFC 9126 lists PKCE, state or nonce as defences against request URI swapping.
The problem PAR and JAR solve
- Integrity: query parameters such as
scope,redirect_uri,authorization_detailsorclaimscan be changed by malware, a malicious extension or an attacker crafting links. - Confidentiality: parameters leak into browser history, proxy and server logs and Referer headers. RFC 9126 notes that a back-channel POST avoids this exposure.
- Client authentication timing: in a plain request the authorisation server cannot authenticate a confidential client until the token request, after the user has already consented.
- Size: rich requests (RFC 9396 authorization details, OpenID Connect claims requests) become too large for URLs.
- Redirect URI trust: RFC 9700, the OAuth 2.0 Security Best Current Practice (BCP 240, January 2025), notes that where the origin and integrity of the request can be verified, for example with JAR or with PAR and client authentication, the server may trust the redirect URI without further checks.
How PAR works (RFC 9126)
- Discovery: the authorisation server publishes
pushed_authorization_request_endpointin its RFC 8414 metadata. - Push: the client sends an HTTPS POST (
application/x-www-form-urlencoded) with all authorisation parameters and its client authentication, using the same methods as at the token endpoint. For JWT client assertions, the server should expect its issuer identifier as audience and must also accept its token or PAR endpoint URL. - Validate: the server validates the request as it would at the authorisation endpoint and must reject a push that itself contains
request_uri. - Respond: on success it returns
201 Createdwithrequest_uriandexpires_in. The suggested format isurn:ietf:params:oauth:request_uri:<reference>; the reference must be cryptographically random and bound to the client. - Redirect: the client sends the browser to the authorisation endpoint with only
client_idandrequest_uri. - Consume: the server looks up the stored request, checks it has not expired and belongs to that client, and should treat the reference as single use.
| PAR detail | Value or rule | Source |
|---|---|---|
| Success status | 201 Created with request_uri, expires_in | RFC 9126 |
| Lifetime | Example range 5 to 600 seconds; FAPI 2.0 requires less than 600 seconds and warns to allow for slow devices | RFC 9126; FAPI 2.0 |
| Error statuses | 400 (invalid or signed-request violation), 405 (not POST), 413 (too large), 429 (rate limited) | RFC 9126 |
| Interaction errors | Errors such as consent_required are never returned at the PAR endpoint | RFC 9126 |
| Enforcement metadata | require_pushed_authorization_requests in server and client metadata, default false | RFC 9126 |
| Unregistered redirect URIs | May be allowed only for authenticated clients, under server policy | RFC 9126 |
How JAR works (RFC 9101)
- Request Object: a JWT whose claims are the authorisation parameters. It must contain everything needed to process the request except
requestandrequest_uri. - Signing and encryption: when signed it should carry
issandaud, withaudset to the authorisation server's issuer identifier. If both signing and encryption are used, sign first, then encrypt (a nested JWT). - By value or reference: send it in
request, or host it and sendrequest_uri(HTTPS if hosted externally, a URN if issued by the server, ideally under 512 ASCII characters). Never both. - Parameter precedence:
client_idoutside the JWT must match the one inside, and the RFC states that a conforming server "MUST only use the parameters included in the Request Object". There is no merging of query and JWT values. - Metadata: clients register
request_object_signing_alg(and encryption algorithms); servers advertise the matching*_values_supported.require_signed_request_object, default false, makes the server reject unsigned requests andalgofnone. - Error codes:
invalid_request_object,invalid_request_uri,request_not_supported,request_uri_not_supported. - Explicit typing: the RFC recommends
typofoauth-authz-req+jwtfor new profiles to prevent cross-JWT confusion, and warns against using the client ID assubso a Request Object cannot be replayed as a client authentication assertion. Separate signing keys for request objects and client assertions are another mitigation. See the JWT Security Guide.
OpenID Connect Core already defined request objects; JAR standardised them for plain OAuth and tightened the rules, notably the no-merge rule. Check which behaviour your server implements, because older OpenID Connect implementations merged parameters.
PAR, JAR or both: decision guidance
| Option | Integrity | Confidentiality from the browser | Client authenticated before consent | Non-repudiation of request | Implementation cost |
|---|---|---|---|---|---|
| Plain front-channel request | None | None | No | No | Lowest |
| JAR by value | Yes (signature) | Only if encrypted | Implicitly, by signature key | Yes | Client key management, larger URLs |
| JAR by external reference | Yes | Yes for parameters | Implicitly | Yes | Hosting, server must fetch URLs (outbound request risk) |
| PAR with client authentication | Yes (back channel) | Yes | Yes | No, unless signed | Low: one extra POST |
| PAR carrying a signed JAR | Yes | Yes | Yes | Yes | Highest |
- Default choice: PAR with strong client authentication (
private_key_jwtor mTLS) is the best value for most confidential clients and is what FAPI 2.0 requires. - Add JAR when: you need evidence of exactly what the client asked for (payments, consent records, regulated data sharing), or a regulator profile demands it, as FAPI 2.0 Message Signing does.
- Avoid external request URIs: having the server fetch client-hosted request objects adds denial-of-service and outbound request risk; RFC 9101 asks servers to check the URI points to an expected location, verify the media type, set a timeout and never follow recursive references. PAR makes this pattern unnecessary.
- Public clients: PAR can be used without client authentication, but FAPI 2.0 only supports confidential clients. For mobile and browser apps, PAR still keeps parameters out of URLs, but the main protection remains PKCE. See the OAuth for Native and Mobile Apps Guide.
Where profiles and standards require them
| Document and status (checked 27 October 2026) | PAR | JAR or signed requests | Related requirements |
|---|---|---|---|
| FAPI 2.0 Security Profile, OpenID Foundation Final (February 2025) | Required: server shall reject authorisation requests not sent via PAR and PAR without client authentication; expires_in under 600 seconds; redirect_uri required in the push | Not required | PKCE S256, confidential clients only, mTLS or private_key_jwt, sender-constrained tokens (mTLS or DPoP) |
| FAPI 2.0 Message Signing, OpenID Foundation (version 02, 25 September 2025, labelled Final) | Used as transport | Required: signed request objects at the PAR endpoint, aud = issuer, nbf no more than 60 minutes old, exp at most 60 minutes after nbf | Signed responses (JARM, response_mode=jwt), signed introspection (RFC 9701) |
| OWASP ASVS 5.0 | V10.4.13 (Level 3): code grant always used with PAR; V10.4.10: confidential clients authenticated for back-channel requests including PAR | Not specifically | V10.4.1 exact redirect URI matching; V10.4.12 restrict response_mode |
| RFC 9700 OAuth Security BCP | Recognised as giving request integrity | Recognised | PKCE, mix-up defences, sender constraint |
The FAPI 2.0 Message Signing page carries a warning that it is not yet an OpenID Foundation international standard despite its Final label; check the current version before contract or regulatory commitments. See the FAPI 2.0 Security Profile Implementation Guide.
Worked example: a payment consent flow
Consider a third-party provider asking a bank to authorise a single payment, described with RFC 9396 authorization_details (amount, currency, creditor account). Without protection, the amount and creditor sit in the browser URL where a malicious extension could change them before the user approves.
- Step 1, signed request object: the client builds a JWT with
iss= its client ID,aud= the bank's issuer,response_type=code,redirect_uri, the PKCEcode_challengewith method S256,state, theauthorization_details,nbfand a shortexp, headertyp=oauth-authz-req+jwt, signed with a key dedicated to request objects. - Step 2, push: the client POSTs
client_id, therequestJWT and aprivate_key_jwtclient assertion to the PAR endpoint. The bank authenticates the client, verifies the signature and innerclient_id, validates the payment details against the client's registration, and returns arequest_urivalid for, say, 90 seconds. - Step 3, redirect: the browser carries only
client_idand the opaquerequest_uri. Nothing an extension changes in the URL can alter the amount. - Step 4, consent and evidence: the bank shows the user the exact payment from the stored request and keeps the signed request object as evidence of what the client asked for.
- Step 5, token: the code is redeemed with the PKCE verifier and client authentication, and the access token is sender-constrained with mTLS or DPoP.
If the bank only implemented PAR without signing, steps 3 to 5 would still hold, but step 4 would lose the non-repudiable record. That is the practical difference between FAPI 2.0 and FAPI 2.0 with Message Signing.
Implementation roadmap
- Confirm support: check your authorisation server for the PAR endpoint, per-client and global enforcement switches, request object validation,
typchecking and request URI lifetime settings. - Strengthen client authentication first: PAR is only as strong as the authentication at the PAR endpoint. Move confidential clients from shared secrets to
private_key_jwtor mTLS. See the JWT Client Authentication (private_key_jwt) Guide. - Enable PAR without enforcing: update one client library to push requests, keep PKCE and state, and confirm sign-in still works across browsers and slow mobile networks.
- Set lifetimes: choose an
expires_inlong enough for real users (FAPI notes this may exceed 30 seconds) and under 600 seconds; make references single use. - Enforce per client: set
require_pushed_authorization_requestson migrated clients, then globally for the protected realm, so a downgraded front-channel request is rejected. - Add signed request objects where needed: register signing algorithms (no
none), setrequire_signed_request_object, settyptooauth-authz-req+jwt, and use a key distinct from the client assertion key. - Roll back safely: enforcement switches are per client, so a failing client can be returned to non-enforced mode while it is fixed; never disable PKCE as part of a rollback.
Testing and detection
- Negative tests: send a front-channel request with full parameters to an enforced client (must fail); reuse a
request_uri(should fail); use an expired one (must fail); use another client'srequest_uri(must fail); push without client authentication (must fail under FAPI). - JAR tests: mismatched outer and inner
client_id; unsigned andalg=noneobjects with enforcement on; altered query parameters next to a valid request object (server must ignore them); wrongaud; expiredexp; a client assertion presented as a request object and vice versa. - Monitoring: log PAR pushes with client ID, outcome and error code, and correlate them with authorisation endpoint hits. Spikes in
invalid_request_urior front-channel attempts against enforced clients indicate probing; 429s indicate abuse of the PAR endpoint. - Threat mapping: PAR and JAR reduce request manipulation by an adversary in the middle (MITRE ATT&CK T1557) and, combined with PKCE and sender-constrained tokens, the downstream risk of stolen application access tokens (T1528).
| Metric | Target |
|---|---|
| Confidential clients with PAR enforced | 100% in high-assurance realms |
| Clients authenticating to PAR with shared secrets | Zero in FAPI scope; decreasing elsewhere |
Median and maximum request_uri lifetime | Within policy, under 600 seconds |
| Front-channel requests rejected for enforced clients | Tracked; each spike investigated |
Request objects without typ or with reused signing keys | Zero for new clients |
Framework mapping
| Framework | Reference | Relevance |
|---|---|---|
| OWASP ASVS 5.0 | V10.4.13, V10.4.10, V10.4.1, V10.4.12 | PAR use, back-channel client authentication, redirect URI matching, response mode |
| NIST SP 800-53 Rev. 5 | SC-8 Transmission Confidentiality and Integrity; SC-23 Session Authenticity | Protecting request parameters and binding the flow |
| NIST SP 800-53 Rev. 5 | IA-9 Service Identification and Authentication; SI-10 Information Input Validation | Client authentication at the PAR endpoint; strict request object validation |
| NIST CSF 2.0 | PR.AA-03, PR.DS-02 | Authenticating services; protecting data in transit |
| MITRE ATT&CK | T1557, T1528, T1550.001 | Request tampering and token theft and reuse |
Common failure patterns
- PAR supported but not required: the endpoint exists, clients use it, but the server still accepts full front-channel requests, so attackers simply bypass it.
- Weak PAR client authentication: a long-lived client secret copied into many places makes the pushed request no more trustworthy than before. See the Machine-to-Machine OAuth (Client Credentials) Guide for credential handling.
- Reusable or long-lived request URIs: references that can be replayed for minutes or shared between clients.
- Parameter merging: a server that combines query parameters with the request object lets an attacker add or override values, which RFC 9101 forbids.
- Dropping PKCE or state: treating PAR as a full replacement opens request URI swapping, against which RFC 9126 recommends PKCE, state or nonce.
- Server-side fetching of arbitrary request URIs: fetching any client-supplied HTTPS URL invites resource exhaustion and outbound requests to internal hosts.
Practitioner checklist
- Publish
pushed_authorization_request_endpointand enable PAR for every confidential client. - Authenticate clients at the PAR endpoint with
private_key_jwtor mTLS. - Set
require_pushed_authorization_requestsper client, then for the whole high-assurance realm. - Issue single-use, client-bound request URIs with lifetimes under 600 seconds.
- Keep PKCE (S256) and state or nonce in every flow.
- For signed requests, require signatures, reject
alg=none, checkaud,exp,nbfandtyp, and never merge query parameters. - Disable server-side fetching of external request URIs unless strictly needed and allow-listed.
- Automate the negative test cases above in CI against a staging authorisation server.
Standards and references
- IETF: RFC 9126 OAuth 2.0 Pushed Authorization Requests
- IETF: RFC 9101 The OAuth 2.0 Authorization Framework: JWT-Secured Authorization Request (JAR)
- OpenID Foundation: FAPI 2.0 Security Profile
- OpenID Foundation: FAPI 2.0 Message Signing
- IETF: RFC 9700 Best Current Practice for OAuth 2.0 Security
- OWASP: Application Security Verification Standard 5.0
Related NHI Mgmt Group resources: OAuth 2.1, GNAP and FAPI Guide · FAPI 2.0 Security Profile Implementation Guide · OAuth 2.0 Security Best Current Practice (RFC 9700) Guide · OAuth Rich Authorization Requests (RAR) Guide · DPoP Guide