# What is OAuth 2.0 Authorization Server Metadata?

> A standard JSON document an OAuth authorization server publishes at a fixed web address built from its own name. Clients fetch it to learn the server's endpoints, keys and supported features instead of having them typed in by hand.

Explainer by Boston Identity, 2026-10-16. 6 min read. https://insights.bostonidentity.com/glossary/authorization-server-metadata

- What it is: standard
- Defined by: IETF, RFC 8414 (Standards Track, 2018)
- Who it's for: Teams running OAuth or MCP clients

## What is OAuth 2.0 Authorization Server Metadata?

An OAuth client needs to know a lot about the authorization server it talks to: where to send the user to sign in, where to get tokens, which keys sign the server's responses, and which options it supports. RFC 8414 puts all of that in one JSON (JavaScript Object Notation) document. The server publishes it at a well-known location derived from its issuer identifier, the https URL that names the server [S1 §1, §2].

The format comes from OpenID Connect Discovery 1.0 and stays compatible with it, but RFC 8414 makes it apply to OAuth uses that have nothing to do with OpenID Connect [S1 §1]. Other specifications can add their own fields through an IANA registry, the public list kept by the Internet Assigned Numbers Authority, after review by designated experts [S1 §7, §7.1].

The document can be self-asserted by the server over HTTPS. It can also carry signed values in a JSON Web Token (JWT), where the signer vouches for the data [S1 §1, §2.1].

Think of it like this: It works like the directory in a building's lobby: you know the street address, and the directory tells you which floor each office is on. The comparison breaks at trust, because anyone can print a directory, so the client has to check that the address printed on it is exactly the one it walked in at.

Not the same as: Not limited to OpenID Connect, even where the names suggest it. The openid-configuration path and the op_policy_uri and op_tos_uri fields come from OpenID Connect Discovery, but in RFC 8414 they refer to general OAuth features [S1 §5].

## How does OAuth 2.0 Authorization Server Metadata work?

Two actors take part: the client, which wants to use OAuth, and the authorization server, which issues tokens. The client starts knowing only the server's issuer identifier.

