We and selected third parties use cookies or similar technologies for technical purposes and, with your consent, to analyze how the site is used.

You can freely give, refuse or withdraw your consent at any time.

API and data

Everything in the directory is public and readable by machines: an API in the official MCP Registry’s format, a JSON search index, every listing as JSON and Markdown, plus llms.txt, a feed and sitemaps. No key, no sign-up.

At a glance

URLWhat you getCached for
/v0.1/serversListings in the official MCP Registry’s format, paged. Details5 minutes
/api/index.jsonEvery listing in one compact array. Details5 minutes
/i/{slug}.jsonOne listing, with its setup actions. Details10 minutes
/i/{slug}.mdOne listing as Markdown. Details15 minutes
/llms.txtThe directory as a list for language models.1 hour
/feed.xmlAtom feed of the 50 newest listings.15 minutes
/changes.xmlAtom feed of the 50 newest changes across the directory. Details15 minutes
/i/{slug}/history.xmlAtom feed of one listing’s History. Details15 minutes
/sitemap.xmlSitemap index: pages, categories and listings, in every language.15 minutes
/mcpmcp.tc’s own MCP server. DocsNot cached
POST /submitSuggest a server for the directory from a script. DetailsNot cached
/openapi.jsonOpenAPI 3.1 description of the registry API, the search index, the listing JSON and Markdown, the change feeds, and POST /submit with its status.1 hour
/.well-known/…Discovery files for agents: the API catalog, the MCP server card, the AI catalog and an agent skill. Details1 hour
/AGENTS.mdA guide for AI agents: how to connect, limits and etiquette. Details1 hour
/{page}.mdAny page as Markdown, in its language. DetailsUp to 5 minutes

All of it is public, and all of it is read-only except POST /submit. There’s no key, no account and no charge. Machine formats are language-neutral: they serve the listings’ English text and have no language prefix. Page Markdown is the exception and follows the page’s language.

Registry-compatible API

https://mcp.tc/v0.1/ is a read-only copy of the official MCP Registry’s read API (version 0.1, server.json schema 2025-12-11), filled with mcp.tc’s approved listings. A client that takes a custom registry URL can browse and install from the directory with it.

GET /v0.1/servers

Servers sorted by name, 30 per page unless you set limit (1 to 100). Pass metadata.nextCursor back as cursor for the next page. search keeps servers whose name, title, slug or vendor contains every word (the official API matches the name only). updated_since takes an RFC 3339 time, counts it inclusively and also returns listings removed since then. version (latest or a version) and include_deleted work as in the official API.

GET /v0.1/servers/{name}/versions

The versions of one server. Each listing has exactly one. URL-encode the name, as in /v0.1/servers/tc.mcp%2Fdeepwiki/versions.

GET /v0.1/servers/{name}/versions/latest

One server. An exact version number works in place of latest.

GET /v0.1/ping, /v0.1/health, /v0.1/version

Liveness and build information, as in the official API.

A page of results has this shape:

GET /v0.1/servers
{
  "servers": [
    {
      "server": { "name": "…", "version": "…", … },
      "_meta": {
        "tc.mcp/listing": {
          "link": "https://mcp.tc/i/…",
          "slug": "…",
          "category": "…",
          "verified": true,
          "auth": "none",
          "status": "active",
          "publishedAt": "…",
          "updatedAt": "…"
        }
      }
    }
  ],
  "metadata": { "count": 30, "nextCursor": "…" }
}

And here’s what server holds for two listings, as the API serves them now:

Remote server

server (tc.mcp/deepwiki)
{
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "name": "tc.mcp/deepwiki",
  "description": "Ask questions about any public GitHub repository and read its AI-generated DeepWiki documentation.",
  "title": "DeepWiki",
  "version": "4.0.2",
  "websiteUrl": "https://docs.devin.ai/work-with-devin/deepwiki-mcp",
  "icons": [
    {
      "src": "https://mcp.tc/media/icons/deepwiki-80b7a72d.webp",
      "mimeType": "image/webp",
      "sizes": [
        "128x128"
      ]
    }
  ],
  "remotes": [
    {
      "type": "streamable-http",
      "url": "https://mcp.deepwiki.com/mcp"
    }
  ]
}

Local server

