Guide
MCP Registry: The Public Registries and How to Run a Private One
Where MCP servers are listed, what a listing actually verifies, and how platform and security teams put a private registry in front of their developers.
An MCP registry is a catalog of Model Context Protocol servers: for each server, a name, a description, a version and the details a client needs to install or reach it (a package to run locally, or a remote URL to connect to). People browse a registry to find servers; MCP clients query one to offer servers inside the app. A registry describes servers. It does not run them, and it does not sit in the path of an agent's tool calls.
Three different things get called "the MCP registry", and an enterprise usually ends up dealing with all of them: the official MCP Registry run by the MCP project, the catalogs and marketplaces built on top of it or beside it (GitHub, Docker and community directories), and the private registry a company runs so its own developers only see approved servers.
The official MCP Registry
The official MCP Registry lives at registry.modelcontextprotocol.io. The MCP project launched it in preview on September 8, 2025, as an open catalog and API for publicly available MCP servers. The registry, and the OpenAPI specification it implements, are open source in the modelcontextprotocol/registry repository, so anyone can build a compatible registry of their own.
What it holds and how publishing works:
- Metadata only. Each server is a
server.jsondocument: name, description (capped at 100 characters), version, repository, and eitherpackages(npm, PyPI, NuGet, OCI images, MCPB) orremotes(a streamable HTTP endpoint). The code itself stays on npm, PyPI, a container registry or the publisher's own servers. - Namespaced names. A server's name is reverse-DNS style, such as
io.github.username/weather. Publishers prove they control the namespace: signing in with GitHub grantsio.github.<username>/, and DNS verification grants a custom domain prefix. - Package ownership checks. The registry checks that the package points back at the listing: an
mcpNamefield in an npm package'spackage.json, or anmcp-name:line in a PyPI or NuGet package's README. - A publisher CLI. Maintainers publish with
mcp-publisher(init,login,publish), by hand or from GitHub Actions. - Moderation by denylist. Anyone can flag spam, malicious code or impersonation; maintainers can mark a server
deletedand remove it from public access after the fact.
Two limits matter for anyone depending on it. It is still marked as a preview, with no uptime or data durability guarantees and breaking changes possible before general availability; check the registry repository for its current status. And for remote servers, it verifies that you control the namespace in the name, not that you control the remote URL the listing points to.
Reading from the API
The registry exposes an unauthenticated, read-only REST API. The v0.1 endpoints are:
| Endpoint | Returns |
|---|---|
GET /v0.1/servers |
Every server, paginated with limit and cursor; filter changes with updated_since |
GET /v0.1/servers/{serverName}/versions |
Every version of one server |
GET /v0.1/servers/{serverName}/versions/{version} |
One version; latest for the newest |
Server names in the path must be URL-encoded (io.modelcontextprotocol%2Feverything). The project asks downstream consumers to sync on an infrequent schedule (for example hourly), keep their own copy, and use updated_since for incremental syncs instead of re-crawling.
Public MCP registries and catalogs compared
The official registry is meant to be the upstream source; most people find servers through a catalog that adds curation, packaging or ratings on top. The main ones:
| Registry | What it is | Who it suits | What to check |
|---|---|---|---|
| Official MCP Registry | The MCP project's open catalog and API of public servers; metadata only | Client builders and sub-registries that need one upstream source | Still in preview; listings are self-reported |
| GitHub MCP Registry | GitHub's catalog of MCP servers, launched September 16, 2025 with a curated selection | Developers using GitHub Copilot and other MCP clients | How a server gets listed today; GitHub said it would move toward self-publication through the open-source registry |
| Docker MCP Catalog | MCP servers packaged as Docker images on Docker Hub, run as isolated containers through the Docker MCP Toolkit | Teams that want local servers containerized | Its source of truth is docker/mcp-registry; local servers built by Docker are pinned to a Git commit, and the catalog marks known publishers apart from community servers |
| Community directories (such as PulseMCP, Smithery, Glama and mcp.so) | Independently run directories and marketplaces of MCP servers | Browsing and discovery | Each sets its own listing and review rules; read them on the directory itself before trusting a listing |
Server counts and features in every one of these change weekly, so check the catalog itself rather than any published number.
What a registry listing does and doesn't tell you
A listing in a public registry proves less than it looks like it does:
- Self-reported. The official registry describes its data as what maintainers publish about their own servers. The description, tool list and claims come from the publisher.
- Identity, not behavior. Namespace and package checks establish who published the entry. They say nothing about what the code does when an agent calls its tools.
- Descriptions change. A server's tool descriptions are read by the model at connect time, and they can change between versions. That is the opening for tool poisoning, and why a review at listing time goes stale.
- Look-alikes exist. The registry's moderation policy names impersonation as grounds for removal because it happens. Docker's catalog write-up points to the malicious
postmark-mcppackage, a one-line backdoor that blind-copied outgoing email to an attacker.
Security scores from registries and scanners help before a server is connected; how those scores are built and where they stop is its own subject. What a registry cannot do is see a tool call.
Running a private MCP registry
The MCP project planned for private sub-registries from the start: enterprises with strict privacy and security requirements run their own registry, built on the official one as their upstream source, and expose only the servers they have approved. Developers' clients point at the private registry instead of the public catalogs.
Ways to stand one up
- Self-host the open-source registry. Fork modelcontextprotocol/registry, or run it with Docker, and load only approved entries.
- Azure API Center. Microsoft's API Center can act as a managed MCP registry; GitHub documents it as a supported option for Copilot. Check Azure's documentation for current tiers and limits.
- Your own implementation of the v0.1 API. Any service that serves the three endpoints above is a registry. The spec lets you add your own fields under
_meta(for example, who approved a server and when it was last scanned) under a key named for your registry. - A governance platform's catalog. Gateway and catalog platforms bundle a curated server catalog with identity, credential handling and policy enforcement. Runlayer is one: it gives employees access to more than 18,000 MCP servers, ties every action to an identity through SSO and SCIM, and enforces policy at tool-call depth. Compare the options in MCP gateway and catalog platforms compared.
Pointing GitHub Copilot at a private registry
GitHub Copilot Business and Enterprise let enterprise and organization owners set an MCP Registry URL and choose between Allow all and Registry only. Under Registry only, Copilot runs only servers from your registry (which also turns off Copilot connectors). GitHub's requirements:
- The registry follows the v0.1 specification and serves
/v0.1/servers,/v0.1/servers/{serverName}/versions/latestand/v0.1/servers/{serverName}/versions/{version}. - Those endpoints send CORS headers:
Access-Control-Allow-Origin: *,Access-Control-Allow-Methods: GET, OPTIONSandAccess-Control-Allow-Headers: Authorization, Content-Type. - The URL you enter is the base URL; Copilot appends
/v0.1paths itself. - Local servers developers should keep using are included in the registry with the correct server ID.
GitHub lists v0.1 registry support in VS Code, Visual Studio, Eclipse, JetBrains IDEs, Xcode and Copilot CLI. It also marks registry-based restriction as a public preview and calls the allowlist in the enterprise's managed-settings.json the more secure, generally available way to restrict servers, so many teams use both. The Copilot setup itself is covered in MCP server configuration for GitHub Copilot Enterprise.
A checklist for operating a private MCP registry
- Sync from upstream, don't copy once. Pull from the official registry with
updated_since, keep a checkpoint, and apply status changes: a server markeddeprecatedordeletedupstream should change in yours too. - Approve versions, not names. Pin the version (or, for container images, the commit or digest) you reviewed; a new version is a new review.
- Record why each server is there. Owner, approver, data it can reach and review date, kept in
_metaor beside the registry. - Cover every client. A registry only governs the clients pointed at it. Inventory what else is in use; shadow MCP is mostly servers that never went through any registry.
- Enforce at runtime too. A registry decides what can be discovered and installed. Credentials, per-user permissions and tool-call policy happen after that, at the gateway or platform layer; see continuous MCP inventory and policy enforcement.
Frequently asked questions
What is the official MCP Registry?
The MCP project's open catalog and REST API for publicly available MCP servers, at registry.modelcontextprotocol.io. It launched in preview in September 2025, holds metadata only (the code stays on npm, PyPI, container registries or the publisher's servers), and is open source so others can build compatible sub-registries.
Is the GitHub MCP Registry the same as the official MCP Registry?
No. The GitHub MCP Registry (github.com/mcp) is GitHub's own catalog, launched in September 2025 with a curated selection. GitHub's head of MCP is one of the official registry's maintainers, and GitHub said it would move toward self-publication through it.
Does being listed in an MCP registry mean a server is safe?
No. Public listings are self-reported. The official registry verifies who controls a server's namespace and package, not what its code or tool descriptions do, and for remote servers it does not verify control of the remote URL. Review the server yourself and enforce policy at runtime.
How do I publish a server to the official MCP Registry?
Publish the package first (for example to npm, with an mcpName field in package.json), create a server.json with the mcp-publisher CLI's init command, sign in with GitHub or verify a domain with DNS, then run mcp-publisher publish. Remote-only servers can publish a remotes entry without a package.
Do we need a private MCP registry if we already have an MCP gateway?
They do different jobs. A private registry controls which servers developers can discover and install in the clients that read it; a gateway or governance platform controls credentials and what happens on each tool call. Many gateway platforms include a curated catalog that serves as the registry.
Sources
- Introducing the MCP Registry (MCP blog, September 8, 2025)
- Quickstart: Publish an MCP server to the MCP Registry
- MCP Registry aggregators and sub-registries
- GitHub MCP Registry: the fastest way to discover AI tools (GitHub changelog)
- Configure an MCP registry for your organization or enterprise (GitHub Docs)
- Restrict MCP server access to a custom registry (GitHub Docs)
- Securing the Docker MCP Catalog: commit pinning, agentic auditing and publisher trust levels





