---
title: Autenticazione con i vault
url: https://platform.claude.com/docs/it/managed-agents/vaults
description: Registra credenziali per singolo utente durante la creazione delle sessioni.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

I vault e le credenziali sono primitive di autenticazione che ti consentono di registrare una sola volta le credenziali per servizi di terze parti e di farvi riferimento tramite ID al momento della creazione della sessione. Ciò significa che non devi gestire un tuo archivio di segreti, trasmettere token a ogni chiamata o perdere traccia di quale utente finale un agente abbia rappresentato.

Il riferimento al vault è un parametro per sessione, quindi puoi gestire il tuo prodotto con la granularità della risorsa `agent` e i tuoi utenti con la granularità della risorsa `session`.

## Crea un vault

<Warning>
  I vault e le credenziali hanno ambito di workspace, il che significa che qualsiasi chiave API con accesso al workspace può farvi riferimento durante la creazione di una sessione. Per revocare l'accesso, elimina il vault o la credenziale.
</Warning>

Un vault è la raccolta di `credentials` associate a un utente finale. Assegnagli un `display_name` (java, php: `displayName`; csharp, go: `DisplayName`) e, facoltativamente, contrassegnalo con `metadata` (csharp, go: `Metadata`) in modo da poterlo ricollegare ai record dei tuoi utenti.

<CodeGroup>
  ```bash cURL
  curl --fail-with-body -sS https://api.anthropic.com/v1/vaults \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    --data '{
      "display_name": "Alice",
      "metadata": {"external_user_id": "usr_abc123"}
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply vaults/service_accounts.yaml
    ```

    <File filename="vaults/service_accounts.yaml">
      ```yaml
      # yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/vault.json
      display_name: Service accounts
      ```
    </File>

    [`ant apply`](https://platform.claude.com/docs/it/cli-sdks-libraries/cli/apply) crea il vault da `vaults/service_accounts.yaml`, ne stampa l'ID e lo registra in `claude-lock.json`. Per visualizzare il record del vault, esegui `ant beta:vaults retrieve`.
  </CodeGroupItem>

  ```python Python
  vault = client.beta.vaults.create(
      display_name="Alice",
      metadata={"external_user_id": "usr_abc123"},
  )
  print(vault.id)  # "vlt_01ABC..."
  ```

  ```typescript TypeScript
  const vault = await client.beta.vaults.create({
    display_name: "Alice",
    metadata: { external_user_id: "usr_abc123" }
  });
  console.log(vault.id); // "vlt_01ABC..."
  ```

  ```csharp C#
  var vault = await client.Beta.Vaults.Create(new()
  {
      DisplayName = "Alice",
      Metadata = new Dictionary<string, string> { ["external_user_id"] = "usr_abc123" },
  });
  Console.WriteLine(vault.ID); // "vlt_01ABC..."
  ```

  ```go Go
  vault, err := client.Beta.Vaults.New(ctx, anthropic.BetaVaultNewParams{
  	DisplayName: "Alice",
  	Metadata:    map[string]string{"external_user_id": "usr_abc123"},
  })
  if err != nil {
  	panic(err)
  }
  fmt.Println(vault.ID) // "vlt_01ABC..."
  ```

  ```java Java
  var vault = client.beta().vaults().create(VaultCreateParams.builder()
      .displayName("Alice")
      .metadata(VaultCreateParams.Metadata.builder()
          .putAdditionalProperty("external_user_id", JsonValue.from("usr_abc123"))
          .build())
      .build());
  IO.println(vault.id()); // "vlt_01ABC..."
  ```

  ```php PHP
  $vault = $client->beta->vaults->create(
      displayName: 'Alice',
      metadata: ['external_user_id' => 'usr_abc123'],
  );
  echo $vault->id . "\n"; // "vlt_01ABC..."
  ```

  ```ruby Ruby
  vault = client.beta.vaults.create(
    display_name: "Alice",
    metadata: {external_user_id: "usr_abc123"}
  )
  puts vault.id # "vlt_01ABC..."
  ```
</CodeGroup>

La risposta è il record completo del vault:

```json
{
  "type": "vault",
  "id": "vlt_01ABC...",
  "display_name": "Alice",
  "metadata": { "external_user_id": "usr_abc123" },
  "created_at": "2026-03-18T10:00:00Z",
  "updated_at": "2026-03-18T10:00:00Z",
  "archived_at": null
}
```

## Aggiungi una credenziale

Sono supportate due categorie di credenziali:

* **Credenziali MCP** (`mcp_oauth`, `static_bearer`): ogni credenziale è identificata da un `mcp_server_url` (java: `mcpServerUrl`; php: `mcpServerURL`; csharp: `McpServerUrl`; go: `MCPServerURL`). Quando l'agente si connette a un server a quell'URL durante l'esecuzione della sessione, il token viene iniettato automaticamente.
* **Variabili d'ambiente** (`environment_variable`): ogni credenziale è identificata da un `secret_name` (java, php: `secretName`; csharp, go: `SecretName`) (il nome della variabile d'ambiente) e memorizzata nella sandbox come segnaposto opaco. Quando l'agente avvia una richiesta in uscita, il segnaposto opaco viene sostituito con il segreto reale in fase di egress (uscita). L'agente non vede mai il valore del segreto. Usala per qualsiasi servizio che si autentica tramite una variabile d'ambiente, come CLI, SDK o chiamate API dirette.

I valori effettivi delle credenziali che fornisci (`token` (csharp, go: `Token`), `access_token` (java, php: `accessToken`; csharp, go: `AccessToken`), `refresh_token` (java, php: `refreshToken`; csharp, go: `RefreshToken`), `client_secret` (java, php: `clientSecret`; csharp, go: `ClientSecret`), `secret_value` (java, php: `secretValue`; csharp, go: `SecretValue`)) sono trattati come campi sensibili di sola scrittura e non vengono mai restituiti nelle risposte dell'API.

<Note>
  Le credenziali di tipo variabile d'ambiente (`environment_variable`) non sono ancora supportate con le [sandbox self-hosted](https://platform.claude.com/docs/it/managed-agents/self-hosted-sandboxes).
</Note>

Per ottenere lo stesso comportamento con una sandbox self-hosted, puoi eseguire un tuo proxy che sostituisca i valori segnaposto con i segreti reali in fase di egress.

