Join our Newsletter — 33% off our NHI Course
Home› Guides› MCP Registry and Server Publishing Security Guide: Namespace…
Guide MCP, Protocols & Agent Platforms

MCP Registry and Server Publishing Security Guide: Namespace Trust, Private Registries and Enterprise Allowlists

PDF for newsletter subscribers · free to read online

← All guides
By NHI Mgmt Group, edited by Lalit Choda Updated 13 November 2026 14 min read
On this page

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/weather or com.example/crm to 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

LayerWhat is provedHowWhat it does not prove
NamespaceThe publisher controls the GitHub account, organisation or domain in the server nameGitHub 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 namesThat the publisher is the vendor the name suggests, or is trustworthy
Package ownershipThe package or image points back to the same server namemcpName 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 releasesThat the package code is benign, or that later package versions match what was reviewed
VersionMetadata for a version string is fixed once publishedEach version must be unique; version ranges such as ^1.2.3, ~1.2.3 or 1.x are rejectedThat 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.json schema 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

ModelFitsTrade-off
Direct use of the official registryIndividual developers and labs with no sensitive dataNo review gate; anything with a valid namespace is discoverable
Curated public subregistry or marketplaceSmall organisations without platform staffYou inherit someone else's review criteria; check what their scan and rating fields mean
Private registry implementing the MCP Registry OpenAPI specMost mid-size and large organisationsYou run review, ownership and refresh; host applications that support the v0.1 API can point at it
Private registry plus client allowlist and gatewayRegulated sectors and anyone with production data behind agentsMost 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. For com.yourdomain/*, the holder of the private key matching the DNS TXT record (v=MCPv1; k=ed25519; p=...) or the /.well-known/mcp-registry-auth file 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: write and mcp-publisher login github-oidc, so no long-lived registry secret exists. Restrict the workflow to protected tags (the example triggers on v*), 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 fileSha256 for 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 in server.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:read and mcp-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 to deprecated or deleted. Sync status for every approved server and treat deleted as 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 deleted upstream or reported malicious.
  • Number of lookalike entries detected against your brand per quarter, and time to report them.

Hardening baseline

For publishers

  1. 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.
  2. Generate the signing key in a KMS, publish the TXT record, and document the key owner and rotation procedure.
  3. Publish only from CI using OIDC, from protected tags, after tests and a dependency scan.
  4. Add the ownership marker (mcpName, mcp-name: or the OCI label) and reference images by digest.
  5. Use semantic versions and never reuse a version string; to fix a bad release, publish a new version and mark the old one deprecated.
  6. Publish a security contact and state on your website which namespace is official, so users can spot impersonators.

For consumers: a phased rollout

  1. Discover: inventory MCP servers already configured on endpoints and in agent platforms. Expect unsanctioned ones; see the Unsanctioned AI Agents and MCP Servers Guide.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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 areaNIST SP 800-53 Rev. 5NIST CSF 2.0Threat reference
Approved server catalogue and allowlistCM-7(5) Authorized Software, Allow-by-exception; CM-8 System Component InventoryID.AM-02ATT&CK T1195.002 Compromise Software Supply Chain
Publisher and package verificationSR-4 Provenance; SR-11 Component Authenticity; SI-7 Software, Firmware, and Information IntegrityGV.SC-07ATLAS AML.T0115.002 Publish Poisoned AI Artifacts: AI Agent Tools
Supplier review of third-party serversSR-3 Supply Chain Controls and Processes; SA-9 External System ServicesGV.SC-07ATLAS AML.T0010.005 AI Agent Tool (supply chain compromise)
Lookalike and rug-pull monitoringAU-6 Audit Record Review, Analysis, and ReportingDE.CM-09ATT&CK T1036.005 Match Legitimate Resource Name or Location; ATLAS AML.T0109 AI Supply Chain Rug Pull
Retiring deleted or deprecated serversCM-8; SI-7PR.PS-02ATT&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 status keep offering servers that the registry has already marked deleted.

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 fileSha256 for 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 status for every approved server.
  • Track coverage, review time and removal time metrics monthly.

Standards and references

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

PDF for subscribers

Take this guide with you

Every section, table and checklist in one PDF, with links to the sources and related guides. Subscribe to our weekly NHI & AI Identity Journal and we’ll email you a download link.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Researched and written by the NHI Mgmt Group editorial team using AI tools, under the editorial direction of Lalit Choda. Facts are drawn from the sources listed on this page and checked by our automated quality process. Last updated 13 November 2026. Spotted an error? Use our contact page.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM and Agentic AI security. nhimg.org

PDF Downloads for Newsletter Subscribers

Get the guide

Enter your details and we’ll email you a download link.

The full guide is free to read online. The PDF is a thank you for subscribing.

Fill in all fields marked * and tick the PDF box to continue.