---
title: "Private Key JWT vs Client Secret: Choosing the right OAuth authentication for confidential clients"
description: "Understand how OAuth clients authenticate and when you should use client secrets vs private key JWT."
url: https://workos.com/blog/private-key-jwt-vs-client-secret
published: "Dec 22, 2025"
---

# Private Key JWT vs Client Secret: Choosing the right OAuth authentication for confidential clients

Most modern application integrations today are built on **OAuth** and **OpenID Connect**.

A developer registers an application, receives a `client_id` and `client_secret`, and uses those credentials to authenticate to the token endpoint. It is familiar, well-documented, and supported by every major identity provider. For many teams, it is also the only client authentication method they ever touch.

At some point, though, another option tends to surface: **`private_key_jwt`**.

Maybe it appears in a security review. Maybe it shows up in an enterprise customer’s requirements. Maybe an SDK mentions it in passing, framed as the “more secure” choice. Suddenly, developers are faced with a question they did not expect to answer: *Should we still be using a client secret, or should we switch to `private_key_jwt`?*

Both approaches solve the same problem. They authenticate a confidential client to an OAuth or OpenID Connect token endpoint. But they do so using fundamentally different models: **shared secrets versus cryptographic proof**.

This article unpacks how each method works, why `client_secret` remains the default in most integrations, and when `private_key_jwt` becomes the better long-term choice.

## **The problem OAuth client authentication is solving**

OAuth 2.0 and OpenID Connect distinguish between two broad client types:

- **Public clients**: Apps that can’t keep credentials secret (mobile apps, single-page apps). If you ship the code to untrusted devices, anything embedded in it can be extracted.
- **Confidential clients**: Apps that c*an* keep credentials secret because they run in a trusted environment (server-side web apps, backend services, CLIs with a secure backend). These clients are expected to authenticate to the authorization server.

