MCP Authorization: OAuth 2.1, Resource Indicators, Scopes
How MCP authorization works in the 2026-07-28 spec: protected resource metadata, RFC 8707 resource indicators, step-up scopes and no token passthrough.
On 28 July 2026 the Model Context Protocol (MCP) published its fourth authorization revision in sixteen months. The changes look small. Together with the rules already in place, they decide whether a stolen token reaches one server or your whole estate. Clients must now check the issuer returned with the authorization code, credentials are bound to the server that minted them, and Dynamic Client Registration is deprecated.
This is for the people who put an MCP server in front of real data: security architects, platform engineers and CISOs. We walk the 2026-07-28 flow, show where scope design limits blast radius, and report what a random sample of the official MCP Registry implements. Our earlier post on designing enterprise MCP servers covered tool design. This one is only about authorization.
TL;DR / Key takeaways
- The server is an OAuth resource server. It must publish Protected Resource Metadata (RFC 9728) and validate that every token was issued for it.
- Resource indicators bind the token to one server. Clients must send
resource=<canonical server URI>in the authorization and token requests (RFC 8707). That stops replay across servers. - Scopes are your blast-radius control. Keep
scopes_supportedminimal and step up with403 insufficient_scope. On our ordinal scoring, per-tool scopes with step-up cut a stolen credential's reach from 18 of 18 points (static key) to 5. - No passthrough, ever. A server that calls a downstream API gets its own token.
- Implementations lag the spec. In our probe, 83% of OAuth-protected servers still offered deprecated Dynamic Client Registration; under half advertised Client ID Metadata Documents or issuer identification.
Download: Editable draw.io file · Open in diagrams.net · Chart data (CSV)
Why this matters now
MCP authorization has moved fast. The 2025-03-26 revision introduced an OAuth 2.1-based framework. 2025-06-18 made MCP servers OAuth resource servers with protected resource metadata, and made resource indicators mandatory for clients. 2025-11-25 added OpenID Connect discovery, incremental scope consent and Client ID Metadata Documents (CIMD). 2026-07-28 adds issuer validation (SEP-2468), binds credentials to their issuer (SEP-2352) and deprecates Dynamic Client Registration (DCR).
The baseline in the field is weak. In October 2025, Astrix analysed 5,205 open-source MCP server repositories: about 88% need credentials, 53% rely on static API keys or personal access tokens, and only 8.5% use OAuth. Meanwhile identity providers have caught up: Microsoft documents MCP servers on Entra ID (updated 1 September 2026), and MCP lists Enterprise-Managed Authorization as a stable extension. "We can't do OAuth for MCP" is no longer credible.
One scoping note: authorization is optional in MCP and defined for HTTP transports. STDIO servers take credentials from the environment. Everything below assumes a remote server over Streamable HTTP.
The flow, step by step
① The 401 challenge
The client calls without a token. The server answers 401 with a WWW-Authenticate header carrying resource_metadata and, ideally, a scope naming what this operation needs. Clients must treat the challenged scopes as authoritative for the current operation. It is the cheapest least-privilege control you have, yet only 19% of servers in our probe named a scope.
② Protected resource metadata (RFC 9728)
The client fetches the metadata document, falling back to the path-inserted well-known URI (/.well-known/oauth-protected-resource/mcp) and then the root if the header is missing. The document must list at least one authorization_servers entry and carries the server's resource identifier. RFC 9728 requires the client to check that resource matches the URL it called, and to discard the metadata otherwise.
③ Authorization server discovery and the PKCE gate
The client fetches the authorization server metadata, trying RFC 8414 and OpenID Connect discovery in a fixed order. The issuer in the document must be identical to the one used to build the URL. If code_challenge_methods_supported is absent, the client must refuse to proceed. It uses S256 and records the expected issuer next to its PKCE verifier for step ⑤.
④ Client identity and consent
The specification's registration priority is: pre-registered credentials, then CIMD where the authorization server advertises client_id_metadata_document_supported, then DCR as a deprecated fallback. With CIMD, the client_id is an HTTPS URL to a JSON document with client_name and redirect_uris, which the authorization server fetches and validates. Your authorization server now fetches URLs supplied by strangers, so apply SSRF controls and a domain allow-list. CIMD cannot prove which local process listens on a localhost redirect, so the consent screen must show the redirect hostname.
⑤ Issuer validation: closing the mix-up hole
New in 2026-07-28: authorization servers should return iss in the authorization response (RFC 9207), and clients must compare it, as a plain string, with the recorded issuer before sending the code anywhere. This defends against mix-up attacks, where a malicious authorization server obtains a code minted by an honest one. The best-practices page is explicit that PKCE alone does not prevent this.
⑥ Resource indicators: the token's audience (RFC 8707)
The client must send resource, set to the server's canonical URI, in both the authorization and the token request, even if the authorization server ignores it. A supporting server issues a token whose audience is that one MCP server. This is the most important property in the flow: a token for https://crm-mcp.example.com is worthless at https://hr-mcp.example.com. Use the form without a trailing slash; some identity providers match it character for character.
⑦ Server-side validation and step-up
On every request the server validates signature, issuer, audience and expiry, then checks the scope against the tool being called. Invalid tokens get a 401. Missing permissions get 403 with error="insufficient_scope" and the needed scope, all of them in one challenge. The client re-authorises with the union of its previous and the challenged scopes, with a retry limit. Incremental consent is what makes fine-grained scopes usable.
⑧ No passthrough: downstream calls get their own token
Most enterprise MCP servers are facades over Microsoft Graph, an ERP or a SaaS API. The server must not accept or transit any token not issued for it. Upstream, it acts as an OAuth client with a separate token, typically via token exchange (RFC 8693) or Entra ID's on-behalf-of flow. Proxy servers that use a static upstream client ID must also collect per-client consent first, or a consent cookie lets an attacker skip the consent screen. Our piece on agent identity and token exchange goes deeper on this hop.
What the numbers say
This matrix is our analysis, not a measurement: six credential and scope models scored 0 (contained) to 3 (high) on six blast-radius dimensions. The biggest single drop comes from audience binding. A shared service token scores 17 of 18; audience-bound, it scores 11, because replay at other servers collapses. But one server-wide scope still lets a hijacked agent call every tool, deletes included. Per-tool scopes with step-up for writes bring the score to 5, and an approval gate on destructive tools, as in our human-in-the-loop approval gates pattern, to 4.
Method. On 15 November 2026 we listed every streamable-HTTP remote in the official MCP Registry (42,420 distinct URLs) and drew a seeded random sample of 150. We sent each one an unauthenticated initialize call (the handshake that 2026-07-28 drops, so servers on earlier revisions still answer it), then fetched only public metadata in the order the specification prescribes. No tokens, no registrations. 142 answered; 48 returned a 401, and most of the rest accepted the anonymous call. One hosting platform accounts for 5 of the 48. With N = 48, read this as direction, not prevalence. Per-server rows are in the CSV.
The mandatory basics are mostly there: 90% publish protected resource metadata and 90% advertise PKCE S256. The newer features lag: 46% advertised CIMD and 46% issuer identification, while 83% still offered DCR. Expect clients to fall back to DCR and to requesting everything in scopes_supported for a while.
In a recent engagement…
A DACH manufacturer wanted an internal MCP server in front of its ERP order data, first for developers' IDE agents, later for a customer-service copilot. The prototype "worked", with three problems we see often. The server checked signature and tenant but not audience, so a Microsoft Graph token from the same tenant was accepted. The app registration still issued v1 tokens, so the team had switched off the resource parameter to get past AADSTS9010010. And one scope, mcp.access, covered both reading and cancelling orders.
The fix was quick. We moved to v2 tokens with the canonical server URL as Application ID URI, added the audience check, split scopes into orders.read, orders.write and orders.cancel with cancel behind an approval step, and moved the ERP call to on-behalf-of. The feared consent fatigue never came: with step-up, most users only ever see the read scope.
The implementation checklist
| # | Who | Control | Spec level | How to test |
|---|---|---|---|---|
| 1 | Server | Publish PRM with resource and authorization_servers | MUST | resource equals the URL clients use |
| 2 | Server | 401 with resource_metadata and a precise scope | SHOULD | Anonymous call returns both |
| 3 | Server | Validate signature, iss, aud, expiry every request | MUST | A token for another API in the same tenant is rejected |
| 4 | Server | 403 insufficient_scope naming all needed scopes | SHOULD | Read-only token on a write tool returns 403 |
| 5 | Server | No passthrough; own token downstream | MUST | Downstream logs show the server's identity |
| 6 | Client | resource in authorization and token requests | MUST | Inspect the authorization URL and token POST |
| 7 | Client | PKCE S256; refuse if not advertised | MUST | Metadata without it aborts the flow |
| 8 | Client | Validate iss before redeeming the code | MUST if present | Tampered iss aborts |
| 9 | Client | SSRF controls on metadata URLs | MUST consider | resource_metadata pointing to 169.254.169.254 is refused |
| 10 | Auth server | Short-lived tokens; CIMD allow-list; open DCR off | SHOULD / MAY | Unknown client_id domains rejected |
On Microsoft Entra ID, follow Microsoft's MCP guidance: set requestedAccessTokenVersion to 2 before setting the server URL as Application ID URI, name the v2.0 issuer in authorization_servers, and expect aud to be the app's client ID, not the URL. Our Entra ID hardening guide covers the tenant side.
Governance for European enterprises
No EU regulation mentions MCP. Several apply to what an MCP server can reach.
- NIS2. Article 21(2) of Directive (EU) 2022/2555 lists access control policies (point i) and multi-factor or continuous authentication (point j). A shared static key is hard to defend as an access control policy; per-user, audience-bound tokens are easy to evidence.
- DORA. Article 9(4)(c) of Regulation (EU) 2022/2554 requires financial entities to limit logical access to what legitimate, approved functions need. Per-tool scopes and step-up map directly to that wording.
- GDPR. Articles 25 and 32 apply whenever a tool returns personal data. Scope minimisation is data minimisation for agents.
Inventory comes first; see our guide to discovering and governing shadow MCP servers.
A pragmatic adoption path
- Week 1: inventory. List every remote MCP server and its credential. Static keys and shared service tokens go first.
- Week 2: resource-server basics. Publish metadata, return a proper 401 and enforce audience validation. This removes cross-server replay.
- Weeks 3–4: scopes per tool group. Start with read, write and destructive tiers; challenge for the rest with
insufficient_scope. - Month 2: the downstream hop. Replace passthrough with token exchange or on-behalf-of; add per-client consent to proxies.
- Month 3: registration. Prefer pre-registration or CIMD with an allow-list, switch off open DCR, require
iss, and evaluate Enterprise-Managed Authorization so your identity provider decides which MCP servers a client may reach.
The verdict
The MCP authorization specification is now good: standard OAuth with the right RFCs, and the mix-up gap closed. The risk has moved to implementation: servers that skip the audience check, clients that drop resource to silence an error, one-entry scope catalogues. Audience binding is non-negotiable and buys the largest single reduction in blast radius. Per-tool scopes with step-up earn the rest.
If you want a second pair of eyes on your MCP estate, from resource metadata to the downstream hop, our Zero Trust and cybersecurity practice reviews exactly this. Where the servers front production agents, our AI practice designs the scope model with you.
FAQ
What changed in MCP authorization with the 2026-07-28 specification?
Clients must validate the iss parameter of the authorization response against the issuer they recorded (RFC 9207) before redeeming a code. Client credentials are bound to the authorization server that issued them. Dynamic Client Registration is deprecated in favour of Client ID Metadata Documents. Resource indicators, protected resource metadata and PKCE were already mandatory.
Is authorization mandatory for MCP servers?
No, the specification makes it optional. An HTTP-based server that does protect itself should follow the MCP authorization specification and must then publish Protected Resource Metadata (RFC 9728). STDIO servers take credentials from the environment instead. For anything that touches company data, we treat it as mandatory.
What is the resource parameter and why does MCP require it?
It comes from RFC 8707. The client sends the MCP server's canonical URI in the authorization and token requests, and a supporting authorization server issues a token whose audience is that one server. The server must reject tokens not issued for it, so a compromised server cannot replay your token elsewhere.
Should we use Dynamic Client Registration or Client ID Metadata Documents?
For new work, Client ID Metadata Documents: the client_id is an HTTPS URL to a metadata document the authorization server fetches. Dynamic Client Registration is deprecated but kept for backwards compatibility. Inside an enterprise, pre-registration remains the most controlled option and comes first in the specification's priority order.
Can an MCP server forward the user's token to a downstream API?
No. Token passthrough is explicitly forbidden. The server only accepts tokens issued for itself. For an upstream API it acts as an OAuth client with a separate token from that API's authorization server, for example via token exchange (RFC 8693) or the Entra ID on-behalf-of flow.
How do we make MCP authorization work with Microsoft Entra ID?
Set requestedAccessTokenVersion to 2 on the server's app registration, then set the Application ID URI to the exact server URL clients send as resource. Define scopes per operation and name the v2.0 issuer in the resource metadata. Microsoft attributes error AADSTS9010010 to a resource value that does not match the Application ID URI, often because of a trailing slash.
Sources
All sources checked on 15 November 2026.
Tier A: primary specifications, standards and regulation
- MCP specification 2026-07-28, Authorization: https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization
- MCP 2026-07-28, Authorization Server Discovery: https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization/authorization-server-discovery
- MCP 2026-07-28, Client Registration: https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization/client-registration
- MCP 2026-07-28, Authorization Security Considerations: https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization/security-considerations
- MCP Security Best Practices (2026-07-28): https://modelcontextprotocol.io/docs/2026-07-28/tutorials/security/security_best_practices
- MCP changelogs (2025-03-26, 2025-06-18, 2025-11-25, 2026-07-28): https://modelcontextprotocol.io/specification/2026-07-28/changelog
- MCP blog, "The 2026-07-28 Specification": https://blog.modelcontextprotocol.io/posts/2026-07-28/
- MCP authorization extensions (Enterprise-Managed Authorization, OAuth Client Credentials): https://github.com/modelcontextprotocol/ext-auth
- RFC 8707, Resource Indicators for OAuth 2.0: https://www.rfc-editor.org/rfc/rfc8707
- RFC 9728, OAuth 2.0 Protected Resource Metadata (April 2025): https://www.rfc-editor.org/rfc/rfc9728
- RFC 9207, OAuth 2.0 Authorization Server Issuer Identification: https://www.rfc-editor.org/rfc/rfc9207
- RFC 8693, OAuth 2.0 Token Exchange: https://www.rfc-editor.org/rfc/rfc8693
- The OAuth 2.1 Authorization Framework (Internet-Draft): https://datatracker.ietf.org/doc/draft-ietf-oauth-v2-1/
- Microsoft Learn, "Secure a Model Context Protocol (MCP) server with Microsoft Entra ID" (updated 1 September 2026): https://learn.microsoft.com/en-us/entra/agent-id/secure-mcp-server-with-entra-id
- Directive (EU) 2022/2555 (NIS2), Article 21: https://eur-lex.europa.eu/eli/dir/2022/2555/oj/eng
- Regulation (EU) 2022/2554 (DORA), Article 9: https://eur-lex.europa.eu/eli/reg/2022/2554/oj/eng
- Regulation (EU) 2016/679 (GDPR), Articles 25 and 32: https://eur-lex.europa.eu/eli/reg/2016/679/oj/eng
Tier B: research and original data
- Astrix Security, "State of MCP Server Security 2025" (15 October 2025): https://astrix.security/learn/blog/state-of-mcp-server-security-2025/
- CC Conceptualise, MCP Registry authorization probe, 15 November 2026 (150 sampled, 48 OAuth-protected; method above, rows in the CSV). Sampling frame: https://registry.modelcontextprotocol.io/v0/servers
Tier C: vendor and directional
- None relied on for facts in this article.
Topics