<Tabs>
  <Tab title="MCP OAuth">
    Usa `mcp_oauth` quando il server MCP utilizza OAuth 2.0. Se fornisci un blocco `refresh` (csharp, go: `Refresh`), Anthropic aggiorna il token di accesso per tuo conto quando scade.

    Il campo `refresh.token_endpoint_auth.type` indica come autenticare la chiamata di refresh:

    * `none`: client pubblico
    * `client_secret_basic`: autenticazione HTTP Basic con il client secret
    * `client_secret_post`: client secret nel corpo della richiesta POST

    <CodeGroup>
      ```bash cURL
      curl --fail-with-body -sS "https://api.anthropic.com/v1/vaults/$VAULT_ID/credentials" \
        -H "x-api-key: $ANTHROPIC_API_KEY" \
        -H "anthropic-version: 2023-06-01" \
        -H "anthropic-beta: managed-agents-2026-04-01" \
        -H "content-type: application/json" \
        --data @- <<'EOF'
      {
        "display_name": "Alice's Slack",
        "auth": {
          "type": "mcp_oauth",
          "mcp_server_url": "https://mcp.slack.com/mcp",
          "access_token": "xoxp-...",
          "expires_at": "2099-12-31T23:59:59Z",
          "refresh": {
            "token_endpoint": "https://slack.com/api/oauth.v2.user.access",
            "client_id": "1234567890.0987654321",
            "scope": "channels:read chat:write",
            "refresh_token": "xoxe-1-...",
            "token_endpoint_auth": {"type": "client_secret_post", "client_secret": "abc123..."}
          }
        }
      }
      EOF
      ```

      ```bash CLI
      ant beta:vaults:credentials create \
        --vault-id "$VAULT_ID" \
        --display-name "Slack" <<'YAML'
      auth:
        type: mcp_oauth
        mcp_server_url: https://mcp.slack.com/mcp
        access_token: xoxp-...
        expires_at: "2099-12-31T23:59:59Z"
        refresh:
          token_endpoint: https://slack.com/api/oauth.v2.user.access
          client_id: "1234567890.0987654321"
          scope: channels:read chat:write
          refresh_token: xoxe-1-...
          token_endpoint_auth:
            type: client_secret_post
            client_secret: abc123...
      YAML
      ```

      ```python Python
      credential = client.beta.vaults.credentials.create(
          vault_id=vault.id,
          display_name="Alice's Slack",
          auth={
              "type": "mcp_oauth",
              "mcp_server_url": "https://mcp.slack.com/mcp",
              "access_token": "xoxp-...",
              "expires_at": "2099-12-31T23:59:59Z",
              "refresh": {
                  "token_endpoint": "https://slack.com/api/oauth.v2.user.access",
                  "client_id": "1234567890.0987654321",
                  "scope": "channels:read chat:write",
                  "refresh_token": "xoxe-1-...",
                  "token_endpoint_auth": {
                      "type": "client_secret_post",
                      "client_secret": "abc123...",
                  },
              },
          },
      )
      ```

      ```typescript TypeScript
      const credential = await client.beta.vaults.credentials.create(vault.id, {
        display_name: "Alice's Slack",
        auth: {
          type: "mcp_oauth",
          mcp_server_url: "https://mcp.slack.com/mcp",
          access_token: "xoxp-...",
          expires_at: "2099-12-31T23:59:59Z",
          refresh: {
            token_endpoint: "https://slack.com/api/oauth.v2.user.access",
            client_id: "1234567890.0987654321",
            scope: "channels:read chat:write",
            refresh_token: "xoxe-1-...",
            token_endpoint_auth: {
              type: "client_secret_post",
              client_secret: "abc123..."
            }
          }
        }
      });
      ```

      ```csharp C#
      var credential = await client.Beta.Vaults.Credentials.Create(vault.ID, new()
      {
          DisplayName = "Alice's Slack",
          Auth = new BetaManagedAgentsMcpOAuthCreateParams
          {
              Type = BetaManagedAgentsMcpOAuthCreateParamsType.McpOAuth,
              McpServerUrl = "https://mcp.slack.com/mcp",
              AccessToken = "xoxp-...",
              ExpiresAt = DateTimeOffset.Parse("2099-12-31T23:59:59Z"),
              Refresh = new()
              {
                  TokenEndpoint = "https://slack.com/api/oauth.v2.user.access",
                  ClientID = "1234567890.0987654321",
                  Scope = "channels:read chat:write",
                  RefreshToken = "xoxe-1-...",
                  TokenEndpointAuth = new BetaManagedAgentsTokenEndpointAuthPostParam
                  {
                      Type = BetaManagedAgentsTokenEndpointAuthPostParamType.ClientSecretPost,
                      ClientSecret = "abc123...",
                  },
              },
          },
      });
      ```

      ```go Go
      credential, err := client.Beta.Vaults.Credentials.New(ctx, vault.ID, anthropic.BetaVaultCredentialNewParams{
      	DisplayName: anthropic.String("Alice's Slack"),
      	Auth: anthropic.BetaVaultCredentialNewParamsAuthUnion{
      		OfMCPOAuth: &anthropic.BetaManagedAgentsMCPOAuthCreateParams{
      			Type:         anthropic.BetaManagedAgentsMCPOAuthCreateParamsTypeMCPOAuth,
      			MCPServerURL: "https://mcp.slack.com/mcp",
      			AccessToken:  "xoxp-...",
      			ExpiresAt:    anthropic.Time(time.Date(2099, time.December, 31, 23, 59, 59, 0, time.UTC)),
      			Refresh: anthropic.BetaManagedAgentsMCPOAuthRefreshParams{
      				TokenEndpoint: "https://slack.com/api/oauth.v2.user.access",
      				ClientID:      "1234567890.0987654321",
      				Scope:         anthropic.String("channels:read chat:write"),
      				RefreshToken:  "xoxe-1-...",
      				TokenEndpointAuth: anthropic.BetaManagedAgentsMCPOAuthRefreshParamsTokenEndpointAuthUnion{
      					OfClientSecretPost: &anthropic.BetaManagedAgentsTokenEndpointAuthPostParam{
      						Type:         anthropic.BetaManagedAgentsTokenEndpointAuthPostParamTypeClientSecretPost,
      						ClientSecret: "abc123...",
      					},
      				},
      			},
      		},
      	},
      })
      if err != nil {
      	panic(err)
      }
      ```

      ```java Java
      var credential = client.beta().vaults().credentials().create(vault.id(),
          CredentialCreateParams.builder()
              .displayName("Alice's Slack")
              .auth(BetaManagedAgentsMcpOAuthCreateParams.builder()
                  .type(BetaManagedAgentsMcpOAuthCreateParams.Type.MCP_OAUTH)
                  .mcpServerUrl("https://mcp.slack.com/mcp")
                  .accessToken("xoxp-...")
                  .expiresAt(OffsetDateTime.parse("2099-12-31T23:59:59Z"))
                  .refresh(BetaManagedAgentsMcpOAuthRefreshParams.builder()
                      .tokenEndpoint("https://slack.com/api/oauth.v2.user.access")
                      .clientId("1234567890.0987654321")
                      .scope("channels:read chat:write")
                      .refreshToken("xoxe-1-...")
                      .clientSecretPostTokenEndpointAuth("abc123...")
                      .build())
                  .build())
              .build());
      ```

      ```php PHP
      $credential = $client->beta->vaults->credentials->create(
          vaultID: $vault->id,
          displayName: "Alice's Slack",
          auth: ManagedAgentsMCPOAuthCreateParams::with(
              type: 'mcp_oauth',
              mcpServerURL: 'https://mcp.slack.com/mcp',
              accessToken: 'xoxp-...',
              expiresAt: new \DateTimeImmutable('2099-12-31T23:59:59Z'),
              refresh: ManagedAgentsMCPOAuthRefreshParams::with(
                  tokenEndpoint: 'https://slack.com/api/oauth.v2.user.access',
                  clientID: '1234567890.0987654321',
                  scope: 'channels:read chat:write',
                  refreshToken: 'xoxe-1-...',
                  tokenEndpointAuth: ManagedAgentsTokenEndpointAuthPostParam::with(
                      type: 'client_secret_post',
                      clientSecret: 'abc123...',
                  ),
              ),
          ),
      );
      ```

      ```ruby Ruby
      credential = client.beta.vaults.credentials.create(
        vault.id,
        display_name: "Alice's Slack",
        auth: {
          type: "mcp_oauth",
          mcp_server_url: "https://mcp.slack.com/mcp",
          access_token: "xoxp-...",
          expires_at: "2099-12-31T23:59:59Z",
          refresh: {
            token_endpoint: "https://slack.com/api/oauth.v2.user.access",
            client_id: "1234567890.0987654321",
            scope: "channels:read chat:write",
            refresh_token: "xoxe-1-...",
            token_endpoint_auth: {
              type: "client_secret_post",
              client_secret: "abc123..."
            }
          }
        }
      )
      ```
    </CodeGroup>

    Imposta `refresh.token_endpoint` (java, php: `refresh.tokenEndpoint`; csharp, go: `Refresh.TokenEndpoint`) sull'endpoint del token del flusso OAuth che ha emesso il "refresh token" (token di aggiornamento), perché Anthropic invia ogni richiesta di refresh a quell'URL e il campo non può essere modificato dopo la creazione della credenziale.
  </Tab>

  <Tab title="MCP static bearer">
    Usa `static_bearer` quando il server MCP accetta un bearer token fisso (chiave API, personal access token o simili). Non è necessario alcun flusso di refresh.

    <CodeGroup>
      ```bash cURL
      curl --fail-with-body -sS "https://api.anthropic.com/v1/vaults/$VAULT_ID/credentials" \
        -H "x-api-key: $ANTHROPIC_API_KEY" \
        -H "anthropic-version: 2023-06-01" \
        -H "anthropic-beta: managed-agents-2026-04-01" \
        -H "content-type: application/json" \
        --data @- <<'EOF'
      {
        "display_name": "Linear API key",
        "auth": {
          "type": "static_bearer",
          "mcp_server_url": "https://mcp.linear.app/mcp",
          "token": "lin_api_your_linear_key"
        }
      }
      EOF
      ```

      ```bash CLI
      ant beta:vaults:credentials create --vault-id "$VAULT_ID" <<'YAML'
      display_name: Linear API key
      auth:
        type: static_bearer
        mcp_server_url: https://mcp.linear.app/mcp
        token: lin_api_your_linear_key
      YAML
      ```

      ```python Python
      bearer_credential = client.beta.vaults.credentials.create(
          vault_id=vault.id,
          display_name="Linear API key",
          auth={
              "type": "static_bearer",
              "mcp_server_url": "https://mcp.linear.app/mcp",
              "token": "lin_api_your_linear_key",
          },
      )
      ```

      ```typescript TypeScript
      const bearerCredential = await client.beta.vaults.credentials.create(vault.id, {
        display_name: "Linear API key",
        auth: {
          type: "static_bearer",
          mcp_server_url: "https://mcp.linear.app/mcp",
          token: "lin_api_your_linear_key"
        }
      });
      ```

      ```csharp C#
      var bearerCredential = await client.Beta.Vaults.Credentials.Create(vault.ID, new()
      {
          DisplayName = "Linear API key",
          Auth = new BetaManagedAgentsStaticBearerCreateParams
          {
              Type = BetaManagedAgentsStaticBearerCreateParamsType.StaticBearer,
              McpServerUrl = "https://mcp.linear.app/mcp",
              Token = "lin_api_your_linear_key",
          },
      });
      ```

      ```go Go
      bearerCredential, err := client.Beta.Vaults.Credentials.New(ctx, vault.ID, anthropic.BetaVaultCredentialNewParams{
      	DisplayName: anthropic.String("Linear API key"),
      	Auth: anthropic.BetaVaultCredentialNewParamsAuthUnion{
      		OfStaticBearer: &anthropic.BetaManagedAgentsStaticBearerCreateParams{
      			Type:         anthropic.BetaManagedAgentsStaticBearerCreateParamsTypeStaticBearer,
      			MCPServerURL: "https://mcp.linear.app/mcp",
      			Token:        "lin_api_your_linear_key",
      		},
      	},
      })
      if err != nil {
      	panic(err)
      }
      _ = bearerCredential
      ```

      ```java Java
      var bearerCredential = client.beta().vaults().credentials().create(vault.id(),
          CredentialCreateParams.builder()
              .displayName("Linear API key")
              .auth(BetaManagedAgentsStaticBearerCreateParams.builder()
                  .type(BetaManagedAgentsStaticBearerCreateParams.Type.STATIC_BEARER)
                  .mcpServerUrl("https://mcp.linear.app/mcp")
                  .token("lin_api_your_linear_key")
                  .build())
              .build());
      ```

      ```php PHP
      $bearerCredential = $client->beta->vaults->credentials->create(
          vaultID: $vault->id,
          displayName: 'Linear API key',
          auth: ManagedAgentsStaticBearerCreateParams::with(
              type: 'static_bearer',
              mcpServerURL: 'https://mcp.linear.app/mcp',
              token: 'lin_api_your_linear_key',
          ),
      );
      ```

      ```ruby Ruby
      bearer_credential = client.beta.vaults.credentials.create(
        vault.id,
        display_name: "Linear API key",
        auth: {
          type: "static_bearer",
          mcp_server_url: "https://mcp.linear.app/mcp",
          token: "lin_api_your_linear_key"
        }
      )
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Variabile d'ambiente">
    Usa `environment_variable` per autenticarti a servizi esterni tramite una variabile d'ambiente, come CLI, SDK o chiamate API dirette. Le credenziali di tipo variabile d'ambiente funzionano per i client che inviano il valore del segreto alla lettera in una richiesta in uscita, quindi verifica i criteri di idoneità del client in questa scheda prima di configurarne una.

    L'array `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) in `networking` (csharp, go: `Networking`) controlla per quali host in uscita il segreto può essere sostituito. Usa `"type": "limited"` con un elenco specifico, oppure `"type": "unrestricted"` se il chiamante raggiunge domini che non puoi elencare in anticipo.

    Limitare i domini è fortemente consigliato per motivi di sicurezza e impedisce che la tua chiave venga mai condivisa con host non autorizzati.

    <Note>
      `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) in `networking` (csharp, go: `Networking`) su una credenziale del vault controlla quali richieste utilizzano il segreto, non quali richieste sono consentite. Affinché l'agente possa effettivamente raggiungere un dominio, questo deve essere consentito anche a [livello di ambiente](https://platform.claude.com/docs/it/managed-agents/environments). Entrambi i livelli devono includere il dominio (tramite networking `unrestricted` oppure elencando esplicitamente il dominio in `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`)) affinché una richiesta con sostituzione del segreto vada a buon fine.
    </Note>

    Il campo facoltativo `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) delimita dove viene sostituito il segreto; la semantica completa è descritta dopo l'esempio.

    <CodeGroup>
      ```bash cURL
      curl --fail-with-body -sS "https://api.anthropic.com/v1/vaults/$VAULT_ID/credentials" \
        -H "x-api-key: $ANTHROPIC_API_KEY" \
        -H "anthropic-version: 2023-06-01" \
        -H "anthropic-beta: managed-agents-2026-04-01" \
        -H "content-type: application/json" \
        --data @- <<'EOF'
      {
        "auth": {
          "type": "environment_variable",
          "secret_name": "NOTION_API_KEY",
          "secret_value": "ntn_your-secret-here",
          "networking": {
            "type": "limited",
            "allowed_hosts": ["api.notion.com"]
          },
          "injection_location": {"header": true}
        },
        "display_name": "Notion API key for sandbox"
      }
      EOF
      ```

      ```bash CLI
      ant beta:vaults:credentials create --vault-id "$VAULT_ID" <<'YAML'
      display_name: Notion API key for sandbox
      auth:
        type: environment_variable
        secret_name: NOTION_API_KEY
        secret_value: ntn_your-secret-here
        injection_location:
          header: true
        networking:
          type: limited
          allowed_hosts: [api.notion.com]
      YAML
      ```

      ```python Python
      env_credential = client.beta.vaults.credentials.create(
          vault_id=vault.id,
          display_name="Notion API key for sandbox",
          auth={
              "type": "environment_variable",
              "secret_name": "NOTION_API_KEY",
              "secret_value": "ntn_your-secret-here",
              "networking": {
                  "type": "limited",
                  "allowed_hosts": ["api.notion.com"],
              },
              "injection_location": {"header": True},
          },
      )
      if env_credential.auth.type == "environment_variable":
          location = env_credential.auth.injection_location
          print(
              f"header: {location.header}, body: {location.body}"
          )  # header: True, body: False
      ```

      ```typescript TypeScript
      const envVarCredential = await client.beta.vaults.credentials.create(vault.id, {
        display_name: "Notion API key for sandbox",
        auth: {
          type: "environment_variable",
          secret_name: "NOTION_API_KEY",
          secret_value: "ntn_your-secret-here",
          networking: {
            type: "limited",
            allowed_hosts: ["api.notion.com"]
          },
          injection_location: { header: true }
        }
      });
      if (envVarCredential.auth.type === "environment_variable") {
        console.log(envVarCredential.auth.injection_location); // { header: true, body: false }
      }
      ```

      ```csharp C#
      var envVarCredential = await client.Beta.Vaults.Credentials.Create(vault.ID, new()
      {
          DisplayName = "Notion API key for sandbox",
          Auth = new BetaManagedAgentsEnvironmentVariableCreateParams
          {
              Type = BetaManagedAgentsEnvironmentVariableCreateParamsType.EnvironmentVariable,
              SecretName = "NOTION_API_KEY",
              SecretValue = "ntn_your-secret-here",
              Networking = new BetaManagedAgentsLimitedCredentialNetworkingParams
              {
                  Type = BetaManagedAgentsLimitedCredentialNetworkingParamsType.Limited,
                  AllowedHosts = ["api.notion.com"],
              },
              InjectionLocation = new() { Header = true },
          },
      });
      if (envVarCredential.Auth.TryPickBetaManagedAgentsEnvironmentVariableAuthResponse(out var envVarAuth))
      {
          var injectionLocation = envVarAuth.InjectionLocation;
          Console.WriteLine($"Header: {injectionLocation.Header}, Body: {injectionLocation.Body}"); // "Header: True, Body: False"
      }
      ```

      ```go Go
      envVarCredential, err := client.Beta.Vaults.Credentials.New(ctx, vault.ID, anthropic.BetaVaultCredentialNewParams{
      	DisplayName: anthropic.String("Notion API key for sandbox"),
      	Auth: anthropic.BetaVaultCredentialNewParamsAuthUnion{
      		OfEnvironmentVariable: &anthropic.BetaManagedAgentsEnvironmentVariableCreateParams{
      			Type:        anthropic.BetaManagedAgentsEnvironmentVariableCreateParamsTypeEnvironmentVariable,
      			SecretName:  "NOTION_API_KEY",
      			SecretValue: "ntn_your-secret-here",
      			Networking: anthropic.BetaManagedAgentsCredentialNetworkingParamsUnion{
      				OfLimited: &anthropic.BetaManagedAgentsLimitedCredentialNetworkingParams{
      					Type:         anthropic.BetaManagedAgentsLimitedCredentialNetworkingParamsTypeLimited,
      					AllowedHosts: []string{"api.notion.com"},
      				},
      			},
      			InjectionLocation: anthropic.BetaManagedAgentsInjectionLocationParams{
      				Header: anthropic.Bool(true),
      			},
      		},
      	},
      })
      if err != nil {
      	panic(err)
      }
      if envVarAuth, ok := envVarCredential.Auth.AsAny().(anthropic.BetaManagedAgentsEnvironmentVariableAuthResponse); ok {
      	injectionLocation := envVarAuth.InjectionLocation
      	fmt.Printf("Header:%t Body:%t\n", injectionLocation.Header, injectionLocation.Body) // "Header:true Body:false"
      }
      ```

      ```java Java
      var envVarCredential = client.beta().vaults().credentials().create(vault.id(),
          CredentialCreateParams.builder()
              .displayName("Notion API key for sandbox")
              .auth(BetaManagedAgentsEnvironmentVariableCreateParams.builder()
                  .type(BetaManagedAgentsEnvironmentVariableCreateParams.Type.ENVIRONMENT_VARIABLE)
                  .secretName("NOTION_API_KEY")
                  .secretValue("ntn_your-secret-here")
                  .limitedNetworking(List.of("api.notion.com"))
                  .injectionLocation(BetaManagedAgentsInjectionLocationParams.builder()
                      .header(true)
                      .build())
                  .build())
              .build());
      envVarCredential.auth().environmentVariable().ifPresent(envVarAuth -> {
          var injectionLocation = envVarAuth.injectionLocation();
          IO.println("header=" + injectionLocation.header() + " body=" + injectionLocation.body()); // header=true body=false
      });
      ```

      ```php PHP
      $envVarCredential = $client->beta->vaults->credentials->create(
          vaultID: $vault->id,
          displayName: 'Notion API key for sandbox',
          auth: ManagedAgentsEnvironmentVariableCreateParams::with(
              type: ManagedAgentsEnvironmentVariableCreateParams\Type::ENVIRONMENT_VARIABLE,
              secretName: 'NOTION_API_KEY',
              secretValue: 'ntn_your-secret-here',
              networking: ManagedAgentsLimitedCredentialNetworkingParams::with(
                  type: ManagedAgentsLimitedCredentialNetworkingParams\Type::LIMITED,
                  allowedHosts: ['api.notion.com'],
              ),
              injectionLocation: ManagedAgentsInjectionLocationParams::with(header: true),
          ),
      );
      if ($envVarCredential->auth instanceof \Anthropic\Beta\Vaults\Credentials\ManagedAgentsEnvironmentVariableAuthResponse) {
          $injectionLocation = $envVarCredential->auth->injectionLocation;
          echo 'header: ' . json_encode($injectionLocation->header) . "\n"; // header: true
          echo 'body: ' . json_encode($injectionLocation->body) . "\n"; // body: false
      }
      ```

      ```ruby Ruby
      env_credential = client.beta.vaults.credentials.create(
        vault.id,
        display_name: "Notion API key for sandbox",
        auth: {
          type: "environment_variable",
          secret_name: "NOTION_API_KEY",
          secret_value: "ntn_your-secret-here",
          networking: {
            type: "limited",
            allowed_hosts: ["api.notion.com"]
          },
          injection_location: {header: true}
        }
      )
      if env_credential.auth.type == :environment_variable
        env_credential.auth.injection_location => {header:, body:}
        puts "header: #{header}, body: #{body}" # header: true, body: false
      end
      ```
    </CodeGroup>

    I payload delle richieste sono spesso assemblati a partire dai contenuti su cui l'agente sta lavorando, quindi il corpo della richiesta è la superficie di esposizione più ampia. La maggior parte dei servizi legge una chiave API da un header della richiesta, quindi abilitare solo `header` (csharp, go: `Header`) è la configurazione più restrittiva. Limita la sostituzione ai valori degli header della richiesta per quella credenziale.

    Il campo `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) della credenziale controlla in quali parti di una richiesta in uscita viene sostituito il segreto. È un oggetto facoltativo, allo stesso livello di `networking` (csharp, go: `Networking`), con due campi booleani: `header` (csharp, go: `Header`) (header della richiesta) e `body` (csharp, go: `Body`) (corpo della richiesta). `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) è indipendente da `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) in `networking` (csharp, go: `Networking`): `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) delimita per quali host viene sostituito il segreto, mentre `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) delimita in quali parti della richiesta viene sostituito.

    `injection_location` si comporta in modo diverso in fase di creazione e di aggiornamento:

    | Operazione                | Comportamento di `injection_location`                                                                                                                                                                                           |
    | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    | Creazione credenziale     | Se fornisci l'oggetto, qualsiasi campo omesso al suo interno assume il valore predefinito `false`: `{"header": true}` crea una credenziale solo header. Ometti completamente l'oggetto ed entrambe le posizioni sono abilitate. |
    | Aggiornamento credenziale | I campi vengono uniti singolarmente: `{"body": false}` disabilita la sostituzione nel corpo e lascia `header` invariato.                                                                                                        |

    Una credenziale deve avere almeno una posizione abilitata, quindi una creazione o un aggiornamento che disabiliterebbe entrambe le posizioni restituisce un errore 400. Anche passare un `null` esplicito per l'oggetto `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) o per uno dei due campi restituisce un errore 400 ("omit the field instead"). La risposta restituisce sempre entrambi i campi con i rispettivi valori risolti.

    Un segnaposto in una posizione disabilitata non viene né sostituito né rimosso. La richiesta viene inviata alla terza parte con la stringa letterale del segnaposto opaco in quella posizione. Se una richiesta arriva alla terza parte contenendo la stringa letterale del segnaposto, significa che quella posizione è disabilitata per la credenziale oppure che l'host di destinazione non è coperto da `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) nel campo `networking` (csharp, go: `Networking`) della credenziale.

    <Note>
      Le credenziali create nella Console abilitano solo l'iniezione negli header. Se il tuo client invia il segreto nel corpo della richiesta, ad esempio una richiesta di token con codifica form, il segnaposto passa alla lettera e il servizio lo rifiuta con il proprio errore di autenticazione. Abilita l'iniezione nel corpo nel modulo della Console quando crei la credenziale, oppure aggiorna la credenziale con `{"injection_location": {"body": true}}`.
    </Note>

    La sostituzione avviene in fase di egress, non all'interno della sandbox. Qualsiasi elemento che elabora la credenziale localmente vede il segnaposto opaco, non il valore reale: i client che convalidano il formato della credenziale all'avvio potrebbero rifiutarla, e i client che calcolano una firma della richiesta a partire dal segreto (ad esempio, AWS SigV4) producono una firma non valida. Le credenziali di tipo variabile d'ambiente funzionano per i client che inviano il valore del segreto alla lettera in una richiesta in uscita, in una posizione abilitata dal campo `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) della credenziale.

    La sostituzione avviene solo in uscita. Se un client usa il segreto memorizzato per ottenere un token di sessione (ad esempio, un grant OAuth client-credentials), il token restituito arriva nella sandbox non oscurato. Per i flussi basati su scambio, esegui tu stesso lo scambio e memorizza invece il token risultante nel vault.

    <Tip>
      Limita la chiave API alle sole autorizzazioni di cui l'agente ha bisogno. L'agente può fare tutto ciò che la chiave consente, quindi una chiave con autorizzazioni più ampie del necessario aumenta il raggio d'impatto se l'agente si comporta in modo inatteso.
    </Tip>
  </Tab>