server (tc.mcp/memory)
{
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "name": "tc.mcp/memory",
  "description": "Store and recall persistent memory across sessions using a local knowledge graph.",
  "title": "Memory",
  "version": "2.1.1",
  "websiteUrl": "https://github.com/modelcontextprotocol/servers/tree/main/src/memory",
  "repository": {
    "url": "https://github.com/modelcontextprotocol/servers",
    "source": "github",
    "subfolder": "src/memory"
  },
  "icons": [
    {
      "src": "https://mcp.tc/media/icons/memory-0e174415.webp",
      "mimeType": "image/webp",
      "sizes": [
        "128x128"
      ]
    }
  ],
  "packages": [
    {
      "registryType": "npm",
      "identifier": "@modelcontextprotocol/server-memory",
      "runtimeHint": "npx",
      "transport": {
        "type": "stdio"
      }
    }
  ]
}
  • name is the server’s name in the official registry when it has one, otherwise tc.mcp/{slug}.
  • remotes always holds the server’s own URL, never the mcp.tc link. Key headers appear only for servers that need an API key.
  • packages is rebuilt from the install command on the listing: npm (npx), PyPI (uvx, pipx run), OCI (docker run) and NuGet (dnx). A command the format can’t express gets no package, because one that starts the wrong program would be worse than none.
  • _meta["tc.mcp/listing"] carries the mcp.tc link, slug, category, checkmark, auth, status and dates. updatedAt moves only when the entry we serve changes, never because of a health check.
  • mcp.tc isn’t the official registry, so entries never carry its io.modelcontextprotocol.registry/official metadata.
  • A listing that’s removed, hidden or renamed comes back as an entry with "status": "deleted" for 180 days, but only when you ask with updated_since or include_deleted.

Errors are problem JSON (application/problem+json), as in the official API: 404 for an unknown server, 422 for a bad limit, cursor or include_deleted, 400 for a bad updated_since. Any method but GET, HEAD and OPTIONS gets 405: the registry is read-only, and new servers come in through Submit.

The API is described in OpenAPI 3.1 at https://mcp.tc/openapi.json, and every response links to it in a Link header.

curl -s 'https://mcp.tc/v0.1/servers?search=notion&limit=5'
curl -s 'https://mcp.tc/v0.1/servers/tc.mcp%2Fdeepwiki/versions/latest'

Use mcp.tc as your registry

These clients take a custom registry URL, according to VS Code’s source and GitHub’s documentation (checked 8 October 2026). In VS Code and in Copilot’s policies, enter the base URL without /v0.1: they add the path themselves.

VS Code

Add this line to the user settings.json of your default profile:

settings.json
"chat.mcp.gallery.serviceUrl": "https://mcp.tc"

The MCP server gallery (type @mcp in the Extensions view) then shows mcp.tc’s servers, and installing one uses the server’s own URL or package. No other setting is needed. The setting doesn’t appear in the Settings editor, and other profiles ignore it unless the default profile’s settings.json also has "workbench.settings.applyToAllProfiles": ["chat.mcp.gallery.serviceUrl"]. Organizations can set it for everyone with the McpGalleryServiceUrl policy (VS Code 1.101 or later), and "chat.mcp.access": "registry" limits VS Code to running servers from that registry.

GitHub Copilot

Organization and enterprise admins can enter https://mcp.tc as the MCP Registry URL in Copilot’s policies. GitHub lists VS Code, Visual Studio, JetBrains IDEs, Eclipse, Xcode and Copilot CLI as supported. With Registry only, servers are matched by name, which GitHub says users can get around by editing their configuration. GitHub calls this route a public preview and not its recommended way to restrict servers: it recommends an allowlist in the enterprise’s managed-settings.json.

Copilot in JetBrains IDEs, Xcode and Eclipse

Users can also enter a registry in Copilot’s own settings (MCP Registry URL), in public preview on pre-release builds of the plugin. GitHub doesn’t say whether that field takes the base URL or the /v0.1 path, and we haven’t tested mcp.tc there.

A few listings have neither a package nor a remote, because their install command can’t be written in the registry format. VS Code hides those; their pages on mcp.tc still have the setup.

Search index

/api/index.json holds every approved listing in one JSON array, the data behind the site’s search. Short keys keep it small:

KeyValue
sSlug: the listing is at /i/{s}.
nName.
vVendor, or an empty string.
tTagline, up to 160 characters (in English).
cCategory slug, as in /c/{slug}.
kremote or local.
aAuth: none, oauth, api_key, optional or unknown.
gTags, an array of strings.
iIcon, a path such as /media/icons/{slug}.webp (WebP or PNG). Missing when the listing has none.
f1 when the listing has the checkmark. Missing otherwise.
One entry
{
  "s": "deepwiki",
  "n": "DeepWiki",
  "v": "Cognition",
  "t": "Ask questions about any public GitHub repository and read its AI-generated DeepWiki documentation.",
  "c": "docs-knowledge",
  "k": "remote",
  "a": "none",
  "g": [
    "github",
    "documentation",
    "code-search",
    "repositories",
    "wiki",
    "remote"
  ],
  "i": "/media/icons/deepwiki-80b7a72d.webp",
  "f": 1
}

