---
title: Tunnel MCP
url: https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/overview
description: Connetti in modo sicuro Claude ai server MCP in esecuzione nella tua rete privata senza aprire porte in ingresso o esporre servizi alla rete internet pubblica.
---

I tunnel MCP ti consentono di connettere Claude ai server Model Context Protocol (MCP) in esecuzione all'interno della tua rete privata. Il traffico scorre su una connessione solo in uscita, quindi non devi aprire porte del firewall in ingresso, esporre servizi alla rete internet pubblica o inserire in allowlist gli intervalli IP di Anthropic sulla tua origine.

<Note>
  I tunnel MCP sono in "research preview" (anteprima di ricerca). [Richiedi l'accesso](https://claude.com/form/mcp-tunnels) per provarli. Sono forniti "così come sono", senza alcun impegno in termini di uptime, supporto o continuità, e dipendono da un fornitore di rete di terze parti (Cloudflare) che non assume alcun impegno di disponibilità per il trasporto sottostante. Anthropic può modificare o interrompere i tunnel MCP in qualsiasi momento.
</Note>

Per l'idoneità a Zero Data Retention e HIPAA BAA, consulta [API e conservazione dei dati](https://platform.claude.com/docs/it/manage-claude/api-and-data-retention#feature-eligibility).

## Come funziona

Lo [stack del tunnel](https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/concepts#components) è costituito da due componenti che vengono eseguiti all'interno della tua rete:

* **[cloudflared](https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/concepts#components):** il connettore tunnel open-source di Cloudflare. Avvia connessioni solo in uscita verso il [tunnel edge](https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/concepts#components) (perimetro del tunnel) e trasporta il traffico crittografato da Anthropic al tuo proxy.
* **[Proxy](https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/concepts#components):** il componente di instradamento di Anthropic. Termina il [TLS interno](https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/concepts#components) (inner TLS), verifica che gli IP upstream rientrino in un intervallo consentito e instrada ogni richiesta al corretto [server MCP upstream](https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/concepts#components) in base al nome host.

Ogni server MCP che esponi ottiene un nome host sotto il dominio del tuo tunnel (ad esempio, `docs.<your-tunnel-domain>`). Puoi associare questi nomi host a una sessione Managed Agent nella Claude Console, oppure passarli alla Messages API tramite il [connettore MCP](https://platform.claude.com/docs/it/agents-and-tools/mcp-connector).

## Prerequisiti

Prima del deployment, assicurati di avere:

* Una destinazione di deployment: un cluster Kubernetes, oppure una VM con Docker e Docker Compose.

* Un tunnel. Creane uno nella Claude Console (vedi [Crea un tunnel](https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/console#create-a-tunnel)) o tramite l'API; anche l'hook di setup del chart Helm può crearne uno per te durante l'installazione.

* Un modo per consentire al tuo stack di autenticarsi alla Tunnels API. Scegli una delle opzioni:

  * **[Accesso programmatico](https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/concepts#credential-provisioning) (consigliato).** Configura la [Workload Identity Federation](https://platform.claude.com/docs/it/manage-claude/workload-identity-federation) quando crei il tunnel. Il tuo stack emette token API a breve durata dal tuo identity provider, recupera il token del tunnel e genera e registra automaticamente un certificato CA. Richiede il permesso di gestire le regole di federazione, un issuer OIDC registrato e una regola di federazione con lo scope `workspace:manage_tunnels`.
  * **[Manuale](https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/concepts#credential-provisioning).** Fornisci tu stesso le credenziali statiche: il token del tunnel dalla Console e un certificato server firmato da una CA che registri lì. Vedi [Ottieni i dettagli di connessione](https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/console#get-the-connection-details) e [Aggiungi un certificato CA](https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/console#add-a-ca-certificate).

* Uno o più server MCP in esecuzione nella tua rete privata. Vedi [Server MCP remoti](https://platform.claude.com/docs/it/agents-and-tools/remote-mcp-servers) per esempi.

* Connettività in uscita come elencato in [Requisiti di rete](https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/overview#network-requirements).

### Requisiti di rete

| Componente          | Destinazione                                         | Porta / protocollo | Utilizzato durante                 |
| ------------------- | ---------------------------------------------------- | ------------------ | ---------------------------------- |
| Componente di setup | `api.anthropic.com`                                  | 443 TCP            | Provisioning e rotazione dei token |
| cloudflared         | Tunnel edge (`198.41.192.0/19`, `2606:4700:a0::/44`) | 7844 TCP e UDP     | Runtime                            |
| Proxy               | I tuoi server MCP upstream                           | Come configurato   | Runtime                            |

## Modello di sicurezza

### Livelli di sicurezza

Tre livelli indipendenti proteggono ogni richiesta:

| Livello                                                                   | Protegge da                                                                                   |
| ------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| mTLS esterno tra Anthropic e il provider di trasporto, con validazione IP | Client non autorizzati che raggiungono il tunnel                                              |
| TLS interno dal back end di Anthropic al tuo proxy                        | Ispezione del payload da parte del provider di trasporto o di qualsiasi intermediario di rete |
| OAuth su ogni server MCP                                                  | Uso non autorizzato degli strumenti MCP da parte di traffico del tunnel autenticato           |

Il trasporto del tunnel viene eseguito sulla rete di Cloudflare. Poiché il proxy termina il TLS interno utilizzando un certificato che solo tu possiedi, Cloudflare non può leggere i payload delle richieste o delle risposte. Anthropic non si connette a un tunnel finché non viene registrato un certificato CA, quindi i payload sono sempre crittografati quando attraversano la rete di Cloudflare. Cloudflare riceve comunque i metadati di connessione; vedi [Cosa può osservare il provider di trasporto](https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/overview#what-the-transport-provider-can-observe).

### Modello di responsabilità condivisa

| Anthropic gestisce                                                                      | La tua organizzazione gestisce                                                                                                                                          |
| --------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Controllo degli accessi al tunnel                                                       | Tutti i contenuti e il traffico che transitano nel tuo tunnel, e la conformità alle policy di uso accettabile di terze parti applicabili (incluse quelle di Cloudflare) |
| Validazione del tuo certificato CA prima della connessione al tuo proxy                 | Aderenza alle indicazioni di deployment riportate in queste pagine                                                                                                      |
| Garanzia che Claude invii richieste solo a tunnel di proprietà della tua organizzazione | Protezione dei token del tunnel e delle chiavi private TLS                                                                                                              |
|                                                                                         | Gestione del certificato server e suo rinnovo prima della scadenza                                                                                                      |
|                                                                                         | Configurazione di OAuth su ogni server MCP                                                                                                                              |
|                                                                                         | Limitazione dell'accesso di rete per il proxy e i server MCP                                                                                                            |
|                                                                                         | Notifica ad Anthropic in caso di sospetta violazione                                                                                                                    |

<Warning>
  Se un attaccante ottiene il tuo token del tunnel **e** una delle tue chiavi private TLS, potrebbe impersonare il tuo proxy e leggere i payload delle richieste MCP. Tratta entrambi come segreti di alto valore. Consulta [Sicurezza dei tunnel MCP](https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/security) per indicazioni di hardening.
</Warning>

### Cosa può osservare il provider di trasporto

Cloudflare fornisce il trasporto in uscita. Non può leggere i payload delle richieste o delle risposte MCP, ma riceve i seguenti metadati di connessione:

* l'indirizzo IP di egress dell'host che esegue cloudflared
* un fingerprint dell'host cloudflared
* tempistiche di connessione e volume di byte
* il sottodominio `*.tunnel.anthropic.com` assegnato al tuo tunnel

L'accordo di Anthropic con Cloudflare limita l'uso di questa telemetria da parte di Cloudflare. Cloudflare agisce come sub-responsabile del trattamento per questa research preview.

## Esegui il deployment di un tunnel

Se sei nuovo ai tunnel MCP, inizia con il quickstart per ottenere un tunnel funzionante in locale prima di configurare un deployment di produzione.

<CardGroup cols={2}>
  <Card title="Quickstart" icon="rocket" href="https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/quickstart">
    Il percorso più breve verso un tunnel funzionante: Docker Compose con un server MCP di esempio.
  </Card>

  <Card title="Deployment con Helm" icon="stack" href="https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/deploy-helm">
    Installa su un cluster Kubernetes utilizzando il chart Helm di Anthropic.
  </Card>

  <Card title="Deployment con Docker Compose" icon="cube" href="https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/deploy-compose">
    Installa su una VM utilizzando Docker Compose.
  </Card>
</CardGroup>

Come scegliere tra le opzioni:

* **Destinazione di deployment**

  * **Helm** per il deployment su Kubernetes.
  * **Docker Compose** per un singolo host o per test in locale.

* **Autenticazione per il setup**

  * **Accesso programmatico** (tramite Workload Identity Federation) quando disponi di un identity provider OIDC come un cluster Kubernetes, un IAM cloud o SPIFFE.
  * **Credenziali manuali** quando non ne disponi, o quando stai effettuando test.

## Usa i server MCP in tunnel

Una volta che il tuo tunnel è attivo (ha un certificato CA attivo e il tuo stack del tunnel è connesso), i server MCP upstream sono raggiungibili da Claude Managed Agents e dalla Messages API.

<Note>
  I tunnel MCP creati tramite la Console non sono disponibili come connettori in claude.ai.
</Note>

In entrambi i casi, il tunnel trasporta traffico crittografato verso il tuo server MCP ma non si autentica presso di esso. Se il server MCP upstream richiede una propria autenticazione (OAuth, bearer token), forniscila nello stesso modo in cui lo faresti per qualsiasi altro server MCP; è indipendente dal tunnel.

### Managed Agents (Console)

1. Nella pagina [Sessions](https://platform.claude.com/sessions) (`platform.claude.com/sessions`) della Claude Console, crea una sessione e scegli **Create new agent** in modo da poter modificare l'elenco dei server MCP.
2. Fai clic su **+ MCP Server** e apri il menu a discesa. I tunnel nel workspace della sessione che hanno almeno un certificato attivo appaiono in cima all'elenco, sopra il catalogo pubblico dei connettori.
3. Seleziona il tunnel e fornisci il **Subdomain** che il tuo proxy instrada verso uno specifico server MCP, e il **Path** che il server MCP upstream si aspetta. La riga **Resolves to** mostra l'URL esatto.

### Messages API

Passa l'URL del server MCP upstream nell'array `mcp_servers`, nello stesso modo di qualsiasi altro server MCP remoto. Il corpo della richiesta e l'header `anthropic-beta` seguono il formato standard del [connettore MCP](https://platform.claude.com/docs/it/agents-and-tools/mcp-connector); solo l'`url` è specifico del tunnel. L'esempio seguente usa l'header beta `mcp-client` del connettore MCP, che è distinto dalla beta `mcp-tunnels` usata dalla [Tunnels API](https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/reference). Esegui la richiesta nel workspace in cui è stato creato il tunnel usando una chiave API per quel workspace oppure, se la tua chiave ha accesso a più workspace, impostando l'[header `anthropic-workspace-id`](https://platform.claude.com/docs/it/manage-claude/authentication#select-a-workspace) su quel workspace.

L'host dell'URL è `<subdomain>.<your-tunnel-domain>`. Il percorso dipende dal tuo server MCP upstream, non dal tunnel: il trasporto `streamable-http` di FastMCP risponde su `/mcp`, mentre altri server possono usare `/` o un percorso personalizzato (consulta la documentazione del server). Il proxy inoltra il percorso senza modificarlo.

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "Content-Type: application/json" \
    -H "X-API-Key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: mcp-client-2025-11-20" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 1000,
      "messages": [{"role": "user", "content": "Use the hello tool to greet tunnel."}],
      "mcp_servers": [
        {
          "type": "url",
          "url": "https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp",
          "name": "echo"
        }
      ],
      "tools": [{"type": "mcp_toolset", "mcp_server_name": "echo"}]
    }'
  ```

  ```bash CLI
  ant beta:messages create --beta mcp-client-2025-11-20 <<'YAML'
  model: claude-opus-5-5
  max_tokens: 1000
  messages:
    - role: user
      content: Use the hello tool to greet tunnel.
  mcp_servers:
    - type: url
      url: https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp
      name: echo
  tools:
    - type: mcp_toolset
      mcp_server_name: echo
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.beta.messages.create(
      model="claude-opus-5-5",
      max_tokens=1000,
      messages=[{"role": "user", "content": "Use the hello tool to greet tunnel."}],
      mcp_servers=[
          {
              "type": "url",
              "url": "https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp",
              "name": "echo",
          }
      ],
      tools=[{"type": "mcp_toolset", "mcp_server_name": "echo"}],
      betas=["mcp-client-2025-11-20"],
  )

  print(response)
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic();

  const response = await anthropic.beta.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1000,
    messages: [
      {
        role: "user",
        content: "Use the hello tool to greet tunnel."
      }
    ],
    mcp_servers: [
      {
        type: "url",
        url: "https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp",
        name: "echo"
      }
    ],
    tools: [
      {
        type: "mcp_toolset",
        mcp_server_name: "echo"
      }
    ],
    betas: ["mcp-client-2025-11-20"]
  });

  console.log(response);
  ```

  ```csharp C#
  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      MaxTokens = 1000,
      Messages = new List<BetaMessageParam>
      {
          new() { Role = Role.User, Content = "Use the hello tool to greet tunnel." }
      },
      McpServers = new List<BetaRequestMcpServerUrlDefinition>
      {
          new()
          {
              Url = "https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp",
              Name = "echo"
          }
      },
      Tools = new List<BetaToolUnion>
      {
          new BetaMcpToolset("echo")
      },
      Betas = ["mcp-client-2025-11-20"]
  };

  var message = await client.Beta.Messages.Create(parameters);
  Console.WriteLine(message);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 1000,
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Use the hello tool to greet tunnel.")),
  	},
  	MCPServers: []anthropic.BetaRequestMCPServerURLDefinitionParam{
  		{
  			URL:  "https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp",
  			Name: "echo",
  		},
  	},
  	Tools: []anthropic.BetaToolUnionParam{
  		{OfMCPToolset: &anthropic.BetaMCPToolsetParam{
  			MCPServerName: "echo",
  		}},
  	},
  	Betas: []anthropic.AnthropicBeta{
  		anthropic.AnthropicBetaMCPClient2025_11_20,
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  import com.anthropic.models.beta.messages.BetaMcpToolset;
  // ...
  import com.anthropic.models.beta.messages.BetaRequestMcpServerUrlDefinition;
  // ...

  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(1000L)
          .addUserMessage("Use the hello tool to greet tunnel.")
          .addMcpServer(BetaRequestMcpServerUrlDefinition.builder()
              .url("https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp")
              .name("echo")
              .build())
          .addTool(BetaMcpToolset.builder()
              .mcpServerName("echo")
              .build())
          .addBeta("mcp-client-2025-11-20")
          .build();

      BetaMessage response = client.beta().messages().create(params);
      IO.println(response);
  }
  ```

  ```php PHP
  $client = new Client();

  $message = $client->beta->messages->create(
      maxTokens: 1000,
      messages: [
          ['role' => 'user', 'content' => 'Use the hello tool to greet tunnel.']
      ],
      model: 'claude-opus-5-5',
      mcpServers: [
          [
              'type' => 'url',
              'url' => 'https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp',
              'name' => 'echo',
          ],
      ],
      tools: [
          [
              'type' => 'mcp_toolset',
              'mcpServerName' => 'echo',
          ],
      ],
      betas: ['mcp-client-2025-11-20'],
  );

  echo $message;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 1000,
    messages: [
      { role: "user", content: "Use the hello tool to greet tunnel." }
    ],
    mcp_servers: [
      {
        type: "url",
        url: "https://echo.YOUR_TUNNEL_DOMAIN_HERE/mcp",
        name: "echo"
      }
    ],
    tools: [
      {
        type: "mcp_toolset",
        mcp_server_name: "echo"
      }
    ],
    betas: ["mcp-client-2025-11-20"]
  )

  puts response
  ```
</CodeGroup>

Per l'autenticazione al server MCP upstream (`authorization_token`) e le altre opzioni di `mcp_servers`, consulta [Connettore MCP](https://platform.claude.com/docs/it/agents-and-tools/mcp-connector).

## Passaggi successivi

<CardGroup cols={2}>
  <Card title="Sicurezza" icon="lock" href="https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/security">
    Indicazioni di hardening, rotazione delle credenziali e risposta alle violazioni.
  </Card>

  <Card title="Risoluzione dei problemi" icon="wrench" href="https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/troubleshooting">
    Diagnostica problemi di connettività, TLS e instradamento.
  </Card>

  <Card title="Riferimento" icon="book" href="https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/reference">
    Campi di configurazione del proxy, la Tunnels API, requisiti dei certificati e il componente di setup.
  </Card>

  <Card title="Connettore MCP" icon="link" href="https://platform.claude.com/docs/it/agents-and-tools/mcp-connector">
    Usa i server in tunnel dalla Messages API.
  </Card>
</CardGroup>