AIScan cover: 174 OAuth clients, 60 consents. Claude and Cursor name chips above the figure 34.5% of registrations reached consent. AIScan authorization server, counted 19 Nov 2026.
AIScan cover: 174 OAuth clients, 60 consents. Claude and Cursor name chips above the figure 34.5% of registrations reached consent. AIScan authorization server, counted 19 Nov 2026.
AI Readiness

174 OAuth Client Registrations on Our MCP Server: Only 60 Reached Consent

174 OAuth clients registered on our MCP server in 82 days and 60 reached consent. What DCR leaves behind, and what CIMD changes. AIScan data, 19 Nov 2026.

19 Nov 2026 20 min read
#MCP#OAuth#MCP server#Dynamic Client Registration#CIMD#case study#AI readiness

This guide covers P4 · Capabilities.

Table of contents

Direct answer: On our own MCP server, 174 OAuth clients registered themselves between 29 August and 18 November 2026, and 60 of them (34.5%) ended with a person approving access. Every one of those 60 was a brand-new client created a median 32 seconds before the approval, so the registry holds one client per connection and never one per app. If you run Dynamic Client Registration for an MCP server, expect about two abandoned client records for every working one, and plan the cleanup yourself, because nothing in the flow deletes them.

We run a public MCP server at https://aiscan.site/mcp. Its sign-in is OAuth 2.1 with Dynamic Client Registration, which is the setup most MCP tutorials still describe. The current MCP specification now calls that mechanism deprecated. Before changing anything we counted what the old mechanism had left behind in our own authorization server. This article is that count: who registered, how they authenticated, how far each registration got, and what the numbers say about moving to Client ID Metadata Documents.

Quick summary

QuestionOur numberSource
How many clients registered?174, all by Dynamic Client RegistrationOur authorization server's client table, 19 Nov 2026
How many reached a consent?60 (34.5%), from 52 peopleConsent table, same day
How many opened the sign-in page and stopped?55 (31.6%)Authorization requests left pending or denied
How many registered and never opened it?59 (33.9%)No authorization request and no consent on record
Which client registered most?Claude, 160 of 174 (92.0%)client_name as the client sent it
How long from registration to approval?Median 32 seconds, longest 151 seconds60 consent rows
How many records were ever deleted?0deleted_at is empty on all 174

What the specification says: according to the MCP authorization specification (revision 2026-07-28, fetched from modelcontextprotocol.io on 19 November 2026), servers and clients SHOULD support Client ID Metadata Documents and MAY support Dynamic Client Registration, which "is deprecated and retained for backwards compatibility".

Who should care: anyone whose authorization server exposes a registration_endpoint to MCP clients. Read your own client table before you read another opinion piece about which mechanism is better.

Where to start: run npx aiscan-cli yoursite.com, or paste the address at aiscan.site (free, no account), and read check P4, which tells you whether an agent can find your authorization server at all. The registration counts in this article come after that step and need your own database.

Why MCP server owners need to look at client registration now

Client registration is the step where an app that has never met your server gets a client_id. Without one, the OAuth flow cannot start. For years the answer in the MCP world was RFC 7591, published in July 2015, which describes itself in its own words as "mechanisms for dynamically registering OAuth 2.0 clients with authorization servers". The client sends a small JSON document to a registration endpoint and gets an identifier back. Nobody has to email anybody.

That convenience has a cost that only shows up in the database. Each registration is a row the authorization server must keep. The MCP specification moved away from it over the last year, and the revision dated 28 July 2026 puts the change in one warning box on its client registration page:

"Dynamic Client Registration is deprecated. New implementations should use Client ID Metadata Documents instead. This option remains available for backwards compatibility with authorization servers that do not support Client ID Metadata Documents."

The replacement is an IETF draft, OAuth Client ID Metadata Document. The datatracker page listed revision 03, last updated 2 November 2026, when we read it on 19 November. The idea is that the client_id is an HTTPS URL, and the authorization server fetches the client's metadata from that URL when it needs it. There is nothing to register, so there is nothing left behind.

Most of what has been written on the choice argues from the specifications. WorkOS published a clear walk through of both mechanisms on 2 December 2025 (MCP client registration: CIMD vs DCR). What we could not find was a server owner publishing what a registration table looks like after a few months of real use. Ours is small, and it is real.

How we counted: the method and its limits