</Tabs>

Le credenziali vengono memorizzate così come fornite e non vengono convalidate fino all'esecuzione della sessione. Una credenziale non valida si manifesta come errore di autenticazione o errore a valle durante la sessione, che viene emesso ma non impedisce alla sessione di continuare.

Vincoli:

* **Chiave univoca per vault.** `mcp_server_url` (java: `mcpServerUrl`; php: `mcpServerURL`; csharp: `McpServerUrl`; go: `MCPServerURL`) (credenziali MCP) e `secret_name` (java, php: `secretName`; csharp, go: `SecretName`) (credenziali di tipo variabile d'ambiente) devono essere univoci tra le credenziali attive in un vault. La creazione di un duplicato restituisce un 409.
* **Le chiavi sono immutabili.** Per modificare `mcp_server_url` (java: `mcpServerUrl`; php: `mcpServerURL`; csharp: `McpServerUrl`; go: `MCPServerURL`) o `secret_name` (java, php: `secretName`; csharp, go: `SecretName`), archivia la credenziale e creane una nuova.
* **Massimo 20 credenziali per vault.**

## Fai riferimento al vault alla creazione della sessione

Passa `vault_ids` (java: `vaultIds`; php: `vaultIDs`; csharp: `VaultIds`; go: `VaultIDs`) durante la creazione di una sessione:

<CodeGroup>
  ```bash cURL
  curl --fail-with-body -sS https://api.anthropic.com/v1/sessions \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    --data '{
      "agent": "'"$AGENT_ID"'",
      "environment_id": "'"$ENVIRONMENT_ID"'",
      "vault_ids": ["'"$VAULT_ID"'"],
      "title": "Slack digest for Alice"
    }'
  ```

  ```bash CLI
  ant beta:sessions create \
    --agent "$AGENT_ID" \
    --environment-id "$ENVIRONMENT_ID" \
    --vault-id "$VAULT_ID" \
    --title "Slack digest"
  ```

  ```python Python
  session = client.beta.sessions.create(
      agent=agent.id,
      environment_id=environment.id,
      vault_ids=[vault.id],
      title="Alice's Slack digest",
  )
  ```

  ```typescript TypeScript
  const session = await client.beta.sessions.create({
    agent: agent.id,
    environment_id: environment.id,
    vault_ids: [vault.id],
    title: "Alice's Slack digest"
  });
  ```

  ```csharp C#
  var session = await client.Beta.Sessions.Create(new()
  {
      Agent = agent.ID,
      EnvironmentID = environment.ID,
      VaultIds = [vault.ID],
      Title = "Alice's Slack digest",
  });
  ```

  ```go Go
  session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  	Agent: anthropic.BetaSessionNewParamsAgentUnion{
  		OfString: anthropic.String(agent.ID),
  	},
  	EnvironmentID: environment.ID,
  	VaultIDs:      []string{vault.ID},
  	Title:         anthropic.String("Alice's Slack digest"),
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  var session = client.beta().sessions().create(SessionCreateParams.builder()
      .agent(agent.id())
      .environmentId(environment.id())
      .vaultIds(List.of(vault.id()))
      .title("Alice's Slack digest")
      .build());
  ```

  ```php PHP
  $session = $client->beta->sessions->create(
      agent: $agent->id,
      environmentID: $environment->id,
      vaultIDs: [$vault->id],
      title: "Alice's Slack digest",
  );
  ```

  ```ruby Ruby
  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id,
    vault_ids: [vault.id],
    title: "Alice's Slack digest"
  )
  ```
</CodeGroup>

Comportamento in fase di esecuzione:

* Quando nessuna credenziale MCP corrisponde per `mcp_server_url` (java: `mcpServerUrl`; php: `mcpServerURL`; csharp: `McpServerUrl`; go: `MCPServerURL`), la connessione viene tentata senza autenticazione e genererà un errore se il server richiede l'autenticazione.
* Quando più vault contengono una credenziale corrispondente, prevale il primo vault con una corrispondenza.
* Nelle [sessioni multiagente](https://platform.claude.com/docs/it/managed-agents/multiagent-orchestration), le credenziali del vault si applicano a ogni thread. Un agente la cui definizione dichiara il server MCP corrispondente si autentica con queste credenziali. Consulta [Connettere gli agenti ai server MCP](https://platform.claude.com/docs/it/managed-agents/multiagent-orchestration#connect-agents-to-mcp-servers).

## Ruota una credenziale

I valori dei segreti, `display_name` (java, php: `displayName`; csharp, go: `DisplayName`) e (sulle credenziali di tipo variabile d'ambiente) `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) possono essere aggiornati. Gli aggiornamenti di `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) vengono uniti campo per campo, come descritto nella scheda Variabile d'ambiente di [Aggiungi una credenziale](https://platform.claude.com/docs/it/managed-agents/vaults#add-a-credential). Per una sessione in esecuzione, un aggiornamento di `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) si propaga allo stesso modo di una rotazione del segreto: le credenziali della sessione vengono risolte nuovamente senza riavvio, come descritto in [Ciclo di vita delle credenziali](https://platform.claude.com/docs/it/managed-agents/vaults#credential-lifecycle), e le posizioni aggiornate si applicano alle successive richieste in uscita della sessione. I campi strutturali (`mcp_server_url` (java: `mcpServerUrl`; php: `mcpServerURL`; csharp: `McpServerUrl`; go: `MCPServerURL`), `secret_name` (java, php: `secretName`; csharp, go: `SecretName`), `token_endpoint` (java, php: `tokenEndpoint`; csharp, go: `TokenEndpoint`), `client_id` (java: `clientId`; php: `clientID`; csharp, go: `ClientID`)) sono bloccati dopo la creazione. Per modificarli, archivia la credenziale e creane una nuova.

<CodeGroup>
  ```bash cURL
  curl --fail-with-body -sS \
    "https://api.anthropic.com/v1/vaults/$VAULT_ID/credentials/$CREDENTIAL_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d @- <<'EOF'
  {
    "auth": {
      "type": "mcp_oauth",
      "access_token": "xoxp-new-...",
      "expires_at": "2099-12-31T23:59:59Z",
      "refresh": {"refresh_token": "xoxe-1-new-..."}
    }
  }
  EOF
  ```

  ```bash CLI
  ant beta:vaults:credentials update \
    --vault-id "$VAULT_ID" \
    --credential-id "$CREDENTIAL_ID" <<'YAML'
  auth:
    type: mcp_oauth
    access_token: xoxp-new-...
    expires_at: "2099-12-31T23:59:59Z"
    refresh:
      refresh_token: xoxe-1-new-...
  YAML
  ```

  ```python Python
  client.beta.vaults.credentials.update(
      credential.id,
      vault_id=vault.id,
      auth={
          "type": "mcp_oauth",
          "access_token": "xoxp-new-...",
          "expires_at": "2099-12-31T23:59:59Z",
          "refresh": {"refresh_token": "xoxe-1-new-..."},
      },
  )
  ```

  ```typescript TypeScript
  await client.beta.vaults.credentials.update(credential.id, {
    vault_id: vault.id,
    auth: {
      type: "mcp_oauth",
      access_token: "xoxp-new-...",
      expires_at: "2099-12-31T23:59:59Z",
      refresh: {
        refresh_token: "xoxe-1-new-..."
      }
    }
  });
  ```

  ```csharp C#
  await client.Beta.Vaults.Credentials.Update(credential.ID, new()
  {
      VaultID = vault.ID,
      Auth = new BetaManagedAgentsMcpOAuthUpdateParams
      {
          Type = BetaManagedAgentsMcpOAuthUpdateParamsType.McpOAuth,
          AccessToken = "xoxp-new-...",
          ExpiresAt = DateTimeOffset.Parse("2099-12-31T23:59:59Z"),
          Refresh = new() { RefreshToken = "xoxe-1-new-..." },
      },
  });
  ```

  ```go Go
  _, err = client.Beta.Vaults.Credentials.Update(ctx, credential.ID, anthropic.BetaVaultCredentialUpdateParams{
  	VaultID: vault.ID,
  	Auth: anthropic.BetaVaultCredentialUpdateParamsAuthUnion{
  		OfMCPOAuth: &anthropic.BetaManagedAgentsMCPOAuthUpdateParams{
  			Type:        anthropic.BetaManagedAgentsMCPOAuthUpdateParamsTypeMCPOAuth,
  			AccessToken: anthropic.String("xoxp-new-..."),
  			ExpiresAt:   anthropic.Time(time.Date(2099, time.December, 31, 23, 59, 59, 0, time.UTC)),
  			Refresh: anthropic.BetaManagedAgentsMCPOAuthRefreshUpdateParams{
  				RefreshToken: anthropic.String("xoxe-1-new-..."),
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().vaults().credentials().update(credential.id(),
      CredentialUpdateParams.builder()
          .vaultId(vault.id())
          .auth(BetaManagedAgentsMcpOAuthUpdateParams.builder()
              .type(BetaManagedAgentsMcpOAuthUpdateParams.Type.MCP_OAUTH)
              .accessToken("xoxp-new-...")
              .expiresAt(OffsetDateTime.parse("2099-12-31T23:59:59Z"))
              .refresh(BetaManagedAgentsMcpOAuthRefreshUpdateParams.builder()
                  .refreshToken("xoxe-1-new-...")
                  .build())
              .build())
          .build());
  ```

  ```php PHP
  $client->beta->vaults->credentials->update(
      $credential->id,
      vaultID: $vault->id,
      auth: ManagedAgentsMCPOAuthUpdateParams::with(
          type: 'mcp_oauth',
          accessToken: 'xoxp-new-...',
          expiresAt: new \DateTimeImmutable('2099-12-31T23:59:59Z'),
          refresh: ManagedAgentsMCPOAuthRefreshUpdateParams::with(refreshToken: 'xoxe-1-new-...'),
      ),
  );
  ```

  ```ruby Ruby
  client.beta.vaults.credentials.update(
    credential.id,
    vault_id: vault.id,
    auth: {
      type: "mcp_oauth",
      access_token: "xoxp-new-...",
      expires_at: "2099-12-31T23:59:59Z",
      refresh: {refresh_token: "xoxe-1-new-..."}
    }
  )
  ```
</CodeGroup>

## Ciclo di vita delle credenziali

Le credenziali vengono risolte nuovamente a intervalli periodici, sia durante una sessione sia durante il ciclo di vita del vault. Ciò garantisce che la rotazione, l'archiviazione o l'eliminazione delle credenziali si propaghi alle sessioni in esecuzione senza riavvio.

Per ricevere una notifica se una credenziale viene archiviata, eliminata o non riesce ad aggiornarsi, puoi iscriverti ai [webhook](https://platform.claude.com/docs/it/managed-agents/webhooks) di vault e credenziali associati a tali cambiamenti del ciclo di vita.

| Evento                            | Attivazione                                                                                                                |
| --------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| `vault.archived`                  | Vault archiviato. Viene emesso anche un evento `vault_credential.archived` per ogni credenziale sottostante.               |
| `vault.deleted`                   | Vault eliminato. Viene emesso anche un evento `vault_credential.deleted` per ogni credenziale sottostante.                 |
| `vault_credential.archived`       | Credenziale archiviata, direttamente o come conseguenza dell'archiviazione del vault.                                      |
| `vault_credential.deleted`        | Credenziale eliminata, direttamente o come conseguenza dell'eliminazione del vault.                                        |
| `vault_credential.refresh_failed` | Una credenziale `mcp_oauth` non può essere aggiornata (refresh token non valido o errore irrecuperabile dal server OAuth). |

<Note>
  Questo è un elenco non esaustivo di webhook; consulta [Iscriversi ai webhook](https://platform.claude.com/docs/it/managed-agents/webhooks) per l'elenco completo.
</Note>

Per le credenziali `mcp_oauth`, la nuova risoluzione aggiorna anche il token di accesso se è scaduto. Se il refresh fallisce, viene emesso un evento `vault_credential.refresh_failed`.

### Diagnostica un errore di refresh OAuth

Per diagnosticare il motivo per cui un refresh non è riuscito, chiama `POST /v1/vaults/{vault_id}/credentials/{credential_id}/mcp_oauth_validate` (oppure `client.beta.vaults.credentials.mcp_oauth_validate(...)` (typescript: `client.beta.vaults.credentials.mcpOAuthValidate(...)`; csharp: `client.Beta.Vaults.Credentials.McpOAuthValidate(...)`; go: `client.Beta.Vaults.Credentials.MCPOAuthValidate(...)`; java: `client.beta().vaults().credentials().mcpOAuthValidate(...)`; php: `$client->beta->vaults->credentials->mcpOAuthValidate(...)`) nell'SDK). In questo modo puoi decidere come gestire l'errore; l'azione corretta dipende dal tipo di errore.

Il campo `status` (csharp, go: `Status`) di primo livello indica cosa fare successivamente:

* `valid`: il token funziona; nessuna azione necessaria.
* `invalid`: il grant non esiste più oppure il server OAuth ha rifiutato il refresh con un 4xx. Chiedi all'utente finale di autorizzare nuovamente.
* `unknown`: un errore transitorio (5xx, 429 o errore di rete). Attendi e riprova.

<CodeGroup>
  ```bash cURL
  curl --fail-with-body -sS -X POST \
    "https://api.anthropic.com/v1/vaults/$VAULT_ID/credentials/$CREDENTIAL_ID/mcp_oauth_validate?beta=true" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"
  ```

  ```bash CLI
  ant beta:vaults:credentials mcp-oauth-validate \
    --vault-id "$VAULT_ID" \
    --credential-id "$CREDENTIAL_ID"
  ```

  ```python Python
  validation = client.beta.vaults.credentials.mcp_oauth_validate(
      credential.id,
      vault_id=vault.id,
  )
  print(validation.status)  # "valid", "invalid", or "unknown"
  ```

  ```typescript TypeScript
  const validation = await client.beta.vaults.credentials.mcpOAuthValidate(credential.id, {
    vault_id: vault.id
  });
  console.log(validation.status); // "valid", "invalid", or "unknown"
  ```

  ```csharp C#
  var validation = await client.Beta.Vaults.Credentials.McpOAuthValidate(credential.ID, new()
  {
      VaultID = vault.ID,
  });
  Console.WriteLine(validation.Status.Raw()); // "valid", "invalid", or "unknown"
  ```

  ```go Go
  validation, err := client.Beta.Vaults.Credentials.MCPOAuthValidate(ctx, credential.ID, anthropic.BetaVaultCredentialMCPOAuthValidateParams{
  	VaultID: vault.ID,
  })
  if err != nil {
  	panic(err)
  }
  fmt.Println(validation.Status) // "valid", "invalid", or "unknown"
  ```

  ```java Java
  var validation = client.beta().vaults().credentials().mcpOAuthValidate(credential.id(),
      CredentialMcpOAuthValidateParams.builder()
          .vaultId(vault.id())
          .build());
  IO.println(validation.status()); // valid, invalid, or unknown
  ```

  ```php PHP
  $validation = $client->beta->vaults->credentials->mcpOAuthValidate(
      $credential->id,
      vaultID: $vault->id,
  );
  echo $validation->status . "\n"; // "valid", "invalid", or "unknown"
  ```

  ```ruby Ruby
  validation = client.beta.vaults.credentials.mcp_oauth_validate(
    credential.id,
    vault_id: vault.id
  )
  puts validation.status # :valid, :invalid, or :unknown
  ```
</CodeGroup>

La risposta è un oggetto `vault_credential_validation`. `mcp_probe` include il passaggio dell'handshake MCP fallito; `refresh` include l'esito del tentativo di refresh.

```json
{
  "type": "vault_credential_validation",
  "credential_id": "vcrd_01ABC...",
  "vault_id": "vlt_01XYZ...",
  "validated_at": "2026-04-29T17:12:00Z",
  "has_refresh_token": false,
  "status": "invalid",
  "mcp_probe": {
    "method": "initialize",
    "http_response": {
      "status_code": 401,
      "content_type": "application/json",
      "body": "{\"error\":\"invalid_token\"}",
      "body_truncated": false
    }
  },
  "refresh": {
    "status": "no_refresh_token",
    "http_response": null
  }
}
```

## Altre operazioni

* **Elencare vault o credenziali:** Paginato, dal più recente. I record archiviati sono esclusi per impostazione predefinita (passa `include_archived=true` per includerli).
* **Archiviare un vault:** `POST /v1/vaults/{id}/archive`. Si propaga a cascata a tutte le credenziali. I segreti vengono eliminati definitivamente; i record vengono conservati a fini di audit. Le sessioni future che fanno riferimento a questo vault falliscono; le sessioni in esecuzione continuano.
* **Archiviare una credenziale:** `POST /v1/vaults/{id}/credentials/{cred_id}/archive`. Elimina definitivamente il payload del segreto; la chiave della credenziale (`mcp_server_url` o `secret_name`) rimane visibile e viene liberata per una credenziale sostitutiva.
* **Eliminare un vault o una credenziale:** Eliminazione definitiva. Il record non viene conservato. Usa l'archiviazione se hai bisogno di una traccia di audit.