MCP OAuth 2.1: PKCE, Resource Metadata and Client ID Metadata Documents The 2026-07-28 revision of the Model Context Protocol specification makes Client ID Metadata Documents (CIMD) the default client registration method for MCP authorization, deprecating Dynamic Client Registration, according to the spec changelog. The revision also requires MCP clients to check the `iss` parameter when the authorization server sends it, and requires clients still using DCR to send an `application_type` of `native` or `web` so OIDC servers do not reject native redirect URIs. The spec continues to require MCP servers to validate that access tokens were issued specifically for them and forbids passing received tokens through to upstream APIs. MCP OAuth 2.1: PKCE, Resource Metadata and Authorization - Share: 3366 Members A remote MCP server that accepts a GitHub token because "the user already consented in GitHub" is not implementing MCP authorization. It is doing token teleportation with better branding. The failure is not theoretical: the MCP authorization spec explicitly treats an MCP server as its own protected resource, requires tokens to be intended for that server, and forbids accepting or passing through tokens meant for some other upstream API. If your MCP server accepts a GitHub access token directly, or forwards the MCP client's token to GitHub, you have collapsed two trust boundaries into one convenient foot-gun. The 2025-06-18 MCP authorization spec https://modelcontextprotocol.io/specification/2025-06-18/basic/authorization says MCP servers must validate that access tokens were issued specifically for them and must not pass through received tokens to upstream APIs. That is the whole story of OAuth on MCP: OAuth is the right foundation, but most implementations stop one layer too early. They add a bearer token, call it "secure," and then let the agent do whatever the server's broad token can do. OAuth 2.1 gives MCP a standard way to authenticate the client session, bind a user delegation to an MCP server, discover the right authorization server, and issue audience-bound access tokens. It does not, by itself, decide whether this particular agent should call delete repo after reading a poisoned issue comment. That second decision is fine-grained authorization, what a proper MCP gateway https://www.permit.io/mcp-gateway handles at the tool-call layer, and pretending scopes alone solve it is how teams end up with production agents holding "admin, but vibes-based." For the broader picture of MCP authorization strategies including RBAC, ABAC, and ReBAC, see MCP Authorization: Spec-Level Security with Resource Metadata and Zero Standing Permissions https://www.permit.io/blog/authorization-strategies-for-model-context-protocol-mcp . Updated November 4, 2026 for the 2026-07-28 MCP spec. Client ID Metadata Documents CIMD are now the default way for an MCP client to register, Dynamic Client Registration is deprecated, and clients must check the iss parameter when the authorization server sends it. Details in the next section. The 2026-07-28 revision https://modelcontextprotocol.io/specification/2026-07-28/changelog is the current MCP spec. Three changes matter for OAuth on MCP: client id , and that URL serves a JSON document describing the client. An authorization server that supports CIMD fetches it when it sees an HTTPS URL as the client id metadata document supported , then DCR as a fallback if the server has a registration endpoint , and only then prompting the user to enter client details manually. iss in the authorization response, and MCP clients MUST check a present The revision also adds a smaller fix scoped to legacy DCR: clients that still use DCR MUST send an appropriate application type native for desktop, CLI, and localhost apps, web for remote browser apps so OIDC servers don't reject native redirect URIs. The rest of this guide reflects these changes. In a normal SaaS app, OAuth answers a familiar question: may this application access this user's data at this service? MCP sharpens the question. The client is often an AI assistant, the resource is an MCP server exposing tools, the user is delegating work, and the tool call may mutate code, send messages, create tickets, query databases, or trigger infrastructure workflows. The MCP authorization model is intentionally transport-level. The 2025-03-26 specification https://modelcontextprotocol.io/specification/2025-03-26/basic/authorization says authorization applies to HTTP-based transports, while STDIO implementations should retrieve credentials from the environment instead of following the HTTP OAuth flow. That is a useful boundary. It means the MCP client sends an access token on HTTP requests to the MCP server, and the MCP server validates that token before processing the request. It also means the authorization layer sits before JSON-RPC tool execution, not inside the model, not in the prompt, and definitely not in a README saying "please don't do dangerous things." The 2025-03-26 version https://modelcontextprotocol.io/specification/2025-03-26/basic/authorization established the core direction: OAuth 2.1, authorization server metadata, dynamic client registration, PKCE, bearer tokens in the Authorization header, token expiration, redirect URI validation, and 401/403 behavior. The later 2025-06-18 version https://modelcontextprotocol.io/specification/2025-06-18/basic/authorization tightened the architecture by making the protected MCP server an OAuth 2.1 resource server and requiring protected resource metadata, authorization server metadata, and resource indicators. This matters because MCP deployments are not one app talking to one known identity provider. They are many clients, many MCP servers, many authorization servers, and many humans delegating to many agents. Static configuration does not scale. It barely survives staging. The MCP-specific OAuth stack is not "OAuth, somehow." It is a set of discovery and registration contracts that let an arbitrary MCP client connect to an arbitrary protected MCP server without hardcoding everything in advance. The key pieces are: /.well-known/oauth-protected-resource . /.well-known/oauth-authorization-server . The 2025-03-26 MCP authorization spec https://modelcontextprotocol.io/specification/2025-03-26/basic/authorization says MCP implementations must implement OAuth 2.1 when authorization is supported, should support dynamic client registration, and requires MCP clients to implement OAuth authorization server metadata discovery. It also requires PKCE for all clients and says access tokens must be sent in the Authorization: Bearer