Live on Product Hunt Intraface launched today. Less steering, more vacations. See the launch
Start for free

What is dynamic client registration?

Dynamic client registration is an OAuth protocol, RFC 7591, that lets an app introduce itself to an authorization server automatically. The app posts its name, redirect URIs and grant types to a registration endpoint and receives a client_id, with no portal and no form. MCP clients use it to sign in to servers they have never met.

Part of Glossary: the terms behind MCP, coding agents and shared pages, defined plainly.

How it works

The agent registers itself by posting its details, gets a client_id back in the reply, and only then sends you to sign in.no developer portal,no humanopen, or protectedby a tokenthe agenta client nobody knows yetauthorization serveryou1. POST its details2. 201 Created, client_id3. sign-in request4. shows the agent's name5. Allow
  1. The client finds the registration_endpoint in the authorization server's metadata document.

  2. It POSTs a JSON body: redirect_uris, client_name, grant_types, and token_endpoint_auth_method, which is none for a public client with no secret.

  3. The server replies 201 Created with client_id, client_id_issued_at and the metadata it accepted; it may swap requested values for its own defaults.

  4. Open endpoints take any request and may rate-limit; protected ones demand an initial access token or a signed software statement first.

  5. The client uses that client_id in the normal authorization code flow. You see the client_name it chose on the approval screen.

Source: RFC 7591: OAuth 2.0 Dynamic Client Registration Protocol

Example: an agent meeting a new MCP server

You add a remote MCP server to your agent. The agent has never talked to this server; the people who run the server have never heard of your agent. Classic OAuth would stop here: someone would have to log in to a developer console, create an app, copy a client_id into a config file, and repeat that for every server and every agent. Dynamic client registration skips all of it. The agent reads the server's metadata, finds the registration_endpoint, and posts a JSON document describing itself: a display name, the redirect URIs it will listen on, the grant types it uses, and token_endpoint_auth_method set to none because it cannot keep a secret. The server answers 201 Created with a client_id. The agent then opens your browser for the usual sign-in, and the approval screen shows the client_name it just sent.

This is what happens under the hood in the moment between adding Intraface's MCP server to Codex or Claude Code and seeing the sign-in page: the client id is minted on the spot, before you ever see it.

Dynamic client registration versus Client ID Metadata Documents

RFC 7591 solved the "strangers" problem by letting the server mint identifiers on demand. Its weakness is that an identifier minted this way says nothing about who the client is; the server has to judge trust from the redirect URIs and the name, both chosen by the caller. The MCP authorization spec dated 2026-07-28 therefore prefers a newer idea, Client ID Metadata Documents: the client's identifier is an HTTPS URL pointing at a JSON document the client hosts, so the server can fetch the metadata itself and see which domain vouches for it. In that spec dynamic client registration is still allowed, but marked deprecated and kept for servers that do not support metadata documents yet. Pre-registered credentials remain the third option for clients and servers that already know each other.

When to use it

Use it when your server must accept clients it cannot list in advance and those clients have no way to host a metadata document, or when you need to support agents that only speak the older MCP flow. Open registration, where anyone may register, should be rate-limited. Protected registration asks for an initial access token or a signed software statement first, which lets a company admit only its own clients. Either way the server owns the policy: it may rewrite requested values with its own defaults, and it may refuse a redirect URI it is not willing to redirect to.

Common mistakes

  • Treating the client_id as proof of identity. It proves nothing. The user's approval and the exact redirect URI check carry the security.
  • Registering on every start. The response includes client_id_issued_at and, for secrets, an expiry. Store the result and reuse it until the server rejects it.
  • Asking for a secret you cannot keep. A CLI or desktop agent is a public client. Request token_endpoint_auth_method none and rely on PKCE.
  • Listing redirect URIs you will not use. A server may refuse the whole request if one URI in the list breaks its policy. Register only the ones this client actually listens on.

FAQ

Is dynamic client registration still required by MCP?
No. The 2026-07-28 MCP authorization spec makes it optional and marks it deprecated, kept for authorization servers that do not yet support Client ID Metadata Documents. The spec's order of preference: credentials the client already holds for that server, then a metadata document, then dynamic registration, and only then asking a person to enter client details.
Does dynamic client registration give the client a secret?
Only for confidential clients. A CLI or desktop agent cannot hide a secret, so it asks for token_endpoint_auth_method none and gets a client_id alone. If a secret is issued the response also says when it expires, with 0 meaning never.
Why would a server refuse a dynamic client registration?
RFC 7591 defines invalid_redirect_uri and invalid_client_metadata, returned with HTTP 400. The usual cause is a redirect URI the server's policy rejects; under MCP every redirect URI must be localhost or HTTPS, and a server may be stricter. One bad URI in the list fails the whole request.

Stop sending HTMLover Slack.

Create an account in a minute, connect your coding agent, and make your first board.