The official MCP Registry proves who published a server's metadata, not whether the server is safe to run. Developers and agents now discover MCP servers through registries and marketplaces, and a single install can hand a stranger's code the same credentials and data the agent holds. This guide explains how trust actually works in the official registry at registry.modelcontextprotocol.io, what it deliberately does not check, and how to publish your own servers so they cannot be impersonated. It then sets out the enterprise pattern most organisations need: a private registry or curated subregistry, a client-side allowlist and monitoring of what gets installed. It is written for platform, AppSec and identity teams who run or consume MCP servers, and it reflects the registry documentation and MCP specification revision 2026-07-28, as checked on 27 October 2026.
Key takeaways
- Namespace authentication is the main control. The registry ties a server name such as
io.github.alice/weatherorcom.example/crmto a verified GitHub account or domain, and checks that the referenced package points back to the same name. - Moderation is minimal by design. The registry's own policy tells consumers to assume minimal to no moderation, and it does not remove servers simply because they contain security vulnerabilities.
- The registry hosts metadata, not code. Security scanning is delegated to package registries such as npm and PyPI and to downstream aggregators, so a clean registry entry says nothing about the code behind it.
- Enterprises need their own source of truth. The official registry does not accept private servers, and its maintainers recommend a private registry that implements the same OpenAPI interface, fed by a reviewed subset of public entries.
- Publishing credentials are privileged NHIs. Whoever holds your DNS signing key, GitHub organisation or CI OIDC trust can publish under your name, and published versions cannot be deleted or edited.
How identity and access work in the MCP Registry
The MCP Registry is the official, centralised metadata repository for publicly accessible MCP servers. It is still labelled preview: the service launched on 8 September 2025 and its v0.1 API entered a freeze on 24 October 2025, and the documentation warns that breaking changes or data resets may occur before general availability. Each entry is a server.json document that names the server, says where the package or remote endpoint lives, and describes how to run it, including arguments and environment variables. The registry is meant to be consumed by aggregators and marketplaces, which are expected to poll it about once an hour, rather than by MCP host applications directly.
Three layers of identity
| Layer | What is proved | How | What it does not prove |
|---|---|---|---|
| Namespace | The publisher controls the GitHub account, organisation or domain in the server name | GitHub OAuth device flow or GitHub Actions OIDC for io.github.*; DNS TXT record or HTTP file at /.well-known/mcp-registry-auth holding an Ed25519 or ECDSA P-384 public key for reverse-DNS names | That the publisher is the vendor the name suggests, or is trustworthy |
| Package ownership | The package or image points back to the same server name | mcpName in npm package.json; an mcp-name: string in the PyPI, NuGet or crates.io README; the OCI label io.modelcontextprotocol.server.name; a fileSha256 for MCPB bundles on GitHub or GitLab releases | That the package code is benign, or that later package versions match what was reviewed |
| Version | Metadata for a version string is fixed once published | Each version must be unique; version ranges such as ^1.2.3, ~1.2.3 or 1.x are rejected | That a mutable package tag behind it has not changed; for MCPB the registry does not validate the hash itself, clients do |
The official registry also restricts package sources to public registries (registry.npmjs.org, pypi.org, the NuGet v3 index, crates.io, listed container registries such as docker.io and ghcr.io, and GitHub or GitLab releases for MCPB), and it keeps only publisher metadata stored under _meta key io.modelcontextprotocol.registry/publisher-provided, with a 4 KB limit. Remote servers listed under remotes must be publicly reachable, should use Streamable HTTP, and may declare URL template variables, including ones marked isSecret.
What the registry deliberately leaves to others
- Moderation: maintainers remove illegal content, malware, spam and non-functioning servers. They do not remove low-quality or buggy servers, servers with known vulnerabilities, or duplicates. A removed server is marked
status: "deleted"and its metadata stays readable through the API. - Scanning and curation: the roadmap lists curation, quality rankings and hosting of server code as out of scope. A design proposal notes that the registry publishes a
server.jsonschema but does not yet fully validate entries against it. - Unpublishing: the FAQ states a publisher cannot currently delete a server; to change metadata you publish a new version.
Choosing a registry model
| Model | Fits | Trade-off |
|---|---|---|
| Direct use of the official registry | Individual developers and labs with no sensitive data | No review gate; anything with a valid namespace is discoverable |
| Curated public subregistry or marketplace | Small organisations without platform staff | You inherit someone else's review criteria; check what their scan and rating fields mean |
| Private registry implementing the MCP Registry OpenAPI spec | Most mid-size and large organisations | You run review, ownership and refresh; host applications that support the v0.1 API can point at it |
| Private registry plus client allowlist and gateway | Regulated sectors and anyone with production data behind agents | Most effort; gives enforcement rather than advice |
A private registry is a list, not a lock. GitHub's own documentation for Copilot describes its registry setting as "not the recommended method for restricting access to MCP servers" and points administrators to an allowlist instead. Treat the registry as the catalogue and the allowlist and gateway as the enforcement. See the MCP Gateway and MCP Server Governance Guide for the gateway side.
Admin roles and privileged access
Two sets of administrators matter: the people who can publish under your organisation's namespace in the public registry, and the people who control your private registry and client policies.
- Namespace owners: for
io.github.yourorg/*, anyone with sufficient rights in the GitHub organisation can authenticate and publish. Review organisation owners and the repositories whose workflows can request OIDC tokens. Forcom.yourdomain/*, the holder of the private key matching the DNS TXT record (v=MCPv1; k=ed25519; p=...) or the/.well-known/mcp-registry-authfile can publish. Keep that key in a KMS or HSM; the registry documentation shows Google Cloud KMS and Azure Key Vault signing options so the key never sits on a laptop. - DNS and web administrators: anyone who can add a TXT record or upload a file to your web root can establish a new publishing key. Bring DNS change rights into the same privileged access review as code signing.
- Private registry administrators: they decide which servers every developer can install. Separate the reviewer role (approve a server version) from the operator role (run the service) and require two-person approval for adding a server that requests write scopes or runs locally.
- Client policy administrators: in GitHub Copilot, enterprise and organisation owners control "MCP servers in Copilot", the "MCP Registry URL" and "Restrict MCP access to registry servers" (Allow all or Registry only). Changes apply to developers immediately, so treat them as production changes with change records.
See the Privileged Access Management Guide for applying just-in-time access and session recording to these roles.
Integrations, API tokens and service accounts
Publishing is mostly automated, which makes the CI identity the real publisher.
- Prefer GitHub Actions OIDC: the documented workflow uses
permissions: id-token: writeandmcp-publisher login github-oidc, so no long-lived registry secret exists. Restrict the workflow to protected tags (the example triggers onv*), require reviews on the workflow file and pin third-party actions by commit SHA. - Protect the package token separately: the same workflow usually publishes to npm or PyPI first. A stolen npm token lets an attacker ship malicious code under a version your registry entry already points to, without touching the registry. Use trusted publishing where the package registry supports it and scope tokens to one package.
- Pin what the entry references: reference OCI images by digest rather than a mutable tag, and include
fileSha256for MCPB bundles. Clients that install by tag get whatever the tag points to today. - Keep secrets out of metadata: declare required credentials as environment variables or URL variables with
isSecret: true, never as defaults inserver.json. Published metadata is public and immutable, so a leaked key in an old version cannot be withdrawn: it must be revoked. - Private registry service accounts: the registry's authorisation note says registries wishing to authenticate SHOULD follow the MCP Authorization specification, acting as an OAuth resource server with scopes such as
mcp-registry:readandmcp-registry:write. Give the aggregator job that syncs from the public registry read access upstream and write access only to a quarantine stage in your registry, never directly to the approved catalogue.
The Smithery.ai MCP hosting breach shows why platform credentials around a registry need the same care: a path traversal in a build setting exposed a fly.io token that controlled more than 3,000 hosted MCP server apps. See the GitHub Actions OIDC Federation Hardening Guide for pipeline credential controls.
Logging and detection
What to log
- Public registry watch: poll
GET /v0.1/servers?updated_since=(RFC 3339 timestamp) and alert on new entries whose name, title or description resembles your brand or products but sits outside your namespaces. This is the registry equivalent of typosquat monitoring. - Your own namespace: alert on any new version published under your namespaces that does not match a release in your CI system, and on any change to the DNS TXT record or the well-known file.
- Status changes: server metadata is immutable except
status, which may move todeprecatedordeleted. Sync status for every approved server and treatdeletedas a possible malware signal that triggers review and removal from endpoints. - Private registry audit: record who approved each server version, the scan evidence attached, and every read by host applications.
- Endpoint and gateway telemetry: inventory MCP configuration files on developer machines and log gateway connections, so you can see servers running that never came through the registry.
Metrics that show it is working
- Percentage of MCP servers observed on endpoints and gateways that are present in the approved registry (target: close to 100%).
- Median time from a new server version appearing upstream to an approve or reject decision.
- Number of approved entries that reference a mutable tag or lack a hash (target: zero).
- Time to remove a server from clients after it is marked
deletedupstream or reported malicious. - Number of lookalike entries detected against your brand per quarter, and time to report them.
Hardening baseline
For publishers
- Choose a domain namespace (
com.yourcompany/*) for official products, so customers can tie the name to your domain rather than to an individual GitHub account. - Generate the signing key in a KMS, publish the TXT record, and document the key owner and rotation procedure.
- Publish only from CI using OIDC, from protected tags, after tests and a dependency scan.
- Add the ownership marker (
mcpName,mcp-name:or the OCI label) and reference images by digest. - Use semantic versions and never reuse a version string; to fix a bad release, publish a new version and mark the old one deprecated.
- Publish a security contact and state on your website which namespace is official, so users can spot impersonators.
For consumers: a phased rollout
- Discover: inventory MCP servers already configured on endpoints and in agent platforms. Expect unsanctioned ones; see the Unsanctioned AI Agents and MCP Servers Guide.
- Stand up the private registry: implement the MCP Registry OpenAPI v0.1 endpoints (
GET /v0.1/servers,/versions/latest,/versions/{version}) over HTTPS. Note that the official registry codebase is not designed for self-hosting. - Define the review gate: for each server version record publisher namespace, package digest, requested scopes and credentials, transport (local stdio or remote), network egress, data classification and a named internal owner. Require a code or binary scan and a test run in a sandbox.
- Pilot in advisory mode: point a pilot group's clients at the private registry with access left open, and compare what they install against the catalogue for two to four weeks.
- Enforce: switch the pilot to registry only or an allowlist, then widen in rings. Route remote servers through a gateway so enforcement does not depend on every client honouring the setting.
- Roll back safely: keep the previous policy setting documented; if enforcement breaks critical work, revert the ring to advisory mode, add the missing servers through the review gate, and re-enforce. Never roll back by approving everything.
Framework mapping
| Control area | NIST SP 800-53 Rev. 5 | NIST CSF 2.0 | Threat reference |
|---|---|---|---|
| Approved server catalogue and allowlist | CM-7(5) Authorized Software, Allow-by-exception; CM-8 System Component Inventory | ID.AM-02 | ATT&CK T1195.002 Compromise Software Supply Chain |
| Publisher and package verification | SR-4 Provenance; SR-11 Component Authenticity; SI-7 Software, Firmware, and Information Integrity | GV.SC-07 | ATLAS AML.T0115.002 Publish Poisoned AI Artifacts: AI Agent Tools |
| Supplier review of third-party servers | SR-3 Supply Chain Controls and Processes; SA-9 External System Services | GV.SC-07 | ATLAS AML.T0010.005 AI Agent Tool (supply chain compromise) |
| Lookalike and rug-pull monitoring | AU-6 Audit Record Review, Analysis, and Reporting | DE.CM-09 | ATT&CK T1036.005 Match Legitimate Resource Name or Location; ATLAS AML.T0109 AI Supply Chain Rug Pull |
| Retiring deleted or deprecated servers | CM-8; SI-7 | PR.PS-02 | ATT&CK T1195.001 Compromise Software Dependencies and Development Tools |
CIS Controls v8.1 Control 2 (Inventory and Control of Software Assets) and ISO/IEC 27001:2022 Annex A 5.19 to 5.21 on supplier and ICT supply chain security cover the same ground for audit purposes.
Common misconfigurations
- Treating a registry listing as a security review. The official policy keeps servers with known vulnerabilities listed. A listing proves namespace control, nothing more.
- Trusting a familiar name in the wrong namespace. The postmark-mcp malicious MCP server used a trusted product name on npm that the real vendor had never published; fifteen clean versions built trust before version 1.0.16 added a single line that blind-copied every email to the attacker. MITRE ATLAS records it as case study AML.CS0053.
- Approving a server, not a version. Allowlisting by name lets any later version through. Approve name plus version plus digest, and re-review on change.
- Relying on the registry setting as the only control. Client support for registry enforcement varies and is in preview in at least one major IDE assistant; local servers launched from hand-edited config files can bypass it. Pair it with endpoint inventory and a gateway.
- Leaving publishing keys on developer machines. A DNS-authentication private key in a home directory is a standing credential that can publish under your brand forever.
- Ignoring status changes. Aggregators that never refresh
statuskeep offering servers that the registry has already markeddeleted.
Practitioner checklist
- Confirm which namespaces your organisation owns in the official registry and who can publish to each.
- Move DNS or HTTP authentication keys into a KMS and add DNS TXT changes to privileged change control.
- Publish only from CI with OIDC, protected tags and pinned actions; scope package registry tokens per package.
- Reference OCI images by digest and include
fileSha256for MCPB bundles. - Stand up a private registry on the v0.1 OpenAPI interface with a documented review gate and named owners.
- Approve servers by name, version and digest, and re-review every new version before it reaches the catalogue.
- Enforce with client allowlists and a gateway; use the registry setting as the catalogue, not the lock.
- Monitor the public registry for lookalikes of your brand and sync
statusfor every approved server. - Track coverage, review time and removal time metrics monthly.
Standards and references
- Model Context Protocol: The MCP Registry
- Model Context Protocol: How to Authenticate When Publishing to the Official MCP Registry
- Model Context Protocol: The MCP Registry Moderation Policy
- Model Context Protocol: MCP Registry Aggregators
- Model Context Protocol: MCP Registry repository and OpenAPI specification
- GitHub Docs: Configure an MCP registry
- MITRE ATLAS: Publish Poisoned AI Artifacts: AI Agent Tools
- MITRE ATT&CK: Compromise Software Supply Chain
Related NHI Mgmt Group resources: MCP Security Guide · MCP Gateway and MCP Server Governance Guide · Local MCP Server Security Guide · MCP Security Testing Guide · MCP Gateway Buyers Guide