An MCP registry is a machine-readable index of MCP servers - a source of truth that tells clients and tools what servers exist and how to connect to them, not a storefront where you click "install." But the registry is only one of four places your AI assistant can pull tools from. Registries, marketplaces, directories, and GitHub lists each answer a different question - what officially exists, what you can connect in one click, what the community has built, and what the code looks like - and knowing which is which keeps you from mistaking a curated list for a security guarantee or a raw index for a ready-to-use store.

  • Registry - the official index at registry.modelcontextprotocol.io: metadata and verified namespaces only, built for aggregators, no hosting, no ratings, minimal moderation.
  • Marketplace - a client-run or hosted store that adds a browsing UI and curation on top of the raw listing; hosted ones also run the server and handle sign-in and billing. You gain convenience; you depend on the operator.
  • Directory - an independent website that indexes the registry and package ecosystems with search, badges, and grades; broad coverage, but it describes servers rather than running them.
  • GitHub list - a community-curated Markdown page; good for discovering source code, no schema and no uptime behind it.
  • Before you connect anything, run it through the 6-point checklist below - hosting, auth, operator, data, cost, support - and treat any question the listing can't answer as the answer.

Your AI assistant has more than one app store

Your phone has one app store. Your AI assistant does not: Claude, ChatGPT, and Cursor can each pull tools from several places, and the closest thing to a canonical index is the official MCP Registry. Before we compare them, two quick definitions. MCP (Model Context Protocol) is the open standard that lets an AI assistant call external tools - reading a file, querying a database, creating a ticket. An MCP registry is a machine-readable index of MCP servers with a REST API (a standard web interface other programs can query); it lists what exists and how to reach it, but it is not a storefront where you click "install."

A few more terms you will see throughout this guide. A server is a single MCP endpoint that exposes a set of capabilities to an assistant. A tool is one action that server offers - for example, "search issues" or "convert file" - and one server usually bundles several. A remote (or hosted) server is one that runs on someone else's infrastructure, and you connect to it over the network, as opposed to a local server you run on your own machine. Around these sit the clients (the assistants themselves) and the wider ecosystem of registries, marketplaces, directories, and GitHub lists that help AI agents find servers to connect to.

This guide is for the PM or IT lead deciding where a team should get its apps from - and how to check one before wiring it into an assistant.

Diagram: four places to get apps for an AI assistant. The official MCP Registry provides the shared metadata; marketplaces, directories, package registries and GitHub lists each add and lack something
The official registry is the upstream index; many marketplaces and directories pull from it and add their own sources and layers.

The official MCP Registry: a source of truth with an API, not a storefront

When people say "MCP registry," they usually mean the official one at registry.modelcontextprotocol.io. It is the MCP project's central index of publicly available servers, and it is worth understanding what it is before you go looking for tools there, because it does not work the way an app store does.

The registry launched in preview on 2025-09-08. Its read API - the interface other software uses to pull the list - froze at v0.1 on 2025-10-24. As of 2026-10-09, the documentation still labels the registry "preview" with no general-availability date (verified 2026-10-09 on modelcontextprotocol.io/registry).

It stores metadata, not servers

The registry holds metadata only: descriptions of servers, not the servers themselves. Each entry is a server.json file that tells a consumer what the server is called and how to obtain and run it. It doesn't host anything, has no ratings, and has no browsing UI for end users.

A server.json entry typically contains:

  • Name - the server's identifier, in a reverse-DNS namespace (more on that below).
  • Where the code or endpoint lives - a package on npm, PyPI, NuGet or Cargo; a Docker/OCI container image; an MCPB bundle; or a remote streamable-HTTP URL. (Streamable HTTP is the transport MCP uses for servers you reach over the network rather than run locally.)
  • How to run it - the command, arguments and any configuration a client needs to launch or connect.
  • Repository and documentation links, so a consumer can point back to the source and the docs.

It's built for aggregators, not host apps

The registry's own docs are explicit that it "is not intended to be directly consumed by host applications" and is "intended to be consumed primarily by downstream aggregators, such as MCP server marketplaces." Those aggregators are expected to pull the API "on a regular but infrequent basis (for example, once per hour)." In other words, the registry is designed as an upstream source; many of the storefronts you browse pull from it, though not all of them depend on it.

Diagram: a real MCP Registry entry (ai.b77/time, remote streamable-HTTP, status active, published 2026-08-14) with what it proves and what it does not prove
One real entry, ai.b77/time, as returned by the registry API (checked 2026-10-09).

Namespaces prove who published, not whether it's good

