The Official MCP Registry Added 7,999 Servers in 19 Days. Find the Ones in Your Niche With This 29-Line Script

Robauto Team · Published · Last updated

The official MCP Registry grew 27% in 19 days to 37,628 remote servers, with bakeries, clinics and booking services joining. Search it with a tested stdlib Python script and see how brands can get listed.

Here is a good-news number for anyone building with AI agents: the official Model Context Protocol (MCP) Registry, the public list agents and apps use to discover MCP servers, listed 29,629 remote servers on November 1 and 37,628 on November 20. That is 7,999 new servers in 19 days, or 27% (Lazaretto). Each one is a new tool an AI agent can connect to, and plenty of them come from small businesses, not just big tech companies.

This post shows you how to search that registry yourself with a 29-line Python script (no installs), what we found when we ran it this morning, and how a brand can get its own listing.

The registry is growing every day

Several independent trackers read the registry's public API every day, and their numbers point the same way. They count slightly different things (remote servers only, every latest version, or day-over-day pulls), so the totals are not meant to match.

What was measuredNumberSource
Remote servers listed, Nov 1 → Nov 20, 202629,629 → 37,628 (+27%)Source
All servers (latest versions), Nov 8 → Nov 1659,612 → 64,972 (+5,360, about 670 a day)Source
Share with a hosted (remote) endpoint, Nov 8 → Nov 1666.8% → 67.8%Source
New servers first published Oct 17 – Nov 1520,136Source
Servers listed on Nov 19 / new that day67,491 / 784Source
Remote servers that list their tools to anyone23,600 (63%)Source
Tools read across answering servers / median per server376,689 / 7Source

Two more pieces of steady progress landed this month. On November 11 the MCP maintainers moved specification releases to a predictable twice-a-year schedule, targeting March 30, 2027 for the next version, and said there is nothing existing clients or servers need to change because of the announcement (MCP blog). And on November 20 the registry shipped v1.8.10, which improves incremental server listing and deep pagination while keeping API ordering and filtering unchanged (GitHub release).

Good habits are growing too. Lazaretto connected to every remote server and read its tool list without calling any tools. A person reviews every server its rules flag, and as of its November reviews it had not yet found a confirmed attack; most flags were security tools whose descriptions name the attacks they look for (Lazaretto). Its advice is still worth following: a clean read doesn't prove a server is harmless, so read a server's instructions before you connect an agent to it.

Try it: search the registry in one command

The registry's quickstart docs show that anyone can search it with a plain HTTP GET (MCP Registry quickstart). The script below wraps that call. It asks for the latest version of each server and follows the page cursor. Then it prints each server's name, whether it is remote (hosted, connect by URL) or local (a package you run yourself), its first publish date, and a short description. It uses only the Python standard library and only reads.

#!/usr/bin/env python3
"""mcpfind.py - list MCP servers in the official MCP Registry whose name matches a word.
Usage: python3 mcpfind.py bakery [max_pages]   (stdlib only, read-only)"""
import json, sys, urllib.parse, urllib.request

API = "https://registry.modelcontextprotocol.io/v0.1/servers"
term = sys.argv[1] if len(sys.argv) > 1 else "weather"
max_pages = int(sys.argv[2]) if len(sys.argv) > 2 else 3
cursor, rows = None, []
for _ in range(max_pages):
    q = {"search": term, "limit": 50, "version": "latest"}
    if cursor:
        q["cursor"] = cursor
    req = urllib.request.Request(API + "?" + urllib.parse.urlencode(q),
                                 headers={"User-Agent": "mcpfind/1.0"})
    page = json.load(urllib.request.urlopen(req, timeout=30))
    for item in page.get("servers", []):
        s = item["server"]
        meta = item.get("_meta", {}).get("io.modelcontextprotocol.registry/official", {})
        kind = "remote" if s.get("remotes") else "local"
        rows.append((s["name"], kind, (meta.get("publishedAt") or "")[:10],
                     (s.get("description") or "")[:60]))
    cursor = page.get("metadata", {}).get("nextCursor")
    if not cursor:
        break
for name, kind, day, desc in rows:
    print(f"{name:45} {kind:6} {day}  {desc}")
remote = sum(r[1] == "remote" for r in rows)
print(f"\n{len(rows)} servers match '{term}' ({remote} remote, {len(rows) - remote} local)")

