Table of contents
- Quick summary
- Why MCP server owners need to look at client registration now
- How we counted: the method and its limits
- The registration funnel: 174 clients, 60 consents
- Which MCP clients registered, and how they authenticate
- One client per connection: the registry only grows
- DCR, CIMD and pre-registration compared
- Dynamic Client Registration: best for servers that cannot do anything else yet
- Client ID Metadata Documents: best for public servers with unknown clients
- Pre-registration: best for partners you already know
- Our own gap: we do not advertise CIMD
- How to check your own server
- What it costs
- Common mistakes when reading a registration table
- What these numbers argue for on our own server
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
| Question | Our number | Source |
|---|---|---|
| How many clients registered? | 174, all by Dynamic Client Registration | Our authorization server's client table, 19 Nov 2026 |
| How many reached a consent? | 60 (34.5%), from 52 people | Consent 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 seconds | 60 consent rows |
| How many records were ever deleted? | 0 | deleted_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.
| Item | Detail |
|---|---|
| Server | https://aiscan.site/mcp, one public MCP server |
| Authorization server | Supabase Auth OAuth 2.1 server, hosted |
| Window | 29 August 2026 (first registration) to 18 November 2026 (last), 82 days |
| Query date | 19 November 2026, 03:07 UTC |
| Tables read | registered clients (174 rows), authorization requests (57 rows), consents (60 rows) |
| What we selected | Counts, dates and medians only |
| What we never selected | Client 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
| Stage | Clients | Share of 174 | What it means |
|---|---|---|---|
| Registered | 174 | 100% | The client posted its metadata and received a client_id |
| Registered, no authorization request on record | 59 | 33.9% | The browser step never started, as far as the tables show |
| Opened an authorization request, never approved | 55 | 31.6% | The sign-in page was reached and then left |
| Approved by a person (consent recorded) | 60 | 34.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 behind | Count | Note |
|---|---|---|
| Total | 57 | Across 56 clients (55 never approved, 1 approved later) |
| Pending, now expired | 56 | Each request lived 600 seconds |
| Explicitly denied | 1 | Someone pressed the deny button |
| No signed-in user attached | 51 | The page was opened and nobody logged in |
| A signed-in user attached | 6 | Logged in, then did not approve |
| PKCE method S256 | 57 | All of them |
Carried a resource parameter | 57 | All 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 sent | Registrations | Reached consent | Client type | Token endpoint auth |
|---|---|---|---|---|
| Claude | 160 | 58 (36.3%) | Confidential | client_secret_post |
| Cursor | 2 | 1 | Public | none |
| Claude Code | 1 | 1 | Public | none |
| Lovable | 1 | 0 | Confidential | client_secret_post |
| Four other names | 10 | 0 | Public | none |
| Total | 174 | 60 | 161 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.
| Measure | Value |
|---|---|
| Consents | 60 |
| Distinct people who consented | 52 |
| Distinct clients those consents belong to | 60 |
| People with 1 consent | 49 |
| People with 2 consents | 2 |
| People with 7 consents | 1 |
| Registration to consent, median | 32 seconds |
| Middle half of consents | 22 to 48 seconds |
| Slowest consent | 151 seconds |
| Consents under 60 seconds | 53 of 60 |
| Consents revoked | 0 |
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) | Registrations | Reached consent | Share |
|---|---|---|---|
| August (from the 29th) | 5 | 2 | 40.0% |
| September | 7 | 4 | 57.1% |
| October | 99 | 34 | 34.3% |
| November (to the 18th) | 63 | 20 | 31.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 Registration | Client ID Metadata Document | Pre-registration | |
|---|---|---|---|
| Defined by | RFC 7591 (July 2015) | IETF draft, revision 03 (Nov 2026) | Your own admin screen |
| Status in MCP 2026-07-28 | MAY, deprecated | SHOULD | SHOULD be supported by clients |
| What the client sends first | A POST to your registration endpoint | Its HTTPS URL as the client_id | A client_id you issued earlier |
| Rows created on your server | One per connection attempt | None required | One per app |
| Who can start a flow | Anyone who can reach the endpoint | Anyone hosting a metadata URL | Only apps you approved |
| Your server must | Store and eventually purge clients | Fetch, validate and cache a remote document | Run a registration process |
| How it is advertised | registration_endpoint | client_id_metadata_document_supported: true | Out of band |
| Best for | Authorization servers with no metadata-document support yet | Public MCP servers with clients you have never met | Known 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.
| Pros | Cons |
|---|---|
| Supported by every MCP client we have seen | One stored client per attempt, including failed ones |
| No manual step for the user | Open write endpoint on your authorization server |
| Simple to switch on in a hosted auth product | Deprecated 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.
| Pros | Cons |
|---|---|
| No per-connection client records | Your server makes outbound requests to client-supplied URLs |
| The client's identity is tied to a domain it controls | Still an IETF draft, not an RFC |
| The mechanism the MCP specification now prefers | Depends 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.
| Pros | Cons |
|---|---|
| One row per app, fully under your control | Does not scale to clients you have never heard of |
| Nothing open to the public | A 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
| Item | Dynamic Client Registration | Client ID Metadata Documents |
|---|---|---|
| Software licence | None; part of the authorization server | None; part of the authorization server, where supported |
| Storage | One small row per attempt (174 rows in 82 days here) | A cache entry per client URL |
| Engineering time to enable | A dashboard switch on hosted products | A dashboard switch where the vendor ships it; real work if you run your own server |
| Ongoing work | A purge job and a look at the table each month | Reviewing which client domains you trust |
| Billing effect on Supabase | None per client; Supabase states it counts monthly active users per distinct user | Same |
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.

About the author
M Asif Rahman
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
We Run a Public MCP Server: 67 Days of Who Calls It, and How
We run a public MCP server, and for 67 days we have been counting who uses it. Between 26 August and 1 November 2026, AI assistants asked it for scans 375 times, which is 10.1% of the 3,723 scans…
OAuth Discovery Metadata on 806 Sites: 133 Pass, and 47 of 50 Soft 200s Fail E1
Of 806 hosts in our scan corpus, 133 pass check P4, the OAuth discovery check. That is 16.5%. The more useful number is 50. fifty hosts answered HTTP 200 at an OAuth metadata path and still did not…
OAuth Discovery for AI Agents: RFC 8414 and RFC 9728 Explained
An agent calls your API cold, with no token. Your server returns 401, and the agent has nowhere to go from there unless something on your domain names the authorization server it should talk to. Two…