Our MCP endpoint is protected by Supabase Auth's OAuth 2.1 server. That is our stack, and it matters for reading the numbers, because the tables below are the ones that product keeps: one for registered clients, one for authorization requests and one for consents.

ItemDetail
Serverhttps://aiscan.site/mcp, one public MCP server
Authorization serverSupabase Auth OAuth 2.1 server, hosted
Window29 August 2026 (first registration) to 18 November 2026 (last), 82 days
Query date19 November 2026, 03:07 UTC
Tables readregistered clients (174 rows), authorization requests (57 rows), consents (60 rows)
What we selectedCounts, dates and medians only
What we never selectedClient secrets, redirect URIs, user identifiers, email addresses, any single row

Three limits apply to everything that follows.

First, this is one small server. The counts describe our traffic and not the MCP ecosystem. A server listed in a busy directory will see different volumes and probably a different mix of clients.

Second, the client name is whatever the client sent at registration. RFC 7591 does not verify it. A row that says "Claude" was registered by something that called itself Claude, and for these 160 rows the authentication method and the timing are consistent with that, but the name alone is not proof.

Third, some of these sign-ins are ours. One account holds 7 of the 60 consents, which is what a team testing its own connector looks like. We did not look up whose account it is, and the share of the remaining rows that came from our own sessions is unknown.

One more point about what the authorization table keeps. Of the 60 clients that reached a consent, 59 have no row left in the authorization request table, while 56 unapproved requests going back to 29 August are still there. So the server clears a request once it is approved and keeps the ones that were not. That is why we can read "no request and no consent" as "registered and never opened the sign-in page". It is an inference from how the table behaves, and it is marked as one wherever it is used.

The registration funnel: 174 clients, 60 consents

StageClientsShare of 174What it means
Registered174100%The client posted its metadata and received a client_id
Registered, no authorization request on record5933.9%The browser step never started, as far as the tables show
Opened an authorization request, never approved5531.6%The sign-in page was reached and then left
Approved by a person (consent recorded)6034.5%A working connection

AIScan authorization server, 174 registrations from 29 Aug to 18 Nov 2026, counted 19 Nov 2026.

A third of registrations became connections. The other two thirds split almost evenly between clients that never opened the sign-in page and clients that opened it and stopped.

The authorization table holds 57 unapproved requests from 56 clients: the 55 that never finished, plus one client that failed once and was approved later. Those requests tell us where people gave up:

Authorization requests left behindCountNote
Total57Across 56 clients (55 never approved, 1 approved later)
Pending, now expired56Each request lived 600 seconds
Explicitly denied1Someone pressed the deny button
No signed-in user attached51The page was opened and nobody logged in
A signed-in user attached6Logged in, then did not approve
PKCE method S25657All of them
Carried a resource parameter57All of them

So 51 of 57 abandoned requests (89.5%) ended at our login screen and not at the consent screen. The person saw "sign in to AIScan" and closed the tab. Only six requests had a signed-in user attached, and one request was denied outright. If we wanted more of these to finish, the login page is where the work is. The consent wording is close to irrelevant at this volume.

The 600-second lifetime matches Supabase's own documentation, which lists an expired authorization code among the causes of a failed token exchange and gives the limit as "10 minutes" (Supabase MCP authentication guide, verified on 19 November 2026).

The two technical columns are worth a line. All 57 requests used the S256 challenge method even though our server's metadata also advertises plain. All 57 carried a resource parameter naming the MCP server, which the MCP specification requires of clients. On the evidence of the requests that failed, the clients are doing the protocol correctly. The drop-off is human.

Which MCP clients registered, and how they authenticate

Client name as sentRegistrationsReached consentClient typeToken endpoint auth
Claude16058 (36.3%)Confidentialclient_secret_post
Cursor21Publicnone
Claude Code11Publicnone
Lovable10Confidentialclient_secret_post
Four other names100Publicnone
Total17460161 confidential, 13 public

Same source and date. The four other names are small clients and one test probe; we group them so that no individual operator is identifiable.

Claude is 92% of the table. That says more about where our users are than about the market: our connector instructions are written for Claude, and the guide to scanning a site from Claude is the page that sends people to this endpoint.

Two details are more portable.

Every client asked for the same grants. All 174 registered authorization_code and refresh_token. Nobody asked for client credentials or anything unusual. If you are deciding which grant types to allow at registration, those two cover everything that has ever arrived here.