Save it as mcpfind.py and run python3 mcpfind.py dental 5. We tested it on our box this morning (Nov 20, 2026, about 9:25 AM MST). The last line looked like this:

$ python3 mcpfind.py dental 5
...
14 servers match 'dental' (13 remote, 1 local)

A few tips from testing it: the search parameter matched server names (like com.example/booking), not descriptions, so try short words such as book or menu. The second argument caps pages at 50 results each, so be gentle with the shared public service. Fast Data's tracker author has the same advice: one full pass a day is plenty (Fast Data).

What we found: small businesses are already there

We ran the script for a few everyday business words. These are name matches in the latest listed versions, as of 9:25 AM MST today. They are a snapshot, not a census, and they will change by tomorrow.

Search wordMatching serversRemote (hosted)Source
booking163160Registry API
hotel7671Registry API
restaurant1615Registry API
dental1413Registry API
bakery55Registry API

The descriptions are encouraging. We saw a dental clinic in Buenos Aires offering a read-only server with its treatments, a bakery letting agents browse its menu and check an order, and mobile trade services in Tulsa and Las Vegas publishing booking servers with prices and ZIP-code service areas. These are ordinary local businesses putting their facts somewhere an AI agent can read them directly.

The opportunity for brands

When a shopper asks an AI assistant to "book a dentist" or "order a birthday cake," the agent works from whatever it can find and trust. A registry listing is one more place to be found, and getting one doesn't take a big team.

1. Start with what you already publish

Hours, services, prices, locations, policies, and how to book. If those facts are clear on your own website, they are easy to expose through a small read-only MCP server.

2. Describe a remote server in server.json

A server that runs only at a URL needs a remotes entry and no package entry. This is the official example from the registry docs (MCP Registry docs):

{
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "name": "com.example/acme-analytics",
  "title": "ACME Analytics",
  "description": "Real-time business intelligence and reporting platform",
  "version": "2.0.0",
  "remotes": [
    {
      "type": "streamable-http",
      "url": "https://analytics.example.com/mcp"
    }
  ]
}

3. Publish under your own domain name

With GitHub sign-in, names look like io.github.username/*. With domain (DNS or HTTP) verification you get your reverse-DNS namespace, so example.com can publish com.example/* (MCP Registry authentication). The docs point out that the registry checks your name's namespace, not the remote URL. Using your own domain lets people see that the server name and the URL come from the same publisher (MCP Registry docs). The DNS TXT record goes on the apex of your domain, not on a subdomain selector (MCP Registry authentication). Then mcp-publisher publish sends it, and the same registry search confirms you're listed (quickstart).

4. Keep your tool text plain and honest

Agents read your tool names, descriptions and any instructions before they call anything (Lazaretto). Short, factual descriptions help agents choose the right tool and help people trust it. One heads-up: the registry docs say it is still in preview, so watch for changes (MCP Registry docs).

Agent-ready summary

{
  "topic": "Official MCP Registry growth and how to search it",
  "as_of": "2026-11-20",
  "registry_api": "https://registry.modelcontextprotocol.io/v0.1/servers?search=WORD&version=latest",
  "growth": {
    "remote_servers_2026_11_01": 29629,
    "remote_servers_2026_11_20": 37628,
    "added_in_19_days": 7999,
    "all_servers_listed_2026_11_19": 67491,
    "new_servers_on_2026_11_19": 784
  },
  "open_tool_lists_share": "63%",
  "median_tools_per_server": 7,
  "next_mcp_spec_target": "2027-03-30",
  "brand_takeaway": "Publish a remote MCP server under your own domain namespace, then confirm it with a registry search",
  "free_check": "https://robauto.ai/scan"
}

Make your site easy for agents to use

An MCP listing works best when the website behind it is clear too: your structured data, your policies, and the pages agents land on. Scan your site free at robauto.ai/scan to see how ready it is for AI agents.

Sources

Where can an agent get this data live?

Robauto MCP — Agent Intelligence & Brand Discovery Infrastructure. A public, stateless Streamable HTTP endpoint at https://mcp.robauto.ai/mcp, callable with no key. Setup and the full tool list are in the Robauto MCP directory.

All blog posts

Optional: AI Agent Appreciation Day — December 1, 2026 at 12 AM MST. All models welcome. Agent RSVP instructions.