Server names follow reverse-DNS namespaces that encode how the publisher was verified:

  • io.github.username/server for GitHub-verified publishers.
  • com.example/server for domain-verified publishers, proven with a DNS TXT record or a /.well-known/mcp-registry-auth file.

This is the authentication layer for publishing: it establishes identity. It does not vet quality. Moderation is explicitly permissive - the policy removes only illegal content, malware, spam, and non-functioning servers, and states that consumers "should assume minimal-to-no moderation." Low-quality or vulnerable servers are not removed. Private servers are not supported.

The architecture is worth holding onto if you're a product manager evaluating tools: the registry proves who published a server, through its namespace, not whether that server is good or safe. Treat a registry listing as a verified identity and a set of connection instructions - a starting point for the checklist later in this article, not a seal of approval.

Marketplaces: the client-run and hosted stores

A registry tells you that a server exists. A marketplace helps you decide whether to use it and then gets it running. On top of the raw listing data, a marketplace typically adds a browsing UI you can search and filter, review or trust labels, and sometimes ratings or usage-based ranking. Hosted marketplaces also run the server, handle sign-in and, for paid tools, billing. The trade-off is that you rely on whoever operates the store.

A marketplace is where those tools get packaged for a specific set of clients, the apps like Claude, ChatGPT, and Cursor that connect to MCP servers.

Client-run stores (verified 2026-10-09)

The clients themselves increasingly ship their own store, curated for their own users.

Anthropic's Connectors Directory in Claude

You reach it inside Claude via Customize > Connectors. It serves Claude.ai, Claude Desktop, mobile, Claude Code, and Cowork. The Claude MCP connectors listed there carry one of two labels:

  • Verified - Anthropic tested the tools for quality and compatibility. Note the boundary: Anthropic's docs state that verification "is not a security audit."
  • Community - screened before listing, but not reviewed in depth.

Ranking is usage-based. Unlike the open MCP Registry, no domain-ownership proof is required to appear here. On Team plans, a member without permission to add connectors sees a Request button that routes the request to admins rather than connecting directly - useful for Enterprise governance where deployment decisions sit with administrators.

The ChatGPT Directory

As of 2026-10-09, OpenAI's developer docs call these listings plugins: bundles of skills, MCP servers, and optional UI, submitted for review and listed in a directory shared by ChatGPT and Codex. The underlying protocol is the same; OpenAI defines the submission and review process.

Cursor's Marketplace

Cursor's Marketplace lists plugins, MCP servers, skills, and automations in one place. Admins can also run team marketplaces, so an organization can curate what its members see and connect.

Hosted third-party marketplaces

A separate category is the hosted marketplace, where a vendor runs the MCP server for you rather than pointing you at a repo to self-host. In this model, the operator manages the server's uptime, handles OAuth 2.1 sign-in - the current authorization standard that lets you grant an app scoped access without sharing your password - and often keeps your credentials in a vault instead of leaving tokens scattered across local configs. Because the server is hosted, you usually connect with a single sign-in step rather than editing JSON by hand.

B77 is one example in this category: an EU-hosted, human-curated MCP marketplace where every listing in the B77 catalog is a remote MCP server that connects to Claude, ChatGPT, and Cursor with OAuth 2.1 sign-in, with no self-serve upload.

The trade-off is straightforward. Hosting and curation buy you convenience and a clear point of accountability - someone operates the server and vets the listing. In return, you depend on that operator staying available and trustworthy, and for paid apps you take on a subscription. Whether that's worth it depends on how critical the tool is and how much you'd rather not run and secure it yourself.

A product manager scrolling through a long list of MCP server entries in a directory on a laptop
Directories are good for breadth: seeing what exists for a task before you check who operates it.

Directories and GitHub lists: broad, searchable, unhosted

If the official registry is the machine-readable source of truth, directories are the human-friendly front ends built on top of it. A directory is an independent website that crawls or ingests the registry and package ecosystems - the npm, PyPI, and container repositories where server code actually lives - then adds search, filters, badges, and sometimes quality grades. The important thing to understand: most directories describe servers; they do not run them. They tell you a server exists; they cannot tell you it is online right now.

GitHub lists are simpler still. They are curated Markdown pages in a public repository, maintained by a community and grown one pull request at a time. Useful for browsing, but with no metadata schema and no uptime guarantees behind them.

