Join our Newsletter — 33% off our NHI Course
Home› Guides› OAuth Pushed Authorization Requests and JAR Guide: Protecting…
Guide Authorisation

OAuth Pushed Authorization Requests and JAR Guide: Protecting Authorisation Request Integrity

PDF for newsletter subscribers · free to read online

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

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_uri for 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_requests and require_signed_request_object both 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_details or claims can 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)

  1. Discovery: the authorisation server publishes pushed_authorization_request_endpoint in its RFC 8414 metadata.
  2. 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.
  3. Validate: the server validates the request as it would at the authorisation endpoint and must reject a push that itself contains request_uri.
  4. Respond: on success it returns 201 Created with request_uri and expires_in. The suggested format is urn:ietf:params:oauth:request_uri:<reference>; the reference must be cryptographically random and bound to the client.
  5. Redirect: the client sends the browser to the authorisation endpoint with only client_id and request_uri.
  6. 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 detailValue or ruleSource
Success status201 Created with request_uri, expires_inRFC 9126
LifetimeExample range 5 to 600 seconds; FAPI 2.0 requires less than 600 seconds and warns to allow for slow devicesRFC 9126; FAPI 2.0
Error statuses400 (invalid or signed-request violation), 405 (not POST), 413 (too large), 429 (rate limited)RFC 9126
Interaction errorsErrors such as consent_required are never returned at the PAR endpointRFC 9126
Enforcement metadatarequire_pushed_authorization_requests in server and client metadata, default falseRFC 9126
Unregistered redirect URIsMay be allowed only for authenticated clients, under server policyRFC 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 request and request_uri.
  • Signing and encryption: when signed it should carry iss and aud, with aud set 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 send request_uri (HTTPS if hosted externally, a URN if issued by the server, ideally under 512 ASCII characters). Never both.
  • Parameter precedence: client_id outside 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 and alg of none.
  • Error codes: invalid_request_object, invalid_request_uri, request_not_supported, request_uri_not_supported.
  • Explicit typing: the RFC recommends typ of oauth-authz-req+jwt for new profiles to prevent cross-JWT confusion, and warns against using the client ID as sub so 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

OptionIntegrityConfidentiality from the browserClient authenticated before consentNon-repudiation of requestImplementation cost
Plain front-channel requestNoneNoneNoNoLowest
JAR by valueYes (signature)Only if encryptedImplicitly, by signature keyYesClient key management, larger URLs
JAR by external referenceYesYes for parametersImplicitlyYesHosting, server must fetch URLs (outbound request risk)
PAR with client authenticationYes (back channel)YesYesNo, unless signedLow: one extra POST
PAR carrying a signed JARYesYesYesYesHighest
  • Default choice: PAR with strong client authentication (private_key_jwt or 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)PARJAR or signed requestsRelated 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 pushNot requiredPKCE 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 transportRequired: signed request objects at the PAR endpoint, aud = issuer, nbf no more than 60 minutes old, exp at most 60 minutes after nbfSigned responses (JARM, response_mode=jwt), signed introspection (RFC 9701)
OWASP ASVS 5.0V10.4.13 (Level 3): code grant always used with PAR; V10.4.10: confidential clients authenticated for back-channel requests including PARNot specificallyV10.4.1 exact redirect URI matching; V10.4.12 restrict response_mode
RFC 9700 OAuth Security BCPRecognised as giving request integrityRecognisedPKCE, 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.

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 PKCE code_challenge with method S256, state, the authorization_details, nbf and a short exp, header typ = oauth-authz-req+jwt, signed with a key dedicated to request objects.
  • Step 2, push: the client POSTs client_id, the request JWT and a private_key_jwt client assertion to the PAR endpoint. The bank authenticates the client, verifies the signature and inner client_id, validates the payment details against the client's registration, and returns a request_uri valid for, say, 90 seconds.
  • Step 3, redirect: the browser carries only client_id and the opaque request_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

  1. Confirm support: check your authorisation server for the PAR endpoint, per-client and global enforcement switches, request object validation, typ checking and request URI lifetime settings.
  2. 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_jwt or mTLS. See the JWT Client Authentication (private_key_jwt) Guide.
  3. 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.
  4. Set lifetimes: choose an expires_in long enough for real users (FAPI notes this may exceed 30 seconds) and under 600 seconds; make references single use.
  5. Enforce per client: set require_pushed_authorization_requests on migrated clients, then globally for the protected realm, so a downgraded front-channel request is rejected.
  6. Add signed request objects where needed: register signing algorithms (no none), set require_signed_request_object, set typ to oauth-authz-req+jwt, and use a key distinct from the client assertion key.
  7. 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's request_uri (must fail); push without client authentication (must fail under FAPI).
  • JAR tests: mismatched outer and inner client_id; unsigned and alg=none objects with enforcement on; altered query parameters next to a valid request object (server must ignore them); wrong aud; expired exp; 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_uri or 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).
MetricTarget
Confidential clients with PAR enforced100% in high-assurance realms
Clients authenticating to PAR with shared secretsZero in FAPI scope; decreasing elsewhere
Median and maximum request_uri lifetimeWithin policy, under 600 seconds
Front-channel requests rejected for enforced clientsTracked; each spike investigated
Request objects without typ or with reused signing keysZero for new clients

Framework mapping

FrameworkReferenceRelevance
OWASP ASVS 5.0V10.4.13, V10.4.10, V10.4.1, V10.4.12PAR use, back-channel client authentication, redirect URI matching, response mode
NIST SP 800-53 Rev. 5SC-8 Transmission Confidentiality and Integrity; SC-23 Session AuthenticityProtecting request parameters and binding the flow
NIST SP 800-53 Rev. 5IA-9 Service Identification and Authentication; SI-10 Information Input ValidationClient authentication at the PAR endpoint; strict request object validation
NIST CSF 2.0PR.AA-03, PR.DS-02Authenticating services; protecting data in transit
MITRE ATT&CKT1557, T1528, T1550.001Request 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_endpoint and enable PAR for every confidential client.
  • Authenticate clients at the PAR endpoint with private_key_jwt or mTLS.
  • Set require_pushed_authorization_requests per 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, check aud, exp, nbf and typ, 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

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

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.