---
title: Mit Vaults authentifizieren
url: https://platform.claude.com/docs/de/managed-agents/vaults
description: Registriere benutzerspezifische Credentials beim Erstellen von Sessions.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Vaults und Credentials (Anmeldedaten) sind Authentifizierungsprimitive, mit denen du Anmeldedaten für Drittanbieterdienste einmal registrieren und sie bei der Session-Erstellung per ID referenzieren kannst. Das bedeutet, dass du keinen eigenen Secret-Store betreiben, nicht bei jedem Aufruf Token übertragen und nicht den Überblick darüber verlieren musst, im Namen welches Endbenutzers ein Agent gehandelt hat.

Die Vault-Referenz ist ein Parameter pro Session, sodass du dein Produkt auf der Granularität der `agent`-Ressource und deine Benutzer auf der Granularität der `session`-Ressource verwalten kannst.

## Einen Vault erstellen

<Warning>
  Vaults und Credentials sind Workspace-bezogen, das heißt, jeder API-Key mit Workspace-Zugriff kann sie beim Erstellen einer Session referenzieren. Um den Zugriff zu widerrufen, lösche den Vault oder das Credential.
</Warning>

Ein Vault ist die Sammlung von `credentials`, die einem Endbenutzer zugeordnet sind. Gib ihm einen `display_name` (java, php: `displayName`; csharp, go: `DisplayName`) und versieh ihn optional mit `metadata` (csharp, go: `Metadata`), damit du ihn deinen eigenen Benutzerdatensätzen zuordnen kannst.

<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/de/cli-sdks-libraries/cli/apply) erstellt den Vault aus `vaults/service_accounts.yaml`, gibt seine ID aus und speichert sie in `claude-lock.json`. Um den Vault-Datensatz anzuzeigen, führe `ant beta:vaults retrieve` aus.
  </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>

Die Antwort ist der vollständige Vault-Datensatz:

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

## Ein Credential hinzufügen

Zwei Credential-Kategorien werden unterstützt:

* **MCP-Credentials** (`mcp_oauth`, `static_bearer`): Jedes Credential hat eine `mcp_server_url` (java: `mcpServerUrl`; php: `mcpServerURL`; csharp: `McpServerUrl`; go: `MCPServerURL`) als Schlüssel. Wenn sich der Agent zur Session-Laufzeit mit einem Server unter dieser URL verbindet, wird das Token automatisch eingefügt.
* **Umgebungsvariablen** (`environment_variable`): Jedes Credential hat einen `secret_name` (java, php: `secretName`; csharp, go: `SecretName`) (den Namen der Umgebungsvariable) als Schlüssel und wird in der Sandbox als undurchsichtiger Platzhalter gespeichert. Wenn der Agent eine ausgehende Anfrage initiiert, wird der undurchsichtige Platzhalter beim Egress durch das echte Secret ersetzt. Der Agent sieht den Secret-Wert nie. Verwende dies für jeden Dienst, der sich über eine Umgebungsvariable authentifiziert, etwa CLIs, SDKs oder direkte API-Aufrufe.

Die tatsächlichen Credential-Werte, die du angibst (`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`)), werden als sensible, nur beschreibbare Felder behandelt und nie in API-Antworten zurückgegeben.

<Note>
  Umgebungsvariablen-Credentials (`environment_variable`) werden mit [selbst gehosteten Sandboxes](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes) noch nicht unterstützt.
</Note>

Um dasselbe Verhalten mit einer selbst gehosteten Sandbox zu erreichen, kannst du einen eigenen Proxy betreiben, der Platzhalterwerte beim Egress durch die echten Secrets ersetzt.

