---
title: Túneis MCP
url: https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/overview
description: Conecte Claude com segurança a servidores MCP em execução na sua rede privada sem abrir portas de entrada ou expor serviços à internet pública.
---

Os túneis MCP permitem que você conecte Claude a servidores Model Context Protocol (MCP) que rodam dentro da sua rede privada. O tráfego flui por uma conexão exclusivamente de saída, então você não precisa abrir portas de entrada no firewall, expor serviços à internet pública ou adicionar os intervalos de IP da Anthropic à lista de permissões na sua origem.

<Note>
  Os túneis MCP estão em "research preview" (prévia de pesquisa). [Solicite acesso](https://claude.com/form/mcp-tunnels) para experimentá-los. Eles são fornecidos "no estado em que se encontram", sem qualquer compromisso de disponibilidade, suporte ou continuidade, e dependem de um provedor de rede terceirizado (Cloudflare) que não assume nenhum compromisso de disponibilidade para o transporte subjacente. A Anthropic pode modificar ou descontinuar os túneis MCP a qualquer momento.
</Note>

Para elegibilidade de Zero Data Retention e HIPAA BAA, consulte [API e retenção de dados](https://platform.claude.com/docs/pt-BR/manage-claude/api-and-data-retention#feature-eligibility).

## Como funciona

A [pilha do túnel](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/concepts#components) consiste em dois componentes que rodam dentro da sua rede:

* **[cloudflared](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/concepts#components):** o conector de túnel de código aberto da Cloudflare. Ele inicia conexões exclusivamente de saída para a [borda do túnel](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/concepts#components) e transporta tráfego criptografado da Anthropic para o seu proxy.
* **[Proxy](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/concepts#components):** o componente de roteamento da Anthropic. Ele encerra o [TLS interno](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/concepts#components), valida que os IPs upstream estão dentro de um intervalo permitido e roteia cada requisição para o [servidor MCP upstream](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/concepts#components) correto com base no nome do host.

Cada servidor MCP que você expõe recebe um nome de host sob o domínio do seu túnel (por exemplo, `docs.<your-tunnel-domain>`). Você anexa esses nomes de host a uma sessão de Managed Agent no Claude Console ou os passa para a Messages API por meio do [conector MCP](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-connector).

## Pré-requisitos

Antes de implantar, certifique-se de ter:

* Um destino de implantação: um cluster Kubernetes ou uma VM com Docker e Docker Compose.

* Um túnel. Crie um no Claude Console (consulte [Criar um túnel](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/console#create-a-tunnel)) ou por meio da API; o hook de configuração do Helm chart também pode criar um para você durante a instalação.

* Uma forma de sua pilha se autenticar na Tunnels API. Escolha uma:

  * **[Acesso programático](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/concepts#credential-provisioning) (recomendado).** Configure a [Workload Identity Federation](https://platform.claude.com/docs/pt-BR/manage-claude/workload-identity-federation) ao criar o túnel. Sua pilha gera tokens de API de curta duração a partir do seu provedor de identidade, busca o token do túnel e gera e registra um certificado CA automaticamente. Requer permissão para gerenciar regras de federação, um emissor OIDC registrado e uma regra de federação com o escopo `workspace:manage_tunnels`.
  * **[Manual](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/concepts#credential-provisioning).** Forneça credenciais estáticas você mesmo: o token do túnel do Console e um certificado de servidor assinado por uma CA que você registra lá. Consulte [Obter os detalhes da conexão](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/console#get-the-connection-details) e [Adicionar um certificado CA](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/console#add-a-ca-certificate).

* Um ou mais servidores MCP em execução na sua rede privada. Consulte [Servidores MCP remotos](https://platform.claude.com/docs/pt-BR/agents-and-tools/remote-mcp-servers) para exemplos.

* Conectividade de saída conforme listado em [Requisitos de rede](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/overview#network-requirements).

### Requisitos de rede

| Componente                 | Destino                                                 | Porta / protocolo    | Usado durante                       |
| -------------------------- | ------------------------------------------------------- | -------------------- | ----------------------------------- |
| Componente de configuração | `api.anthropic.com`                                     | 443 TCP              | Provisionamento e rotação de tokens |
| cloudflared                | Borda do túnel (`198.41.192.0/19`, `2606:4700:a0::/44`) | 7844 TCP e UDP       | Tempo de execução                   |
| Proxy                      | Seus servidores MCP upstream                            | Conforme configurado | Tempo de execução                   |

## Modelo de segurança

### Camadas de segurança

Três camadas independentes protegem cada requisição:

| Camada                                                                         | Protege contra                                                                    |
| ------------------------------------------------------------------------------ | --------------------------------------------------------------------------------- |
| mTLS externo entre a Anthropic e o provedor de transporte, com validação de IP | Clientes não autorizados alcançando o túnel                                       |
| TLS interno do back end da Anthropic até o seu proxy                           | Inspeção de payload pelo provedor de transporte ou qualquer intermediário de rede |
| OAuth em cada servidor MCP                                                     | Uso não autorizado de ferramentas MCP por tráfego de túnel autenticado            |

O transporte do túnel roda na rede da Cloudflare. Como o proxy encerra o TLS interno usando um certificado que somente você possui, a Cloudflare não consegue ler os payloads de requisição ou resposta. A Anthropic não se conecta a um túnel até que um certificado CA seja registrado, então os payloads estão sempre criptografados quando atravessam a rede da Cloudflare. A Cloudflare recebe metadados de conexão; consulte [O que o provedor de transporte pode observar](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/overview#what-the-transport-provider-can-observe).

### Modelo de responsabilidade compartilhada

| A Anthropic cuida de                                                                       | Sua organização cuida de                                                                                                                                     |
| ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Controle de acesso ao túnel                                                                | Todo o conteúdo e tráfego que transita pelo seu túnel, e conformidade com as políticas de uso aceitável de terceiros aplicáveis (incluindo as da Cloudflare) |
| Validar seu certificado CA antes de se conectar ao seu proxy                               | Aderência às orientações de implantação nestas páginas                                                                                                       |
| Garantir que Claude envie requisições apenas para túneis de propriedade da sua organização | Proteger os tokens de túnel e as chaves privadas TLS                                                                                                         |
|                                                                                            | Gerenciar o certificado de servidor e renová-lo antes que expire                                                                                             |
|                                                                                            | Configurar OAuth em cada servidor MCP                                                                                                                        |
|                                                                                            | Restringir o acesso de rede ao proxy e aos servidores MCP                                                                                                    |
|                                                                                            | Notificar a Anthropic se você suspeitar de uma violação                                                                                                      |

<Warning>
  Se um invasor obtiver seu token de túnel **e** uma de suas chaves privadas TLS, ele poderia se passar pelo seu proxy e ler os payloads de requisição MCP. Trate ambos como segredos de alto valor. Consulte [Segurança dos túneis MCP](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/security) para orientações de fortalecimento.
</Warning>

### O que o provedor de transporte pode observar

A Cloudflare fornece o transporte de saída. Ela não consegue ler os payloads de requisição ou resposta MCP, mas recebe os seguintes metadados de conexão:

* o endereço IP de saída do host que executa o cloudflared
* uma impressão digital do host cloudflared
* tempo de conexão e volume de bytes
* o subdomínio `*.tunnel.anthropic.com` atribuído ao seu túnel

O acordo da Anthropic com a Cloudflare restringe o uso dessa telemetria pela Cloudflare. A Cloudflare atua como subprocessador para este research preview.

## Implantar um túnel

Se você é novo nos túneis MCP, comece pelo quickstart para obter um túnel funcional localmente antes de configurar uma implantação de produção.

<CardGroup cols={2}>
  <Card title="Quickstart" icon="rocket" href="https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/quickstart">
    O caminho mais curto para um túnel funcional: Docker Compose com um servidor MCP de exemplo.
  </Card>

  <Card title="Implantar com Helm" icon="stack" href="https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/deploy-helm">
    Instale em um cluster Kubernetes usando o Helm chart da Anthropic.
  </Card>

  <Card title="Implantar com Docker Compose" icon="cube" href="https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/deploy-compose">
    Instale em uma VM usando Docker Compose.
  </Card>
</CardGroup>

Escolhendo entre eles:

* **Destino de implantação**

  * **Helm** ao implantar no Kubernetes.
  * **Docker Compose** para um único host ou testes locais.

* **Autenticação para configuração**

  * **Acesso programático** (por meio da Workload Identity Federation) quando você tem um provedor de identidade OIDC, como um cluster Kubernetes, IAM de nuvem ou SPIFFE.
  * **Credenciais manuais** quando você não tem, ou quando está testando.

## Usar os servidores MCP tunelados

Assim que seu túnel estiver ativo (ele tem um certificado CA ativo e sua pilha de túnel está conectada), os servidores MCP upstream ficam acessíveis a partir dos Claude Managed Agents e da Messages API.

<Note>
  Túneis criados por meio do Console não estão disponíveis como conectores no claude.ai.
</Note>

Em ambos os casos, o túnel transporta tráfego criptografado para o seu servidor MCP, mas não se autentica nele. Se o servidor MCP upstream exigir sua própria autenticação (OAuth, bearer token), forneça-a da mesma forma que faria para qualquer outro servidor MCP; ela é independente do túnel.

### Managed Agents (Console)

1. Na página [Sessions](https://platform.claude.com/sessions) (`platform.claude.com/sessions`) do Claude Console, crie uma sessão e escolha **Create new agent** para poder editar a lista de servidores MCP.
2. Clique em **+ MCP Server** e abra o menu suspenso. Túneis no workspace da sessão que tenham pelo menos um certificado ativo aparecem no topo da lista, acima do catálogo de conectores públicos.
3. Selecione o túnel e forneça o **Subdomain** que seu proxy roteia para um servidor MCP específico, e o **Path** que o servidor MCP upstream espera. A linha **Resolves to** mostra a URL exata.

### Messages API

Passe a URL do servidor MCP upstream no array `mcp_servers`, da mesma forma que qualquer outro servidor MCP remoto. O corpo da requisição e o cabeçalho `anthropic-beta` seguem o formato padrão do [conector MCP](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-connector); apenas a `url` é específica do túnel. O exemplo a seguir usa o cabeçalho beta `mcp-client` do conector MCP, que é separado do beta `mcp-tunnels` usado pela [Tunnels API](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/reference). Faça a requisição no workspace em que o túnel foi criado usando uma chave de API para esse workspace ou, se sua chave tiver acesso a múltiplos workspaces, definindo o [cabeçalho `anthropic-workspace-id`](https://platform.claude.com/docs/pt-BR/manage-claude/authentication#select-a-workspace) para esse workspace.

O host da URL é `<subdomain>.<your-tunnel-domain>`. O caminho depende do seu servidor MCP upstream, não do túnel: o transporte `streamable-http` do FastMCP serve em `/mcp`, e outros servidores podem usar `/` ou um caminho personalizado (verifique a documentação do servidor). O proxy encaminha o caminho sem alterações.

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

Para autenticar no servidor MCP upstream (`authorization_token`) e outras opções de `mcp_servers`, consulte [conector MCP](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-connector).

## Próximos passos

<CardGroup cols={2}>
  <Card title="Segurança" icon="lock" href="https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/security">
    Orientações de fortalecimento, rotação de credenciais e resposta a violações.
  </Card>

  <Card title="Solução de problemas" icon="wrench" href="https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/troubleshooting">
    Diagnostique problemas de conectividade, TLS e roteamento.
  </Card>

  <Card title="Referência" icon="book" href="https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/reference">
    Campos de configuração do proxy, a Tunnels API, requisitos de certificado e o componente de configuração.
  </Card>

  <Card title="Conector MCP" icon="link" href="https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-connector">
    Use servidores tunelados a partir da Messages API.
  </Card>
</CardGroup>