---
title: ボールトによる認証
url: https://platform.claude.com/docs/ja/managed-agents/vaults
description: セッション作成時にユーザーごとの認証情報を登録します。
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

ボールト（vault）と認証情報（credential）は、サードパーティサービスの認証情報を一度登録しておき、セッション作成時にIDで参照できるようにする認証プリミティブです。これにより、独自のシークレットストアを運用したり、呼び出しごとにトークンを送信したり、エージェントがどのエンドユーザーの代理として動作したかを見失ったりする必要がなくなります。

ボールトの参照はセッションごとのパラメータであるため、プロダクトは `agent` リソースの粒度で、ユーザーは `session` リソースの粒度で管理できます。

## ボールトを作成する

<Warning>
  ボールトと認証情報はワークスペーススコープです。つまり、ワークスペースへのアクセス権を持つAPIキーであれば、セッション作成時にそれらを参照できます。アクセスを取り消すには、ボールトまたは認証情報を削除してください。
</Warning>

ボールトは、エンドユーザーに関連付けられた `credentials` のコレクションです。`display_name` (java, php: `displayName`; csharp, go: `DisplayName`) を付け、必要に応じて `metadata` (csharp, go: `Metadata`) でタグ付けすることで、自社のユーザーレコードに対応付けられるようにします。