Claude registers as a confidential client and the desktop tools do not. The 160 Claude rows and the single Lovable row took a client secret and said they would send it in the POST body. The other 13 registered as public clients with none, relying on PKCE alone. This follows from where the code runs: a hosted service can keep a secret and a tool on a laptop cannot. A server that only accepts one of the two styles will turn away part of this list.

Only three of the 174 registrations included a client_uri and two a logo_uri. If your consent screen was designed around showing the app's logo and home page, 98% of the time there will be nothing to show.

One client per connection: the registry only grows

This is the finding that changed how we read the rest.

MeasureValue
Consents60
Distinct people who consented52
Distinct clients those consents belong to60
People with 1 consent49
People with 2 consents2
People with 7 consents1
Registration to consent, median32 seconds
Middle half of consents22 to 48 seconds
Slowest consent151 seconds
Consents under 60 seconds53 of 60
Consents revoked0

Sixty consents belong to sixty different clients. No client was approved by two people, and the person who connected seven times did it with seven clients. Add the timing and the picture is complete: every approval came within about two and a half minutes of the registration it belongs to. No registration here was created on one day and used on another.

Those 52 people are about a third of the 151 accounts on the site, so connecting an AI client is something one account in three has done.

In other words, a "client" in our table is not an application. It is one attempt to connect. An earlier registration is never reused.

Anthropic documents this behaviour for Claude. Its connector authentication page says, verbatim, "DCR causes Claude to register a new client on every fresh connection, which can result in very large numbers of registered clients on your authorization server" (Authentication for connectors, fetched from claude.com on 19 November 2026). Our 160 Claude rows for 58 working connections are that sentence measured on a small server.

The failed attempts cluster as well. Of the 114 registrations that never reached a consent, 71 were created within two minutes of another registration, and 36 within ten minutes of one that did succeed. That is the shape of retries: someone clicks connect, something stalls, they click again, and each click is a new client.

And nothing cleans up. All 174 rows have an empty deleted_at, and none was modified after it was created. Of the 114 dead registrations, 93 were more than a week old on the day we counted. RFC 7591 defines how to create a client. Deleting one is a separate specification, RFC 7592, and nothing in our table suggests any client has called it.

At our size this is untidy and harmless. The growth is what to plan for:

Month (2026)RegistrationsReached consentShare
August (from the 29th)5240.0%
September7457.1%
October993434.3%
November (to the 18th)632031.7%

October is the month our request log starts showing the authenticated endpoint answering Claude with 401, the first step of a sign-in, which our 67-day usage report covers from the request side. Across the table's 46 active days the median is 3 registrations a day and the busiest day had 13. October and November together added 162 rows in 49 days, a rate of about 1,200 a year. A server with a hundred times our traffic would pass 100,000 rows a year at that rate, two thirds of them dead on arrival.

DCR, CIMD and pre-registration compared

The MCP specification lists three ways to get a client ID and gives clients a priority order: use pre-registered credentials if they have them, then a Client ID Metadata Document if the server advertises support, then Dynamic Client Registration as the fallback.

Dynamic Client RegistrationClient ID Metadata DocumentPre-registration
Defined byRFC 7591 (July 2015)IETF draft, revision 03 (Nov 2026)Your own admin screen
Status in MCP 2026-07-28MAY, deprecatedSHOULDSHOULD be supported by clients
What the client sends firstA POST to your registration endpointIts HTTPS URL as the client_idA client_id you issued earlier
Rows created on your serverOne per connection attemptNone requiredOne per app
Who can start a flowAnyone who can reach the endpointAnyone hosting a metadata URLOnly apps you approved
Your server mustStore and eventually purge clientsFetch, validate and cache a remote documentRun a registration process
How it is advertisedregistration_endpointclient_id_metadata_document_supported: trueOut of band
Best forAuthorization servers with no metadata-document support yetPublic MCP servers with clients you have never metKnown partners and internal tools

Dynamic Client Registration: best for servers that cannot do anything else yet

It works today with every client in our table, and that is its whole case. The cost is the table you have just read: 174 rows for 60 connections, no deletions, and an open endpoint that Supabase's documentation describes plainly: "Dynamic registration allows any MCP client to register with your project." The same page advises monitoring registered clients regularly.

ProsCons
Supported by every MCP client we have seenOne stored client per attempt, including failed ones
No manual step for the userOpen write endpoint on your authorization server
Simple to switch on in a hosted auth productDeprecated in the current MCP specification