[Figure: How an OAuth client fetches an authorization server's metadata and checks it before use.]

1. **The client starts from the issuer identifier.** The issuer identifier is an https URL with no query or fragment. RFC 8414 does not say how the client picks a server: the identifier may be configured by hand, or found through a lookup such as WebFinger [S1 §1, §2].
2. **The client builds the well-known URL.** The client inserts "/.well-known/oauth-authorization-server" between the host and any path in the issuer identifier, after removing a trailing slash. So an issuer of https://example.com/issuer1 gives /.well-known/oauth-authorization-server/issuer1 on example.com, which lets one host serve many tenants [S1 §3, §3.1]. An application may register its own suffix instead, but it must say which one it uses [S1 §3].
3. **The client fetches it over TLS.** The client must send an HTTP GET to that path, and the path must use https [S1 §3, §3.1]. The client must check the server's TLS (Transport Layer Security) certificate against the issuer URL, which blocks man-in-the-middle and DNS-based attacks [S1 §6.1, §6.2].
4. **The server answers with its metadata.** A successful answer must be a 200 OK with a JSON object [S1 §3.2]. Its members are a subset of the values RFC 8414 defines. The issuer and the supported response types are required, while fields such as the jwks_uri where the signing keys live, the supported grant types and the client authentication methods are optional [S1 §2, §3.2]. The authorization endpoint is required unless no grant type the server supports uses it, and the token endpoint is required unless the server supports only the implicit grant [S1 §2]. Lists with no entries must be left out [S1 §3.2].
5. **The client checks the issuer matches.** The issuer value in the document must be identical to the identifier the client used to build the URL. If the two differ, the client must not use any of the data [S1 §3.3]. The comparison is code point by code point, with no Unicode normalization [S1 §4].
6. **The client uses what the server advertised.** The client uses the listed endpoints and picks among the methods the server says it supports [S1 §2, §3.2]. Some omitted fields carry defaults: with no grant_types_supported, the default is authorization_code and implicit, and with no code_challenge_methods_supported the server does not support PKCE, Proof Key for Code Exchange [S1 §2]. For the signing algorithm lists, no default is implied [S1 §2]. If the client supports signed metadata, signed values must win over the plain ones [S1 §2.1].

## Why does OAuth 2.0 Authorization Server Metadata matter now?

More OAuth rules now key on the issuer identifier that RFC 8414 defines. RFC 8414 says that identifier is there to prevent authorization server mix-up attacks [S1 §2]. The OAuth working group's revision of RFC 7523 says a JWT that authenticates a client must use the server's issuer identifier as its sole audience, the party the token is meant for. The token endpoint URL must not be used, and the server must reject any JWT without the issuer as its only audience [BI-FIND-2026-0350](https://insights.bostonidentity.com/ref/BI-FIND-2026-0350). The draft's reason is that endpoint addresses other than the issuer cannot be validated, and the attack it answers is the audience-injection class University of Stuttgart researchers disclosed in January 2025 [BI-FIND-2026-0350](https://insights.bostonidentity.com/ref/BI-FIND-2026-0350).

The Model Context Protocol (MCP) applies the same binding on the client side. Its revision of 2026-07-28 says clients must key stored credentials by the issuer identifier and must re-register when the authorization server changes. Two client-side SDK bugs broke that rule, and the Python SDK's fix was exactly that binding [BI-FIND-2026-0399](https://insights.bostonidentity.com/ref/BI-FIND-2026-0399).

A draft on refresh-token lifetimes notes that missing lifetime fields may mean no fixed limit, or, from a server that has not declared support in its metadata, possibly no support at all. The draft says clients should handle the two cases the same way [BI-FIND-2026-1067](https://insights.bostonidentity.com/ref/BI-FIND-2026-1067).

## Where does it fit?

- Compared with Pushed Authorization Requests: The revision of RFC 7523 gives pushed authorization requests the same audience rule it sets for client-authentication JWTs. The issuer identifier defined by RFC 8414 is the only allowed value [BI-FIND-2026-0350](https://insights.bostonidentity.com/ref/BI-FIND-2026-0350).
- Compared with Dynamic Client Registration: Dynamic Client Registration is how a client signs itself up with a server at runtime. RFC 8414 tells the client where that sign-up happens, through the optional registration_endpoint field [S1 §2].
- Compared with JWT Bearer Grant: RFC 7523 covers the JWT a client signs to authenticate itself. Its revision makes the RFC 8414 issuer identifier that JWT's only audience and bars the token endpoint URL [BI-FIND-2026-0350](https://insights.bostonidentity.com/ref/BI-FIND-2026-0350). RFC 8414 lists which signing algorithms the token endpoint accepts for such JWTs [S1 §2].
- Compared with PKCE: RFC 8414 is where a server lists the PKCE code challenge methods it supports. Leaving that field out means the server does not support PKCE [S1 §2].

## What goes wrong?

- An attacker who can sit in the network path or poison DNS can feed a client fake endpoints and keys if the client skips the certificate check. The attacker could then reach whatever the client has access to [S1 §6.2].
- An attacker can publish a document that copies the real server's issuer value but lists its own endpoints and signing keys. The exact issuer match is the defense, and the client must perform it [S1 §6.2].
- When the issuer has a path, RFC 8414 and OpenID Connect Discovery put the well-known string in different places. Legacy deployments may need to publish at both, and clients should try the RFC 8414 location first [S1 §5].
- The standard does not decide which APIs a client should use with a server. If a client uses the wrong one, an attacker may proxy a real API without the server or client noticing [S1 §6.4].
- The document is not a full inventory. A server may choose not to advertise some scopes it supports [S1 §2], and a standard format makes the server easier to use for attackers as well as for clients [S1 §6.3].

## What should a security leader ask?

1. Do our OAuth and MCP clients refuse a metadata document whose issuer does not exactly match the issuer they started from?
2. Do our clients store tokens and registrations keyed by issuer, and re-register when the authorization server changes?
3. Which of our clients that sign JWTs to authenticate still put the token endpoint URL in the audience instead of the issuer?
4. For tenants whose issuer has a path, which discovery location do our libraries try first?
5. Does our authorization server publish code_challenge_methods_supported, so clients can see that PKCE is on?

## Sources

- [S1] [RFC 8414: OAuth 2.0 Authorization Server Metadata](https://www.rfc-editor.org/rfc/rfc8414) (IETF, RFC, Standards Track, June 2018)

## Evidence

- [BI-FIND-2026-0350](https://insights.bostonidentity.com/ref/BI-FIND-2026-0350): A JWT used to authenticate an OAuth client now has exactly one permitted audience. The draft rewrites RFC 7523's rule so that the audience 'MUST use the issuer identifier [RFC8414] of the authorization server as its sole value', that 'the token endpoint URL of the authorization server MUST NOT be used as an audience value', and that the server 'MUST reject any JWT that does not contain its issuer identifier as its sole audience value', compared by simple string comparison. Pushed authorization requests get the same rule. The reason given is that endpoint addresses other than the issuer cannot be validated and, sent to a different endpoint, 'can open an attack vector'; the attack itself is the audience-injection class University of Stuttgart researchers disclosed in January 2025. (from "The JWT an agent or other OAuth client signs in with may name only the server's issuer, never the token endpoint")
- [BI-FIND-2026-0399](https://insights.bostonidentity.com/ref/BI-FIND-2026-0399): The rule the two client-side bugs broke is already written into the protocol, as a minor change. The MCP revision of 2026-07-28 says clients 'MUST key persisted credentials by the issuer identifier, MUST NOT reuse them with a different authorization server, and MUST re-register when the authorization server changes', and must validate a present iss parameter before redeeming an authorization code; the Python SDK's affected versions span that revision, and its fix is exactly that binding. The IETF's OAuth working group is tightening the same screw from the other side: its revision of RFC 7523 restricts a client-authentication JWT's audience to the issuer identifier alone, for the same mix-up reason. The SDKs lagged the specifications they implement; the field usually tells the MCP authorization story the other way round. (from "Three MCP auth flaws in a month, and the spec had already written the rule the SDKs skipped")
- [BI-FIND-2026-1067](https://insights.bostonidentity.com/ref/BI-FIND-2026-1067): The draft adds two fields to the token response: refresh_token_timeout, the seconds a client may hold a refresh token without using it, and authorization_expires_in, the lifetime in seconds of the user's grant for the scopes the token covers. If they are finite, the server MUST return them in every response that carries a refresh token. Leaving them out means no fixed limit, or, from a server that has not declared support in its metadata, possibly no support at all, and the draft says clients should handle the two cases the same way. Where one grant covers scopes with different lifetimes, it recommends returning the shortest and admits this risks an app asking the user to reauthorize too early. (from "An OAuth draft caps every refresh token at the user's grant, and tells the app when that grant ends")

---

© 2026 Boston Identity LLC. All rights reserved. Published by Boston Identity LLC.
Quote up to 100 words with the credit "Boston Identity, IAM Insights" and a link to https://insights.bostonidentity.com/glossary/authorization-server-metadata. Claim numbers may be cited freely. Training, fine-tuning and text-and-data-mining use of this page is permitted.
Terms: https://insights.bostonidentity.com/terms · How to cite: https://insights.bostonidentity.com/cite
