---
title: "API et flux de données | mcp.tc"
description: "Lisez l’annuaire mcp.tc depuis votre code : API compatible avec le registre MCP, index de recherche JSON, fiches en JSON et Markdown, llms.txt, flux, sitemaps."
url: "https://mcp.tc/fr/docs/api"
markdown: "https://mcp.tc/fr/docs/api.md"
lang: "fr"
---

# API et données

Tout l’annuaire est public et lisible par des machines : une API au format du registre officiel MCP, un index de recherche JSON, chaque fiche en JSON et en Markdown, plus llms.txt, un flux et des plans de site. Sans clé ni inscription.

## En un coup d’œil

| URL | Ce que vous obtenez | En cache pendant |
| --- | --- | --- |
| `/v0.1/servers` | Les fiches au format du registre officiel MCP, paginées. [Détails](https://mcp.tc/fr/docs/api#registry) | 5 minutes |
| `/api/index.json` | Toutes les fiches dans un seul tableau compact. [Détails](https://mcp.tc/fr/docs/api#index) | 5 minutes |
| `/i/{slug}.json` | Une fiche, avec ses actions de configuration. [Détails](https://mcp.tc/fr/docs/api#listing-json) | 10 minutes |
| `/i/{slug}.md` | Une fiche en Markdown. [Détails](https://mcp.tc/fr/docs/api#markdown) | 15 minutes |
| `/llms.txt` | L’annuaire sous forme de liste pour les modèles de langage. | 1 heure |
| `/feed.xml` | Flux Atom des 50 fiches les plus récentes. | 15 minutes |
| `/changes.xml` | Flux Atom des 50 changements les plus récents de tout l’annuaire. [Détails](https://mcp.tc/fr/docs/api#feeds) | 15 minutes |
| `/i/{slug}/history.xml` | Flux Atom de l’Historique d’une fiche. [Détails](https://mcp.tc/fr/docs/api#feeds) | 15 minutes |
| `/sitemap.xml` | Index des plans de site : pages, catégories et fiches, dans toutes les langues. | 15 minutes |
| `/mcp` | Le serveur MCP de mcp.tc. [Documentation](https://mcp.tc/fr/docs/mcp) | Pas de cache |
| `POST /submit` | Proposer un serveur pour l’annuaire depuis un script. [Détails](https://mcp.tc/fr/docs/api#submit) | Pas de cache |
| `/openapi.json` | Description OpenAPI 3.1 de l’API registre, de l’index de recherche, du JSON et Markdown des fiches, des flux de changements et de `POST /submit` avec son statut. | 1 heure |
| `/.well-known/…` | Fichiers de découverte pour les agents : catalogue d’API, server card MCP, catalogue d’IA et une skill pour agents. [Détails](https://mcp.tc/fr/docs/api#discovery) | 1 heure |
| `/AGENTS.md` | Un guide pour les agents d’IA : comment se connecter, limites et bonnes pratiques. [Détails](https://mcp.tc/fr/docs/api#discovery) | 1 heure |
| `/{page}.md` | N’importe quelle page en Markdown, dans sa langue. [Détails](https://mcp.tc/fr/docs/api#markdown) | Jusqu’à 5 minutes |

Tout est public, et tout est en lecture seule sauf `POST /submit`. Pas de clé, pas de compte, pas de frais. Les formats pour machines ne dépendent pas de la langue : ils servent le texte anglais des fiches et n’ont pas de préfixe de langue. Le Markdown des pages fait exception : il suit la langue de la page.

## API compatible avec le registre

`https://mcp.tc/v0.1/` est une copie en lecture seule de l’API de lecture du registre officiel MCP (version 0.1, schéma `server.json` 2025-12-11), remplie avec les fiches approuvées de mcp.tc. Un client qui accepte l’URL d’un registre personnalisé peut parcourir l’annuaire et installer depuis lui.

Une page de résultats a cette forme :

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

Et voici ce que contient `server` pour deux fiches, telles que l’API les sert actuellement :

### Serveur distant

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

### Serveur local

`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` est le nom du serveur dans le registre officiel quand il en a un, sinon `tc.mcp/{slug}`.
- `remotes` contient toujours l’URL du serveur lui-même, jamais le lien mcp.tc. Les en-têtes de clé n’apparaissent que pour les serveurs qui demandent une clé API.
- `packages` est reconstruit à partir de la commande d’installation de la fiche : npm (`npx`), PyPI (`uvx`, `pipx run`), OCI (`docker run`) et NuGet (`dnx`). Une commande que le format ne peut pas exprimer n’a pas de paquet, car un paquet qui lancerait le mauvais programme serait pire que rien.
- `_meta["tc.mcp/listing"]` contient le lien mcp.tc, le slug, la catégorie, la coche, l’accès, l’état et les dates. `updatedAt` ne change que quand l’entrée servie change, jamais à cause d’une vérification d’état.
- mcp.tc n’est pas le registre officiel, donc les entrées ne portent jamais ses métadonnées `io.modelcontextprotocol.registry/official`.
- Une fiche retirée, masquée ou renommée revient comme une entrée avec `"status": "deleted"` pendant 180 jours, mais seulement si vous le demandez avec `updated_since` ou `include_deleted`.

Les erreurs sont au format problem JSON (`application/problem+json`), comme dans l’API officielle : 404 pour un serveur inconnu, 422 pour un `limit`, un `cursor` ou un `include_deleted` invalide, 400 pour un `updated_since` invalide. Toute méthode autre que GET, HEAD et OPTIONS reçoit 405 : le registre est en lecture seule, et les nouveaux serveurs arrivent par [Proposer](https://mcp.tc/fr/submit).

L’API est décrite en OpenAPI 3.1 à [`https://mcp.tc/openapi.json`](https://mcp.tc/openapi.json), et chaque réponse y renvoie par un en-tête `Link`.

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

## Utiliser mcp.tc comme registre

Ces clients acceptent l’URL d’un registre personnalisé, d’après le code source de VS Code et la documentation de GitHub (vérifié le 8 octobre 2026). Dans VS Code et dans les stratégies de Copilot, saisissez l’URL de base sans `/v0.1` : ils ajoutent eux-mêmes le chemin.

### VS Code

Ajoutez cette ligne au `settings.json` utilisateur de votre profil par défaut :

`settings.json`:

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

La galerie de serveurs MCP (tapez `@mcp` dans la vue Extensions) affiche alors les serveurs de mcp.tc, et en installer un utilise l’URL ou le paquet du serveur lui-même. Aucun autre réglage n’est nécessaire. Ce réglage n’apparaît pas dans l’éditeur de paramètres, et les autres profils l’ignorent, sauf si le `settings.json` du profil par défaut contient aussi `"workbench.settings.applyToAllProfiles": ["chat.mcp.gallery.serviceUrl"]`. Les organisations peuvent le définir pour tout le monde avec la stratégie `McpGalleryServiceUrl` (VS Code 1.101 ou ultérieur), et `"chat.mcp.access": "registry"` limite VS Code aux serveurs de ce registre.

### GitHub Copilot

Les administrateurs d’organisation et d’entreprise peuvent saisir `https://mcp.tc` comme **MCP Registry URL** dans les stratégies de Copilot. GitHub indique comme compatibles VS Code, Visual Studio, les IDE JetBrains, Eclipse, Xcode et Copilot CLI. Avec **Registry only**, les serveurs sont mis en correspondance par nom, ce que les utilisateurs peuvent contourner en modifiant leur configuration, selon GitHub. GitHub présente cette voie comme un aperçu public et non comme sa méthode recommandée pour restreindre les serveurs : il recommande une liste d’autorisation dans le `managed-settings.json` de l’entreprise.

### Copilot dans les IDE JetBrains, Xcode et Eclipse

Les utilisateurs peuvent aussi saisir un registre dans les réglages de Copilot (**MCP Registry URL**), en aperçu public sur les préversions du plugin. GitHub ne précise pas si ce champ attend l’URL de base ou le chemin `/v0.1`, et nous n’y avons pas testé mcp.tc.

Quelques fiches n’ont ni paquet ni remote, parce que leur commande d’installation ne peut pas s’écrire au format du registre. VS Code les masque ; leurs pages sur mcp.tc ont quand même la configuration.

## Index de recherche

`/api/index.json` contient toutes les fiches approuvées dans un seul tableau JSON, les données derrière la recherche du site. Des clés courtes le gardent léger :

| Clé | Valeur |
| --- | --- |
| `s` | Slug : la fiche est à `/i/{s}`. |
| `n` | Nom. |
| `v` | Éditeur, ou une chaîne vide. |
| `t` | Accroche, jusqu’à 160 caractères (en anglais). |
| `c` | Slug de catégorie, comme dans `/c/{slug}`. |
| `k` | `remote` ou `local`. |
| `a` | Accès : `none`, `oauth`, `api_key`, `optional` ou `unknown`. |
| `g` | Étiquettes, un tableau de chaînes. |
| `i` | Icône, un chemin comme `/media/icons/{slug}.webp` (WebP ou PNG). Absent quand la fiche n’en a pas. |
| `f` | `1` quand la fiche a la [coche](https://mcp.tc/fr/verify). Absent sinon. |

`Une entrée`:

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

## Une fiche en JSON

Ajoutez `.json` au lien de n’importe quelle fiche pour obtenir cette fiche en JSON :

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

Elle contient tout ce que montre la page : l’`endpoint` du serveur ou sa `install_command`, le libellé `access`, les outils, la coche, l’état, et les actions en un clic `add`, qui utilisent toujours l’URL ou le paquet du serveur lui-même. L’objet `history` renvoie à l’Historique de la fiche : son `url` et son flux Atom `feed`, ce que nous observons (`tracking` : `tools`, `version` ou `listing`), quand nous avons lu ses outils pour la dernière fois (`tools_checked`) et quand elle a changé pour la dernière fois (`last_changed`), tous deux en ISO 8601 ou `null`. Un slug non référencé reçoit 404 avec `"error": "not_found"`, et une fiche retirée 410 avec `"gone"`. Les anciens slugs et les alias renvoient la fiche actuelle, donc lisez `slug` dans la réponse.

N’importe quel site peut la lire : la réponse porte `Access-Control-Allow-Origin: *`, et elle ne demande aucune clé. Les champs sans valeur valent `null`, ils ne sont jamais omis. Le texte est l’original anglais de la fiche, sauf si vous ajoutez `?lang=` ([langues](https://mcp.tc/fr/embed#lang)). Tous les champs :

| Champ | Type | Ce que c’est |
| --- | --- | --- |
| `slug` | chaîne | Le slug actuel de la fiche. Les anciens slugs et les alias renvoient la fiche actuelle, donc lisez-le ici. |
| `name` | chaîne | Nom du serveur. |
| `vendor` | chaîne ou null | L’éditeur du serveur. |
| `tagline` | chaîne ou null | Une ligne, jusqu’à 200 caractères. |
| `description` | chaîne ou null | Texte brut, paragraphes séparés par une ligne vide, jusqu’à 2 000 caractères. Un modèle d’IA l’a rédigé à partir des métadonnées publiques du serveur. |
| `link` | chaîne | La page de la fiche, `https://mcp.tc/i/{slug}`, ou, avec `?lang=`, la page dans cette langue une fois traduite. |
| `lang`\ `text_lang` | chaîne | `lang` : la langue des libellés (`en`, sauf si vous en demandez une autre avec `?lang=`). `text_lang` : la langue de `tagline`, `description` et des résumés des outils, soit `lang` quand la fiche a une traduction à jour, sinon `en`. Un outil dont la description a changé depuis la dernière traduction garde son résumé en anglais jusqu’à ce qu’il soit traduit à nouveau. |
| `category`\ `category_name` | chaîne ou null | Slug de catégorie (comme dans `/c/{slug}`) et son nom. |
| `kind` | chaîne | `remote` (connexion en HTTPS) ou `local` (tourne sur votre ordinateur). |
| `transport` | chaîne | `streamable-http`, `sse` ou `stdio`. |
| `auth` | chaîne | `none`, `oauth`, `api_key`, `optional` ou `unknown`. |
| `access` | objet | Comment mcp.tc le qualifie : `group` (`ok`, `auth` ou `local`, le filtre Accès de l’annuaire), `label` (texte du badge, comme « No sign-in »), `text` (forme longue) et `note` (une phrase). |
| `endpoint` | chaîne ou null | L’URL du serveur lui-même (serveurs distants). C’est à elle qu’un client se connecte. |
| `install_command` | chaîne ou null | La commande qui lance un serveur local, comme `npx -y @playwright/mcp`. |
| `package` | objet ou null | `registry` (`npm`, `pypi`, `oci`, `nuget`…) et `identifier`. |
| `relay` | booléen | False pour chaque fiche : le lien mcp.tc est une page, et les clients se connectent à l’URL du serveur lui-même. Le champ reste pour que les lecteurs existants continuent de fonctionner. |
| `verified`\ `verified_by` | booléen, chaîne ou null | La coche, et ce qu’elle signifie pour cette fiche. |
| `icon` | chaîne ou null | URL de l’icône 128 × 128 de la fiche sur mcp.tc. |
| `tools_count`\ `tools` | nombre, tableau | Les outils lus sur le serveur (jusqu’à 150) : `name`, `summary` et `read_only` / `destructive` (true, false, ou null quand le serveur ne le dit pas). |
| `add` | tableau | Les actions en un clic : `client` (`claude-code`, `cursor`, `vscode`, `claude-ai`), `label`, `kind` et `value` : une commande à copier pour `copy`, un lien d’installation pour `link`. Elles utilisent toujours l’URL ou le paquet du serveur lui-même. |
| `homepage`\ `repository`\ `docs` | chaîne ou null | Liens de la fiche. |
| `health` | chaîne | Notre dernière vérification : `ok`, `auth` (il a répondu et demandé une authentification), `down` ou `unknown` (les serveurs locaux ne sont pas vérifiés). |
| `last_checked`\ `listed`\ `updated` | chaîne ou null | Horodatages ISO 8601 en UTC : la dernière vérification, la date de référencement, la dernière modification du contenu. |
| `history` | objet | L’historique de la fiche : `url` (son onglet Historique) et `feed` (Atom), ce que nous observons dans `tracking` (`tools`, `version` ou `listing`), et deux horodatages ISO 8601 en UTC, ou null : `tools_checked` (notre dernière lecture de ses outils) et `last_changed` (son changement le plus récent). |
| `embeds` | objet | Les URL `badge`, `widget`, `iframe` et `markdown` de cette fiche. `widget` et `iframe` gardent votre `?lang=`. `snippets` contient le code de la section Intégrer de la page de la fiche, prêt à coller : `markdown` et `html` pour le badge, `script` pour la carte pour site web, `placeholder` (un `div` où la carte s’affiche, avec un lien à l’intérieur pour les visiteurs sans JavaScript) et `iframe`. Leur texte alternatif et leurs liens suivent `?lang=`. |
| `format` | chaîne | Un lien vers cette liste de champs. |

## Badges et intégrations

Comment la [carte pour site web](https://mcp.tc/fr/embed) se comporte sur votre page :

- Chaque fichier contient tout : les données de la fiche, les styles et l’icône. Il ne fait aucune autre requête et n’utilise ni cookies ni stockage local, il n’y a donc rien pour suivre les visiteurs.
- Elle se dessine dans une shadow root fermée : vos styles ne l’atteignent pas et les siens n’atteignent pas votre page.
- Elle écrit le texte uniquement comme texte (jamais comme HTML) et ne renvoie qu’à mcp.tc et aux pages d’installation des clients, en HTTPS.
- Avec une Content Security Policy, autorisez `script-src https://mcp.tc`. L’icône est une image `data:` ; si votre politique les bloque, la carte affiche à la place la première lettre du nom.
- Pour un slug non référencé, rien n’apparaît et la console du navigateur affiche un avertissement.

### Combien de temps les copies sont gardées

- La carte, l’iframe et le JSON contiennent des boutons d’installation, ils se mettent donc à jour rapidement. Les navigateurs les gardent 10 minutes, et une modification de la fiche atteint les copies de notre CDN (Cloudflare) en 15 minutes au plus.
- Le badge n’affiche qu’un nom. Cloudflare le garde jusqu’à un jour et les navigateurs une heure ; pendant qu’il rafraîchit une copie, Cloudflare peut servir l’ancienne jusqu’à une semaine.

## Les pages et les fiches en Markdown

Pour les agents et les modèles de langage, chaque fiche existe aussi en Markdown : ajoutez `.md` au lien, ou demandez `text/markdown` à l’adresse de la fiche.

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

Elle commence par un résumé (le lien, comment se connecter, type, accès, catégorie, éditeur, coche), puis donne la description, ce que le serveur peut faire, ses outils, des exemples de prompts, les étapes d’installation pour chaque client et ses cinq changements les plus récents. Un ancien nom répond 301 avec le nom actuel.

Les pages du site fonctionnent de la même façon : l’accueil, l’annuaire et ses catégories, cette documentation, le blog, les modifications récentes, la page de la coche et les pages légales. Ajoutez `.md` à l’adresse (`/docs/connect.md`, `/it/c/databases.md` ; l’accueil est `/index.md`) ou demandez `text/markdown` à la page elle-même. Vous recevez le texte de la page dans sa langue, sans les menus, sous un court en-tête de métadonnées. Une requête dont l’en-tête `Accept` préfère `text/markdown` le reçoit avec `Vary: Accept`, et `x-markdown-tokens` donne un nombre approximatif de tokens (les caractères divisés par quatre). Les copies `.md` sont en `noindex`, donc les moteurs de recherche continuent d’indexer la page HTML.

## llms.txt, flux et plans de site

- [`/llms.txt`](https://mcp.tc/llms.txt) suit [llmstxt.org](https://llmstxt.org/) : le fonctionnement de la connexion, cette documentation, les catégories avec leurs effectifs, les versions linguistiques du site, et chaque fiche avec un résumé d’une ligne et quelques faits (distant ou local, accès, vérifié), chacune liée à son Markdown.
- [`/feed.xml`](https://mcp.tc/feed.xml) est un flux Atom des 50 fiches approuvées le plus récemment, avec accroche et description.
- [`/changes.xml`](https://mcp.tc/changes.xml) est un flux Atom des 50 changements les plus récents de tout l’annuaire (outils ajoutés, retirés ou modifiés, nouvelles versions, modifications des propriétaires de serveurs), chacun avec un lien vers l’Historique de la fiche. La page [Modifications récentes](https://mcp.tc/fr/changes) montre la même liste.
- `/i/{slug}/history.xml` est l’Historique d’une fiche en flux Atom, par exemple [`/i/deepwiki/history.xml`](https://mcp.tc/i/deepwiki/history.xml). [Historique et alertes](https://mcp.tc/fr/docs/changes) explique ce qui compte comme un changement.
- [`/sitemap.xml`](https://mcp.tc/sitemap.xml) indexe trois plans de site : pages, catégories et fiches, chacun avec la date de dernière modification du contenu. Chaque page y figure dans chaque langue où elle existe, avec ses alternatives (`hreflang`) ; les pages traduites d’une fiche apparaissent une fois son texte traduit.
- [`/robots.txt`](https://mcp.tc/robots.txt) laisse entrer tous les robots, y compris ceux des IA (`Content-Signal: search=yes, ai-input=yes, ai-train=yes`). Il les tient à l’écart de `/api/`, sauf l’index de recherche, et des pages privées de proposition.

## Proposer un serveur depuis un script

Le formulaire [Proposer](https://mcp.tc/fr/submit) accepte aussi le JSON. Envoyez une requête `POST` à `https://mcp.tc/submit` avec `Content-Type: application/json`, l’URL du serveur et, si vous le souhaitez, une note pour la personne qui l’examine :

```
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` (obligatoire) : un endpoint MCP distant, un dépôt ou une page npm ou PyPI, jusqu’à 2 048 caractères.
- `note` (facultatif) : jusqu’à 500 caractères. L’URL et la note sont vérifiées automatiquement, y compris par un modèle d’IA : n’y mettez donc pas de données personnelles.
- `notify_email` (facultatif) : l’adresse de la personne qui suggère le serveur, qui reçoit un seul e-mail en anglais quand il est publié (la réponse 202 contient alors `"notify": true`). Ajoutez-la seulement avec le consentement de cette personne. Une adresse peut attendre cinq serveurs à la fois.

Les autres champs sont ignorés. Une proposition envoyée ainsi passe par les mêmes vérifications et les mêmes limites qu’une proposition faite avec le formulaire, sans clé ni compte. Seule l’adresse sans préfixe de langue accepte le JSON. La réponse n’a pas d’en-têtes CORS : une page d’un autre site ne peut donc pas l’envoyer, et une requête que le navigateur marque comme intersite reçoit 403.

Une proposition acceptée reçoit 202, avec l’URL de suivi également dans l’en-tête `Location` :

`HTTP 202`:

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

| Statut | `state` ou `error` | Ce que cela signifie |
| --- | --- | --- |
| 202 | `queued` | En file d’attente : suivez-la sur `status_url`. Si la même URL attend déjà, vous recevez le jeton de cette proposition et `"existing_submission": true`. |
| 200 | `duplicate` | Déjà dans l’annuaire : `listing` contient son `slug`, son `name` et son `link`. |
| 400 | `invalid_request` | Le corps n’est pas un objet JSON avec une chaîne `url`. |
| 403 | `cross_site` | Un navigateur l’a envoyée depuis un autre site. |
| 413 | `too_large` | Le corps dépasse 16 Ko. |
| 422 | `empty`, `too_long`, `invalid_url`, `personal_url`, `blocked`, `invalid_email`, `notify_limited` | Nous ne pouvons pas accepter cette URL, ou `notify_email` n’est pas une adresse ou attend déjà cinq serveurs. `message` explique pourquoi, et la renvoyer donne la même réponse. |
| 429 | `rate_limited` | Trop de propositions. `scope` indique la limite (`ip_hour`, `ip_day` ou `global_day`) ; `retry_after` et l’en-tête `Retry-After` donnent le nombre de secondes à attendre. |
| 503 | `paused` | Les propositions sont suspendues pour le moment. Réessayez après `Retry-After`. |

Chaque réponse est un JSON avec `ok`. Une erreur ajoute le code dans `error` et une phrase en anglais dans `message`. Une rafale de requêtes peut aussi recevoir un 429 du serveur web ou de Cloudflare, sans ce corps : attendez `Retry-After`, ou 10 secondes s’il manque. Envoyez aussi un User-Agent descriptif : Cloudflare répond à ceux par défaut de Python-urllib et de libwww-perl par un 403 qui n’est pas du JSON, ici comme à `status_url`.

### Suivre le statut

Lisez `status_url` toutes les 5 à 10 secondes jusqu’à ce que `terminal` soit `true` ; la plupart des propositions sont traitées en quelques minutes. `state` passe de `queued` à `checking` et `reviewing`, puis se termine en `listed`, `duplicate`, `pending` (une personne l’examine avant sa mise en ligne), `rejected` ou `error`. Quand une fiche existe, `link` et `name` y renvoient. `title` et `message` sont le texte anglais de la page de suivi, et `page` est cette page, à ouvrir dans un navigateur. Un jeton inconnu reçoit 404. Voici une proposition terminée :

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

L’outil open source en ligne de commande [mcp-tc](https://www.npmjs.com/package/mcp-tc) envoie cette requête depuis un terminal et suit l’état pour vous : `npx mcp-tc submit https://mcp.example.com/mcp`.

## Fichiers de découverte

Les agents et les robots trouvent les API de mcp.tc, son serveur MCP et sa skill grâce à ces fichiers. Ils sont en anglais, publics et en cache pendant une heure, avec un ETag et un CORS ouvert à tous les sites. Chaque page envoie aussi un en-tête `Link` qui pointe vers le catalogue d’API.

- [`/.well-known/api-catalog`](https://mcp.tc/.well-known/api-catalog) : les trois API (registre, serveur MCP, index de recherche) sous forme de linkset RFC 9727, chacune avec sa description, sa documentation, ses conditions et sa politique de confidentialité.
- [`/openapi.json`](https://mcp.tc/openapi.json) : OpenAPI 3.1 pour `/v0.1/`, `/api/index.json`, `/i/{slug}.json`, `/i/{slug}.md`, les flux de changements (`/changes.xml`, `/i/{slug}/history.xml`) et `POST /submit` avec son statut (`/s/{token}.json`).
- [`/mcp/server-card`](https://mcp.tc/mcp/server-card) : la server card du serveur MCP de mcp.tc (nom, version, URL, versions du protocole), aussi à `/.well-known/mcp/server-card.json`.
- [`/.well-known/ard.json`](https://mcp.tc/.well-known/ard.json) : un catalogue d’IA (ARD) des ressources propres à mcp.tc : le serveur MCP, l’API et la skill. Le même fichier est à `/.well-known/ai-catalog.json`. Il ne liste pas les serveurs de l’annuaire, qu’il ne nous appartient pas de publier.
- [`/.well-known/agent-skills/index.json`](https://mcp.tc/.well-known/agent-skills/index.json) : un index Agent Skills avec une skill, find-and-install-mcp-servers, qui explique à un agent comment trouver un serveur ici et le configurer dans un client.
- [`/AGENTS.md`](https://mcp.tc/AGENTS.md) : un guide pour les agents d’IA au format [AGENTS.md](https://agents.md/) : comment se connecter au serveur MCP et aux API, limites, durées de cache, bonnes pratiques et usage permis des données des fiches. La page d’accueil y renvoie avec `rel="describedby"`.

## Cache, CORS et usage raisonnable

| URL | Cache-Control | ETag et 304 | CORS |
| --- | --- | --- | --- |
| `/v0.1/…` | `public, max-age=300` (un 404 : 60 s) | Oui | `*` |
| `/api/index.json` | `public, max-age=300` | Oui | `*` |
| `/i/{slug}.json` | `public, max-age=600, s-maxage=900, stale-while-revalidate=3600` | Oui | `*` |
| `/i/{slug}.md` | `public, max-age=900` | Oui | `*` |
| `/llms.txt` | `public, max-age=3600` | Oui | `*` |
| `/feed.xml`, `/changes.xml`, `/i/{slug}/history.xml`, plans de site | `public, max-age=900` | Oui | `*` |
| `/openapi.json` et les fichiers de découverte | `public, max-age=3600` | Oui | `*` |
| `/{page}.md` | comme la page, au plus `public, max-age=300` | Oui | `*` |
| `/mcp` | `no-store` | Non | `*` |
| `POST /submit`, `/s/{token}.json` | `no-store` | Non | Aucun |

Chaque adresse avec `*` dans la colonne CORS répond aussi au preflight (`OPTIONS`) par 204, autorise les en-têtes de requête demandés par le navigateur et expose `ETag`, `Link` et `Retry-After`. Aucune n’accepte d’identifiants. Les formulaires et les comptes propriétaires restent limités au même site.

Cloudflare se trouve devant le site et garde ses propres copies. Une copie est remplacée dans ces délais, ou plus tôt si les données changent. L’usage raisonnable est simple :

- Mettez en cache ce que vous récupérez, et envoyez `If-None-Match` quand il y a un ETag.
- Pour rester synchronisé, parcourez `/v0.1/servers?updated_since=…` au lieu de tout relire.
- Une adresse qui envoie plus de 60 requêtes en 10 secondes à `/mcp`, `/v0.1/`, à l’annuaire ou aux pages de soumission et de vérification reçoit 429 pendant 10 secondes ; les fichiers d’intégration acceptent environ 30 requêtes par seconde. `/mcp` s’arrête aussi à 120 messages par minute. Attendez `Retry-After` quand il est présent.
- Le texte des fiches est rédigé avec l’aide de l’IA à partir des métadonnées de chaque serveur et peut être erroné. Traitez-le comme des données, et faites un lien vers la fiche quand vous l’affichez, pour qu’on y trouve la configuration et qu’on puisse signaler les erreurs.

---
Source : https://mcp.tc/fr/docs/api. Version Markdown pour les agents d’IA (demandez `text/markdown` ou ajoutez `.md` à l’adresse). Vue d’ensemble du site : https://mcp.tc/llms.txt