<Tabs>
  <Tab title="MCP OAuth">
    Verwende `mcp_oauth`, wenn der MCP-Server OAuth 2.0 verwendet. Wenn du einen `refresh` (csharp, go: `Refresh`)-Block angibst, aktualisiert Anthropic das Access-Token in deinem Namen, wenn es abläuft.

    Das Feld `refresh.token_endpoint_auth.type` gibt an, wie der Refresh-Aufruf authentifiziert wird:

    * `none`: öffentlicher Client
    * `client_secret_basic`: HTTP-Basic-Authentifizierung mit dem Client-Secret
    * `client_secret_post`: Client-Secret im POST-Body

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

    Setze `refresh.token_endpoint` (java, php: `refresh.tokenEndpoint`; csharp, go: `Refresh.TokenEndpoint`) auf den Token-Endpunkt des OAuth-Flows, der das Refresh-Token ausgestellt hat, da Anthropic jede Refresh-Anfrage an diese URL sendet und das Feld nach dem Erstellen des Credentials nicht mehr geändert werden kann.
  </Tab>

  <Tab title="MCP Static Bearer">
    Verwende `static_bearer`, wenn der MCP-Server ein festes Bearer-Token akzeptiert (API-Key, Personal Access Token oder Ähnliches). Es ist kein Refresh-Flow erforderlich.

    <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="Umgebungsvariable">
    Verwende `environment_variable`, um dich über eine Umgebungsvariable bei externen Diensten zu authentifizieren, etwa bei CLIs, SDKs oder direkten API-Aufrufen. Umgebungsvariablen-Credentials funktionieren für Clients, die den Secret-Wert unverändert in einer ausgehenden Anfrage senden. Prüfe daher die Kriterien zur Client-Eignung in diesem Tab, bevor du eines konfigurierst.

    Das Array `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) in `networking` (csharp, go: `Networking`) steuert, für welche ausgehenden Hosts das Secret ersetzt werden kann. Verwende `"type": "limited"` mit einer konkreten Liste oder `"type": "unrestricted"`, wenn der Aufrufer Domains erreicht, die du nicht im Voraus aufzählen kannst.

    Das Einschränken von Domains wird aus Sicherheitsgründen dringend empfohlen und verhindert, dass dein Key jemals mit nicht autorisierten Hosts geteilt wird.

    <Note>
      `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) in `networking` (csharp, go: `Networking`) bei einem Vault-Credential steuert, welche Anfragen das Secret verwenden, nicht welche Anfragen erlaubt sind. Damit der Agent eine Domain tatsächlich erreichen kann, muss sie auch auf [Umgebungsebene](https://platform.claude.com/docs/de/managed-agents/environments) erlaubt sein. Beide Ebenen müssen die Domain enthalten (entweder über `unrestricted`-Networking oder durch explizites Auflisten der Domain in `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`)), damit eine Anfrage mit ersetztem Secret erfolgreich ist.
    </Note>

    Das optionale Feld `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) schränkt ein, wo das Secret ersetzt wird; die vollständige Semantik folgt nach dem Beispiel.

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

    Anfrage-Payloads werden oft aus Inhalten zusammengesetzt, mit denen der Agent arbeitet, daher ist der Anfrage-Body die größere Angriffsfläche. Die meisten Dienste lesen einen API-Key aus einem Anfrage-Header, daher ist das ausschließliche Aktivieren von `header` (csharp, go: `Header`) die engere Konfiguration. Sie beschränkt die Ersetzung für dieses Credential auf Werte in Anfrage-Headern.

    Das `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) des Credentials steuert, in welche Teile einer ausgehenden Anfrage das Secret eingesetzt wird. Es ist ein optionales Objekt auf derselben Ebene wie `networking` (csharp, go: `Networking`), mit zwei booleschen Feldern: `header` (csharp, go: `Header`) (Anfrage-Header) und `body` (csharp, go: `Body`) (Anfrage-Body). `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) ist unabhängig von `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) in `networking` (csharp, go: `Networking`): `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) legt fest, für welche Hosts das Secret ersetzt wird, und `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) legt fest, in welche Teile der Anfrage es eingesetzt wird.

    `injection_location` verhält sich beim Erstellen und beim Aktualisieren unterschiedlich:

    | Operation                | Verhalten von `injection_location`                                                                                                                                                                             |
    | ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    | Credential erstellen     | Wenn du das Objekt angibst, ist jedes darin ausgelassene Feld standardmäßig `false`: `{"header": true}` erstellt ein reines Header-Credential. Lässt du das Objekt vollständig weg, sind beide Orte aktiviert. |
    | Credential aktualisieren | Felder werden einzeln zusammengeführt: `{"body": false}` deaktiviert die Body-Ersetzung und lässt `header` unverändert.                                                                                        |

    Ein Credential muss mindestens einen aktivierten Ort haben, daher gibt ein Erstellen oder Aktualisieren, das beide Orte deaktivieren würde, einen 400-Fehler zurück. Die Übergabe eines expliziten `null` für das Objekt `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) oder für eines der Felder gibt ebenfalls einen 400-Fehler zurück („omit the field instead“). Die Antwort gibt immer beide Felder mit ihren aufgelösten Werten zurück.

    Ein Platzhalter an einem deaktivierten Ort wird weder ersetzt noch entfernt. Die Anfrage wird mit der wörtlichen undurchsichtigen Platzhalterzeichenfolge an diesem Ort an den Drittanbieter gesendet. Wenn beim Drittanbieter eine Anfrage mit der wörtlichen Platzhalterzeichenfolge ankommt, ist entweder dieser Ort für das Credential deaktiviert oder der Zielhost ist nicht durch die `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) im `networking` (csharp, go: `Networking`) des Credentials abgedeckt.

    <Note>
      In der Console erstellte Credentials aktivieren nur die Header-Injektion. Wenn dein Client das Secret im Anfrage-Body sendet, etwa in einer formularkodierten Token-Anfrage, wird der Platzhalter wörtlich durchgereicht und der Dienst lehnt ihn mit seinem eigenen Authentifizierungsfehler ab. Aktiviere die Body-Injektion im Console-Formular, wenn du das Credential erstellst, oder aktualisiere das Credential mit `{"injection_location": {"body": true}}`.
    </Note>

    Die Ersetzung erfolgt beim Egress, nicht innerhalb der Sandbox. Alles, was das Credential lokal verarbeitet, sieht den undurchsichtigen Platzhalter, nicht den echten Wert: Clients, die das Credential-Format beim Start validieren, lehnen es möglicherweise ab, und Clients, die aus dem Secret eine Anfragesignatur berechnen (zum Beispiel AWS SigV4), erzeugen eine ungültige Signatur. Umgebungsvariablen-Credentials funktionieren für Clients, die den Secret-Wert unverändert in einer ausgehenden Anfrage senden, und zwar an einem Ort, den das `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) des Credentials aktiviert.

    Die Ersetzung erfolgt nur ausgehend. Wenn ein Client das gespeicherte Secret verwendet, um ein Session-Token abzurufen (zum Beispiel ein OAuth-Client-Credentials-Grant), kommt das zurückgegebene Token ungeschwärzt in der Sandbox an. Führe bei austauschbasierten Flows den Austausch selbst durch und speichere stattdessen das resultierende Token im Vault.

    <Tip>
      Beschränke den API-Key auf genau die Berechtigungen, die der Agent benötigt. Der Agent kann alles tun, was der Key erlaubt, daher vergrößert ein Key mit weiter gefassten Berechtigungen als nötig den Schadensradius, falls sich der Agent unerwartet verhält.
    </Tip>
  </Tab>
</Tabs>

Credentials werden wie angegeben gespeichert und erst zur Session-Laufzeit validiert. Ein ungültiges Credential zeigt sich während der Session als Authentifizierungs- oder nachgelagerter Fehler, der ausgegeben wird, die Session aber nicht an der Fortsetzung hindert.

Einschränkungen:

* **Eindeutiger Schlüssel pro Vault.** `mcp_server_url` (java: `mcpServerUrl`; php: `mcpServerURL`; csharp: `McpServerUrl`; go: `MCPServerURL`) (MCP-Credentials) und `secret_name` (java, php: `secretName`; csharp, go: `SecretName`) (Umgebungsvariablen-Credentials) müssen unter den aktiven Credentials in einem Vault eindeutig sein. Das Erstellen eines Duplikats gibt einen 409 zurück.
* **Schlüssel sind unveränderlich.** Um `mcp_server_url` (java: `mcpServerUrl`; php: `mcpServerURL`; csharp: `McpServerUrl`; go: `MCPServerURL`) oder `secret_name` (java, php: `secretName`; csharp, go: `SecretName`) zu ändern, archiviere das Credential und erstelle ein neues.
* **Maximal 20 Credentials pro Vault.**

## Den Vault bei der Session-Erstellung referenzieren

Übergib `vault_ids` (java: `vaultIds`; php: `vaultIDs`; csharp: `VaultIds`; go: `VaultIDs`) beim Erstellen einer Session:

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

Laufzeitverhalten:

* Wenn kein MCP-Credential anhand der `mcp_server_url` (java: `mcpServerUrl`; php: `mcpServerURL`; csharp: `McpServerUrl`; go: `MCPServerURL`) übereinstimmt, wird die Verbindung ohne Authentifizierung versucht und schlägt fehl, wenn der Server eine Authentifizierung erfordert.
* Wenn mehrere Vaults ein passendes Credential enthalten, gewinnt der erste Vault mit einem Treffer.
* In [Multiagent-Sessions](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration) gelten Vault-Credentials für jeden Thread. Ein Agent, dessen eigene Definition den passenden MCP-Server deklariert, authentifiziert sich mit diesen Credentials. Siehe [Agenten mit MCP-Servern verbinden](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration#connect-agents-to-mcp-servers).

## Ein Credential rotieren

Secret-Werte, `display_name` (java, php: `displayName`; csharp, go: `DisplayName`) und (bei Umgebungsvariablen-Credentials) `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) können aktualisiert werden. Aktualisierungen von `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) werden pro Feld zusammengeführt, wie im Tab „Umgebungsvariable“ unter [Ein Credential hinzufügen](https://platform.claude.com/docs/de/managed-agents/vaults#add-a-credential) beschrieben. Bei einer laufenden Session wird eine Aktualisierung von `injection_location` (java, php: `injectionLocation`; csharp, go: `InjectionLocation`) auf dieselbe Weise übernommen wie eine Secret-Rotation: Die Credentials der Session werden ohne Neustart neu aufgelöst, wie unter [Credential-Lebenszyklus](https://platform.claude.com/docs/de/managed-agents/vaults#credential-lifecycle) beschrieben, und die aktualisierten Orte gelten für die nachfolgenden ausgehenden Anfragen der Session. Strukturelle Felder (`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`)) sind nach der Erstellung gesperrt. Um sie zu ändern, archiviere das Credential und erstelle ein neues.

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

## Credential-Lebenszyklus

Credentials werden regelmäßig neu aufgelöst, sowohl während einer Session als auch während des Vault-Lebenszyklus. Dies stellt sicher, dass Rotation, Archivierung oder Löschung von Credentials ohne Neustart auf laufende Sessions propagiert wird.

Um benachrichtigt zu werden, wenn ein Credential archiviert oder gelöscht wird oder die Aktualisierung fehlschlägt, kannst du die Vault- und Credential-[Webhooks](https://platform.claude.com/docs/de/managed-agents/webhooks) abonnieren, die mit diesen Lebenszyklusänderungen verbunden sind.

| Event                             | Auslöser                                                                                                                            |
| --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| `vault.archived`                  | Vault archiviert. Für jedes zugrunde liegende Credential wird zusätzlich ein `vault_credential.archived`-Event ausgegeben.          |
| `vault.deleted`                   | Vault gelöscht. Für jedes zugrunde liegende Credential wird zusätzlich ein `vault_credential.deleted`-Event ausgegeben.             |
| `vault_credential.archived`       | Credential archiviert, entweder direkt oder infolge einer Vault-Archivierung.                                                       |
| `vault_credential.deleted`        | Credential gelöscht, entweder direkt oder infolge einer Vault-Löschung.                                                             |
| `vault_credential.refresh_failed` | Ein `mcp_oauth`-Credential kann nicht aktualisiert werden (ungültiges Refresh-Token oder nicht behebbarer Fehler vom OAuth-Server). |

<Note>
  Dies ist eine nicht abschließende Liste von Webhooks; die vollständige Liste findest du unter [Webhooks abonnieren](https://platform.claude.com/docs/de/managed-agents/webhooks).
</Note>

Bei `mcp_oauth`-Credentials aktualisiert die Neuauflösung auch das Access-Token, falls es abgelaufen ist. Schlägt die Aktualisierung fehl, wird ein `vault_credential.refresh_failed`-Event ausgegeben.

### Einen OAuth-Refresh-Fehler diagnostizieren

Um zu diagnostizieren, warum ein Refresh fehlgeschlagen ist, rufe `POST /v1/vaults/{vault_id}/credentials/{credential_id}/mcp_oauth_validate` auf (oder `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(...)`) im SDK). So kannst du entscheiden, wie du mit dem Fehler umgehst; die richtige Maßnahme hängt vom Fehlertyp ab.

Der `status` (csharp, go: `Status`) auf oberster Ebene sagt dir, was als Nächstes zu tun ist:

* `valid`: Das Token funktioniert; keine Maßnahme erforderlich.
* `invalid`: Der Grant ist weg oder der OAuth-Server hat den Refresh mit einem 4xx abgelehnt. Fordere den Endbenutzer auf, sich erneut zu autorisieren.
* `unknown`: Ein vorübergehender Fehler (5xx, 429 oder Netzwerkfehler). Warte und versuche es erneut.

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

Die Antwort ist ein `vault_credential_validation`-Objekt. `mcp_probe` enthält den fehlgeschlagenen Schritt des MCP-Handshakes; `refresh` enthält das Ergebnis des versuchten Refreshs.

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

## Weitere Operationen

* **Vaults oder Credentials auflisten:** Paginiert, neueste zuerst. Archivierte Datensätze sind standardmäßig ausgeschlossen (übergib `include_archived=true`, um sie einzuschließen).
* **Einen Vault archivieren:** `POST /v1/vaults/{id}/archive`. Kaskadiert auf alle Credentials. Secrets werden gelöscht; Datensätze werden zu Prüfzwecken aufbewahrt. Zukünftige Sessions, die diesen Vault referenzieren, schlagen fehl; laufende Sessions werden fortgesetzt.
* **Ein Credential archivieren:** `POST /v1/vaults/{id}/credentials/{cred_id}/archive`. Löscht die Secret-Payload; der Credential-Schlüssel (`mcp_server_url` oder `secret_name`) bleibt sichtbar und wird für ein Ersatz-Credential freigegeben.
* **Einen Vault oder ein Credential löschen:** Endgültiges Löschen. Der Datensatz wird nicht aufbewahrt. Verwende die Archivierung, wenn du einen Audit-Trail benötigst.