What the major directories look like (checked 2026-10-09)

  • PulseMCP describes itself as "a daily-updated directory of all Model Context Protocol (MCP) servers available on the internet" and listed 21,729 servers. It adds badges to distinguish official-repository, Anthropic-reference, and community servers, and offers a "Remote Available" filter so you can narrow to servers you can connect to over the network rather than run locally.
  • Glama's directory showed 97,619 servers, with each entry carrying a license, a letter quality grade (A to F), a maintenance status, and a category tag for remote, local, or hybrid deployment.
  • The GitHub MCP Registry page at github.com/mcp listed 394 servers, shown with install counts and one-click install into VS Code and GitHub Copilot. It is smaller and more curated than the crawl-everything directories.
  • Docker's MCP Catalog offers containerized servers from known publishers, packaged as images you pull and run yourself - a middle ground between a directory listing and a hosted service.

What the GitHub lists look like (checked 2026-10-09)

The punkpeye/awesome-mcp-servers repository - a community "awesome list" of servers grouped by category - had 96k stars. Entries are added by pull request, so the "Contributing" section of the repo is the mechanism: someone submits a link, a maintainer reviews it, and it appears in the list. Stars measure popularity of the list itself, not the quality of any server on it.

What directories and lists are good for

  • Breadth. If you want to know what exists for a task - every Postgres server, every web-scraping server - a directory's search and filters get you a shortlist fast.
  • Comparing alternatives. License, quality grade, maintenance status, and remote/local tags let you rank candidates before you read a single line of documentation.
  • Discovery for developers. If you plan to self-host, seeing the underlying repository, package name, and stars helps you judge whether a project is actively maintained.

What they cannot tell you

Directories catalog metadata, not operations. A listing will not reliably tell you:

  • Whether the server is actually running. A "Remote Available" badge means a remote endpoint was advertised, not that it responded today.
  • Who answers when it breaks. There is no SLA in a Markdown table or a crawled entry. Support depends on the publisher, and the directory is not in that loop.
  • What data the server retains. Whether a server logs your prompts, stores tokens, or forwards data to a third party is a privacy question the listing rarely answers - you have to read the publisher's own documentation and terms.

Why a big number is not a quality signal

The gap between 394 and 97,619 is not a gap in quality - it is a difference in what each source counts. Crawl-everything directories include duplicates, forks of the same server, experimental one-offs, and abandoned projects that no longer build. In an open ecosystem where anyone can publish a package, the raw count inflates quickly. Treat the number as a measure of coverage, not of curation. When you compare two directories, look at how they filter and grade, not at which one claims more servers. A short, well-maintained list can be more useful than a large crawl for the simple reason that someone made a call on each entry.

Registry vs marketplace vs directory vs GitHub list: side-by-side

Each of these four surfaces plays a different role in the MCP ecosystem, and the differences matter the moment you go from browsing to connecting. The table below summarizes how they compare as of 2026-10-09.

Dimension Official registry Marketplace Directory GitHub list
Who runs it The MCP project as a community-maintained catalog A commercial operator or an AI client vendor An independent site owner Individual maintainers or a community
What it lists Server metadata and namespaces (a source of truth for clients) Ready-to-use, often hosted MCP servers Links to servers, both hosted and self-hosted Repository links, usually to open-source servers
How an entry gets in Namespace ownership proven via GitHub, DNS, or HTTP challenge Operator review before publication Crawled or submitted, sometimes lightly checked Pull request
What is verified Namespace ownership; metadata shape against requirements Varies by operator; may include compatibility, functionality, and security checks Little to none, beyond search and badges None
Hosting Not hosted (a catalog, not a runtime) Varies: hosted marketplaces run the server; client directories point to servers run by their publishers Not hosted; points elsewhere Not hosted; you run it yourself
Sign-in and credentials Not handled; that is the server's job Varies: hosted marketplaces manage sign-in; in client directories you authenticate with each server Not handled Not handled; you configure it
Ratings and reviews No Sometimes Sometimes (badges, popularity) Stars only
Billing No Sometimes: subscriptions or usage metering No No
Support when it breaks Community issues on the catalog itself An operator with support requests you can file None; you contact the source Issues on the repo, best effort
Best for Authoritative discovery and client integrations Fast, accountable connections for non-developers Broad browsing across the ecosystem Developers who want the code

Many marketplaces and directories use the official registry as one of their data sources, alongside independent submissions and other package ecosystems, and add hosting, curation, ratings, or billing on top. GitHub lists are maintained separately and do not depend on it.

The practical difference for a team is who answers when something breaks. A directory or GitHub list entry is a pointer: it tells you a server exists and roughly what it does, and there may be no dedicated party responsible for support. A marketplace entry comes with an operator who reviewed the listing and, in the hosted case, runs the server and manages sign-in. Choose the surface by how much accountability you need, not by how many entries it has.

