---
title: "API y fuentes de datos | mcp.tc"
description: "Lee el directorio de mcp.tc desde código: API compatible con el registro de MCP, índice de búsqueda JSON, fichas en JSON y Markdown, llms.txt, feed y sitemaps."
url: "https://mcp.tc/es/docs/api"
markdown: "https://mcp.tc/es/docs/api.md"
lang: "es"
---

# API y datos

Todo el directorio es público y legible por máquinas: una API en el formato del registro oficial de MCP, un índice de búsqueda JSON, cada ficha en JSON y Markdown, además de llms.txt, un feed y sitemaps. Sin clave ni registro.

## De un vistazo

| URL | Qué obtienes | En caché durante |
| --- | --- | --- |
| `/v0.1/servers` | Fichas en el formato del registro oficial de MCP, paginadas. [Detalles](https://mcp.tc/es/docs/api#registry) | 5 minutos |
| `/api/index.json` | Todas las fichas en un único array compacto. [Detalles](https://mcp.tc/es/docs/api#index) | 5 minutos |
| `/i/{slug}.json` | Una ficha, con sus acciones de configuración. [Detalles](https://mcp.tc/es/docs/api#listing-json) | 10 minutos |
| `/i/{slug}.md` | Una ficha en Markdown. [Detalles](https://mcp.tc/es/docs/api#markdown) | 15 minutos |
| `/llms.txt` | El directorio como lista para modelos de lenguaje. | 1 hora |
| `/feed.xml` | Feed Atom de las 50 fichas más recientes. | 15 minutos |
| `/changes.xml` | Feed Atom de los 50 cambios más recientes de todo el directorio. [Detalles](https://mcp.tc/es/docs/api#feeds) | 15 minutos |
| `/i/{slug}/history.xml` | Feed Atom del Historial de una ficha. [Detalles](https://mcp.tc/es/docs/api#feeds) | 15 minutos |
| `/sitemap.xml` | Índice de sitemaps: páginas, categorías y fichas, en todos los idiomas. | 15 minutos |
| `/mcp` | El servidor MCP propio de mcp.tc. [Documentación](https://mcp.tc/es/docs/mcp) | Sin caché |
| `POST /submit` | Propón un servidor para el directorio desde un script. [Detalles](https://mcp.tc/es/docs/api#submit) | Sin caché |
| `/openapi.json` | Descripción OpenAPI 3.1 de la API de registro, el índice de búsqueda, el JSON y Markdown de las fichas, los feeds de cambios y `POST /submit` con su estado. | 1 hora |
| `/.well-known/…` | Archivos de descubrimiento para agentes: el catálogo de API, la server card MCP, el catálogo de IA y una skill para agentes. [Detalles](https://mcp.tc/es/docs/api#discovery) | 1 hora |
| `/AGENTS.md` | Una guía para agentes de IA: cómo conectarse, límites y normas de uso. [Detalles](https://mcp.tc/es/docs/api#discovery) | 1 hora |
| `/{page}.md` | Cualquier página en Markdown, en su idioma. [Detalles](https://mcp.tc/es/docs/api#markdown) | Hasta 5 minutos |

Todo es público, y todo es de solo lectura salvo `POST /submit`. Sin clave, sin cuenta y sin coste. Los formatos para máquinas no dependen del idioma: sirven el texto en inglés de las fichas y no llevan prefijo de idioma. La excepción es el Markdown de las páginas, que sigue el idioma de la página.

## API compatible con el registro

`https://mcp.tc/v0.1/` es una copia de solo lectura de la API de lectura del registro oficial de MCP (versión 0.1, esquema `server.json` 2025-12-11), con las fichas aprobadas de mcp.tc. Un cliente que acepte la URL de un registro personalizado puede explorar el directorio e instalar desde él.

Una página de resultados tiene esta forma:

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

Y esto es lo que contiene `server` para dos fichas, tal como las sirve ahora la API:

### Servidor remoto

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

### Servidor 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` es el nombre del servidor en el registro oficial cuando tiene uno; si no, `tc.mcp/{slug}`.
- `remotes` contiene siempre la URL propia del servidor, nunca el enlace de mcp.tc. Las cabeceras de clave solo aparecen en los servidores que requieren una clave de API.
- `packages` se reconstruye a partir del comando de instalación de la ficha: npm (`npx`), PyPI (`uvx`, `pipx run`), OCI (`docker run`) y NuGet (`dnx`). Un comando que el formato no puede expresar no recibe paquete, porque uno que iniciara el programa equivocado sería peor que ninguno.
- `_meta["tc.mcp/listing"]` lleva el enlace de mcp.tc, el slug, la categoría, la marca, el acceso, el estado y las fechas. `updatedAt` solo cambia cuando cambia la entrada que servimos, nunca por una comprobación de estado.
- mcp.tc no es el registro oficial, así que las entradas nunca llevan sus metadatos `io.modelcontextprotocol.registry/official`.
- Una ficha retirada, oculta o renombrada vuelve como una entrada con `"status": "deleted"` durante 180 días, pero solo si la pides con `updated_since` o `include_deleted`.

Los errores son problem JSON (`application/problem+json`), como en la API oficial: 404 para un servidor desconocido, 422 para un `limit`, `cursor` o `include_deleted` incorrectos, 400 para un `updated_since` incorrecto. Cualquier método que no sea GET, HEAD u OPTIONS recibe 405: el registro es de solo lectura, y los servidores nuevos llegan por [Proponer](https://mcp.tc/es/submit).

La API está descrita en OpenAPI 3.1 en [`https://mcp.tc/openapi.json`](https://mcp.tc/openapi.json), y cada respuesta enlaza a ella con una cabecera `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'
```

## Usar mcp.tc como registro

Estos clientes aceptan la URL de un registro personalizado, según el código fuente de VS Code y la documentación de GitHub (comprobado el 8 de octubre de 2026). En VS Code y en las directivas de Copilot, introduce la URL base sin `/v0.1`: añaden la ruta por su cuenta.

### VS Code

Añade esta línea al `settings.json` de usuario de tu perfil predeterminado:

`settings.json`:

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

La galería de servidores MCP (escribe `@mcp` en la vista de Extensiones) muestra entonces los servidores de mcp.tc, e instalar uno usa la URL o el paquete propios del servidor. No hace falta ningún otro ajuste. El ajuste no aparece en el editor de configuración, y los demás perfiles lo ignoran, salvo que el `settings.json` del perfil predeterminado incluya también `"workbench.settings.applyToAllProfiles": ["chat.mcp.gallery.serviceUrl"]`. Las organizaciones pueden fijarlo para todos con la directiva `McpGalleryServiceUrl` (VS Code 1.101 o posterior), y `"chat.mcp.access": "registry"` limita VS Code a ejecutar servidores de ese registro.

### GitHub Copilot

Los administradores de organizaciones y empresas pueden introducir `https://mcp.tc` como **MCP Registry URL** en las directivas de Copilot. GitHub indica como compatibles VS Code, Visual Studio, los IDE de JetBrains, Eclipse, Xcode y Copilot CLI. Con **Registry only**, los servidores se emparejan por nombre, algo que según GitHub los usuarios pueden eludir editando su configuración. GitHub presenta esta vía como una versión preliminar pública y no como su método recomendado para restringir servidores: recomienda una lista de permitidos en el `managed-settings.json` de la empresa.

### Copilot en los IDE de JetBrains, Xcode y Eclipse

Los usuarios también pueden introducir un registro en los ajustes de Copilot (**MCP Registry URL**), en versión preliminar pública en las compilaciones preliminares del plugin. GitHub no indica si ese campo espera la URL base o la ruta `/v0.1`, y no hemos probado mcp.tc ahí.

Algunas fichas no tienen ni paquete ni URL remota, porque su comando de instalación no puede escribirse en el formato del registro. VS Code las oculta; sus páginas en mcp.tc siguen teniendo la configuración.

## Índice de búsqueda

`/api/index.json` contiene todas las fichas aprobadas en un único array JSON, los datos detrás de la búsqueda del sitio. Unas claves cortas lo mantienen ligero:

| Clave | Valor |
| --- | --- |
| `s` | Slug: la ficha está en `/i/{s}`. |
| `n` | Nombre. |
| `v` | Proveedor, o una cadena vacía. |
| `t` | Descripción corta, hasta 160 caracteres (en inglés). |
| `c` | Slug de la categoría, como en `/c/{slug}`. |
| `k` | `remote` o `local`. |
| `a` | Acceso: `none`, `oauth`, `api_key`, `optional` o `unknown`. |
| `g` | Etiquetas, un array de cadenas. |
| `i` | Icono, una ruta como `/media/icons/{slug}.webp` (WebP o PNG). No aparece si la ficha no tiene. |
| `f` | `1` cuando la ficha tiene la [marca](https://mcp.tc/es/verify). Si no, no aparece. |

`Una entrada`:

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

## Una ficha en JSON

Añade `.json` al enlace de cualquier ficha para obtener esa ficha en JSON:

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

Tiene todo lo que muestra la página: el `endpoint` propio del servidor o su `install_command`, la etiqueta `access`, las herramientas, la marca, el estado y las acciones en un clic `add`, que siempre usan la URL o el paquete propios del servidor. El objeto `history` apunta al Historial de la ficha: su `url` y su `feed` Atom, qué observamos (`tracking`: `tools`, `version` o `listing`), cuándo leímos sus herramientas por última vez (`tools_checked`) y cuándo cambió por última vez (`last_changed`), ambos en ISO 8601 o `null`. Un slug que no está en el directorio recibe 404 con `"error": "not_found"`, y una ficha retirada 410 con `"gone"`. Los slugs antiguos y los alias devuelven la ficha actual, así que lee `slug` en la respuesta.

Cualquier sitio puede leerla: la respuesta lleva `Access-Control-Allow-Origin: *` y no necesita clave. Los campos sin valor son `null`, nunca se omiten. El texto es el original en inglés de la ficha, salvo que añadas `?lang=` ([idiomas](https://mcp.tc/es/embed#lang)). Todos los campos:

| Campo | Tipo | Qué es |
| --- | --- | --- |
| `slug` | cadena | El slug actual de la ficha. Los slugs antiguos y los alias devuelven la ficha actual, así que léelo de aquí. |
| `name` | cadena | Nombre del servidor. |
| `vendor` | cadena o null | Quién desarrolla el servidor. |
| `tagline` | cadena o null | Una línea, hasta 200 caracteres. |
| `description` | cadena o null | Texto simple, con párrafos separados por una línea en blanco, hasta 2000 caracteres. Lo escribió un modelo de IA a partir de los metadatos públicos del servidor. |
| `link` | cadena | La página de la ficha, `https://mcp.tc/i/{slug}`, o, con `?lang=`, la página en ese idioma cuando está traducida. |
| `lang`\ `text_lang` | cadena | `lang`: el idioma de las etiquetas (`en` salvo que pidas otro con `?lang=`). `text_lang`: el idioma de `tagline`, `description` y los resúmenes de las herramientas: `lang` cuando la ficha tiene una traducción al día; si no, `en`. Una herramienta cuya descripción cambió desde la última traducción conserva su resumen en inglés hasta que se vuelva a traducir. |
| `category`\ `category_name` | cadena o null | Slug de la categoría (como en `/c/{slug}`) y su nombre. |
| `kind` | cadena | `remote` (te conectas por HTTPS) o `local` (se ejecuta en tu equipo). |
| `transport` | cadena | `streamable-http`, `sse` o `stdio`. |
| `auth` | cadena | `none`, `oauth`, `api_key`, `optional` o `unknown`. |
| `access` | objeto | Cómo lo etiqueta mcp.tc: `group` (`ok`, `auth` o `local`, el filtro de acceso del directorio), `label` (texto de la insignia, como «No sign-in»), `text` (forma larga) y `note` (una frase). |
| `endpoint` | cadena o null | La URL propia del servidor (servidores remotos). Es a la que se conecta un cliente. |
| `install_command` | cadena o null | El comando que inicia un servidor local, como `npx -y @playwright/mcp`. |
| `package` | objeto o null | `registry` (`npm`, `pypi`, `oci`, `nuget`…) e `identifier`. |
| `relay` | booleano | Falso en todas las fichas: el enlace de mcp.tc es una página, y los clientes se conectan a la URL propia del servidor. El campo se mantiene para que los lectores existentes sigan funcionando. |
| `verified`\ `verified_by` | booleano, cadena o null | La marca, y lo que significa para esta ficha. |
| `icon` | cadena o null | URL del icono de 128 × 128 de la ficha en mcp.tc. |
| `tools_count`\ `tools` | número, array | Herramientas leídas del servidor (hasta 150): `name`, `summary` y `read_only` / `destructive` (true, false, o null cuando el servidor no lo indica). |
| `add` | array | Las acciones en un clic: `client` (`claude-code`, `cursor`, `vscode`, `claude-ai`), `label`, `kind` y `value`: un comando que copiar para `copy`, un enlace de instalación para `link`. Siempre usan la URL o el paquete propios del servidor. |
| `homepage`\ `repository`\ `docs` | cadena o null | Enlaces de la ficha. |
| `health` | cadena | Nuestra última comprobación: `ok`, `auth` (respondió y pidió iniciar sesión), `down` o `unknown` (los servidores locales no se comprueban). |
| `last_checked`\ `listed`\ `updated` | cadena o null | Horas ISO 8601 en UTC: la última comprobación, cuándo entró en el directorio, el último cambio de su contenido. |
| `history` | objeto | El historial de la ficha: `url` (su pestaña Historial) y `feed` (Atom), qué observamos en `tracking` (`tools`, `version` o `listing`) y dos horas ISO 8601 en UTC, o null: `tools_checked` (cuándo leímos sus herramientas por última vez) y `last_changed` (su cambio más reciente). |
| `embeds` | objeto | Las URL `badge`, `widget`, `iframe` y `markdown` de esta ficha. `widget` e `iframe` mantienen tu `?lang=`. `snippets` contiene el código de la sección Insertar de la página de la ficha, listo para pegar: `markdown` y `html` para la insignia, `script` para la tarjeta para web, `placeholder` (un `div` donde aparece la tarjeta, con un enlace dentro para quien no tiene JavaScript) e `iframe`. Su texto alternativo y sus enlaces siguen `?lang=`. |
| `format` | cadena | Un enlace a esta lista de campos. |

## Insignias e inserciones

Cómo se comporta la [tarjeta para web](https://mcp.tc/es/embed) en tu página:

- Cada archivo lo contiene todo: los datos de la ficha, los estilos y el icono. No hace otras solicitudes ni usa cookies o almacenamiento local, así que no hay nada con lo que seguir a los visitantes.
- Se dibuja dentro de un shadow root cerrado: tus estilos no le llegan y los suyos no llegan a tu página.
- Escribe el texto solo como texto (nunca como HTML) y solo enlaza a mcp.tc y a las páginas de instalación de los propios clientes, por HTTPS.
- Con una Content Security Policy, permite `script-src https://mcp.tc`. El icono es una imagen `data:`; si tu política las bloquea, la tarjeta muestra en su lugar la primera letra del nombre.
- Para un slug que no está en el directorio no aparece nada, y la consola del navegador muestra un aviso.

### Cuánto tiempo se guardan las copias

- La tarjeta, el iframe y el JSON llevan botones de instalación, así que se actualizan rápido. Los navegadores los guardan 10 minutos, y un cambio en la ficha llega a las copias de nuestra CDN (Cloudflare) en 15 minutos como máximo.
- La insignia solo muestra un nombre. Cloudflare la guarda hasta un día y los navegadores una hora; mientras Cloudflare actualiza una copia, puede servir la anterior durante hasta una semana.

## Páginas y fichas en Markdown

Para agentes y modelos de lenguaje, cada ficha también está en Markdown: añade `.md` al enlace, o pide `text/markdown` en la dirección de la ficha.

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

Empieza con un resumen (el enlace, cómo conectarse, tipo, acceso, categoría, proveedor, marca) y después tiene la descripción, lo que puede hacer el servidor, sus herramientas, prompts de ejemplo, los pasos de instalación para cada cliente y sus cinco cambios más recientes. Un nombre antiguo responde 301 con el actual.

Las páginas del sitio funcionan igual: la portada, el directorio y sus categorías, esta documentación, el blog, los cambios recientes, la página de la marca de verificación y las páginas legales. Añade `.md` a la dirección (`/docs/connect.md`, `/it/c/databases.md`; la portada es `/index.md`) o pide `text/markdown` a la propia página. Recibes el texto de la página en su idioma, sin menús, bajo una breve cabecera de metadatos. Una solicitud cuya cabecera `Accept` prefiere `text/markdown` lo recibe con `Vary: Accept`, y `x-markdown-tokens` da un número aproximado de tokens (los caracteres divididos entre cuatro). Las copias `.md` llevan `noindex`, así que los buscadores siguen indexando la página HTML.

## llms.txt, feeds y sitemaps

- [`/llms.txt`](https://mcp.tc/llms.txt) sigue [llmstxt.org](https://llmstxt.org/): cómo funciona la conexión, esta documentación, las categorías con sus recuentos, las versiones de idioma del sitio y cada ficha con un resumen de una línea y datos breves (remoto o local, acceso, verificado), cada una enlazada a su Markdown.
- [`/feed.xml`](https://mcp.tc/feed.xml) es un feed Atom de las 50 fichas aprobadas más recientemente, con su descripción corta y su descripción completa.
- [`/changes.xml`](https://mcp.tc/changes.xml) es un feed Atom de los 50 cambios más recientes de todo el directorio (herramientas añadidas, eliminadas o modificadas, versiones nuevas, ediciones de los responsables de los servidores), cada uno con un enlace al Historial de la ficha. La página [Cambios recientes](https://mcp.tc/es/changes) muestra la misma lista.
- `/i/{slug}/history.xml` es el Historial de una ficha como feed Atom, por ejemplo [`/i/deepwiki/history.xml`](https://mcp.tc/i/deepwiki/history.xml). [Historial y avisos](https://mcp.tc/es/docs/changes) explica qué cuenta como un cambio.
- [`/sitemap.xml`](https://mcp.tc/sitemap.xml) indexa tres sitemaps: páginas, categorías y fichas, cada uno con la fecha del último cambio de contenido. Cada página aparece en cada idioma en el que existe, con sus alternativas (`hreflang`); las páginas traducidas de una ficha aparecen cuando su texto se ha traducido.
- [`/robots.txt`](https://mcp.tc/robots.txt) deja entrar a todos los rastreadores, incluidos los de IA (`Content-Signal: search=yes, ai-input=yes, ai-train=yes`). Los mantiene fuera de `/api/`, salvo el índice de búsqueda, y de las páginas privadas de propuestas.

## Proponer un servidor desde un script

El formulario [Proponer](https://mcp.tc/es/submit) también acepta JSON. Envía una petición `POST` a `https://mcp.tc/submit` con `Content-Type: application/json`, la URL del servidor y, si quieres, una nota para la persona que la revisa:

```
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` (obligatorio): un endpoint MCP remoto, un repositorio o una página de npm o PyPI, de hasta 2048 caracteres.
- `note` (opcional): hasta 500 caracteres. La URL y la nota se revisan de forma automática, también con un modelo de IA, así que no pongas datos personales.
- `notify_email` (opcional): la dirección de quien sugiere el servidor, que recibe un solo correo en inglés cuando está en el directorio (la respuesta 202 incluye entonces `"notify": true`). Añádela solo con el consentimiento de esa persona. Una dirección puede esperar cinco servidores a la vez.

Los demás campos se ignoran. Una propuesta enviada así pasa por las mismas comprobaciones y los mismos límites que una enviada con el formulario, sin clave ni cuenta. Solo la dirección sin prefijo de idioma acepta JSON. La respuesta no lleva cabeceras CORS, así que una página de otro sitio no puede enviarla, y una petición que el navegador marca como cross-site recibe 403.

Una propuesta aceptada recibe 202, con la URL de estado también en la cabecera `Location`:

`HTTP 202`:

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

| Estado | `state` o `error` | Qué significa |
| --- | --- | --- |
| 202 | `queued` | En la cola: síguela en `status_url`. Si la misma URL ya está esperando, recibes el token de esa propuesta y `"existing_submission": true`. |
| 200 | `duplicate` | Ya está en el directorio: `listing` contiene su `slug`, `name` y `link`. |
| 400 | `invalid_request` | El cuerpo no es un objeto JSON con una cadena `url`. |
| 403 | `cross_site` | La envió un navegador desde otro sitio. |
| 413 | `too_large` | El cuerpo supera los 16 KB. |
| 422 | `empty`, `too_long`, `invalid_url`, `personal_url`, `blocked`, `invalid_email`, `notify_limited` | No podemos aceptar esta URL, o `notify_email` no es una dirección o ya espera cinco servidores. `message` explica por qué, y enviarla otra vez da la misma respuesta. |
| 429 | `rate_limited` | Demasiadas propuestas. `scope` indica el límite (`ip_hour`, `ip_day` o `global_day`); `retry_after` y la cabecera `Retry-After` dan los segundos que hay que esperar. |
| 503 | `paused` | Las propuestas están en pausa por ahora. Vuelve a intentarlo después de `Retry-After`. |

Cada respuesta es un JSON con `ok`. Un error añade el código en `error` y una frase en inglés en `message`. Una ráfaga de peticiones también puede recibir un 429 del servidor web o de Cloudflare sin este cuerpo: espera `Retry-After`, o 10 segundos si no está. Envía también un User-Agent descriptivo: Cloudflare responde a los predeterminados de Python-urllib y libwww-perl con un 403 que no es JSON, aquí y en `status_url`.

### Seguir el estado

Consulta `status_url` cada 5 o 10 segundos hasta que `terminal` sea `true`; la mayoría de las propuestas terminan en pocos minutos. `state` pasa de `queued` a `checking` y `reviewing`, y termina como `listed`, `duplicate`, `pending` (una persona la revisa antes de publicarla), `rejected` o `error`. Cuando hay una ficha, `link` y `name` apuntan a ella. `title` y `message` son el texto en inglés de la página de estado, y `page` es esa página, para abrirla en un navegador. Un token desconocido recibe 404. Así se ve una propuesta terminada:

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

La herramienta de línea de comandos de código abierto [mcp-tc](https://www.npmjs.com/package/mcp-tc) envía esta solicitud desde un terminal y sigue el estado por ti: `npx mcp-tc submit https://mcp.example.com/mcp`.

## Archivos de descubrimiento

Los agentes y rastreadores encuentran las API de mcp.tc, su servidor MCP y su skill a través de estos archivos. Están en inglés, son públicos y se guardan en caché una hora, con ETag y CORS abierto a cualquier sitio. Cada página envía además una cabecera `Link` que apunta al catálogo de API.

- [`/.well-known/api-catalog`](https://mcp.tc/.well-known/api-catalog): las tres API (registro, servidor MCP, índice de búsqueda) como linkset RFC 9727, cada una con su descripción, documentación, términos y política de privacidad.
- [`/openapi.json`](https://mcp.tc/openapi.json): OpenAPI 3.1 para `/v0.1/`, `/api/index.json`, `/i/{slug}.json`, `/i/{slug}.md`, los feeds de cambios (`/changes.xml`, `/i/{slug}/history.xml`) y `POST /submit` con su estado (`/s/{token}.json`).
- [`/mcp/server-card`](https://mcp.tc/mcp/server-card): la server card del servidor MCP de mcp.tc (nombre, versión, URL, versiones del protocolo), también en `/.well-known/mcp/server-card.json`.
- [`/.well-known/ard.json`](https://mcp.tc/.well-known/ard.json): un catálogo de IA (ARD) de los recursos propios de mcp.tc: el servidor MCP, la API y la skill. El mismo archivo está en `/.well-known/ai-catalog.json`. No incluye los servidores del directorio, porque no nos corresponde publicarlos.
- [`/.well-known/agent-skills/index.json`](https://mcp.tc/.well-known/agent-skills/index.json): un índice de Agent Skills con una skill, find-and-install-mcp-servers, que explica a un agente cómo encontrar aquí un servidor y configurarlo en un cliente.
- [`/AGENTS.md`](https://mcp.tc/AGENTS.md): una guía para agentes de IA en el formato [AGENTS.md](https://agents.md/): cómo conectarse al servidor MCP y a las API, límites, tiempos de caché, normas de uso y cómo se pueden usar los datos de las fichas. La página de inicio la enlaza con `rel="describedby"`.

## Caché, CORS y uso razonable

| URL | Cache-Control | ETag y 304 | CORS |
| --- | --- | --- | --- |
| `/v0.1/…` | `public, max-age=300` (un 404: 60 s) | Sí | `*` |
| `/api/index.json` | `public, max-age=300` | Sí | `*` |
| `/i/{slug}.json` | `public, max-age=600, s-maxage=900, stale-while-revalidate=3600` | Sí | `*` |
| `/i/{slug}.md` | `public, max-age=900` | Sí | `*` |
| `/llms.txt` | `public, max-age=3600` | Sí | `*` |
| `/feed.xml`, `/changes.xml`, `/i/{slug}/history.xml`, sitemaps | `public, max-age=900` | Sí | `*` |
| `/openapi.json` y los archivos de descubrimiento | `public, max-age=3600` | Sí | `*` |
| `/{page}.md` | como la página, como máximo `public, max-age=300` | Sí | `*` |
| `/mcp` | `no-store` | No | `*` |
| `POST /submit`, `/s/{token}.json` | `no-store` | No | Ninguno |

Cada dirección con `*` en la columna CORS también responde al preflight (`OPTIONS`) con 204, admite las cabeceras de solicitud que pide el navegador y expone `ETag`, `Link` y `Retry-After`. Ninguna acepta credenciales. Los formularios y las cuentas de propietario siguen limitados al mismo sitio.

Cloudflare está delante del sitio y guarda sus propias copias. Una copia se sustituye dentro de estos plazos, o antes si los datos cambian. El uso razonable es sencillo:

- Guarda en caché lo que descargas, y envía `If-None-Match` donde haya un ETag.
- Para mantenerte sincronizado, recorre `/v0.1/servers?updated_since=…` en lugar de volver a leerlo todo.
- Una dirección que envía más de 60 solicitudes en 10 segundos a `/mcp`, `/v0.1/`, al directorio o a las páginas de envío y verificación recibe 429 durante 10 segundos; los archivos de inserción admiten unas 30 solicitudes por segundo. `/mcp` también se detiene en 120 mensajes por minuto. Espera `Retry-After` cuando venga.
- El texto de las fichas se escribe con ayuda de IA a partir de los metadatos de cada servidor y puede contener errores. Trátalo como datos y enlaza a la ficha cuando lo muestres, para que la gente encuentre la configuración y pueda reportar errores.

---
Fuente: https://mcp.tc/es/docs/api. Versión Markdown para agentes de IA (pide `text/markdown` o añade `.md` a la dirección). Resumen del sitio: https://mcp.tc/llms.txt