Client ID Metadata Documents: best for public servers with unknown clients

The client's identity is a URL it controls, so two connections from the same app share one identifier and your server stores nothing per attempt. The authorization server takes on a new job in exchange, which is fetching a document from an address supplied by a stranger. The specification attaches security requirements to that fetch, and you should read them before enabling it.

ProsCons
No per-connection client recordsYour server makes outbound requests to client-supplied URLs
The client's identity is tied to a domain it controlsStill an IETF draft, not an RFC
The mechanism the MCP specification now prefersDepends on your authorization server product supporting it

Pre-registration: best for partners you already know

You create the client by hand and give the ID to the app's developer. It is the oldest method and still the right one when the list of clients is short and known. Anthropic documents a version of this for Claude, where the server owner creates one OAuth client and Anthropic holds the credentials.

ProsCons
One row per app, fully under your controlDoes not scale to clients you have never heard of
Nothing open to the publicA manual step for every new client

Our own gap: we do not advertise CIMD

We would rather report this than have a reader find it. Our authorization server metadata, read on 19 November 2026, contains a registration_endpoint and has no client_id_metadata_document_supported field. No client can use a metadata document with us today, whatever it supports.

The Claude documentation quoted above is specific about what it needs before it will choose the newer mechanism: the metadata must advertise both "client_id_metadata_document_supported": true and "none" in token_endpoint_auth_methods_supported, and otherwise Claude falls back to Dynamic Client Registration. We already list none. The first flag is the missing one, and on a hosted authorization server that is the vendor's switch to add and not ours. The two Supabase guides we read for this article describe dynamic registration and pre-registered clients and do not mention metadata documents.

So our position on 19 November 2026 is the fallback case the specification describes: an authorization server that does not support the preferred mechanism, kept working by the deprecated one. Until that changes, our fix is housekeeping.

How to check your own server

Step 1. Check that agents can find your authorization server. Run npx aiscan-cli yoursite.com or paste the URL at aiscan.site. Read check P4 under capabilities. P4 grades the RFC 9728 protected-resource file. It does not read your registration settings and it cannot see your client table, so a pass means discovery works and says nothing about the numbers in this article. If P4 fails, fix that first with the OAuth discovery guide; a client that cannot find the authorization server never reaches registration at all. The P4 corpus study shows how often that first step fails elsewhere.

Step 2. Read what your metadata advertises. If you would rather check by hand, this is the whole test:

curl -s https://YOUR-ISSUER/.well-known/oauth-authorization-server \
  | jq '{registration_endpoint, client_id_metadata_document_supported, token_endpoint_auth_methods_supported}'

A registration_endpoint with no metadata-document flag is our situation. If your issuer has a path, the well-known location moves; the issuer mismatch fix explains where.

Step 3. Count your own funnel. The exact tables depend on your authorization server. On Supabase Auth the three counts we used were these, and each returns one row of totals:

select count(*)                                   as registered,
       count(*) filter (where deleted_at is not null) as deleted
from auth.oauth_clients;

select count(*) as consents,
       count(distinct user_id)  as people,
       count(distinct client_id) as clients
from auth.oauth_consents;

select status, count(*) as requests,
       count(*) filter (where user_id is null) as nobody_signed_in
from auth.oauth_authorizations
group by status;

Divide consents by registered. If the answer is far below ours, look at where requests stop before you blame the clients.

Step 4. Decide what to purge. A registration with no consent and no authorization request after a day is not coming back; in our data every consent arrived within 151 seconds. On our data a threshold of 24 hours with no consent would be safe. Check your vendor's supported way to remove clients before deleting rows by hand.

Step 5. Log the sign-in as its own event. Our request logs could not show whether a sign-in finished, a hole we named in the usage report. The consent table closes it. If you are setting up logging from scratch, the MCP request logging guide covers the request side.

What it costs

ItemDynamic Client RegistrationClient ID Metadata Documents
Software licenceNone; part of the authorization serverNone; part of the authorization server, where supported
StorageOne small row per attempt (174 rows in 82 days here)A cache entry per client URL
Engineering time to enableA dashboard switch on hosted productsA dashboard switch where the vendor ships it; real work if you run your own server
Ongoing workA purge job and a look at the table each monthReviewing which client domains you trust
Billing effect on SupabaseNone per client; Supabase states it counts monthly active users per distinct userSame