<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/ja/cli-sdks-libraries/cli/apply)は`vaults/service_accounts.yaml`からボールトを作成し、そのIDを出力して`claude-lock.json`に記録します。ボールトレコードを確認するには、`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>

レスポンスは完全なボールトレコードです。

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

## 認証情報を追加する

2つの認証情報カテゴリがサポートされています。

* **MCP認証情報**（`mcp_oauth`、`static_bearer`）：各認証情報は `mcp_server_url` (java: `mcpServerUrl`; php: `mcpServerURL`; csharp: `McpServerUrl`; go: `MCPServerURL`) をキーとします。セッション実行時にエージェントがそのURLのサーバーに接続すると、トークンが自動的に注入されます。
* **環境変数**（`environment_variable`）：各認証情報は `secret_name` (java, php: `secretName`; csharp, go: `SecretName`)（環境変数名）をキーとし、サンドボックス内には不透明なプレースホルダーとして保存されます。エージェントがアウトバウンドリクエストを開始すると、不透明なプレースホルダーはエグレス時に実際のシークレットに置き換えられます。エージェントがシークレットの値を目にすることはありません。CLI、SDK、直接のAPI呼び出しなど、環境変数を通じて認証するあらゆるサービスにこれを使用してください。

指定する実際の認証情報の値（`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`)）は機密性の高い書き込み専用フィールドとして扱われ、APIレスポンスで返されることはありません。

<Note>
  環境変数の認証情報（`environment_variable`）は、[セルフホスト型サンドボックス](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes)ではまだサポートされていません。
</Note>

セルフホスト型サンドボックスで同じ動作を実現するには、エグレス時にプレースホルダーの値を実際のシークレットに置き換える独自のプロキシを実行できます。

<Tabs>
  <Tab title="MCP OAuth">
    MCPサーバーがOAuth 2.0を使用する場合は `mcp_oauth` を使用します。`refresh` (csharp, go: `Refresh`) ブロックを指定すると、アクセストークンの有効期限が切れた際にAnthropicが代わりにリフレッシュを行います。

    `refresh.token_endpoint_auth.type` フィールドは、リフレッシュ呼び出しの認証方法を示します。

    * `none`：パブリッククライアント
    * `client_secret_basic`：クライアントシークレットによるHTTP Basic認証
    * `client_secret_post`：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>

    `refresh.token_endpoint` (java, php: `refresh.tokenEndpoint`; csharp, go: `Refresh.TokenEndpoint`) には、リフレッシュトークンを発行したOAuthフローのトークンエンドポイントを設定してください。AnthropicはすべてのリフレッシュリクエストをそのURLに送信し、このフィールドは認証情報の作成後に変更できないためです。
  </Tab>

  <Tab title="MCP静的ベアラー">
    MCPサーバーが固定のベアラートークン（APIキー、パーソナルアクセストークンなど）を受け付ける場合は `static_bearer` を使用します。リフレッシュフローは不要です。

    <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="環境変数">
    CLI、SDK、直接のAPI呼び出しなど、環境変数を通じて外部サービスに認証するには `environment_variable` を使用します。環境変数の認証情報は、アウトバウンドリクエストでシークレットの値をそのまま送信するクライアントで機能するため、設定する前にこのタブにあるクライアントの適格基準を確認してください。

    `networking` (csharp, go: `Networking`) 内の `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) 配列は、シークレットの置換対象となるアウトバウンドホストを制御します。特定のリストを指定する場合は `"type": "limited"` を、呼び出し元が事前に列挙できないドメインに到達する場合は `"type": "unrestricted"` を使用します。

    セキュリティ上の理由からドメインを制限することを強く推奨します。これにより、キーが許可されていないホストと共有されることを防げます。

    <Note>
      ボールト認証情報の `networking` (csharp, go: `Networking`) 内の `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) は、どのリクエストでシークレットを使用するかを制御するものであり、どのリクエストを許可するかを制御するものではありません。エージェントが実際にドメインに到達するには、[環境レベル](https://platform.claude.com/docs/ja/managed-agents/environments)でも許可されている必要があります。シークレットが置換されたリクエストが成功するには、両方のレベルにそのドメインが含まれている必要があります（`unrestricted` ネットワーキングによるか、`allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) にドメインを明示的に列挙するかのいずれか）。
    </Note>

    オプションの `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) フィールドは、シークレットが置換される場所のスコープを指定します。完全なセマンティクスは例の後に説明します。

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

    リクエストペイロードはエージェントが扱っているコンテンツから組み立てられることが多いため、リクエストボディはより広い露出面となります。ほとんどのサービスはリクエストヘッダーからAPIキーを読み取るため、`header` (csharp, go: `Header`) のみを有効にするのがより限定的な設定です。これにより、その認証情報の置換はリクエストヘッダーの値に限定されます。

    認証情報の `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) は、アウトバウンドリクエストのどの部分にシークレットが置換されるかを制御します。これは `networking` (csharp, go: `Networking`) と同階層にあるオプションのオブジェクトで、`header` (csharp, go: `Header`)（リクエストヘッダー）と `body` (csharp, go: `Body`)（リクエストボディ）の2つのブール値フィールドを持ちます。`injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) は `networking` (csharp, go: `Networking`) 内の `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) とは独立しています。`allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) はシークレットがどのホストに対して置換されるかのスコープを指定し、`injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) はリクエストのどの部分に置換されるかのスコープを指定します。

    `injection_location` は作成時と更新時で動作が異なります。

    | 操作      | `injection_location` の動作                                                                                             |
    | ------- | -------------------------------------------------------------------------------------------------------------------- |
    | 認証情報の作成 | オブジェクトを指定した場合、その中で省略したフィールドはデフォルトで `false` になります。`{"header": true}` はヘッダーのみの認証情報を作成します。オブジェクト全体を省略すると、両方の場所が有効になります。 |
    | 認証情報の更新 | フィールドは個別にマージされます。`{"body": false}` はボディの置換を無効にし、`header` は変更されません。                                                   |

    認証情報は少なくとも1つの場所が有効になっている必要があるため、両方の場所を無効にするような作成または更新は400エラーを返します。`injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) オブジェクトまたはいずれかのフィールドに明示的な `null` を渡した場合も400エラー（「omit the field instead」）を返します。レスポンスは常に、解決済みの値を持つ両方のフィールドを返します。

    無効化された場所にあるプレースホルダーは、置換も除去もされません。リクエストは、その場所にリテラルの不透明なプレースホルダー文字列を含んだままサードパーティに送信されます。リテラルのプレースホルダー文字列を含むリクエストがサードパーティに届いた場合、その認証情報でその場所が無効になっているか、宛先ホストが認証情報の `networking` (csharp, go: `Networking`) 内の `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) でカバーされていないかのいずれかです。

    <Note>
      Consoleで作成された認証情報は、ヘッダーへの注入のみが有効になります。フォームエンコードされたトークンリクエストなど、クライアントがリクエストボディでシークレットを送信する場合、プレースホルダーはそのまま通過し、サービスは独自の認証エラーでそれを拒否します。認証情報を作成する際にConsoleのフォームでボディへの注入を有効にするか、`{"injection_location": {"body": true}}` で認証情報を更新してください。
    </Note>

    置換はサンドボックス内ではなくエグレス時に行われます。認証情報をローカルで処理するものはすべて、実際の値ではなく不透明なプレースホルダーを目にします。起動時に認証情報の形式を検証するクライアントはそれを拒否する可能性があり、シークレットからリクエスト署名を計算するクライアント（例：AWS SigV4）は無効な署名を生成します。環境変数の認証情報は、認証情報の `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) で有効になっている場所において、アウトバウンドリクエストでシークレットの値をそのまま送信するクライアントで機能します。

    置換はアウトバウンドのみです。クライアントが保存されたシークレットを使用してセッショントークンを取得する場合（例：OAuthクライアントクレデンシャルグラント）、返されたトークンは編集されずにサンドボックスに届きます。交換ベースのフローでは、交換を自分で実行し、結果として得られたトークンを代わりにボールトに保存してください。

    <Tip>
      APIキーのスコープは、エージェントが必要とする権限のみに限定してください。エージェントはキーが許可することなら何でも実行できるため、必要以上に広い権限を持つキーは、エージェントが予期しない動作をした場合の影響範囲を拡大させます。
    </Tip>
  </Tab>
</Tabs>

認証情報は指定されたとおりに保存され、セッション実行時まで検証されません。無効な認証情報は、セッション中に認証エラーまたは下流のエラーとして表面化します。このエラーは発行されますが、セッションの継続を妨げることはありません。

制約：

* **ボールトごとに一意のキー。** `mcp_server_url` (java: `mcpServerUrl`; php: `mcpServerURL`; csharp: `McpServerUrl`; go: `MCPServerURL`)（MCP認証情報）と `secret_name` (java, php: `secretName`; csharp, go: `SecretName`)（環境変数の認証情報）は、ボールト内のアクティブな認証情報の間で一意である必要があります。重複を作成すると409が返されます。
* **キーは不変。** `mcp_server_url` (java: `mcpServerUrl`; php: `mcpServerURL`; csharp: `McpServerUrl`; go: `MCPServerURL`) または `secret_name` (java, php: `secretName`; csharp, go: `SecretName`) を変更するには、認証情報をアーカイブして新しいものを作成してください。
* **ボールトごとに最大20個の認証情報。**

## セッション作成時にボールトを参照する

セッション作成時に `vault_ids` (java: `vaultIds`; php: `vaultIDs`; csharp: `VaultIds`; go: `VaultIDs`) を渡します。

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

実行時の動作：

* `mcp_server_url` (java: `mcpServerUrl`; php: `mcpServerURL`; csharp: `McpServerUrl`; go: `MCPServerURL`) で一致するMCP認証情報がない場合、接続は認証なしで試行され、サーバーが認証を必要とする場合はエラーになります。
* 複数のボールトに一致する認証情報が含まれている場合、最初に一致したボールトが優先されます。
* [マルチエージェントセッション](https://platform.claude.com/docs/ja/managed-agents/multiagent-orchestration)では、ボールトの認証情報はすべてのスレッドに適用されます。自身の定義で一致するMCPサーバーを宣言しているエージェントは、これらの認証情報で認証します。[エージェントをMCPサーバーに接続する](https://platform.claude.com/docs/ja/managed-agents/multiagent-orchestration#connect-agents-to-mcp-servers)を参照してください。

## 認証情報をローテーションする

シークレットの値、`display_name` (java, php: `displayName`; csharp, go: `DisplayName`)、および（環境変数の認証情報では）`injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) を更新できます。`injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) の更新は、[認証情報を追加する](https://platform.claude.com/docs/ja/managed-agents/vaults#add-a-credential)の「環境変数」タブで説明したとおり、フィールドごとにマージされます。実行中のセッションでは、`injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) の更新はシークレットのローテーションと同じ方法で伝播します。[認証情報のライフサイクル](https://platform.claude.com/docs/ja/managed-agents/vaults#credential-lifecycle)で説明するとおり、セッションの認証情報は再起動なしで再解決され、更新された場所はセッションのその後のアウトバウンドリクエストに適用されます。構造的なフィールド（`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`)）は作成後にロックされます。これらを変更するには、認証情報をアーカイブして新しいものを作成してください。

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

## 認証情報のライフサイクル

認証情報は、セッション中とボールトのライフサイクル中の両方で定期的に再解決されます。これにより、認証情報のローテーション、アーカイブ、または削除が、再起動なしで実行中のセッションに伝播することが保証されます。

認証情報がアーカイブされた、削除された、またはリフレッシュに失敗した場合に通知を受けるには、それらのライフサイクルの変更に関連付けられたボールトおよび認証情報の[Webhook](https://platform.claude.com/docs/ja/managed-agents/webhooks)をサブスクライブできます。

| イベント                              | トリガー                                                                   |
| --------------------------------- | ---------------------------------------------------------------------- |
| `vault.archived`                  | ボールトがアーカイブされました。配下の各認証情報に対しても `vault_credential.archived` イベントが発行されます。 |
| `vault.deleted`                   | ボールトが削除されました。配下の各認証情報に対しても `vault_credential.deleted` イベントが発行されます。     |
| `vault_credential.archived`       | 認証情報が、直接またはボールトのアーカイブの結果としてアーカイブされました。                                 |
| `vault_credential.deleted`        | 認証情報が、直接またはボールトの削除の結果として削除されました。                                       |
| `vault_credential.refresh_failed` | `mcp_oauth` 認証情報をリフレッシュできません（無効なリフレッシュトークン、またはOAuthサーバーからの回復不能なエラー）。   |

<Note>
  これはWebhookの網羅的なリストではありません。完全なリストについては[Webhookをサブスクライブする](https://platform.claude.com/docs/ja/managed-agents/webhooks)を参照してください。
</Note>

`mcp_oauth` 認証情報の場合、再解決時にアクセストークンの有効期限が切れていればリフレッシュも行われます。リフレッシュに失敗すると、`vault_credential.refresh_failed` イベントが発行されます。

### OAuthリフレッシュの失敗を診断する

リフレッシュが失敗した理由を診断するには、`POST /v1/vaults/{vault_id}/credentials/{credential_id}/mcp_oauth_validate`（SDKでは`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(...)`)）を呼び出します。これにより、失敗への対処方法を判断できます。適切な対処はエラーの種類によって異なります。

トップレベルの `status` (csharp, go: `Status`) が次に何をすべきかを示します。

* `valid`：トークンは機能しています。アクションは不要です。
* `invalid`：グラントが失われたか、OAuthサーバーが4xxでリフレッシュを拒否しました。エンドユーザーに再認可を促してください。
* `unknown`：一時的なエラー（5xx、429、またはネットワーク障害）。待機して再試行してください。

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

レスポンスは `vault_credential_validation` オブジェクトです。`mcp_probe` には失敗したMCPハンドシェイクのステップが含まれ、`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
  }
}
```

## その他の操作

* **ボールトまたは認証情報の一覧表示：** ページネーションされ、新しい順に並びます。アーカイブ済みのレコードはデフォルトで除外されます（含めるには `include_archived=true` を渡します）。
* **ボールトのアーカイブ：** `POST /v1/vaults/{id}/archive`。すべての認証情報にカスケードされます。シークレットは消去され、レコードは監査のために保持されます。このボールトを参照する今後のセッションは失敗しますが、実行中のセッションは継続します。
* **認証情報のアーカイブ：** `POST /v1/vaults/{id}/credentials/{cred_id}/archive`。シークレットのペイロードを消去します。認証情報のキー（`mcp_server_url` または `secret_name`）は引き続き表示され、代替の認証情報のために解放されます。
* **ボールトまたは認証情報の削除：** ハードデリートです。レコードは保持されません。監査証跡が必要な場合はアーカイブを使用してください。