One listing as JSON

Add .json to any listing link for that listing as JSON:

curl -s https://mcp.tc/i/deepwiki.json

It has everything the page shows: the server’s own endpoint or install_command, the access label, the tools, the checkmark, health, and the one-click add actions, which always use the server’s own URL or package. The history object points to the listing’s History: its url and Atom feed, what we watch (tracking: tools, version or listing), when we last read its tools (tools_checked) and when it last changed (last_changed), both ISO 8601 or null. A slug that isn’t listed gets 404 with "error": "not_found", and a removed listing 410 with "gone". Old slugs and aliases return the current listing, so read slug from the answer.

Any site can read it: the answer carries Access-Control-Allow-Origin: *, and it needs no key. Fields with no value are null, never left out. The text is the listing’s English original unless you add ?lang= (languages). Every field:

FieldTypeWhat it is
slugstringThe listing’s current slug. Old slugs and aliases return the current listing, so read it from here.
namestringServer name.
vendorstring or nullWho makes the server.
taglinestring or nullOne line, up to 200 characters.
descriptionstring or nullPlain text, paragraphs separated by a blank line, up to 2,000 characters. An AI model wrote it from the server’s public metadata.
linkstringThe listing page, https://mcp.tc/i/{slug}, or with ?lang= the page in that language once it is translated.
lang
text_lang
stringlang: the language of the labels (en unless you ask for another with ?lang=). text_lang: the language of tagline, description and the tool summaries: lang when the listing has an up-to-date translation, else en. A tool whose description changed since the last translation keeps its English summary until it’s translated again.
category
category_name
string or nullCategory slug (as in /c/{slug}) and its name.
kindstringremote (you connect over HTTPS) or local (runs on your computer).
transportstringstreamable-http, sse or stdio.
authstringnone, oauth, api_key, optional or unknown.
accessobjectHow mcp.tc labels it: group (ok, auth or local, the directory’s Access filter), label (badge text, like “No sign-in”), text (long form) and note (one sentence).
endpointstring or nullThe server’s own URL (remote servers). This is what a client connects to.
install_commandstring or nullThe command that starts a local server, like npx -y @playwright/mcp.
packageobject or nullregistry (npm, pypi, oci, nuget…) and identifier.
relaybooleanFalse for every listing: the mcp.tc link is a page, and clients connect to the server’s own URL. The field stays so existing readers keep working.
verified
verified_by
boolean, string or nullThe checkmark, and what it means for this listing.
iconstring or nullURL of the listing’s 128 × 128 icon on mcp.tc.
tools_count
tools
number, arrayTools read from the server (up to 150): name, summary, and read_only / destructive (true, false, or null when the server doesn’t say).
addarrayThe one-click actions: client (claude-code, cursor, vscode, claude-ai), label, kind and value: a command to copy for copy, an install link for link. They always use the server’s own URL or package.
homepage
repository
docs
string or nullLinks from the listing.
healthstringOur last check: ok, auth (it answered and asked for sign-in), down or unknown (local servers aren’t checked).
last_checked
listed
updated
string or nullISO 8601 times in UTC: the last check, when it was listed, the last change to its content.
historyobjectThe listing’s History: url (its History tab) and feed (Atom), what we watch in tracking (tools, version or listing), and two ISO 8601 times in UTC, or null: tools_checked (when we last read its tools) and last_changed (its newest change).
embedsobjectThis listing’s badge, widget, iframe and markdown URLs. widget and iframe keep your ?lang=. snippets has the code from the Embed section of the listing page, ready to paste: markdown and html for the badge, script for the website card, placeholder (a div where the card appears, with a link inside for visitors without JavaScript) and iframe. Their alt text and links follow ?lang=.
formatstringA link to this field list.

Badges and embeds

How the website card behaves on your page:

  • Each file holds everything: the listing’s data, the styles and the icon. It makes no other requests and sets no cookies or local storage, so there is nothing to track visitors with.
  • It draws inside a closed shadow root: your styles don’t reach it and its styles don’t reach your page.
  • It writes text only as text (never as HTML) and links only to mcp.tc and the clients’ own install pages, over HTTPS.
  • With a Content Security Policy, allow script-src https://mcp.tc. The icon is a data: image; if your policy blocks those, the card shows the first letter of the name instead.
  • For a slug that isn’t listed, nothing appears and the browser console shows a warning.