This distinction matters because the most common OAuth flow (the [Authorization Code Flow](https://workos.com/blog/oauth-authorization-code-grant)) looks like this:

1. The user signs in at the authorization server.
2. The client (i.e., your app) receives an **authorization code** (a short-lived, one-time credential).
3. The client sends that code to the **token endpoint** to exchange it for tokens (access token, and in OIDC, an ID token)

That last step is where **client authentication** comes in.
At the token endpoint, the authorization server needs to answer: *"Is the caller exchanging this code actually the client it claims to be?"*

Why? Because if the token endpoint accepted a code *without* authenticating the client, then possession of the code alone would be enough to mint tokens. That creates a problem. OAuth assumes that authorization codes can leak in many ways (misconfigured redirect URIs, logs, compromised frontends, etc.). So clients need to prove their identity.

For confidential clients, there are a few standard ways to prove who they are. The two you’ll most often encounter are:

- **`client_secret`**: The client proves *knowledge* of a **shared secret** (usually via HTTP Basic auth or a form field). Same thing as using a password.
- **`private_key_jwt`**: The client proves *possession* of a **private key** by signing a short-lived JWT that the server verifies with the client’s registered public key.

Choosing between these two changes your security posture and your operational experience: how you store credentials, how you rotate them, and how ugly it gets when something leaks.

## **Client Secret: The password analogy**

With `client_secret`, the client authenticates using a shared secret issued at registration time. Like a password for your app.

When a confidential client uses a `client_secret`, the OAuth spec defines multiple ways to transmit that secret to the token endpoint. The two most common are `client_secret_basic` and `client_secret_post`.They differ only in *where* the credentials are placed in the request, not in what is being proven.

With `client_secret_basic`, the client authenticates using **HTTP Basic Authentication**. The client concatenates `client_id` and `client_secret` with a colon, base64-encodes the result, and sends it in the `Authorization` header.

Example:

```js
POST /oauth/token
Authorization: Basic Y2xpZW50X2lkOmNsaWVudF9zZWNyZXQ=
Content-Type: application/x-www-form-urlencoded

grant_type=authorization_code
&code=SplxlOBeZQQYbYS6WxSbIA
&redirect_uri=https://example.com/callback
```

Despite the name, this is not encryption. Base64 is just an encoding. Anyone who can see the header can recover the secret. The advantage of `client_secret_basic` is that credentials stay out of the request body, which some libraries and proxies handle more safely by default.

With `client_secret_post`, the client sends its credentials directly in the request body.

Example:

```js
POST /oauth/token
Content-Type: application/x-www-form-urlencoded

grant_type=authorization_code
&client_id=client_id
&client_secret=client_secret
&code=SplxlOBeZQQYbYS6WxSbIA
```

This method is simpler to implement and works in environments where setting custom headers is awkward. That convenience is also why it’s more likely to show up in logs, traces, or error reports if you are not careful.

### **Why it’s popular**

`client_secret` persists for good reasons:

- Simple mental model
- Easy to implement
- Works everywhere
- No cryptography required

For internal tools, prototypes, and low-risk systems, it feels like the path of least resistance.

### **Where it breaks down**

The simplicity hides structural weaknesses:

- **Shared secret risk**: Anyone who gets the secret *is* the client.
- **At-rest exposure**: Secrets must be stored and protected.
- **Rotation pain**: Rotating secrets risks downtime.
- **Poor cloud ergonomics**: Secrets sprawl across env vars, vaults, and CI logs.

In practice, breaches involving `client_secret` rarely involve cryptography failures. They involve copy-paste failures, logging failures, and human failures.Passwords age poorly. Client secrets behave the same way.

## **Private Key JWT: Cryptographic proof instead of knowledge**

`private_key_jwt` replaces shared secrets with **asymmetric cryptography**.At registration time:

- The client generates a key pair.
- The **public key** is shared with the authorization server.
- The **private key** never leaves the client.

When authenticating, the client:

1. Creates a JWT that contains the following claims:

- `iss`: The issuer of the assertion. Contains the `client_id`
- `sub`: The subject of the assertion. Contains the `client_id`. OAuth profiles require `iss` and `sub` to match for client authentication, which avoids ambiguity and simplifies validation.
- `aud`: The intended recipient of the JWT. `aud` binds the assertion to a **specific token endpoint**. Even if an attacker captures the JWT, they cannot replay it against a different authorization server or endpoint. This is one of the key replay protections built into `private_key_jwt`.
- `exp`: Expiration time. A timestamp after which the JWT is no longer valid. Client assertions are intentionally **very short-lived**. This dramatically limits the usefulness of a leaked JWT and ensures that authentication is based on *fresh proof of possession*, not long-term credentials.
- `jti`: A unique identifier for the JWT. Typically, a random UUID. The authorization server can store recently seen `jti` values and reject replays. This turns a stolen assertion into a one-shot artifact. Even within its validity window, it cannot be reused.

Sample JWT:

```js
// JOSE header
{
  "alg": "RS256",
  "kid": "k1",
  "typ": "JWT"
}
// JWT payload (claims)
{
  "iss": "client_123",
  "sub": "client_123",
  "aud": "https://id.example.com/token",
  "iat": 1700000000,
  "exp": 1700000300,
  "jti": "99eaa625-a1b4-44ac-84f7-a1596d8c4504"
}
```

2.Signs it with its private key.

3. Sends the JWT to the token endpoint.

```js
POST /oauth/token
client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer
client_assertion=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...
```

The server verifies the signature using the registered public key. No shared secret ever crosses the wire.

### **Why it’s more secure**

`private_key_jwt` does not just strengthen client authentication. It **changes the failure mode of the system**.

- With `client_secret`, the system fails when a long-lived shared secret leaks.
- With `private_key_jwt`, the system fails only if a private key is compromised *and* actively misused within a very narrow window.

That difference matters.

#### 1. Reduced impersonation risk

`client_secret` authentication relies on **symmetric cryptography**. The client and the authorization server both know the same secret. Anyone who gains access to that secret can impersonate the client indefinitely.

In practice, client secrets are often:

- Long-lived or never rotated.
- Stored in environment variables, config files, or secret managers.
- Accidentally exposed via logs, HAR files, error traces, or CI output.
- Sent verbatim on every token request.

Once leaked, there is no cryptographic distinction between the legitimate client and the attacker.

`private_key_jwt` uses **asymmetric cryptography** instead:

- The client holds a private key that never leaves its environment.
- The authorization server stores only the corresponding public key.
- Authentication is performed by signing a JWT (`client_assertion`) with the private key.

The public key cannot be used to forge signatures, and interception of traffic is useless without access to the private key.

Even a fully compromised authorization server does not expose client credentials that could be reused elsewhere.

This dramatically reduces the attack surface for credential theft.

#### 2. Short-lived, one-time authentication artifacts

With `client_secret`, the credential itself is static. Every request proves identity using the same secret.

With `private_key_jwt`, the credential is **the assertion**, not the key.

Each authentication attempt uses a freshly generated JWT that includes:

- `exp` to strictly limit its lifetime (often minutes)
- `jti` to uniquely identify the assertion

Authorization servers can reject expired assertions and track used `jti` values to prevent replay. Even if a signed assertion is captured, it is valid only once and only for a very short period.

This shifts authentication from “something you have forever” to “something you prove right now.”

#### 3. Stronger proof of which client made which request

A shared secret provides weak attribution.

If multiple systems, environments, or people have access to the same `client_secret`, it is impossible to prove which one initiated a specific request. From the server’s perspective, all requests authenticated with that secret are indistinguishable.

`private_key_jwt` provides **cryptographic proof of origin**:

- Only the holder of the private key can produce a valid signature
- The signature is verified against a specific registered public key
- Each assertion is bound to a single request and a specific audience

This enables much stronger **auditability**. When a token exchange is logged, the authorization server can assert with high confidence which client performed the action. That makes incident response, forensics, and compliance significantly more reliable.

#### 4. Safer and simpler credential management

Shared secrets create operational risk:

- They must be securely distributed
- Stored in multiple environments
- Rotated carefully to avoid downtime
- Protected from accidental exposure

Key-based authentication simplifies this lifecycle.

With `private_key_jwt`:

- No secret is transmitted during registration or authentication.
- Only public keys are stored server-side.
- Key rotation can be additive by publishing multiple public keys.
- Old keys can be retired without coordination windows or outages.

## **When Client Secret still makes sense**

Despite its flaws, `client_secret` is not obsolete. It can be acceptable when:

- Risk tolerance is low.
- Clients are short-lived.
- Environments are tightly controlled.
- Developer velocity matters more than defense-in-depth.

The danger is not in using it. The danger is in forgetting its limits.

## **Final thoughts**

If you remember only one thing:

- **Use `client_secret` for convenience**
- **Use `private_key_jwt` for confidence**

OAuth does not fail loudly. It fails quietly, months before anyone notices. Choosing stronger client authentication is one of the rare cases where the more secure option is also the more future-proof one.
