---
title: "API e feed di dati | mcp.tc"
description: "Leggi l’elenco di mcp.tc dal codice: un’API compatibile con il registro MCP, un indice di ricerca JSON, schede in JSON e Markdown, llms.txt, feed e sitemap."
url: "https://mcp.tc/it/docs/api"
markdown: "https://mcp.tc/it/docs/api.md"
lang: "it"
---

# API e dati

Tutto nell’elenco è pubblico e leggibile dalle macchine: un’API nel formato del registro ufficiale MCP, un indice di ricerca JSON, ogni scheda in JSON e Markdown, più llms.txt, un feed e le sitemap. Niente chiave, niente registrazione.

## In breve

| URL | Cosa ottieni | In cache per |
| --- | --- | --- |
| `/v0.1/servers` | Le schede nel formato del registro ufficiale MCP, a pagine. [Dettagli](https://mcp.tc/it/docs/api#registry) | 5 minuti |
| `/api/index.json` | Tutte le schede in un unico array compatto. [Dettagli](https://mcp.tc/it/docs/api#index) | 5 minuti |
| `/i/{slug}.json` | Una scheda, con le sue azioni di configurazione. [Dettagli](https://mcp.tc/it/docs/api#listing-json) | 10 minuti |
| `/i/{slug}.md` | Una scheda in Markdown. [Dettagli](https://mcp.tc/it/docs/api#markdown) | 15 minuti |
| `/llms.txt` | L’elenco come lista per i modelli linguistici. | 1 ora |
| `/feed.xml` | Feed Atom delle 50 schede più recenti. | 15 minuti |
| `/changes.xml` | Feed Atom delle 50 modifiche più recenti in tutto l’elenco. [Dettagli](https://mcp.tc/it/docs/api#feeds) | 15 minuti |
| `/i/{slug}/history.xml` | Feed Atom della Cronologia di una scheda. [Dettagli](https://mcp.tc/it/docs/api#feeds) | 15 minuti |
| `/sitemap.xml` | Indice delle sitemap: pagine, categorie e schede, in tutte le lingue. | 15 minuti |
| `/mcp` | Il server MCP di mcp.tc. [Documentazione](https://mcp.tc/it/docs/mcp) | Nessuna cache |
| `POST /submit` | Proponi un server per l’elenco da uno script. [Dettagli](https://mcp.tc/it/docs/api#submit) | Nessuna cache |
| `/openapi.json` | Descrizione OpenAPI 3.1 dell’API del registro, dell’indice di ricerca, del JSON e Markdown delle schede, dei feed delle modifiche e di `POST /submit` con il suo stato. | 1 ora |
| `/.well-known/…` | File di scoperta per agenti: catalogo delle API, server card MCP, catalogo AI e una skill per agenti. [Dettagli](https://mcp.tc/it/docs/api#discovery) | 1 ora |
| `/AGENTS.md` | Una guida per gli agenti AI: come collegarsi, limiti e regole d’uso. [Dettagli](https://mcp.tc/it/docs/api#discovery) | 1 ora |
| `/{page}.md` | Qualsiasi pagina in Markdown, nella sua lingua. [Dettagli](https://mcp.tc/it/docs/api#markdown) | Fino a 5 minuti |

Tutto è pubblico, e tutto è in sola lettura tranne `POST /submit`. Niente chiave, niente account, niente costi. I formati per le macchine sono indipendenti dalla lingua: servono il testo inglese delle schede e non hanno prefisso di lingua. Fa eccezione il Markdown delle pagine, che segue la lingua della pagina.

## API compatibile con il registro

`https://mcp.tc/v0.1/` è una copia in sola lettura dell’API di lettura del registro ufficiale MCP (versione 0.1, schema `server.json` 2025-12-11), riempita con le schede approvate di mcp.tc. Un client che accetta l’URL di un registro personalizzato può sfogliare l’elenco e installare da lì.

Una pagina di risultati ha questa 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": "…" }
}
```

Ed ecco cosa contiene `server` per due schede, così come l’API le serve adesso:

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

### Server locale

`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` è il nome del server nel registro ufficiale quando ne ha uno, altrimenti `tc.mcp/{slug}`.
- `remotes` contiene sempre l’URL del server stesso, mai il link di mcp.tc. Gli header per le chiavi compaiono solo per i server che richiedono una chiave API.
- `packages` viene ricostruito dal comando di installazione della scheda: npm (`npx`), PyPI (`uvx`, `pipx run`), OCI (`docker run`) e NuGet (`dnx`). Un comando che il formato non può esprimere non riceve alcun pacchetto, perché uno che avvia il programma sbagliato sarebbe peggio di niente.
- `_meta["tc.mcp/listing"]` contiene il link di mcp.tc, lo slug, la categoria, la spunta, l’accesso, lo stato e le date. `updatedAt` cambia solo quando cambia la voce che serviamo, mai per un controllo di stato.
- mcp.tc non è il registro ufficiale, quindi le voci non hanno mai i suoi metadati `io.modelcontextprotocol.registry/official`.
- Una scheda rimossa, nascosta o rinominata torna come voce con `"status": "deleted"` per 180 giorni, ma solo se la chiedi con `updated_since` o `include_deleted`.

Gli errori sono problem JSON (`application/problem+json`), come nell’API ufficiale: 404 per un server sconosciuto, 422 per un `limit`, `cursor` o `include_deleted` non validi, 400 per un `updated_since` non valido. Qualsiasi metodo diverso da GET, HEAD e OPTIONS riceve 405: il registro è in sola lettura, e i nuovi server arrivano da [Proponi](https://mcp.tc/it/submit).

L’API è descritta in OpenAPI 3.1 su [`https://mcp.tc/openapi.json`](https://mcp.tc/openapi.json), e ogni risposta vi rimanda con un’intestazione `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'
```

## Usa mcp.tc come registro

Questi client accettano l’URL di un registro personalizzato, secondo il codice sorgente di VS Code e la documentazione di GitHub (verificato l’8 ottobre 2026). In VS Code e nelle policy di Copilot inserisci l’URL di base senza `/v0.1`: il percorso lo aggiungono loro.

### VS Code

Aggiungi questa riga al `settings.json` utente del tuo profilo predefinito:

`settings.json`:

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

La galleria dei server MCP (digita `@mcp` nella vista Estensioni) mostra allora i server di mcp.tc, e installarne uno usa l’URL o il pacchetto del server stesso. Non serve nessun’altra impostazione. L’impostazione non compare nell’editor delle impostazioni, e gli altri profili la ignorano, a meno che il `settings.json` del profilo predefinito contenga anche `"workbench.settings.applyToAllProfiles": ["chat.mcp.gallery.serviceUrl"]`. Le organizzazioni possono impostarla per tutti con la policy `McpGalleryServiceUrl` (VS Code 1.101 o successivo), e `"chat.mcp.access": "registry"` limita VS Code ai server di quel registro.

### GitHub Copilot

Gli amministratori di organizzazioni ed enterprise possono inserire `https://mcp.tc` come **MCP Registry URL** nelle policy di Copilot. GitHub indica come supportati VS Code, Visual Studio, gli IDE JetBrains, Eclipse, Xcode e Copilot CLI. Con **Registry only**, i server vengono abbinati per nome, e secondo GitHub gli utenti possono aggirarlo modificando la propria configurazione. GitHub definisce questa strada un’anteprima pubblica e non il modo consigliato per limitare i server: consiglia una lista di server ammessi nel `managed-settings.json` dell’enterprise.

### Copilot negli IDE JetBrains, in Xcode ed Eclipse

Gli utenti possono inserire un registro anche nelle impostazioni di Copilot (**MCP Registry URL**), in anteprima pubblica sulle build pre-release del plugin. GitHub non dice se quel campo vuole l’URL di base o il percorso `/v0.1`, e non abbiamo provato mcp.tc lì.

Alcune schede non hanno né un pacchetto né un remote, perché il loro comando di installazione non si può scrivere nel formato del registro. VS Code le nasconde; le loro pagine su mcp.tc hanno comunque la configurazione.

## Indice di ricerca

`/api/index.json` contiene tutte le schede approvate in un unico array JSON, i dati dietro la ricerca del sito. Le chiavi brevi lo tengono leggero:

| Chiave | Valore |
| --- | --- |
| `s` | Slug: la scheda è a `/i/{s}`. |
| `n` | Nome. |
| `v` | Fornitore, o una stringa vuota. |
| `t` | Descrizione breve, fino a 160 caratteri (in inglese). |
| `c` | Slug della categoria, come in `/c/{slug}`. |
| `k` | `remote` o `local`. |
| `a` | Accesso: `none`, `oauth`, `api_key`, `optional` o `unknown`. |
| `g` | Tag, un array di stringhe. |
| `i` | Icona, un percorso come `/media/icons/{slug}.webp` (WebP o PNG). Assente quando la scheda non ne ha. |
| `f` | `1` quando la scheda ha la [spunta](https://mcp.tc/it/verify). Altrimenti assente. |

`Una voce`:

```
{
  "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 scheda in JSON

Aggiungi `.json` al link di qualsiasi scheda per avere quella scheda in JSON:

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

Contiene tutto ciò che mostra la pagina: l’`endpoint` del server o il suo `install_command`, l’etichetta `access`, i tool, la spunta, lo stato e le azioni in un clic `add`, che usano sempre l’URL o il pacchetto del server stesso. L’oggetto `history` rimanda alla Cronologia della scheda: il suo `url` e il `feed` Atom, cosa controlliamo (`tracking`: `tools`, `version` o `listing`), quando abbiamo letto i suoi tool l’ultima volta (`tools_checked`) e quando è cambiata l’ultima volta (`last_changed`), entrambi in ISO 8601 o `null`. Uno slug non in elenco riceve 404 con `"error": "not_found"`, e una scheda rimossa 410 con `"gone"`. I vecchi slug e gli alias restituiscono la scheda attuale, quindi leggi `slug` dalla risposta.

Qualsiasi sito può leggerla: la risposta include `Access-Control-Allow-Origin: *` e non richiede chiavi. I campi senza valore sono `null`, mai omessi. Il testo è quello originale inglese della scheda, a meno che tu non aggiunga `?lang=` ([lingue](https://mcp.tc/it/embed#lang)). Tutti i campi:

| Campo | Tipo | Cos’è |
| --- | --- | --- |
| `slug` | stringa | Lo slug attuale della scheda. I vecchi slug e gli alias restituiscono la scheda attuale, quindi leggilo da qui. |
| `name` | stringa | Nome del server. |
| `vendor` | stringa o null | Chi realizza il server. |
| `tagline` | stringa o null | Una riga, fino a 200 caratteri. |
| `description` | stringa o null | Testo semplice, paragrafi separati da una riga vuota, fino a 2.000 caratteri. L’ha scritto un modello di AI dai metadati pubblici del server. |
| `link` | stringa | La pagina della scheda, `https://mcp.tc/i/{slug}`, oppure, con `?lang=`, la pagina in quella lingua quando è tradotta. |
| `lang`\ `text_lang` | stringa | `lang`: la lingua delle etichette (`en`, a meno che tu non ne chieda un’altra con `?lang=`). `text_lang`: la lingua di `tagline`, `description` e dei riassunti degli strumenti: `lang` quando la scheda ha una traduzione aggiornata, altrimenti `en`. Un tool la cui descrizione è cambiata dopo l’ultima traduzione mantiene il riassunto in inglese finché non viene tradotto di nuovo. |
| `category`\ `category_name` | stringa o null | Slug della categoria (come in `/c/{slug}`) e il suo nome. |
| `kind` | stringa | `remote` (ti colleghi via HTTPS) o `local` (gira sul tuo computer). |
| `transport` | stringa | `streamable-http`, `sse` o `stdio`. |
| `auth` | stringa | `none`, `oauth`, `api_key`, `optional` o `unknown`. |
| `access` | oggetto | Come lo etichetta mcp.tc: `group` (`ok`, `auth` o `local`, il filtro Accesso dell’elenco), `label` (testo del badge, come «No sign-in»), `text` (forma estesa) e `note` (una frase). |
| `endpoint` | stringa o null | L’URL del server stesso (server remoti). È quello a cui si collega un client. |
| `install_command` | stringa o null | Il comando che avvia un server locale, come `npx -y @playwright/mcp`. |
| `package` | oggetto o null | `registry` (`npm`, `pypi`, `oci`, `nuget`…) e `identifier`. |
| `relay` | booleano | False per ogni scheda: il link di mcp.tc è una pagina, e i client si collegano all’URL del server stesso. Il campo resta perché i programmi che già lo leggono continuino a funzionare. |
| `verified`\ `verified_by` | booleano, stringa o null | La spunta, e cosa significa per questa scheda. |
| `icon` | stringa o null | URL dell’icona 128 × 128 della scheda su mcp.tc. |
| `tools_count`\ `tools` | numero, array | I tool letti dal server (fino a 150): `name`, `summary` e `read_only` / `destructive` (true, false, o null quando il server non lo dice). |
| `add` | array | Le azioni in un clic: `client` (`claude-code`, `cursor`, `vscode`, `claude-ai`), `label`, `kind` e `value`: un comando da copiare per `copy`, un link di installazione per `link`. Usano sempre l’URL o il pacchetto del server stesso. |
| `homepage`\ `repository`\ `docs` | stringa o null | Link della scheda. |
| `health` | stringa | Il nostro ultimo controllo: `ok`, `auth` (ha risposto e ha chiesto un accesso), `down` o `unknown` (i server locali non vengono controllati). |
| `last_checked`\ `listed`\ `updated` | stringa o null | Orari ISO 8601 in UTC: l’ultimo controllo, l’inserimento in elenco, l’ultima modifica del contenuto. |
| `history` | oggetto | La Cronologia della scheda: `url` (la Cronologia sulla sua pagina) e `feed` (Atom), cosa controlliamo in `tracking` (`tools`, `version` o `listing`) e due orari ISO 8601 in UTC, oppure null: `tools_checked` (quando abbiamo letto i suoi tool l’ultima volta) e `last_changed` (la sua modifica più recente). |
| `embeds` | oggetto | Gli URL di `badge`, `widget`, `iframe` e `markdown` di questa scheda. `widget` e `iframe` mantengono il tuo `?lang=`. `snippets` contiene il codice della sezione Embed della pagina della scheda, pronto da incollare: `markdown` e `html` per il badge, `script` per la card per il sito, `placeholder` (un `div` in cui compare la card, con dentro un link per chi non ha JavaScript) e `iframe`. Testo alternativo e link seguono `?lang=`. |
| `format` | stringa | Un link a questo elenco di campi. |

## Badge ed embed

Come si comporta la [card per il sito](https://mcp.tc/it/embed) sulla tua pagina:

- Ogni file contiene tutto: i dati della scheda, gli stili e l’icona. Non fa altre richieste e non imposta cookie né local storage, quindi non c’è nulla con cui tracciare chi visita.
- Si disegna dentro una shadow root chiusa: i tuoi stili non la raggiungono e i suoi non raggiungono la tua pagina.
- Scrive il testo solo come testo (mai come HTML) e rimanda solo a mcp.tc e alle pagine di installazione dei client, in HTTPS.
- Con una Content Security Policy, consenti `script-src https://mcp.tc`. L’icona è un’immagine `data:`; se la tua policy le blocca, la card mostra invece l’iniziale del nome.
- Per uno slug non in elenco non compare nulla e la console del browser mostra un avviso.

### Per quanto tempo vengono conservate le copie

- La card, l’iframe e il JSON contengono pulsanti di installazione, quindi si aggiornano in fretta. I browser li conservano per 10 minuti, e una modifica alla scheda raggiunge le copie della nostra CDN (Cloudflare) entro 15 minuti.
- Il badge mostra solo un nome. Cloudflare lo conserva fino a un giorno e i browser per un’ora; mentre Cloudflare aggiorna una copia, può servire quella vecchia fino a una settimana.

## Pagine e schede in Markdown

Per agenti e modelli linguistici, ogni scheda è disponibile anche in Markdown: aggiungi `.md` al link, oppure chiedi `text/markdown` all’indirizzo della scheda.

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

Inizia con un riepilogo (il link, come collegarsi, tipo, accesso, categoria, fornitore, spunta), poi contiene la descrizione, cosa può fare il server, i suoi tool, i prompt di esempio, i passaggi di installazione per ogni client e le sue cinque modifiche più recenti. Un vecchio nome risponde 301 con quello attuale.

Le pagine del sito funzionano allo stesso modo: la home, l’elenco e le sue categorie, questa documentazione, il blog, le modifiche recenti, la pagina della spunta e le pagine legali. Aggiungi `.md` all’indirizzo (`/docs/connect.md`, `/it/c/databases.md`; la home è `/index.md`) oppure chiedi `text/markdown` alla pagina stessa. Ricevi il testo della pagina nella sua lingua, senza menu, sotto una breve intestazione di metadati. Una richiesta il cui header `Accept` preferisce `text/markdown` lo riceve con `Vary: Accept`, e `x-markdown-tokens` indica un numero approssimativo di token (i caratteri divisi per quattro). Le copie `.md` sono `noindex`, così i motori di ricerca continuano a indicizzare la pagina HTML.

## llms.txt, feed e sitemap

- [`/llms.txt`](https://mcp.tc/llms.txt) segue [llmstxt.org](https://llmstxt.org/): come funziona il collegamento, questa documentazione, le categorie con i loro conteggi, le versioni linguistiche del sito e ogni scheda con un riassunto di una riga e dati essenziali (remoto o locale, accesso, verificato), ognuna collegata al suo Markdown.
- [`/feed.xml`](https://mcp.tc/feed.xml) è un feed Atom delle 50 schede approvate più di recente, con descrizione breve e descrizione.
- [`/changes.xml`](https://mcp.tc/changes.xml) è un feed Atom delle 50 modifiche più recenti in tutto l’elenco (tool aggiunti, rimossi o modificati, nuove versioni, modifiche di chi gestisce i server), ognuna con un link alla Cronologia della scheda. La pagina [Modifiche recenti](https://mcp.tc/it/changes) mostra lo stesso elenco.
- `/i/{slug}/history.xml` è la Cronologia di una scheda come feed Atom, per esempio [`/i/deepwiki/history.xml`](https://mcp.tc/i/deepwiki/history.xml). [Cronologia e avvisi](https://mcp.tc/it/docs/changes) spiega cosa conta come modifica.
- [`/sitemap.xml`](https://mcp.tc/sitemap.xml) indicizza tre sitemap: pagine, categorie e schede, ognuna con la data dell’ultima modifica del contenuto. Ogni pagina compare in ogni lingua in cui esiste, con le sue alternative (`hreflang`); le pagine tradotte di una scheda compaiono quando il suo testo è stato tradotto.
- [`/robots.txt`](https://mcp.tc/robots.txt) lascia entrare ogni crawler, compresi quelli AI (`Content-Signal: search=yes, ai-input=yes, ai-train=yes`). Li tiene fuori da `/api/`, tranne l’indice di ricerca, e dalle pagine private delle proposte.

## Proporre un server da uno script

Il modulo [Proponi](https://mcp.tc/it/submit) accetta anche JSON. Invia una richiesta `POST` a `https://mcp.tc/submit` con `Content-Type: application/json`, l’URL del server e, se vuoi, una nota per chi la esamina:

```
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` (obbligatorio): un endpoint MCP remoto, un repository o una pagina npm o PyPI, fino a 2.048 caratteri.
- `note` (facoltativo): fino a 500 caratteri. L’URL e la nota vengono controllati in automatico, anche da un modello di AI, quindi non inserire dati personali.
- `notify_email` (facoltativo): l’indirizzo di chi suggerisce il server, che riceve una sola email in inglese quando è in elenco (la risposta 202 ha allora `"notify": true`). Aggiungilo solo con il consenso di quella persona. Un indirizzo può aspettare cinque server alla volta.

Gli altri campi vengono ignorati. Una proposta inviata così passa per gli stessi controlli e gli stessi limiti di una inviata con il modulo, e non servono chiavi né account. Solo l’indirizzo senza prefisso di lingua accetta JSON. La risposta non ha intestazioni CORS, quindi una pagina di un altro sito non può inviarla, e una richiesta che il browser segna come cross-site riceve 403.

Una proposta accettata riceve 202, con l’URL dello stato anche nell’intestazione `Location`:

`HTTP 202`:

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

| Stato | `state` o `error` | Cosa significa |
| --- | --- | --- |
| 202 | `queued` | In coda: seguila su `status_url`. Se lo stesso URL è già in attesa, ricevi il token di quella proposta e `"existing_submission": true`. |
| 200 | `duplicate` | Già nell’elenco: `listing` contiene il suo `slug`, `name` e `link`. |
| 400 | `invalid_request` | Il corpo non è un oggetto JSON con una stringa `url`. |
| 403 | `cross_site` | L’ha inviata un browser da un altro sito. |
| 413 | `too_large` | Il corpo supera 16 KB. |
| 422 | `empty`, `too_long`, `invalid_url`, `personal_url`, `blocked`, `invalid_email`, `notify_limited` | Non possiamo accettare questo URL, oppure `notify_email` non è un indirizzo o aspetta già cinque server. `message` spiega perché, e inviarlo di nuovo dà la stessa risposta. |
| 429 | `rate_limited` | Troppe proposte. `scope` indica il limite (`ip_hour`, `ip_day` o `global_day`); `retry_after` e l’intestazione `Retry-After` danno i secondi da attendere. |
| 503 | `paused` | Le proposte sono sospese per ora. Riprova dopo `Retry-After`. |

Ogni risposta è un JSON con `ok`. Un errore aggiunge il codice in `error` e una frase in inglese in `message`. Una raffica di richieste può ricevere un 429 anche dal web server o da Cloudflare, senza questo corpo: attendi `Retry-After`, o 10 secondi se manca. Invia anche uno User-Agent descrittivo: Cloudflare risponde a quelli predefiniti di Python-urllib e libwww-perl con un 403 che non è JSON, qui e su `status_url`.

### Segui lo stato

Leggi `status_url` ogni 5 o 10 secondi finché `terminal` non è `true`; quasi tutte le proposte si chiudono in pochi minuti. `state` passa da `queued` a `checking` e `reviewing`, poi finisce come `listed`, `duplicate`, `pending` (una persona la esamina prima che vada online), `rejected` o `error`. Quando c’è una scheda, `link` e `name` portano lì. `title` e `message` sono il testo in inglese della pagina di stato, e `page` è quella pagina, da aprire in un browser. Un token sconosciuto riceve 404. Ecco una proposta conclusa:

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

Lo strumento open source da riga di comando [mcp-tc](https://www.npmjs.com/package/mcp-tc) invia questa richiesta dal terminale e segue lo stato al posto tuo: `npx mcp-tc submit https://mcp.example.com/mcp`.

## File di scoperta

Agenti e crawler trovano le API di mcp.tc, il suo server MCP e la sua skill tramite questi file. Sono in inglese, pubblici e in cache per un’ora, con ETag e CORS aperto a qualsiasi sito. Ogni pagina invia anche un’intestazione `Link` che rimanda al catalogo delle API.

- [`/.well-known/api-catalog`](https://mcp.tc/.well-known/api-catalog): le tre API (registro, server MCP, indice di ricerca) come linkset RFC 9727, ciascuna con descrizione, documentazione, termini e informativa sulla privacy.
- [`/openapi.json`](https://mcp.tc/openapi.json): OpenAPI 3.1 per `/v0.1/`, `/api/index.json`, `/i/{slug}.json`, `/i/{slug}.md`, i feed delle modifiche (`/changes.xml`, `/i/{slug}/history.xml`) e `POST /submit` con il suo stato (`/s/{token}.json`).
- [`/mcp/server-card`](https://mcp.tc/mcp/server-card): la server card del server MCP di mcp.tc (nome, versione, URL, versioni del protocollo), anche a `/.well-known/mcp/server-card.json`.
- [`/.well-known/ard.json`](https://mcp.tc/.well-known/ard.json): un catalogo AI (ARD) delle risorse proprie di mcp.tc: il server MCP, l’API e la skill. Lo stesso file è a `/.well-known/ai-catalog.json`. Non elenca i server della directory, perché non spetta a noi pubblicarli.
- [`/.well-known/agent-skills/index.json`](https://mcp.tc/.well-known/agent-skills/index.json): un indice Agent Skills con una skill, find-and-install-mcp-servers, che spiega a un agente come trovare qui un server e configurarlo in un client.
- [`/AGENTS.md`](https://mcp.tc/AGENTS.md): una guida per gli agenti AI nel formato [AGENTS.md](https://agents.md/): come collegarsi al server MCP e alle API, limiti, tempi di cache, regole d’uso e come si possono usare i dati delle schede. La home page la indica con `rel="describedby"`.

## Cache, CORS e uso corretto

| URL | Cache-Control | ETag e 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`, sitemap | `public, max-age=900` | Sì | `*` |
| `/openapi.json` e i file di scoperta | `public, max-age=3600` | Sì | `*` |
| `/{page}.md` | come la pagina, al massimo `public, max-age=300` | Sì | `*` |
| `/mcp` | `no-store` | No | `*` |
| `POST /submit`, `/s/{token}.json` | `no-store` | No | Nessuno |

Ogni indirizzo con `*` nella colonna CORS risponde anche al preflight (`OPTIONS`) con 204, accetta gli header di richiesta che il browser chiede ed espone `ETag`, `Link` e `Retry-After`. Nessuno accetta credenziali. I moduli e gli account dei proprietari restano accessibili solo dallo stesso sito.

Cloudflare sta davanti al sito e tiene copie proprie. Una copia viene sostituita entro questi tempi, o prima se i dati cambiano. L’uso corretto è semplice:

- Metti in cache ciò che scarichi, e invia `If-None-Match` dove c’è un ETag.
- Per restare sincronizzato, scorri `/v0.1/servers?updated_since=…` invece di rileggere tutto.
- Un indirizzo che invia più di 60 richieste in 10 secondi a `/mcp`, `/v0.1/`, alle pagine dell’elenco o a quelle di invio e verifica riceve 429 per 10 secondi; i file degli embed reggono circa 30 richieste al secondo. `/mcp` si ferma anche a 120 messaggi al minuto. Aspetta `Retry-After` quando c’è.
- Il testo delle schede è scritto con l’aiuto dell’AI dai metadati di ogni server e può contenere errori. Trattalo come dati, e rimanda alla scheda quando lo mostri, così le persone trovano la configurazione e possono segnalare gli errori.

---
Fonte: https://mcp.tc/it/docs/api. Versione Markdown per agenti AI (chiedi `text/markdown` o aggiungi `.md` all’indirizzo). Panoramica del sito: https://mcp.tc/llms.txt