On the last row, according to the Supabase guide cited earlier, "multiple agents or MCP clients acting for the same user count as one MAU". The dead registrations cost us nothing on the invoice. They cost attention.

Common mistakes when reading a registration table

  • Treating registrations as users. We have 174 clients and 52 people. A dashboard that charts "registered OAuth clients" as adoption overstates ours by a factor of three.
  • Treating registrations as apps. Eight names account for all 174 rows.
  • Reading abandoned requests as a broken client. All 57 of ours were well formed. 51 stopped at a login page nobody completed.
  • Trusting the client name. It is self-declared. Use it for display, never for an access decision.
  • Waiting for clients to delete themselves. None of ours ever has.
  • Switching off registration before the replacement works. With no metadata-document support on our server, removing the registration endpoint would have locked out all 60 working connections.

What these numbers argue for on our own server

Three things, in this order. A scheduled purge of registrations older than 24 hours with no consent would remove 112 of our 174 rows today without touching a working connection. The sign-in funnel (registered, opened, signed in, approved) belongs next to the request counts, so that a usage report has the completion figure our last one lacked. And the authorization server's metadata is worth re-reading each month for the metadata-document flag, because the day it appears, most of this table stops growing. None of the three is in place as of 19 November 2026.

If you run an MCP server behind OAuth, start with the scan: npx aiscan-cli yoursite.com, check P4 for discovery, and P2 if you also publish a server card. Then run the three counts above on your own tables and compare your consent rate with our 34.5%. The rest of the agent-readiness fixes, in the order they usually pay off, are on the guides page.

Data from AIScan's own authorization server, counted 19 November 2026. Aggregates only; no user, redirect URI or secret was read for this article.

Frequently asked questions

How many OAuth clients will an MCP server collect with Dynamic Client Registration?

About one per connection attempt, not one per app. On our server 174 clients registered in 82 days for 60 working connections from 52 people. Anthropic's connector documentation says DCR causes Claude to register a new client on every fresh connection, and our table matches that description.

Why does my OAuth client table show dozens of clients all named Claude?

Because each fresh connection registers a new client under the same name. We hold 160 rows named Claude for 58 approved connections. The rows are separate client IDs with separate secrets, and none is reused by a later sign-in, so duplicates here are expected behaviour and not an attack.

Why are most authorization requests on my MCP server stuck at pending?

Usually because nobody signed in. Of our 57 unapproved requests, 56 are pending and expired, and 51 have no user attached, which means the login page was opened and then closed. Look at your login screen before you look at the consent screen or the client.

Claude keeps using Dynamic Client Registration even though I want CIMD. What is missing?

Your authorization server metadata probably lacks one of two values. Anthropic's documentation says Claude normally selects a Client ID Metadata Document only when the metadata advertises client_id_metadata_document_supported: true and lists none in token_endpoint_auth_methods_supported. Without both it falls back to DCR, which is what happens on our server today.

Is Dynamic Client Registration deprecated in MCP?

Yes, in the specification revision dated 28 July 2026. It says authorization servers and clients SHOULD support Client ID Metadata Documents and MAY support Dynamic Client Registration, which is deprecated and retained for backwards compatibility with authorization servers that do not support metadata documents. It still works with every client we have seen.

Is it safe to delete OAuth clients that never reached a consent?

On our data, yes after a short wait. Every one of our 60 consents arrived within 151 seconds of the registration it belongs to, and no older registration was ever used later. A 24-hour threshold would have removed 112 of our 174 rows without touching a working connection. Use your authorization server's supported method to remove clients, and check your own timing first.

Does AIScan check which client registration method my server supports?

No. Check P4 grades the RFC 9728 protected-resource file, which tells an agent where your authorization server is. It does not read the registration endpoint, the CIMD flag or your client table. Run the scan for discovery, then use the curl and SQL in this article for registration.

Do abandoned OAuth client registrations cost money on Supabase?

Not directly on our plan. Supabase's MCP authentication guide says it counts monthly active users per distinct user, so several MCP clients acting for one person count once. The 114 registrations that never reached a consent added rows to a table and nothing to the bill. Check your own plan's terms.

M Asif Rahman

About the author

Entrepreneur, curious about AI

I have been building companies for a long time, and lately most of my curiosity goes to AI. AIScan is a small personal project I built on a flight from Dubai to Narita. I use it to understand how ready the web is for AI agents, and I share what the scans teach me.

Related guides

Browse every guide by check and platform