How long copies are kept

  • The card, the iframe and the JSON carry install buttons, so they refresh quickly. Browsers keep them for 10 minutes, and a change to the listing reaches the copies our CDN (Cloudflare) keeps within 15 minutes.
  • The badge only shows a name. Cloudflare keeps it for up to a day and browsers for an hour; while Cloudflare refreshes a copy, it can serve the old one for up to a week.

Pages and listings as Markdown

For agents and language models, every listing is also Markdown: add .md to the link, or ask for text/markdown at the listing’s own address.

curl -s https://mcp.tc/i/deepwiki.md
curl -s -H 'Accept: text/markdown' https://mcp.tc/i/deepwiki

It starts with a summary (the link, how to connect, type, auth, category, vendor, checkmark), then has the description, what the server can do, its tools, example prompts, the install steps for each client and its five most recent changes. An old name answers 301 with the current one.

The site’s pages work the same way: the home page, the directory and its categories, these docs, the blog, the recent changes, the checkmark page and the legal pages. Add .md to the address (/docs/connect.md, /it/c/databases.md; the home page is /index.md) or ask for text/markdown at the page itself. You get the page’s text in its language, without menus, under a short header of metadata. A request whose Accept header prefers text/markdown gets it with Vary: Accept, and x-markdown-tokens gives a rough token count (characters divided by four). The .md copies are noindex, so search engines keep indexing the HTML page.

llms.txt, feeds and sitemaps

  • /llms.txt follows llmstxt.org: how connecting works, these docs, the categories with their counts, the language versions of the site, and every listing with a one-line summary and short facts (remote or local, auth, verified), each linked to its Markdown.
  • /feed.xml is an Atom feed of the 50 most recently approved listings, with tagline and description.
  • /changes.xml is an Atom feed of the 50 newest changes across the directory (tools added, removed or changed, new versions, edits by server owners), each with a link to the listing’s History. The Recent changes page shows the same list.
  • /i/{slug}/history.xml is one listing’s History as an Atom feed, for example /i/deepwiki/history.xml. Change history and alerts explains what counts as a change.
  • /sitemap.xml indexes three sitemaps: pages, categories and listings, each with the date its content last changed. Every page is listed in each language it exists in, with its alternates (hreflang); a listing’s translated pages appear once its text is translated.
  • /robots.txt lets every crawler in, AI crawlers included (Content-Signal: search=yes, ai-input=yes, ai-train=yes). It keeps them out of /api/, except the search index, and out of private submission pages.

Suggest a server from a script

The Submit form also takes JSON. Send a POST to https://mcp.tc/submit with Content-Type: application/json, the server’s URL and, if you like, a note for the person who reviews it:

curl -s https://mcp.tc/submit \
  -H 'Content-Type: application/json' \
  -d '{"url": "https://mcp.example.com/mcp", "note": "The official server of Example."}'
  • url (required): a remote MCP endpoint, a repository, or an npm or PyPI page, up to 2,048 characters.
  • note (optional): up to 500 characters. The URL and the note are checked automatically, including by an AI model, so leave personal data out.
  • notify_email (optional): the address of the person suggesting the server, who gets one email in English when it’s listed (the 202 answer then has "notify": true). Add it only with that person’s consent. An address can wait for five servers at a time.

Other fields are ignored. A suggestion sent this way goes through the same checks and the same limits as one from the form, and needs no key or account. Only the address without a language prefix takes JSON. The answer carries no CORS headers, so a page on another site can’t send it, and a browser request marked as cross-site gets 403.

An accepted suggestion gets 202, with the status URL in the Location header too:

HTTP 202
{
  "ok": true,
  "state": "queued",
  "token": "{token}",
  "status_url": "https://mcp.tc/s/{token}.json",
  "page": "https://mcp.tc/s/{token}"
}
Statusstate or errorWhat it means
202queuedIn the queue: follow it at status_url. If the same URL is already waiting, you get that suggestion’s token and "existing_submission": true.
200duplicateAlready listed: listing holds its slug, name and link.
400invalid_requestThe body isn’t a JSON object with a url string.
403cross_siteA browser sent it from another site.
413too_largeThe body is over 16 KB.
422empty, too_long, invalid_url, personal_url, blocked, invalid_email, notify_limitedWe can’t take this URL, or notify_email isn’t an address or already waits for five servers. message says why, and sending it again gets the same answer.
429rate_limitedToo many suggestions. scope names the limit (ip_hour, ip_day or global_day); retry_after and the Retry-After header give the seconds to wait.
503pausedSuggestions are paused for now. Try again after Retry-After.