Diagram: which store to use by situation. Five situations mapped to the recommended source: client directory or hosted marketplace, official registry entry or package, directory first, treat a GitHub list entry as source code, admin controls in the client
Start from what you need to run and who is allowed to connect it.

Which store to use, by situation

There is no single right source for every MCP server. The best choice depends on how you plan to run it and who is allowed to connect it. Here are five common situations and where to start with each.

You want one app working in Claude, ChatGPT, or Cursor today, with no local install

Use the client's own directory (Claude connectors, the ChatGPT Directory, Cursor plugins) or a hosted marketplace, where the server is already running on someone's infrastructure and you connect over a remote URL. Prefer entries that clearly name an operator - the party responsible for running the server and handling your OAuth 2.1 authorization - so you know who can see your data. This is the fastest path for non-developers because there is nothing to install or maintain.

Your team must self-host or run on-premises

Start from the official registry entry or the underlying package - an npm module, PyPI package, or Docker image - and run it inside your own infrastructure. This keeps deployment, network boundaries, and secrets under your control, which matters when compliance requirements rule out sending data to a third-party operator. Expect to involve developers to build, configure, and monitor the server.

You are surveying what exists for a category before choosing

Use a directory to see the breadth of options for a task, then check whether a hosted, remote version exists for the ones you shortlist. A directory tells you what is out there; it rarely tells you whether an entry is production-ready or who operates it. Treat that first pass as research, not a shortlist you can connect as-is.

You found a server only on a GitHub list

Treat it as source code to review, not an app to install. Check the recent commit history and open issues for signs of active maintenance, and read the license before your team relies on it. If it looks solid, the safe move is to run it yourself in a controlled environment rather than pointing production agents at code you have not vetted.

You manage a company account

For Enterprise and team accounts, use the admin controls your clients provide - such as Claude Team's Request flow or Cursor's team marketplaces - so members cannot connect unreviewed servers on their own. Route new connections through an approval step where someone checks the operator, scopes, and data handling first. This turns ad-hoc, self-hosted or hosted picks into a governed, auditable set of tools your organization has actually reviewed.

Diagram: six questions before you connect any MCP server. Hosted or local, auth model, who operates it, what data it sees and keeps, what it costs, who supports and updates it
If a listing cannot answer questions 3 and 4, do not connect it to company data.

The 6-point checklist before you connect any MCP server

Whichever store you found it in - the official registry, a client marketplace, or a GitHub list - run any MCP server through these six questions before you connect it. Each question tells you something about risk, cost, or reliability, and each has a place you can go to check the answer. If the listing can't answer a question, treat that gap as the answer.

  1. Is it hosted or local? A remote server exposes a streamable HTTP URL - an endpoint your client calls over the network - so nothing runs on your machine and updates happen on the operator's side. A local server ships as a package (for example, an npm or PyPI command) that you install, run, and keep up to date yourself. Check the listing: a URL means hosted; an install command or repository means local. Local deployment gives you more control over the server environment, but data may still be sent to external services; hosted removes maintenance but means you trust the operator with whatever the server sees.
  2. What is the authentication model? Prefer OAuth 2.1 sign-in with scopes (the specific permissions being requested) you can review before you approve, and tokens you can revoke later from the provider's account settings. Modern OAuth 2.1 flows use PKCE (Proof Key for Code Exchange), an extension that stops an intercepted authorization code from being reused by an attacker. Favor this over pasting a long-lived API key into a config file, which grants broad access, rarely expires, and is hard to audit. Look for the auth method in the server's documentation and for a consent screen that lists scopes when you connect.
  3. Who operates it? In the official registry, look at the namespace: a domain-verified name like com.example/server tells you a real domain owner published it, versus an anonymous handle that anyone could register. In a client's directory, look for a "Verified" or "Community" label. Across any source, check whether a company name, a website, and a support channel are published. An operator you can name and contact is one you can hold accountable.
  4. What data does it see and keep? Look for a permissions statement - often phrased as "what this app can see" - and read which tools are read-only versus which can write or delete. Check whether the operator states a data-retention policy: what they log, for how long, and whether prompts or results are stored. If no permissions or retention information is published, assume the server can access the widest scope its tools allow and plan accordingly.
  5. What does it cost? Confirm whether the server is free, subscription-based, or metered by usage, and note what happens when a trial ends - whether it stops working, keeps running on a free tier, or starts billing. Pricing should be stated on the listing or the operator's site, not discovered after you connect.
  6. Who supports and updates it? Check the version history, the last-updated date, and whether there's an issue tracker or support address. In the official registry, check the entry's status field: active, deprecated, or deleted. A server that hasn't been touched in a long time, or is marked deprecated, may break against current clients or the current spec.

