---
title: "API und Datenfeeds | mcp.tc"
description: "Lies das Verzeichnis von mcp.tc per Code: eine zur MCP-Registry kompatible API, ein JSON-Suchindex, Einträge als JSON und Markdown, llms.txt, Feed und Sitemaps."
url: "https://mcp.tc/de/docs/api"
markdown: "https://mcp.tc/de/docs/api.md"
lang: "de"
---

# API und Daten

Alles im Verzeichnis ist öffentlich und maschinenlesbar: eine API im Format der offiziellen MCP-Registry, ein JSON-Suchindex, jeder Eintrag als JSON und Markdown, dazu llms.txt, ein Feed und Sitemaps. Kein Schlüssel, keine Registrierung.

## Auf einen Blick

| URL | Was du bekommst | Gecacht für |
| --- | --- | --- |
| `/v0.1/servers` | Einträge im Format der offiziellen MCP-Registry, seitenweise. [Details](https://mcp.tc/de/docs/api#registry) | 5 Minuten |
| `/api/index.json` | Jeder Eintrag in einem kompakten Array. [Details](https://mcp.tc/de/docs/api#index) | 5 Minuten |
| `/i/{slug}.json` | Ein Eintrag, mit seinen Einrichtungsaktionen. [Details](https://mcp.tc/de/docs/api#listing-json) | 10 Minuten |
| `/i/{slug}.md` | Ein Eintrag als Markdown. [Details](https://mcp.tc/de/docs/api#markdown) | 15 Minuten |
| `/llms.txt` | Das Verzeichnis als Liste für Sprachmodelle. | 1 Stunde |
| `/feed.xml` | Atom-Feed der 50 neuesten Einträge. | 15 Minuten |
| `/changes.xml` | Atom-Feed der 50 neuesten Änderungen im ganzen Verzeichnis. [Details](https://mcp.tc/de/docs/api#feeds) | 15 Minuten |
| `/i/{slug}/history.xml` | Atom-Feed des Verlaufs eines Eintrags. [Details](https://mcp.tc/de/docs/api#feeds) | 15 Minuten |
| `/sitemap.xml` | Sitemap-Index: Seiten, Kategorien und Einträge, in jeder Sprache. | 15 Minuten |
| `/mcp` | Der eigene MCP-Server von mcp.tc. [Doku](https://mcp.tc/de/docs/mcp) | Nicht gecacht |
| `POST /submit` | Einen Server per Skript für das Verzeichnis vorschlagen. [Details](https://mcp.tc/de/docs/api#submit) | Nicht gecacht |
| `/openapi.json` | OpenAPI-3.1-Beschreibung der Registry-API, des Suchindex, von JSON und Markdown der Einträge, der Änderungs-Feeds sowie von `POST /submit` mit seinem Status. | 1 Stunde |
| `/.well-known/…` | Discovery-Dateien für Agenten: API-Katalog, MCP-Server-Card, KI-Katalog und ein Agenten-Skill. [Details](https://mcp.tc/de/docs/api#discovery) | 1 Stunde |
| `/AGENTS.md` | Ein Leitfaden für KI-Agenten: Verbindung, Limits und Umgangsregeln. [Details](https://mcp.tc/de/docs/api#discovery) | 1 Stunde |
| `/{page}.md` | Jede Seite als Markdown, in ihrer Sprache. [Details](https://mcp.tc/de/docs/api#markdown) | Bis zu 5 Minuten |

Alles ist öffentlich und, bis auf `POST /submit`, nur lesend. Kein Schlüssel, kein Konto, keine Kosten. Maschinenformate sind sprachneutral: Sie liefern den englischen Text der Einträge und haben kein Sprachpräfix. Ausnahme ist das Markdown der Seiten: Es folgt der Sprache der Seite.

## Registry-kompatible API

`https://mcp.tc/v0.1/` ist eine nur lesende Kopie der Lese-API der offiziellen MCP-Registry (Version 0.1, `server.json`-Schema 2025-12-11), gefüllt mit den freigegebenen Einträgen von mcp.tc. Ein Client, der eine eigene Registry-URL akzeptiert, kann damit das Verzeichnis durchsuchen und daraus installieren.

Eine Ergebnisseite hat diese Form:

`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": "…" }
}
```

Und das steht in `server` für zwei Einträge, so wie die API sie jetzt ausliefert:

### 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"
    }
  ]
}
```

### Lokaler 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` ist der Name des Servers in der offiziellen Registry, wenn er einen hat, sonst `tc.mcp/{slug}`.
- `remotes` enthält immer die eigene URL des Servers, nie den mcp.tc-Link. Schlüssel-Header erscheinen nur bei Servern, die einen API-Schlüssel brauchen.
- `packages` wird aus dem Installationsbefehl des Eintrags neu aufgebaut: npm (`npx`), PyPI (`uvx`, `pipx run`), OCI (`docker run`) und NuGet (`dnx`). Ein Befehl, den das Format nicht ausdrücken kann, bekommt kein Paket, denn eines, das das falsche Programm startet, wäre schlimmer als keines.
- `_meta["tc.mcp/listing"]` enthält den mcp.tc-Link, Slug, Kategorie, Häkchen, Zugang, Status und Zeitstempel. `updatedAt` ändert sich nur, wenn sich der ausgelieferte Eintrag ändert, nie durch eine Statusprüfung.
- mcp.tc ist nicht die offizielle Registry, daher tragen Einträge nie deren Metadaten `io.modelcontextprotocol.registry/official`.
- Ein entfernter, ausgeblendeter oder umbenannter Eintrag kommt 180 Tage lang als Eintrag mit `"status": "deleted"` zurück, aber nur, wenn du mit `updated_since` oder `include_deleted` danach fragst.

Fehler sind Problem-JSON (`application/problem+json`), wie in der offiziellen API: 404 für einen unbekannten Server, 422 für ein ungültiges `limit`, `cursor` oder `include_deleted`, 400 für ein ungültiges `updated_since`. Jede Methode außer GET, HEAD und OPTIONS bekommt 405: Die Registry ist nur lesend, neue Server kommen über [Einreichen](https://mcp.tc/de/submit).

Die API ist in OpenAPI 3.1 unter [`https://mcp.tc/openapi.json`](https://mcp.tc/openapi.json) beschrieben, und jede Antwort verweist mit einem `Link`-Header darauf.

```
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'
```

## mcp.tc als Registry nutzen

Diese Clients nehmen laut Quellcode von VS Code und Dokumentation von GitHub eine eigene Registry-URL an (geprüft am 8. Oktober 2026). Gib in VS Code und in den Copilot-Richtlinien die Basis-URL ohne `/v0.1` ein: Sie hängen den Pfad selbst an.

### VS Code

Füge diese Zeile in die Benutzer-`settings.json` deines Standardprofils ein:

`settings.json`:

```
"chat.mcp.gallery.serviceUrl": "https://mcp.tc"
```

Die MCP-Server-Galerie (tippe `@mcp` in der Erweiterungsansicht) zeigt dann die Server von mcp.tc, und beim Installieren wird die eigene URL oder das Paket des Servers genutzt. Weitere Einstellungen sind nicht nötig. Die Einstellung erscheint nicht im Einstellungseditor, und andere Profile ignorieren sie, außer die `settings.json` des Standardprofils enthält zusätzlich `"workbench.settings.applyToAllProfiles": ["chat.mcp.gallery.serviceUrl"]`. Organisationen können sie mit der Richtlinie `McpGalleryServiceUrl` (VS Code 1.101 oder neuer) für alle setzen, und `"chat.mcp.access": "registry"` beschränkt VS Code auf Server aus dieser Registry.

### GitHub Copilot

Admins von Organisationen und Enterprises können `https://mcp.tc` als **MCP Registry URL** in den Copilot-Richtlinien eintragen. GitHub nennt VS Code, Visual Studio, JetBrains-IDEs, Eclipse, Xcode und Copilot CLI als unterstützt. Mit **Registry only** werden Server über ihren Namen zugeordnet; laut GitHub können Nutzer das umgehen, indem sie ihre Konfiguration ändern. GitHub nennt diesen Weg eine öffentliche Vorschau und nicht die empfohlene Methode, Server einzuschränken: Empfohlen wird eine Allowlist in der `managed-settings.json` des Enterprise.

### Copilot in JetBrains-IDEs, Xcode und Eclipse

Nutzer können auch in den Copilot-Einstellungen selbst eine Registry eintragen (**MCP Registry URL**), als öffentliche Vorschau in Vorabversionen des Plugins. GitHub sagt nicht, ob das Feld die Basis-URL oder den Pfad `/v0.1` erwartet, und wir haben mcp.tc dort nicht getestet.

Ein paar Einträge haben weder ein Paket noch ein Remote, weil sich ihr Installationsbefehl nicht im Registry-Format schreiben lässt. VS Code blendet sie aus; ihre Seiten auf mcp.tc haben trotzdem die Einrichtung.

## Suchindex

`/api/index.json` enthält jeden freigegebenen Eintrag in einem JSON-Array, die Daten hinter der Suche der Website. Kurze Schlüssel halten ihn klein:

| Schlüssel | Wert |
| --- | --- |
| `s` | Slug: Der Eintrag liegt unter `/i/{s}`. |
| `n` | Name. |
| `v` | Anbieter oder ein leerer String. |
| `t` | Kurzbeschreibung, bis zu 160 Zeichen (auf Englisch). |
| `c` | Slug der Kategorie, wie in `/c/{slug}`. |
| `k` | `remote` oder `local`. |
| `a` | Zugang: `none`, `oauth`, `api_key`, `optional` oder `unknown`. |
| `g` | Tags, ein Array von Strings. |
| `i` | Icon, ein Pfad wie `/media/icons/{slug}.webp` (WebP oder PNG). Fehlt, wenn der Eintrag keines hat. |
| `f` | `1`, wenn der Eintrag das [Häkchen](https://mcp.tc/de/verify) hat. Fehlt sonst. |

`Ein Eintrag`:

```
{
  "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
}
```

## Ein Eintrag als JSON

Hänge `.json` an einen beliebigen Eintrags-Link an, um diesen Eintrag als JSON zu bekommen:

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

Er enthält alles, was die Seite zeigt: den eigenen `endpoint` des Servers oder sein `install_command`, das `access`-Label, die Tools, das Häkchen, den Status und die Ein-Klick-Aktionen `add`, die immer die eigene URL oder das Paket des Servers nutzen. Das Objekt `history` verweist auf den Verlauf des Eintrags: seine `url` und den Atom-`feed`, was wir beobachten (`tracking`: `tools`, `version` oder `listing`), wann wir seine Tools zuletzt abgerufen haben (`tools_checked`) und wann er sich zuletzt geändert hat (`last_changed`), beides ISO 8601 oder `null`. Ein nicht gelisteter Slug bekommt 404 mit `"error": "not_found"`, ein entfernter Eintrag 410 mit `"gone"`. Alte Slugs und Aliase liefern den aktuellen Eintrag, lies also `slug` aus der Antwort.

Jede Website kann ihn lesen: Die Antwort trägt `Access-Control-Allow-Origin: *`, und er braucht keinen Schlüssel. Felder ohne Wert sind `null`, nie weggelassen. Der Text ist das englische Original des Eintrags, außer du hängst `?lang=` an ([Sprachen](https://mcp.tc/de/embed#lang)). Alle Felder:

| Feld | Typ | Was es ist |
| --- | --- | --- |
| `slug` | String | Der aktuelle Slug des Eintrags. Alte Slugs und Aliase liefern den aktuellen Eintrag, lies ihn also hier. |
| `name` | String | Name des Servers. |
| `vendor` | String oder null | Wer den Server entwickelt. |
| `tagline` | String oder null | Eine Zeile, bis zu 200 Zeichen. |
| `description` | String oder null | Reiner Text, Absätze durch eine Leerzeile getrennt, bis zu 2.000 Zeichen. Ein KI-Modell hat ihn aus den öffentlichen Metadaten des Servers geschrieben. |
| `link` | String | Die Seite des Eintrags, `https://mcp.tc/i/{slug}`, mit `?lang=` die Seite in dieser Sprache, sobald sie übersetzt ist. |
| `lang`\ `text_lang` | String | `lang`: die Sprache der Beschriftungen (`en`, außer du fragst mit `?lang=` nach einer anderen). `text_lang`: die Sprache von `tagline`, `description` und den Tool-Zusammenfassungen: `lang`, wenn der Eintrag eine aktuelle Übersetzung hat, sonst `en`. Ein Tool, dessen Beschreibung sich seit der letzten Übersetzung geändert hat, behält seine englische Zusammenfassung, bis es neu übersetzt ist. |
| `category`\ `category_name` | String oder null | Slug der Kategorie (wie in `/c/{slug}`) und ihr Name. |
| `kind` | String | `remote` (du verbindest dich über HTTPS) oder `local` (läuft auf deinem Rechner). |
| `transport` | String | `streamable-http`, `sse` oder `stdio`. |
| `auth` | String | `none`, `oauth`, `api_key`, `optional` oder `unknown`. |
| `access` | Objekt | Wie mcp.tc ihn kennzeichnet: `group` (`ok`, `auth` oder `local`, der Zugangsfilter des Verzeichnisses), `label` (Badge-Text, etwa „No sign-in“), `text` (Langform) und `note` (ein Satz). |
| `endpoint` | String oder null | Die eigene URL des Servers (Remote-Server). Damit verbindet sich ein Client. |
| `install_command` | String oder null | Der Befehl, der einen lokalen Server startet, etwa `npx -y @playwright/mcp`. |
| `package` | Objekt oder null | `registry` (`npm`, `pypi`, `oci`, `nuget`…) und `identifier`. |
| `relay` | Boolean | False für jeden Eintrag: Der mcp.tc-Link ist eine Seite, und Clients verbinden sich mit der eigenen URL des Servers. Das Feld bleibt, damit bestehende Leser weiter funktionieren. |
| `verified`\ `verified_by` | Boolean, String oder null | Das Häkchen und was es für diesen Eintrag bedeutet. |
| `icon` | String oder null | URL des 128 × 128 großen Icons des Eintrags auf mcp.tc. |
| `tools_count`\ `tools` | Zahl, Array | Vom Server gelesene Tools (bis zu 150): `name`, `summary` und `read_only` / `destructive` (true, false oder null, wenn der Server es nicht angibt). |
| `add` | Array | Die Ein-Klick-Aktionen: `client` (`claude-code`, `cursor`, `vscode`, `claude-ai`), `label`, `kind` und `value`: ein Befehl zum Kopieren bei `copy`, ein Installationslink bei `link`. Sie nutzen immer die eigene URL oder das Paket des Servers. |
| `homepage`\ `repository`\ `docs` | String oder null | Links aus dem Eintrag. |
| `health` | String | Unsere letzte Prüfung: `ok`, `auth` (er hat geantwortet und eine Anmeldung verlangt), `down` oder `unknown` (lokale Server werden nicht geprüft). |
| `last_checked`\ `listed`\ `updated` | String oder null | ISO-8601-Zeiten in UTC: die letzte Prüfung, wann er gelistet wurde, die letzte inhaltliche Änderung. |
| `history` | Objekt | Der Verlauf des Eintrags: `url` (der Verlauf auf seiner Seite) und `feed` (Atom), was wir beobachten, in `tracking` (`tools`, `version` oder `listing`) und zwei ISO-8601-Zeiten in UTC oder null: `tools_checked` (wann wir seine Tools zuletzt abgerufen haben) und `last_changed` (seine letzte Änderung). |
| `embeds` | Objekt | Die URLs für `badge`, `widget`, `iframe` und `markdown` dieses Eintrags. `widget` und `iframe` behalten dein `?lang=`. `snippets` enthält den Code aus dem Abschnitt „Einbinden“ der Eintragsseite, fertig zum Einfügen: `markdown` und `html` für das Badge, `script` für die Website-Karte, `placeholder` (ein `div`, in dem die Karte erscheint, mit einem Link darin für Besucher ohne JavaScript) und `iframe`. Alt-Text und Links folgen `?lang=`. |
| `format` | String | Ein Link zu dieser Feldliste. |

## Badges und Einbindungen

So verhält sich die [Website-Karte](https://mcp.tc/de/embed) auf deiner Seite:

- Jede Datei enthält alles: die Daten des Eintrags, die Styles und das Icon. Sie stellt keine weiteren Anfragen und setzt weder Cookies noch Local Storage, es gibt also nichts, womit Besucher verfolgt werden könnten.
- Sie wird in einem geschlossenen Shadow Root gerendert: Deine Styles erreichen sie nicht, und ihre erreichen deine Seite nicht.
- Sie schreibt Text nur als Text (nie als HTML) und verlinkt nur auf mcp.tc und die Installationsseiten der Clients, über HTTPS.
- Mit einer Content Security Policy erlaubst du `script-src https://mcp.tc`. Das Icon ist ein `data:`-Bild; blockiert deine Richtlinie solche Bilder, zeigt die Karte stattdessen den Anfangsbuchstaben des Namens.
- Bei einem nicht gelisteten Slug erscheint nichts, und die Browserkonsole zeigt eine Warnung.

### Wie lange Kopien gehalten werden

- Karte, iframe und JSON enthalten Installations-Buttons und werden daher schnell aktualisiert. Browser halten sie 10 Minuten, und eine Änderung am Eintrag erreicht die Kopien unseres CDN (Cloudflare) innerhalb von 15 Minuten.
- Das Badge zeigt nur einen Namen. Cloudflare hält es bis zu einen Tag, Browser eine Stunde; während Cloudflare eine Kopie auffrischt, kann es bis zu eine Woche lang die alte ausliefern.

## Seiten und Einträge als Markdown

Für Agenten und Sprachmodelle gibt es jeden Eintrag auch als Markdown: Hänge `.md` an den Link an, oder frag unter der Adresse des Eintrags nach `text/markdown`.

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

Er beginnt mit einer Zusammenfassung (der Link, wie man sich verbindet, Art, Zugang, Kategorie, Anbieter, Häkchen) und enthält dann die Beschreibung, was der Server kann, seine Tools, Beispiel-Prompts, die Installationsschritte für jeden Client und seine fünf letzten Änderungen. Ein alter Name antwortet mit 301 und dem aktuellen.

Die Seiten der Website funktionieren genauso: die Startseite, das Verzeichnis und seine Kategorien, diese Doku, der Blog, die letzten Änderungen, die Seite zum Häkchen und die rechtlichen Seiten. Häng `.md` an die Adresse an (`/docs/connect.md`, `/it/c/databases.md`; die Startseite ist `/index.md`) oder frag direkt bei der Seite nach `text/markdown`. Du bekommst den Text der Seite in ihrer Sprache, ohne Menüs, unter einem kurzen Kopf mit Metadaten. Eine Anfrage, deren `Accept`-Header `text/markdown` bevorzugt, bekommt es mit `Vary: Accept`, und `x-markdown-tokens` nennt eine grobe Token-Zahl (Zeichen geteilt durch vier). Die `.md`-Kopien sind `noindex`, damit Suchmaschinen weiter die HTML-Seite indexieren.

## llms.txt, Feeds und Sitemaps

- [`/llms.txt`](https://mcp.tc/llms.txt) folgt [llmstxt.org](https://llmstxt.org/): wie das Verbinden funktioniert, diese Doku, die Kategorien mit ihren Zahlen, die Sprachversionen der Website und jeder Eintrag mit einer einzeiligen Zusammenfassung und kurzen Fakten (remote oder lokal, Zugang, verifiziert), jeweils mit Link zu seinem Markdown.
- [`/feed.xml`](https://mcp.tc/feed.xml) ist ein Atom-Feed der 50 zuletzt freigegebenen Einträge, mit Kurzbeschreibung und Beschreibung.
- [`/changes.xml`](https://mcp.tc/changes.xml) ist ein Atom-Feed der 50 neuesten Änderungen im ganzen Verzeichnis (Tools hinzugefügt, entfernt oder geändert, neue Versionen, Änderungen der Server-Betreiber), jede mit einem Link zum Verlauf des Eintrags. Die Seite [Letzte Änderungen](https://mcp.tc/de/changes) zeigt dieselbe Liste.
- `/i/{slug}/history.xml` ist der Verlauf eines Eintrags als Atom-Feed, zum Beispiel [`/i/deepwiki/history.xml`](https://mcp.tc/i/deepwiki/history.xml). [Verlauf und Benachrichtigungen](https://mcp.tc/de/docs/changes) erklärt, was als Änderung zählt.
- [`/sitemap.xml`](https://mcp.tc/sitemap.xml) verweist auf drei Sitemaps: Seiten, Kategorien und Einträge, jeweils mit dem Datum der letzten inhaltlichen Änderung. Jede Seite steht darin in jeder Sprache, in der es sie gibt, mit ihren Alternativen (`hreflang`); die übersetzten Seiten eines Eintrags erscheinen, sobald sein Text übersetzt ist.
- [`/robots.txt`](https://mcp.tc/robots.txt) lässt jeden Crawler herein, KI-Crawler eingeschlossen (`Content-Signal: search=yes, ai-input=yes, ai-train=yes`). Es hält sie aus `/api/` heraus, außer dem Suchindex, und aus privaten Einreichungsseiten.

## Einen Server per Skript vorschlagen

Das Formular [Einreichen](https://mcp.tc/de/submit) nimmt auch JSON an. Schick eine `POST`-Anfrage an `https://mcp.tc/submit` mit `Content-Type: application/json`, der URL des Servers und, wenn du magst, einer Notiz für die Person, die ihn prüft:

```
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` (Pflicht): ein Remote-MCP-Endpunkt, ein Repository oder eine npm- bzw. PyPI-Seite, bis zu 2.048 Zeichen.
- `note` (optional): bis zu 500 Zeichen. URL und Notiz werden automatisch geprüft, auch von einem KI-Modell; schreib deshalb keine personenbezogenen Daten hinein.
- `notify_email` (optional): die Adresse der Person, die den Server vorschlägt; sie bekommt eine einzige E-Mail auf Englisch, sobald er gelistet ist (die Antwort 202 enthält dann `"notify": true`). Gib sie nur mit dem Einverständnis dieser Person an. Eine Adresse kann auf fünf Server gleichzeitig warten.

Andere Felder werden ignoriert. Ein so gesendeter Vorschlag durchläuft dieselben Prüfungen und Limits wie einer über das Formular, ohne Schlüssel oder Konto. Nur die Adresse ohne Sprachpräfix nimmt JSON an. Die Antwort hat keine CORS-Header, deshalb kann eine Seite auf einer anderen Website sie nicht senden, und eine Anfrage, die der Browser als Cross-Site markiert, bekommt 403.

Ein angenommener Vorschlag bekommt 202, mit der Status-URL auch im Header `Location`:

`HTTP 202`:

```
{
  "ok": true,
  "state": "queued",
  "token": "{token}",
  "status_url": "https://mcp.tc/s/{token}.json",
  "page": "https://mcp.tc/s/{token}"
}
```

| Status | `state` oder `error` | Bedeutung |
| --- | --- | --- |
| 202 | `queued` | In der Warteschlange: Verfolge ihn unter `status_url`. Wartet dieselbe URL schon, bekommst du das Token dieses Vorschlags und `"existing_submission": true`. |
| 200 | `duplicate` | Schon im Verzeichnis: `listing` enthält `slug`, `name` und `link` des Eintrags. |
| 400 | `invalid_request` | Der Body ist kein JSON-Objekt mit einem String `url`. |
| 403 | `cross_site` | Ein Browser hat ihn von einer anderen Website gesendet. |
| 413 | `too_large` | Der Body ist größer als 16 KB. |
| 422 | `empty`, `too_long`, `invalid_url`, `personal_url`, `blocked`, `invalid_email`, `notify_limited` | Diese URL können wir nicht annehmen, oder `notify_email` ist keine Adresse oder wartet schon auf fünf Server. `message` sagt, warum, und erneutes Senden bringt dieselbe Antwort. |
| 429 | `rate_limited` | Zu viele Vorschläge. `scope` nennt das Limit (`ip_hour`, `ip_day` oder `global_day`); `retry_after` und der Header `Retry-After` geben die Wartezeit in Sekunden an. |
| 503 | `paused` | Vorschläge sind gerade pausiert. Versuch es nach `Retry-After` wieder. |

Jede Antwort ist JSON mit `ok`. Ein Fehler enthält zusätzlich den Code in `error` und einen englischen Satz in `message`. Bei vielen Anfragen in kurzer Zeit kann auch der Webserver oder Cloudflare mit 429 antworten, ohne diesen Body: Warte dann `Retry-After` ab, oder 10 Sekunden, wenn der Header fehlt. Schick außerdem einen aussagekräftigen User-Agent: Auf die Standardwerte von Python-urllib und libwww-perl antwortet Cloudflare mit einem 403, das kein JSON ist, hier wie bei `status_url`.

### Den Status verfolgen

Lies `status_url` alle 5 bis 10 Sekunden, bis `terminal` den Wert `true` hat; die meisten Vorschläge sind in wenigen Minuten fertig. `state` geht von `queued` über `checking` und `reviewing` zu `listed`, `duplicate`, `pending` (eine Person prüft ihn, bevor er online geht), `rejected` oder `error`. Gibt es einen Eintrag, verweisen `link` und `name` darauf. `title` und `message` sind der englische Text der Statusseite, und `page` ist diese Seite für den Browser. Ein unbekanntes Token bekommt 404. So sieht ein abgeschlossener Vorschlag aus:

`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
}
```

Das Open-Source-Kommandozeilentool [mcp-tc](https://www.npmjs.com/package/mcp-tc) sendet diese Anfrage aus dem Terminal und verfolgt den Status für dich: `npx mcp-tc submit https://mcp.example.com/mcp`.

## Discovery-Dateien

Agenten und Crawler finden die APIs von mcp.tc, seinen MCP-Server und seinen Skill über diese Dateien. Sie sind auf Englisch, öffentlich und eine Stunde gecacht, mit ETag und CORS für jede Website. Jede Seite sendet außerdem einen `Link`-Header, der auf den API-Katalog verweist.

- [`/.well-known/api-catalog`](https://mcp.tc/.well-known/api-catalog): die drei APIs (Registry, MCP-Server, Suchindex) als Linkset nach RFC 9727, jeweils mit Beschreibung, Doku, Nutzungsbedingungen und Datenschutzerklärung.
- [`/openapi.json`](https://mcp.tc/openapi.json): OpenAPI 3.1 für `/v0.1/`, `/api/index.json`, `/i/{slug}.json`, `/i/{slug}.md`, die Änderungs-Feeds (`/changes.xml`, `/i/{slug}/history.xml`) und `POST /submit` mit seinem Status (`/s/{token}.json`).
- [`/mcp/server-card`](https://mcp.tc/mcp/server-card): die Server Card des MCP-Servers von mcp.tc (Name, Version, URL, Protokollversionen), auch unter `/.well-known/mcp/server-card.json`.
- [`/.well-known/ard.json`](https://mcp.tc/.well-known/ard.json): ein KI-Katalog (ARD) der eigenen Ressourcen von mcp.tc: MCP-Server, API und Skill. Dieselbe Datei liegt unter `/.well-known/ai-catalog.json`. Die Server im Verzeichnis stehen nicht darin, denn sie als Katalog zu veröffentlichen ist nicht unsere Sache.
- [`/.well-known/agent-skills/index.json`](https://mcp.tc/.well-known/agent-skills/index.json): ein Agent-Skills-Index mit einem Skill, find-and-install-mcp-servers, der einem Agenten erklärt, wie er hier einen Server findet und in einem Client einrichtet.
- [`/AGENTS.md`](https://mcp.tc/AGENTS.md): ein Leitfaden für KI-Agenten im Format [AGENTS.md](https://agents.md/): wie man sich mit dem MCP-Server und den APIs verbindet, Limits, Cache-Zeiten, Umgangsregeln und wie die Daten der Einträge genutzt werden dürfen. Die Startseite verweist mit `rel="describedby"` darauf.

## Caching, CORS und faire Nutzung

| URL | Cache-Control | ETag und 304 | CORS |
| --- | --- | --- | --- |
| `/v0.1/…` | `public, max-age=300` (ein 404: 60 s) | Ja | `*` |
| `/api/index.json` | `public, max-age=300` | Ja | `*` |
| `/i/{slug}.json` | `public, max-age=600, s-maxage=900, stale-while-revalidate=3600` | Ja | `*` |
| `/i/{slug}.md` | `public, max-age=900` | Ja | `*` |
| `/llms.txt` | `public, max-age=3600` | Ja | `*` |
| `/feed.xml`, `/changes.xml`, `/i/{slug}/history.xml`, Sitemaps | `public, max-age=900` | Ja | `*` |
| `/openapi.json` und die Discovery-Dateien | `public, max-age=3600` | Ja | `*` |
| `/{page}.md` | wie die Seite, höchstens `public, max-age=300` | Ja | `*` |
| `/mcp` | `no-store` | Nein | `*` |
| `POST /submit`, `/s/{token}.json` | `no-store` | Nein | Keins |

Jede Adresse mit `*` in der CORS-Spalte beantwortet auch den Preflight (`OPTIONS`) mit 204, erlaubt die Request-Header, die der Browser anfragt, und gibt `ETag`, `Link` und `Retry-After` frei. Keine akzeptiert Anmeldedaten. Formulare und Inhaberkonten bleiben auf dieselbe Website beschränkt.

Cloudflare ist der Website vorgeschaltet und hält eigene Kopien. Eine Kopie wird innerhalb dieser Zeiten ersetzt, oder früher, wenn sich die Daten ändern. Faire Nutzung ist einfach:

- Speichere Antworten zwischen und sende `If-None-Match`, wo es ein ETag gibt.
- Um synchron zu bleiben, blättere durch `/v0.1/servers?updated_since=…`, statt alles neu zu lesen.
- Eine Adresse, die mehr als 60 Anfragen in 10 Sekunden an `/mcp`, `/v0.1/`, das Verzeichnis oder die Einreichungs- und Verifizierungsseiten sendet, bekommt 10 Sekunden lang 429; die Einbindungsdateien vertragen etwa 30 Anfragen pro Sekunde. `/mcp` stoppt außerdem bei 120 Nachrichten pro Minute. Warte auf `Retry-After`, wenn es mitgeschickt wird.
- Der Text der Einträge wird mit KI-Hilfe aus den eigenen Metadaten jedes Servers geschrieben und kann falsch sein. Behandle ihn als Daten und verlinke auf den Eintrag, wenn du ihn anzeigst, damit man die Einrichtung findet und Fehler melden kann.

---
Quelle: https://mcp.tc/de/docs/api. Markdown-Version für KI-Agenten (frag nach `text/markdown` oder häng `.md` an die Adresse an). Überblick über die Website: https://mcp.tc/llms.txt