Every answer is JSON with ok. An error adds the code in error and one English sentence in message. A burst of requests can also get a 429 from the web server or from Cloudflare without this body: wait for Retry-After, or 10 seconds if it’s missing. Send a descriptive User-Agent too: Cloudflare answers the default ones of Python-urllib and libwww-perl with a 403 that isn’t JSON, here and at status_url.

Follow the status

Read status_url every 5 to 10 seconds until terminal is true; most suggestions are done within a few minutes. state goes from queued to checking and reviewing, then ends as listed, duplicate, pending (a person reviews it before it goes live), rejected or error. When there’s a listing, link and name point to it. title and message are the status page’s English text, and page is that page, for a browser. An unknown token gets 404. A finished suggestion looks like this:

GET /s/{token}.json
{
  "state": "listed",
  "title": "It’s listed",
  "message": "It’s live in the directory. Copy its link below.",
  "link": "https://mcp.tc/i/deepwiki",
  "name": "DeepWiki",
  "display": "mcp.tc/i/deepwiki",
  "terminal": true
}

The open-source command-line tool mcp-tc sends this request from a terminal and follows the status for you: npx mcp-tc submit https://mcp.example.com/mcp.

Discovery files

Agents and crawlers find mcp.tc’s APIs, its MCP server and its skill through these files. They’re in English, public and cached for an hour, with an ETag and CORS open to any site. Every page also sends a Link header that points to the API catalog.

  • /.well-known/api-catalog: the three APIs (registry, MCP server, search index) as an RFC 9727 linkset, each with its description, docs, terms and privacy policy.
  • /openapi.json: OpenAPI 3.1 for /v0.1/, /api/index.json, /i/{slug}.json, /i/{slug}.md, the change feeds (/changes.xml, /i/{slug}/history.xml) and POST /submit with its status (/s/{token}.json).
  • /mcp/server-card: the server card of mcp.tc’s MCP server (name, version, URL, protocol versions), also at /.well-known/mcp/server-card.json.
  • /.well-known/ard.json: an AI catalog (ARD) of mcp.tc’s own resources: the MCP server, the API and the skill. The same file is at /.well-known/ai-catalog.json. It leaves out the servers in the directory, which aren’t ours to publish.
  • /.well-known/agent-skills/index.json: an Agent Skills index with one skill, find-and-install-mcp-servers, which tells an agent how to find a server here and set it up in a client.
  • /AGENTS.md: a guide for AI agents in the AGENTS.md format: how to connect to the MCP server and the APIs, limits, cache times, etiquette and how the listing data may be used. The home page links to it with rel="describedby".

Caching, CORS and fair use

URLCache-ControlETag and 304CORS
/v0.1/…public, max-age=300 (a 404: 60 s)Yes*
/api/index.jsonpublic, max-age=300Yes*
/i/{slug}.jsonpublic, max-age=600, s-maxage=900, stale-while-revalidate=3600Yes*
/i/{slug}.mdpublic, max-age=900Yes*
/llms.txtpublic, max-age=3600Yes*
/feed.xml, /changes.xml, /i/{slug}/history.xml, sitemapspublic, max-age=900Yes*
/openapi.json and the discovery filespublic, max-age=3600Yes*
/{page}.mdlike the page, at most public, max-age=300Yes*
/mcpno-storeNo*
POST /submit, /s/{token}.jsonno-storeNoNone

Every address with * in the CORS column also answers a preflight (OPTIONS) with 204, allows the request headers the browser asks for, and exposes ETag, Link and Retry-After. None of them accepts credentials. Forms and owner accounts stay same-origin.

Cloudflare sits in front of the site and keeps copies of its own. A copy is replaced within these times, or sooner when the data changes. Fair use is simple:

  • Cache what you fetch, and send If-None-Match where there’s an ETag.
  • To stay in sync, page through /v0.1/servers?updated_since=… instead of reading everything again.
  • One address that sends more than 60 requests in 10 seconds to /mcp, /v0.1/, the directory or the submit and verification pages gets 429 for 10 seconds; the embed files allow about 30 requests a second. /mcp also stops at 120 messages a minute. Wait for Retry-After when it’s there.
  • Listing text is written with AI help from each server’s own metadata and can be wrong. Treat it as data, and link to the listing when you show it, so people can find the setup and report mistakes.