Rule of thumb: connect only from a source that can answer all six of these questions, because every gap is a requirement you're accepting on trust. If a listing cannot answer questions 3 and 4 - who operates it and what data it sees - do not connect it to company data. Our guide to MCP security for teams covers what to check next.

Diagram: how a publisher gets into the official MCP Registry in five steps. Prove the namespace, write server.json, package ownership check, push with mcp-publisher, downstream pull by directories and marketplaces
Identity is verified at every step of publishing; quality is not.

How publishers get into the registry, and what that means for you

Getting into the official MCP Registry comes down to proving you own the name you want to publish under. A publisher claims a namespace: either io.github.*, verified by a GitHub login, or a domain such as ai.b77/*, verified with a DNS TXT record or a /.well-known/mcp-registry-auth file on the site. They then write a server.json describing the server and push it with the mcp-publisher CLI. If the listing points at a package rather than a remote URL, ownership of that package is checked too: an mcpName field in package.json for npm, an mcp-name marker in the README for PyPI, or an image label for Docker. The registry's authentication guide on modelcontextprotocol.io documents the full flow if you want the exact steps.

A concrete, dated example: on 2026-08-14 B77 published its apps to the official registry under the ai.b77/* namespace as remote streamable-HTTP servers - for instance, ai.b77/time pointing at time.b77.ai/mcp. As of 2026-10-09, a registry search returns 16 ai.b77 entries. Because the namespace is a domain, that publication went through domain-based verification (a DNS record or a well-known file) rather than a GitHub login.

What you can safely read from an entry like that: the domain owner vouches for the URL, so ai.b77/time genuinely comes from whoever controls b77.ai, and directories that poll the registry pick the listing up on their next pull, which the registry docs suggest happens about once per hour. For quality, uptime, and data handling, you still have to look at the operator's own pages and at the review labels some clients show before you connect.

One practical note for PMs on the publishing side: you don't have to build and operate a server yourself to publish your MCP here. A marketplace operator can co-build and host the MCP for you, run the namespace and package verification, and keep the listing current - useful if you have an API but no appetite to maintain a preview-then-production release pipeline in-house.

Frequently asked questions

What is an MCP registry?

An MCP registry is a machine-readable index of MCP servers with an API - a way for clients and tools to look up what servers exist and how to connect to them, rather than a storefront you browse and buy from. The official one is run by the MCP project and has been in preview since 2025-09-08. It holds metadata only (names, descriptions, endpoints, versions), not the servers themselves and not your credentials.

Is the MCP Registry open source?

Yes. The code and the API specification live on GitHub under the modelcontextprotocol organization, so anyone can read exactly how it works. Per its own docs, the official codebase is not designed for self-hosting, but the OpenAPI interface is public - so any organization can build a sub-registry or private MCP catalog that implements the same shape and stays compatible with clients.

What MCP servers are available for Claude?

Claude supports custom remote MCP connectors on every plan (Free is limited to one), provided the server is reachable from the public internet and meets Claude's authentication requirements; on Team and Enterprise only owners or roles with the right permission can add them (verified 2026-10-09). Claude's Connectors Directory lists both Verified and Community entries you can enable directly. Beyond that, B77's Claude connectors directory lists hosted servers that are already running and ready to connect, which saves you from operating anything yourself.

How do I find MCP servers for a specific task?

Start broad: search an MCP directory to see the full range of options for your task. Then narrow down by checking the registry namespace to confirm who publishes each server, and read the operator's own page for auth, scopes, and support. If you do not want to run anything, prefer hosted entries from an MCP hub or marketplace so the connection is a URL rather than a local install.

Which MCP server is best?

There is no single best MCP server - the right choice depends on the six checklist questions above, especially what data the server can see and who operates it. Directory rankings and lists of the best MCP servers tend to reflect installs and ratings, which signal popularity, not fit for your data or compliance needs. Use them as a starting point, then evaluate each candidate against your own requirements.

Putting it together

The four surfaces work best in sequence: use the official registry to confirm who published a server, a directory to survey what exists for your task, and a marketplace when you want a hosted, accountable connection with managed sign-in - then run every candidate through the six-point checklist before you wire it into an assistant. If your next step is finding a hosted server you can connect to Claude, ChatGPT, or Cursor with OAuth 2.1 in a couple of clicks - or publishing your own API as a co-built, operated MCP - B77 is one place to do it, and the checklist above works just as well anywhere else you look.