Join our Newsletter — 33% off our NHI Course
Home› FAQ› Authentication, Authorisation & Trust› What is the difference between using one JWT…
Authentication, Authorisation & Trust

What is the difference between using one JWT and multiple JWTs in an authorisation request?

← Back to all FAQ
By NHI Mgmt Group Editorial Team Updated October 31, 2026 Domain: Authentication, Authorisation & Trust

A single JWT works when one token contains everything the policy needs. Multiple JWTs are better when a request crosses identity boundaries, such as a service token and a user token. Keeping them separate preserves each token’s verification and lets policies compare claims across identities instead of flattening claims into attributes and losing trust context.

When one JWT is enough, and when it is not

A single JWT is appropriate when one bearer token can accurately represent the full authorisation context for the request. That works best when the caller, the resource, and the policy decision all sit in one trust boundary. Once a request crosses identity boundaries, the better pattern is to keep those identities separate rather than compress them into one token.

The practical difference is not token count, it is trust context. One JWT can be simpler to validate, but it can also blur which claims belong to which actor. Multiple JWTs preserve that separation, so policy can reason about a service identity and a user identity independently instead of treating them as one blended subject.

That distinction matters when the request is delegated. If a service is acting on behalf of a user, each JWT should continue to prove its own issuer, audience, and intended subject. Collapsing both identities into one token can make downstream policy look easier, but it removes the ability to distinguish who initiated the action from what system is carrying it out.

Why separate JWTs preserve better authorisation decisions

Separate tokens let you compare claims across identities instead of flattening them into generic attributes. That is useful when a policy needs to confirm that the service is allowed to call the API, and that the user is allowed to request the action. The result is clearer authorisation logic and less accidental privilege transfer between actors.

This also reduces ambiguity during audit and troubleshooting. If a request fails, you can tell whether the service token, the user token, or the relationship between them caused the denial. With a single merged JWT, failures can become harder to interpret because one token is carrying multiple trust assertions at once.

Multiple JWTs are especially useful where token lifespan or delegation scope differs between actors. A user token may be short-lived and interactive, while a service token may be non-interactive and machine-oriented. Keeping them separate allows each token to follow its own validation, expiry, and revocation rules without forcing a compromise between very different use cases.

Choosing the right pattern in a real authorisation flow

The deciding question is whether the policy decision needs to preserve actor separation. If yes, use multiple JWTs and evaluate each one for its own claims, issuer trust, and audience. If no, and a single actor fully represents the request, one JWT is usually simpler and less error-prone.

That separation is easiest to maintain when the surrounding control plane already treats authentication and authorisation as distinct steps. NHIMG’s JWT Security Guide covers the validation discipline that keeps each token trustworthy, while the Authorisation Models Guide helps map claims into policy decisions without overloading a single token with every control decision.

For delegated and service-to-service flows, the Guide to SPIFFE and SPIRE is useful because it shows how workload identity can stay distinct from user identity in modern service paths. When the flow is broader than a simple front-end login, that separation is often what keeps the policy explainable and the blast radius manageable.

Risk and Threat Considerations

Using a single JWT for multiple identities can create trust confusion, privilege overreach, and weaker auditability. The main risk is that a token becomes too broad to express which claims belong to which actor, so the policy engine may accept a request that should have required stronger separation or additional checks.

Failure mechanism: the application or gateway flattens user and service claims into one token, then authorises on the merged view. That can hide delegation boundaries, make overbroad scopes look legitimate, and create a harder-to-detect path for misuse if one token is stolen or replayed.

Impact: the request may be authorised with less context than the policy really needs, which can lead to incorrect access decisions, weaker attribution, and larger blast radius if the token is compromised. In mixed-user-and-service flows, that is often the difference between a contained denial and a delegated action being treated as fully trusted.

Standards & Framework Alignment

This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.

OWASP ASVS, NIST SP 800-53 Rev 5 and NIST Zero Trust (SP 800-207) set the governance and control requirements practitioners need to meet.

FrameworkControl / ReferenceRelevance
OWASP ASVSV10 — OAuth and OIDCJWT authorisation flows rely on OIDC/OAuth token handling and delegated claims.
Recommendation — Validate token audiences, issuers, and claim use before authorising delegated requests.
NIST SP 800-53 Rev 5IA-5 — Authenticator ManagementJWTs are bearer authenticators whose lifecycle and validity affect authorisation decisions.
AC-3 — Access EnforcementThe choice between one and multiple JWTs changes how access decisions are enforced across identities.
IA-9 — Service Identification and AuthenticationSeparate JWTs matter when a service identity and user identity both participate in the request.
Recommendation — Manage token issuance, expiry, rotation, and revocation so authorisation decisions stay trustworthy. Enforce access decisions on each identity's claims rather than on flattened combined attributes. Authenticate service identities separately from user identities when delegation crosses trust boundaries.
NIST Zero Trust (SP 800-207)Zero Trust ArchitectureThe question is about preserving explicit trust boundaries and per-request verification.
Recommendation — Verify each participating identity on every request instead of collapsing distinct trust contexts.

Practitioner Guidance

What to verify: check whether your policy must distinguish between the initiator and the actor carrying the request. If those are different, separate JWTs are usually the safer design because they let you validate each identity on its own terms.

Decision rule: if the request is purely single-actor, one JWT is acceptable; if it crosses an identity boundary, keep the tokens separate and compare their claims explicitly. Do not use a single merged token just to simplify implementation if that removes a meaningful trust boundary.

Common mistake: treating “more tokens” as complexity for its own sake. In delegated authorisation, the complexity already exists, and separate JWTs often make it more honest rather than more complicated.

Practitioner takeaway: choose the token structure that preserves the trust model, not the one that makes the parser simplest. If the request has two identities, the policy should be able to see two identities.

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
Reviewed and updated by the NHIMG editorial team on October 31, 2026.
NHI Mgmt Group — the #1 independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org