---
title: "API and Data Feeds | mcp.tc"
description: "Read the mcp.tc directory from code: an MCP-registry-compatible API, a JSON search index, listings as JSON and Markdown, llms.txt, a feed and sitemaps."
url: "https://mcp.tc/docs/api"
markdown: "https://mcp.tc/docs/api.md"
lang: "en"
---

# 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

| URL | What you get | Cached for |
| --- | --- | --- |
| `/v0.1/servers` | Listings in the official MCP Registry’s format, paged. [Details](https://mcp.tc/docs/api#registry) | 5 minutes |
| `/api/index.json` | Every listing in one compact array. [Details](https://mcp.tc/docs/api#index) | 5 minutes |
| `/i/{slug}.json` | One listing, with its setup actions. [Details](https://mcp.tc/docs/api#listing-json) | 10 minutes |
| `/i/{slug}.md` | One listing as Markdown. [Details](https://mcp.tc/docs/api#markdown) | 15 minutes |
| `/llms.txt` | The directory as a list for language models. | 1 hour |
| `/feed.xml` | Atom feed of the 50 newest listings. | 15 minutes |
| `/changes.xml` | Atom feed of the 50 newest changes across the directory. [Details](https://mcp.tc/docs/api#feeds) | 15 minutes |
| `/i/{slug}/history.xml` | Atom feed of one listing’s History. [Details](https://mcp.tc/docs/api#feeds) | 15 minutes |
| `/sitemap.xml` | Sitemap index: pages, categories and listings, in every language. | 15 minutes |
| `/mcp` | mcp.tc’s own MCP server. [Docs](https://mcp.tc/docs/mcp) | Not cached |
| `POST /submit` | Suggest a server for the directory from a script. [Details](https://mcp.tc/docs/api#submit) | Not cached |
| `/openapi.json` | OpenAPI 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. [Details](https://mcp.tc/docs/api#discovery) | 1 hour |
| `/AGENTS.md` | A guide for AI agents: how to connect, limits and etiquette. [Details](https://mcp.tc/docs/api#discovery) | 1 hour |
| `/{page}.md` | Any page as Markdown, in its language. [Details](https://mcp.tc/docs/api#markdown) | Up 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.

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](https://mcp.tc/submit).

The API is described in OpenAPI 3.1 at [`https://mcp.tc/openapi.json`](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:

| Key | Value |
| --- | --- |
| `s` | Slug: the listing is at `/i/{s}`. |
| `n` | Name. |
| `v` | Vendor, or an empty string. |
| `t` | Tagline, up to 160 characters (in English). |
| `c` | Category slug, as in `/c/{slug}`. |
| `k` | `remote` or `local`. |
| `a` | Auth: `none`, `oauth`, `api_key`, `optional` or `unknown`. |
| `g` | Tags, an array of strings. |
| `i` | Icon, a path such as `/media/icons/{slug}.webp` (WebP or PNG). Missing when the listing has none. |
| `f` | `1` when the listing has the [checkmark](https://mcp.tc/verify). 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](https://mcp.tc/embed#lang)). Every field:

| Field | Type | What it is |
| --- | --- | --- |
| `slug` | string | The listing’s current slug. Old slugs and aliases return the current listing, so read it from here. |
| `name` | string | Server name. |
| `vendor` | string or null | Who makes the server. |
| `tagline` | string or null | One line, up to 200 characters. |
| `description` | string or null | Plain text, paragraphs separated by a blank line, up to 2,000 characters. An AI model wrote it from the server’s public metadata. |
| `link` | string | The listing page, `https://mcp.tc/i/{slug}`, or with `?lang=` the page in that language once it is translated. |
| `lang`\ `text_lang` | string | `lang`: 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 null | Category slug (as in `/c/{slug}`) and its name. |
| `kind` | string | `remote` (you connect over HTTPS) or `local` (runs on your computer). |
| `transport` | string | `streamable-http`, `sse` or `stdio`. |
| `auth` | string | `none`, `oauth`, `api_key`, `optional` or `unknown`. |
| `access` | object | How 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). |
| `endpoint` | string or null | The server’s own URL (remote servers). This is what a client connects to. |
| `install_command` | string or null | The command that starts a local server, like `npx -y @playwright/mcp`. |
| `package` | object or null | `registry` (`npm`, `pypi`, `oci`, `nuget`…) and `identifier`. |
| `relay` | boolean | False 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 null | The checkmark, and what it means for this listing. |
| `icon` | string or null | URL of the listing’s 128 × 128 icon on mcp.tc. |
| `tools_count`\ `tools` | number, array | Tools read from the server (up to 150): `name`, `summary`, and `read_only` / `destructive` (true, false, or null when the server doesn’t say). |
| `add` | array | The 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 null | Links from the listing. |
| `health` | string | Our 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 null | ISO 8601 times in UTC: the last check, when it was listed, the last change to its content. |
| `history` | object | The 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). |
| `embeds` | object | This 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=`. |
| `format` | string | A link to this field list. |

## Badges and embeds

How the [website card](https://mcp.tc/embed) 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`](https://mcp.tc/llms.txt) follows [llmstxt.org](https://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`](https://mcp.tc/feed.xml) is an Atom feed of the 50 most recently approved listings, with tagline and description.
- [`/changes.xml`](https://mcp.tc/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](https://mcp.tc/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`](https://mcp.tc/i/deepwiki/history.xml). [Change history and alerts](https://mcp.tc/docs/changes) explains what counts as a change.
- [`/sitemap.xml`](https://mcp.tc/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`](https://mcp.tc/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](https://mcp.tc/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}"
}
```

| Status | `state` or `error` | What it means |
| --- | --- | --- |
| 202 | `queued` | In the queue: follow it at `status_url`. If the same URL is already waiting, you get that suggestion’s token and `"existing_submission": true`. |
| 200 | `duplicate` | Already listed: `listing` holds its `slug`, `name` and `link`. |
| 400 | `invalid_request` | The body isn’t a JSON object with a `url` string. |
| 403 | `cross_site` | A browser sent it from another site. |
| 413 | `too_large` | The body is over 16 KB. |
| 422 | `empty`, `too_long`, `invalid_url`, `personal_url`, `blocked`, `invalid_email`, `notify_limited` | We 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. |
| 429 | `rate_limited` | Too 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. |
| 503 | `paused` | Suggestions 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](https://www.npmjs.com/package/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`](https://mcp.tc/.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`](https://mcp.tc/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`](https://mcp.tc/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`](https://mcp.tc/.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`](https://mcp.tc/.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`](https://mcp.tc/AGENTS.md): a guide for AI agents in the [AGENTS.md](https://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

| URL | Cache-Control | ETag and 304 | CORS |
| --- | --- | --- | --- |
| `/v0.1/…` | `public, max-age=300` (a 404: 60 s) | Yes | `*` |
| `/api/index.json` | `public, max-age=300` | Yes | `*` |
| `/i/{slug}.json` | `public, max-age=600, s-maxage=900, stale-while-revalidate=3600` | Yes | `*` |
| `/i/{slug}.md` | `public, max-age=900` | Yes | `*` |
| `/llms.txt` | `public, max-age=3600` | Yes | `*` |
| `/feed.xml`, `/changes.xml`, `/i/{slug}/history.xml`, sitemaps | `public, max-age=900` | Yes | `*` |
| `/openapi.json` and the discovery files | `public, max-age=3600` | Yes | `*` |
| `/{page}.md` | like the page, at most `public, max-age=300` | Yes | `*` |
| `/mcp` | `no-store` | No | `*` |
| `POST /submit`, `/s/{token}.json` | `no-store` | No | None |

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.

---
Source: https://mcp.tc/docs/api. Markdown version for AI agents (ask for `text/markdown` or add `.md` to the address). Site overview: https://mcp.tc/llms.txt
