> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mcpmanager.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP Authorization Support

> Which MCP revisions and OAuth standards MCP Manager supports on each OAuth leg of a call, AI client to gateway and gateway to upstream MCP server: client ID metadata documents (CIMD), dynamic client registration, client pre-registration, PKCE, resource indicators, signed client assertions, and what is not supported.

**MCP Manager** implements the OAuth-based authorization model that the Model Context Protocol defines for HTTP servers, on each leg of a call that uses OAuth. An AI client signs in to the gateway, and the gateway signs in to an upstream MCP server that uses OAuth. The two legs work differently, so this page lists what is supported on each, and what is not. It describes what MCP Manager does. It doesn't claim conformance to any one revision of the specification.

Servers that authenticate with a token in custom headers, and headless agents that use a [gateway API token](https://docs.mcpmanager.ai/features/api-tokens-and-headless-agents.md), do not use this model. For how the two sign-ins fit together, see [Two separate authentications](https://docs.mcpmanager.ai/security/authentication-and-identity.md#two-separate-authentications).

## Supported MCP revisions

The gateway speaks these MCP revisions, with AI clients and with upstream servers:

`2026-07-28` · `2025-11-25` · `2025-06-18` · `2025-03-26` · `2024-11-05`

The OAuth behavior on this page is the same whichever revision a client or server speaks.

## What is supported, by leg

| | AI client to gateway | Gateway to upstream server |
| - | - | - |
| **Authorization server metadata** ([RFC 8414](https://datatracker.ietf.org/doc/html/rfc8414)) | Served at `/.well-known/oauth-authorization-server`. | Read from the upstream server's authorization server. |
| **Protected resource metadata** ([RFC 9728](https://datatracker.ietf.org/doc/html/rfc9728)) | Served at `/.well-known/oauth-protected-resource`. A `401` from the gateway names it in its `WWW-Authenticate` header. | Read from the server's well-known path, or from the `resource_metadata` URL in the server's `401`. Which one MCP Manager tries first depends on the step: see [How MCP Manager identifies itself](#how-mcp-manager-identifies-itself-to-an-upstream-server) and [Resource indicators sent upstream](#resource-indicators-sent-upstream). |
| **Client ID metadata document (CIMD)** | Supported. An `https` URL with a host and a path longer than `/` is read as the client's document. An unusable one is refused. | Supported. Used for a server with no client yet, when its authorization server advertises it. MCP Manager presents its own document. |
| **Dynamic client registration** ([RFC 7591](https://datatracker.ietf.org/doc/html/rfc7591)) | Supported, at `/api/v1/oauth/register`. | Supported. Used for a server with no client yet, when its authorization server does not advertise CIMD. |
| **Client pre-registration** | Not applicable. AI clients use a client ID metadata document or register dynamically. | Supported. You provide a Client ID, and a Client Secret if the provider gave you one. |
| **PKCE** ([RFC 7636](https://datatracker.ietf.org/doc/html/rfc7636)) | Required on every authorization, with the `S256` method. | Sent on every authorization. |
| **Resource indicators** ([RFC 8707](https://datatracker.ietf.org/doc/html/rfc8707)) | The `resource` parameter is accepted and recorded, as supplied, as the token's audience. | Sent when the server's protected resource metadata allows it. See [Resource indicators sent upstream](#resource-indicators-sent-upstream). |
| **Client authentication at the token endpoint** | `none` (public client with PKCE), `client_secret_basic`, `client_secret_post`, and `private_key_jwt`. | `client_secret_post`, `client_secret_basic`, or `none`. |
| **Grant types** | Authorization code and refresh token. | Authorization code and refresh token. MCP Manager refreshes tokens automatically. |

## How an AI client identifies itself to the gateway

MCP Manager tells the two methods apart by the `client_id` the client sends. If it is an `https` URL, MCP Manager treats it as a client ID metadata document, and refuses it if it isn't a usable document URL. Any other `client_id` is looked up as a registered client, for example one that registered dynamically.

### Client ID metadata documents

The client publishes a JSON document at a URL it controls and uses that URL as its `client_id`. MCP Manager fetches the document and checks it before the user sees a consent screen. The document must meet these requirements:

* Its URL, which is the `client_id`, is `https`, has a path longer than `/`, has no embedded credentials or control characters, and is at most 2,048 characters long.
* It is served over `https`, straight from the URL. MCP Manager doesn't follow redirects, so a document behind an `http` to `https` redirect or a vanity-domain redirect is refused.
* It is served as `application/json`, is no larger than 64 KiB, and answers within 5 seconds.
* It is served from a publicly reachable address. MCP Manager refuses a document on a private network address.
* Its `client_id` field equals the URL it was fetched from.
* It has a `client_name` of at most 255 characters and a `redirect_uris` list of at most 20 entries, each at most 2,048 characters long.
* Each redirect URI passes the same checks MCP Manager applies when a client registers dynamically. For example, no `javascript:` scheme, no embedded credentials, and `http` only on a loopback address.
* It declares a `token_endpoint_auth_method` of `none` or `private_key_jwt`. A document that leaves it out is refused.
* If it has a `logo_uri` or a `client_uri`, each is an `https` URL of at most 2,048 characters.

The `redirect_uri` the client sends at sign-in must match one the document lists, character for character. The one exception is the port on an `http` loopback address such as `http://127.0.0.1` or `http://localhost`: a document may list one without a port, and the client may then send the port it opened.

When MCP Manager refuses a document, the error response gives the reason. If the request came from a signed-in workspace member, an admin may also see an [AI client sign-in alert](https://docs.mcpmanager.ai/features/alerts.md#ai-client-sign-in-alerts).

### Signed client assertions

A client document can declare `private_key_jwt` and publish its keys with `jwks_uri` or an inline `jwks`. MCP Manager registers the client for `private_key_jwt` when it can use those keys. For such a client, MCP Manager verifies the signed assertion with the keys the client publishes, at the token, revocation, and introspection endpoints. MCP Manager supports these algorithms: `RS256`, `RS384`, `RS512`, `PS256`, `PS384`, `PS512`, `ES256`, `ES384`, `ES512`, and `EdDSA`.

The assertion's audience must be the URL of MCP Manager's token, revocation, or introspection endpoint, or its issuer URL. It must expire within one hour (plus about a minute of clock skew) and carry a unique `jti`. MCP Manager accepts each assertion only once. If MCP Manager then refuses the request the assertion signed, the assertion can be used again. A client that registered dynamically can use `private_key_jwt` too.

## How MCP Manager identifies itself to an upstream server

MCP Manager first discovers the server's authorization server. It reads the server's protected resource metadata, then the authorization server's own metadata, from well-known paths. If that doesn't work, MCP Manager looks for authorization server metadata at the MCP server's own address. If all of that fails, it follows the `resource_metadata` URL in the server's `401`. It then picks how to identify itself:

1. **A client that already exists for the server is normally reused.** That is a client you pre-registered, or one MCP Manager already holds for the server.
2. **Otherwise, a client ID metadata document**, when the authorization server advertises support for them. MCP Manager does not register. It presents the address of its own document as its `client_id`.
3. **Otherwise, dynamic client registration**, at the registration endpoint the authorization server advertises. When none is advertised, MCP Manager tries `/register` on the MCP server's own address: its scheme, host, and port, without the path.

If none of these works, use [client pre-registration](https://docs.mcpmanager.ai/security/authentication-and-identity.md#oauth-with-client-pre-registration). [Choosing a remote server's authentication method](https://docs.mcpmanager.ai/mcp-gateway-concepts/mcp-servers/choosing-remote-auth.md) explains when.

MCP Manager's own client ID metadata document is at:

```text MCP Manager's client ID metadata document theme={null}
https://app.mcpmanager.ai/api/v1/oauth/client-metadata.json
```

Its `client_id` is that same URL. It lists the [callback URL](https://docs.mcpmanager.ai/security/authentication-and-identity.md#standard-oauth-with-dynamic-client-registration) as its only redirect URI. It declares `token_endpoint_auth_method` as `none`, because MCP Manager is a public client that uses PKCE, and it publishes no keys.

> [!NOTE]
>
> With a client ID metadata document, the upstream authorization server fetches the document from MCP Manager over the internet. If the authorization
> server's network blocks outbound requests or uses an allowlist, allow that URL, or the authorization server cannot identify MCP Manager.

## Resource indicators sent upstream

When MCP Manager authorizes against an upstream server, it reads the server's protected resource metadata again. This time it tries the `resource_metadata` URL from the server's `401` first, and the well-known path after that. It then decides which [resource indicator](https://datatracker.ietf.org/doc/html/rfc8707) to send:

* If the server's protected resource metadata names a usable `resource` on the server's own origin, MCP Manager sends it.
* If the metadata names no `resource`, MCP Manager sends the server's own address, without any query, fragment, or credentials.
* If there is no metadata, the named value is unusable or on another origin, or the server's address isn't `https`, MCP Manager sends nothing.
* If the lookup itself fails (for example, it times out) and the server was authorized before, MCP Manager resends the resource from the server's most recently updated grant, as long as it is still usable. When MCP Manager knows the server's address, that resource must also be on the server's origin. If nothing usable is stored, it sends nothing.

If the server rejects the resource indicator, MCP Manager retries once without it when the error could be about that parameter. That means any OAuth error except `access_denied`, `login_required`, `consent_required`, `interaction_required`, `invalid_client`, `invalid_grant`, `server_error`, and `temporarily_unavailable`, and also a bare HTTP 400. It doesn't retry on a `5xx`.

## What is not supported

* **OpenID Connect discovery.** The gateway does not serve `/.well-known/openid-configuration`, and it does not use it to find an upstream server's endpoints. It uses RFC 8414 and RFC 9728 metadata only.
* **Grant types other than authorization code and refresh token.** The gateway's token endpoint does not issue tokens for the `client_credentials` grant or the device authorization grant.
* **Signed assertions from MCP Manager to an upstream server.** MCP Manager identifies itself upstream with a client secret or as a public client with PKCE. It does not use `private_key_jwt` and publishes no keys.
* **Upstream servers that accept only clients they have approved.** MCP Manager cannot connect to such a server until its vendor approves MCP Manager. Figma's remote server is an example. See [Connect Figma](https://docs.mcpmanager.ai/mcp-server-guides/figma.md).

## Further reading

> [card] [Authentication & Identity](https://docs.mcpmanager.ai/security/authentication-and-identity.md)
>
> The two separate authentications, and how MCP Manager stores and refreshes the credentials it brokers.

> [card] [Choosing a Remote Server's Authentication Method](https://docs.mcpmanager.ai/mcp-gateway-concepts/mcp-servers/choosing-remote-auth.md)
>
> When to use standard OAuth, client pre-registration, or a token in custom headers.

> [card] [Alerts](https://docs.mcpmanager.ai/features/alerts.md#ai-client-sign-in-alerts)
>
> The alerts an admin sees when an AI client cannot be verified.

## External sources

> [card] [MCP authorization spec](https://modelcontextprotocol.io/specification/draft/basic/authorization)
>
> The OAuth-based authorization model defined by the Model Context Protocol.

> [card] [RFC 7523](https://datatracker.ietf.org/doc/html/rfc7523)
>
> JWT profile for client authentication, the basis of `private_key_jwt`.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.